KoSvgTextShapeLayoutFunc Namespace Reference

Functions
void	addWordToLine (QVector< CharacterResult > &result, QPointF &currentPos, QVector< int > &wordIndices, LineBox &currentLine, bool ltr, bool isHorizontal)
	addWordToLine Small function used in break lines to quickly add a 'word' to the current line. Returns the last added index.
static void	applyInlineSizeAnchoring (QVector< CharacterResult > &result, LineChunk &chunk, const KoSvgText::TextAnchor anchor, const QPointF anchorPoint, const bool ltr, const bool isHorizontal, const QPointF textIndent, const KoSvgText::ResolutionHandler &resHandler)
QVector< LineBox >	breakLines (const KoSvgTextProperties &properties, const QMap< int, int > &logicalToVisual, QVector< CharacterResult > &result, QPointF startPos, const KoSvgText::ResolutionHandler &resHandler)
void	calculateLineHeight (CharacterResult cr, double &ascent, double &descent, bool isHorizontal, bool compare)
	calculateLineHeight calculate the total ascent and descent (including baseline-offset) of a charResult and optionally only return it if it is larger than the provided ascent and descent variable. This is necessary for proper line-height calculation.
void	finalizeLine (QVector< CharacterResult > &result, QPointF &currentPos, LineBox &currentLine, QPointF &lineOffset, const KoSvgText::TextAnchor anchor, const KoSvgText::WritingMode writingMode, const bool ltr, const bool inlineSize, const bool textInShape, const KoSvgText::ResolutionHandler &resHandler)
static QVector< QLineF >	findLineBoxesForFirstPos (QPainterPath shape, QPointF firstPos, const QRectF wordBox, KoSvgText::WritingMode writingMode)
QVector< LineBox >	flowTextInShapes (const KoSvgTextProperties &properties, const QMap< int, int > &logicalToVisual, QVector< CharacterResult > &result, QList< QPainterPath > shapes, QPointF &startPos, const KoSvgText::ResolutionHandler &resHandler)
static void	getEstimatedHeight (QVector< CharacterResult > &result, const int index, QRectF &wordBox, const QRectF boundingBox, KoSvgText::WritingMode writingMode)
	getEstimatedHeight Adjust the wordbox with the estimated height.
static bool	getFirstPosition (QPointF &firstPoint, QPainterPath p, QRectF wordBox, QPointF terminator, KoSvgText::WritingMode writingMode, bool ltr)
QList< QPainterPath >	getShapes (QList< KoShape * > shapesInside, QList< KoShape * > shapesSubtract, const KoSvgTextProperties &properties)
static void	handleCollapseAndHang (QVector< CharacterResult > &result, LineChunk &chunk, bool ltr, bool isHorizontal)
static QPointF	lineHeightOffset (KoSvgText::WritingMode writingMode, QVector< CharacterResult > &result, LineBox &currentLine, const bool firstLine, const KoSvgText::ResolutionHandler resHandler)
static bool	pointLessThan (const QPointF &a, const QPointF &b)
static bool	pointLessThanVertical (const QPointF &a, const QPointF &b)
static KoSvgText::TextAnchor	textAnchorForTextAlign (KoSvgText::TextAlign align, KoSvgText::TextAlign alignLast, bool ltr)

Function Documentation

addWordToLine()

void KoSvgTextShapeLayoutFunc::addWordToLine	(	QVector< CharacterResult > &	result,
		QPointF &	currentPos,
		QVector< int > &	wordIndices,
		LineBox &	currentLine,
		bool	ltr,
		bool	isHorizontal )

addWordToLine Small function used in break lines to quickly add a 'word' to the current line. Returns the last added index.

Definition at line 54 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    QPointF lineAdvance = currentPos;
 
    LineChunk currentChunk  = currentLine.chunk();
 
    Q_FOREACH (const int j, wordIndices) {
        CharacterResult cr = result.at(j);
        if (currentLine.isEmpty() && j == wordIndices.first()) {
            if (result.at(j).lineStart == LineEdgeBehaviour::Collapse) {
                if (isHorizontal) {
                    result[j].scaleCharacterResult(0.0, 1.0);
                } else {
                    result[j].scaleCharacterResult(1.0, 0.0);
                }
                result[j].hidden = true;
                continue;
            }
            cr.anchored_chunk = true;
            if (result.at(j).lineStart == LineEdgeBehaviour::ForceHang && currentLine.firstLine) {
                currentPos -= cr.advance;
                cr.isHanging = true;
            }
        }
        calculateLineHeight(cr, currentLine.actualLineTop, currentLine.actualLineBottom, isHorizontal, !cr.anchored_chunk);
 
        cr.cssPosition = currentPos;
        cr.calculateAndApplyTabsize(currentPos, isHorizontal, KoSvgText::ResolutionHandler());
        currentPos += cr.advance;
        lineAdvance = currentPos;
 
        result[j] = cr;
        currentChunk.boundingBox |= cr.layoutBox().translated(cr.cssPosition + cr.totalBaselineOffset());
    }
    currentPos = lineAdvance;
    currentChunk.chunkIndices += wordIndices;
    currentLine.setCurrentChunk(currentChunk);
    wordIndices.clear();
}

References LineBox::actualLineBottom, LineBox::actualLineTop, CharacterResult::advance, CharacterResult::anchored_chunk, LineChunk::boundingBox, CharacterResult::calculateAndApplyTabsize(), calculateLineHeight(), LineBox::chunk(), LineChunk::chunkIndices, Collapse, CharacterResult::cssPosition, LineBox::firstLine, ForceHang, LineBox::isEmpty(), CharacterResult::isHanging, CharacterResult::layoutBox(), LineBox::setCurrentChunk(), and CharacterResult::totalBaselineOffset().

applyInlineSizeAnchoring()

static void KoSvgTextShapeLayoutFunc::applyInlineSizeAnchoring ( QVector< CharacterResult > & result, LineChunk & chunk, const KoSvgText::TextAnchor anchor, const QPointF anchorPoint, const bool ltr, const bool isHorizontal, const QPointF textIndent, const KoSvgText::ResolutionHandler & resHandler )

static

Definition at line 248 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    const QVector<int> lineIndices = chunk.chunkIndices;
    qreal shift = isHorizontal ? anchorPoint.x() : anchorPoint.y();
 
    qreal a = 0;
    qreal b = 0;
 
    bool first = true;
    Q_FOREACH (int i, lineIndices) {
        if (!result.at(i).addressable || result.at(i).hidden || (result.at(i).isHanging && result.at(i).anchored_chunk)) {
            continue;
        }
 
        QPointF p = result.at(i).finalPosition;
        QPointF d = result.at(i).advance;
        if (result.at(i).isHanging) {
            d -= chunk.conditionalHangEnd;
            if (!ltr) {
                p += chunk.conditionalHangEnd;
            }
        }
        const qreal pos = isHorizontal ? p.x() : p.y();
        const qreal advance = isHorizontal ? d.x() : d.y();
 
        if (first) {
            a = qMin(pos, pos + advance);
            b = qMax(pos, pos + advance);
            first = false;
        } else {
            a = qMin(a, qMin(pos, pos + advance));
            b = qMax(b, qMax(pos, pos + advance));
        }
    }
 
 
    if (anchor == KoSvgText::AnchorStart) {
        const qreal indent = isHorizontal ? textIndent.x() : textIndent.y();
        if (ltr) {
            a -= indent;
        } else {
            b += indent;
        }
    }
 
    if ((anchor == KoSvgText::AnchorStart && ltr) || (anchor == KoSvgText::AnchorEnd && !ltr)) {
        shift -= a;
 
    } else if ((anchor == KoSvgText::AnchorEnd && ltr) || (anchor == KoSvgText::AnchorStart && !ltr)) {
        shift -= b;
 
    } else {
        shift -= ((a + b) * 0.5);
    }
 
    QPointF shiftP = resHandler.adjust(isHorizontal ? QPointF(shift, 0) : QPointF(0, shift));
    Q_FOREACH (int j, lineIndices) {
        result[j].cssPosition = result[j].cssPosition+shiftP;
        result[j].finalPosition = result.at(j).cssPosition;
    }
    chunk.boundingBox.translate(shiftP);
}

References KoSvgText::ResolutionHandler::adjust(), KoSvgText::AnchorEnd, KoSvgText::AnchorStart, LineChunk::boundingBox, LineChunk::chunkIndices, LineChunk::conditionalHangEnd, and p.

breakLines()

QVector< LineBox > KoSvgTextShapeLayoutFunc::breakLines	(	const KoSvgTextProperties &	properties,
		const QMap< int, int > &	logicalToVisual,
		QVector< CharacterResult > &	result,
		QPointF	startPos,
		const KoSvgText::ResolutionHandler &	resHandler )

< Used for hanging glyphs at the end of a line.

< 'word' in this case meaning characters inbetween softbreaks.

< Approximated advance of the current wordindices.

< Current position with advances of each character.

< Current line offset.

< Indices of characters in line.

< Whether to do a softbreak;

< Used for hanging glyphs at the end of a line.

< 'word' in this case meaning characters inbetween softbreaks.

< Approximated advance of the current wordindices.

< Current position with advances of each character.

< Current line offset.

< Indices of characters in line.

< Whether to do a softbreak;

Definition at line 442 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    KoSvgText::WritingMode writingMode = KoSvgText::WritingMode(properties.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
    KoSvgText::Direction direction = KoSvgText::Direction(properties.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    KoSvgText::AutoValue inlineSize = properties.propertyOrDefault(KoSvgTextProperties::InlineSizeId).value<KoSvgText::AutoValue>();
    KoSvgText::TextAnchor anchor = KoSvgText::TextAnchor(properties.propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt());
 
    bool ltr = direction == KoSvgText::DirectionLeftToRight;
    bool isHorizontal = writingMode == KoSvgText::HorizontalTB;
 
    QVector<LineBox> lineBoxes;
 
    QPointF endPos; 
 
    KoSvgText::TextIndentInfo textIndentInfo = properties.propertyOrDefault(KoSvgTextProperties::TextIndentId).value<KoSvgText::TextIndentInfo>();
    QPointF textIndent;
    if (!inlineSize.isAuto) {
 
        qreal textIdentValue = textIndentInfo.length.unit == KoSvgText::CssLengthPercentage::Percentage?
                    textIndentInfo.length.value * inlineSize.customValue: textIndentInfo.length.value;
        if (isHorizontal) {
            textIndent = resHandler.adjust(QPointF(textIdentValue, 0));
            endPos = ltr ? QPointF(startPos.x() + inlineSize.customValue, 0) : QPointF(startPos.x() - inlineSize.customValue, 0);
        } else {
            textIndent = resHandler.adjust(QPointF(0, textIdentValue));
            endPos = ltr ? QPointF(0, startPos.y() + inlineSize.customValue) : QPointF(0, startPos.y() - inlineSize.customValue);
        }
    }
    LineBox currentLine(startPos, endPos, resHandler);
    currentLine.firstLine = true;
 
    QVector<int> wordIndices; 
    QPointF wordAdvance; 
 
    QPointF currentPos = startPos; 
    if (!textIndentInfo.hanging && !inlineSize.isAuto) {
        currentLine.textIndent = textIndent;
        currentPos += currentLine.textIndent;
    }
    QPointF lineOffset = startPos; 
 
    QVector<int> lineIndices; 
 
    QListIterator<int> it(logicalToVisual.keys());
    while (it.hasNext()) {
        int index = it.next();
        result[index].calculateAndApplyTabsize(wordAdvance + currentPos, isHorizontal, resHandler);
        CharacterResult charResult = result.at(index);
        if (!charResult.addressable) {
            continue;
        }
        bool softBreak = false; 
        bool doNotCountAdvance =
            ((charResult.lineEnd != LineEdgeBehaviour::NoChange)
             && !(currentLine.isEmpty() && wordIndices.isEmpty()));
        if (!doNotCountAdvance) {
            if (wordIndices.isEmpty()) {
                wordAdvance = charResult.advance;
            } else {
                wordAdvance += charResult.advance;
            }
        }
        wordIndices.append(index);
        currentLine.lastLine = !it.hasNext();
 
        if (charResult.breakType != BreakType::NoBreak || currentLine.lastLine) {
            qreal lineLength = isHorizontal ? (currentPos - startPos + wordAdvance).x()
                                            : (currentPos - startPos + wordAdvance).y();
            if (!inlineSize.isAuto) {
                // Sometimes glyphs are a fraction larger than you'd expect, but
                // not enough to really break the line, so the following is a
                // bit more stable than a simple compare.
                if (abs(lineLength) - inlineSize.customValue > 0.01) {
                    softBreak = true;
                } else {
                    addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
                }
            } else {
                addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
            }
        }
 
        if (softBreak) {
            bool firstLine = currentLine.firstLine;
            if (!currentLine.isEmpty()) {
                finalizeLine(result,
                             currentPos,
                             currentLine,
                             lineOffset,
                             anchor,
                             writingMode,
                             ltr,
                             !inlineSize.isAuto,
                             false,
                             resHandler);
                lineBoxes.append(currentLine);
                currentLine.clearAndAdjust(isHorizontal, lineOffset, textIndentInfo.hanging? textIndent: QPointF());
                if (!inlineSize.isAuto) {
                    currentPos += currentLine.textIndent;
                }
            }
 
            if (charResult.overflowWrap) {
                qreal wordLength = isHorizontal ? wordAdvance.x() : wordAdvance.y();
                if (!inlineSize.isAuto && wordLength > inlineSize.customValue) {
                    // Word is too large, so we try to add it in
                    // max-width-friendly-chunks.
                    wordAdvance = QPointF();
                    wordLength = 0;
                    QVector<int> partialWord;
                    currentLine.firstLine = firstLine;
                    Q_FOREACH (const int i, wordIndices) {
                        result[i].calculateAndApplyTabsize(wordAdvance + currentPos, isHorizontal, resHandler);
                        wordAdvance += result.at(i).advance;
                        wordLength = isHorizontal ? wordAdvance.x() : wordAdvance.y();
                        if (wordLength <= inlineSize.customValue) {
                            partialWord.append(i);
                        } else {
                            addWordToLine(result, currentPos, partialWord, currentLine, ltr, isHorizontal);
 
                            finalizeLine(result,
                                         currentPos,
                                         currentLine,
                                         lineOffset,
                                         anchor,
                                         writingMode,
                                         ltr,
                                         !inlineSize.isAuto,
                                         false,
                                         resHandler);
                            lineBoxes.append(currentLine);
                            currentLine.clearAndAdjust(isHorizontal, lineOffset, textIndentInfo.hanging? textIndent: QPointF());
                            if (!inlineSize.isAuto) {
                                currentPos += currentLine.textIndent;
                            }
                            result[i].calculateAndApplyTabsize(wordAdvance + currentPos, isHorizontal, resHandler);
                            wordAdvance = result.at(i).advance;
                            partialWord.append(i);
                        }
                    }
                    wordIndices = partialWord;
                }
            }
            addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
        }
 
        if (charResult.breakType == BreakType::HardBreak) {
            finalizeLine(result,
                         currentPos,
                         currentLine,
                         lineOffset,
                         anchor,
                         writingMode,
                         ltr,
                         !inlineSize.isAuto,
                         false,
                         resHandler);
            lineBoxes.append(currentLine);
            bool indentLine = textIndentInfo.hanging? false: textIndentInfo.eachLine;
            currentLine.clearAndAdjust(isHorizontal, lineOffset, indentLine? textIndent: QPointF());
            if (!inlineSize.isAuto) {
                currentPos += currentLine.textIndent;
            }
        }
 
        if (currentLine.lastLine) {
            if (!wordIndices.isEmpty()) {
                addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
            }
            finalizeLine(result,
                         currentPos,
                         currentLine,
                         lineOffset,
                         anchor,
                         writingMode,
                         ltr,
                         !inlineSize.isAuto,
                         false,
                         resHandler);
            lineBoxes.append(currentLine);
        }
    }
    debugFlake << "Linebreaking finished";
    return lineBoxes;
}

References CharacterResult::addressable, addWordToLine(), KoSvgText::ResolutionHandler::adjust(), CharacterResult::advance, CharacterResult::breakType, LineBox::clearAndAdjust(), KoSvgText::AutoValue::customValue, debugFlake, KoSvgTextProperties::DirectionId, KoSvgText::DirectionLeftToRight, KoSvgText::TextIndentInfo::eachLine, finalizeLine(), LineBox::firstLine, KoSvgText::TextIndentInfo::hanging, HardBreak, KoSvgText::HorizontalTB, KoSvgTextProperties::InlineSizeId, KoSvgText::AutoValue::isAuto, LineBox::isEmpty(), LineBox::lastLine, KoSvgText::TextIndentInfo::length, CharacterResult::lineEnd, NoBreak, NoChange, CharacterResult::overflowWrap, KoSvgText::CssLengthPercentage::Percentage, KoSvgTextProperties::propertyOrDefault(), KoSvgTextProperties::TextAnchorId, LineBox::textIndent, KoSvgTextProperties::TextIndentId, KoSvgText::CssLengthPercentage::unit, KoSvgText::CssLengthPercentage::value, and KoSvgTextProperties::WritingModeId.

calculateLineHeight()

void KoSvgTextShapeLayoutFunc::calculateLineHeight	(	CharacterResult	cr,
		double &	ascent,
		double &	descent,
		bool	isHorizontal,
		bool	compare )

calculateLineHeight calculate the total ascent and descent (including baseline-offset) of a charResult and optionally only return it if it is larger than the provided ascent and descent variable. This is necessary for proper line-height calculation.

Parameters

cr	- char result with the data.
ascent	- output ascent variable.
descent	- output descent variable.
isHorizontal	- whether it is horizontal.
compare	- whether to only return the value if it is larger than the relative ascent or descent.

Definition at line 29 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    QRectF lineHeightBox = cr.lineHeightBox().translated(cr.totalBaselineOffset());
    double offsetAsc = isHorizontal? lineHeightBox.top(): lineHeightBox.right();
    double offsetDsc = isHorizontal? lineHeightBox.bottom(): lineHeightBox.left();
 
    if (!compare) {
        ascent = offsetAsc;
        descent = offsetDsc;
    } else {
        if (isHorizontal) {
            ascent = qMin(offsetAsc, ascent);
            descent = qMax(offsetDsc, descent);
        } else {
            ascent = qMax(offsetAsc, ascent);
            descent = qMin(offsetDsc, descent);
        }
    }
}

References CharacterResult::lineHeightBox(), and CharacterResult::totalBaselineOffset().

finalizeLine()

void KoSvgTextShapeLayoutFunc::finalizeLine	(	QVector< CharacterResult > &	result,
		QPointF &	currentPos,
		LineBox &	currentLine,
		QPointF &	lineOffset,
		const KoSvgText::TextAnchor	anchor,
		const KoSvgText::WritingMode	writingMode,
		const bool	ltr,
		const bool	inlineSize,
		const bool	textInShape,
		const KoSvgText::ResolutionHandler &	resHandler )

Finalizing the line consists of several steps, like hang/collapse, anchoring into place and offsetting correctly. This can happen several times during a linebreak, hence this convenience function to handle this.

< Because we may have collapsed the last glyph, we'll need to recalculate the total advance;

< Because we may have collapsed the last glyph, we'll need to recalculate the total advance;

Definition at line 321 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    bool isHorizontal = writingMode == KoSvgText::HorizontalTB;
 
    bool firstLine = textInShape? true: currentLine.firstLine;
 
    for (auto currentChunk = currentLine.chunks.begin(); currentChunk != currentLine.chunks.end(); currentChunk++) {
        QMap<int, int> visualToLogical;
        Q_FOREACH (int j, currentChunk->chunkIndices) {
            visualToLogical.insert(result.at(j).visualIndex, j);
        }
        currentPos = lineOffset;
 
        handleCollapseAndHang(result, *currentChunk, ltr, isHorizontal);
 
        QPointF justifyOffset;
        QVector<int> before;
        QVector<int> after;
 
        if (currentLine.justifyLine) {
            double hangingGlyphLength = isHorizontal? currentChunk->conditionalHangEnd.x(): currentChunk->conditionalHangEnd.y();
            QPointF advanceLength; 
            bool first = true;
            Q_FOREACH (int j, visualToLogical.values()) {
                if (!result.at(j).addressable || result.at(j).hidden) {
                    continue;
                }
                advanceLength += result.at(j).advance;
                if (result.at(j).isHanging) {
                    if (result.at(j).anchored_chunk) {
                        hangingGlyphLength += isHorizontal? result.at(j).advance.x(): result.at(j).advance.y();
                    }
                    continue;
                }
                bool last = visualToLogical.values().last() == j;
                if (!last) {
                    last = result.at(j+1).isHanging;
                }
 
                if (result.at(j).justifyBefore && !first) {
                    before.append(j);
                }
                if (result.at(j).justifyAfter && !last) {
                    after.append(j);
                }
                first = false;
            }
 
            int justificationCount = before.size()+after.size();
            if (justificationCount > 0) {
                if (isHorizontal) {
                    double val = currentChunk->length.length() + hangingGlyphLength - advanceLength.x();
                    val = val / justificationCount;
                    justifyOffset = QPointF(val, 0);
                } else {
                    double val = currentChunk->length.length() + hangingGlyphLength - advanceLength.y();
                    val = val / justificationCount;
                    justifyOffset = QPointF(0, val);
                }
            }
        }
 
        Q_FOREACH (const int j, visualToLogical.values()) {
            if (!result.at(j).addressable) {
                continue;
            }
            if ((result.at(j).isHanging && result.at(j).anchored_chunk)) {
                if (ltr) {
                    result[j].cssPosition = currentPos - result.at(j).advance;
                    result[j].finalPosition = result[j].cssPosition;
                } else {
                    result[j].cssPosition = currentPos;
                    result[j].finalPosition = result[j].cssPosition;
                }
            } else {
                if (before.contains(j)) {
                    currentPos += justifyOffset;
                }
                result[j].cssPosition = currentPos;
                result[j].finalPosition = currentPos;
                currentPos = currentPos + result.at(j).advance;
                if (after.contains(j)) {
                    currentPos += justifyOffset;
                }
            }
        }
 
        if (inlineSize) {
            QPointF anchorPoint = currentChunk->length.p1();
            if (textInShape) {
                if (anchor == KoSvgText::AnchorMiddle) {
                    anchorPoint = currentChunk->length.center();
                } else if (anchor == KoSvgText::AnchorEnd) {
                    anchorPoint = currentChunk->length.p2();
                }
            }
            applyInlineSizeAnchoring(result, *currentChunk, anchor, anchorPoint, ltr, isHorizontal, currentLine.textIndent, resHandler);
        } else {
            if (!ltr) {
                // RTL relies on the start being 0.0, so we need to align it to the startAnchor.
                applyInlineSizeAnchoring(result, *currentChunk, KoSvgText::AnchorStart, currentChunk->length.p1(), ltr, isHorizontal, currentLine.textIndent, resHandler);
            } else {
                // this adds a length for preformated text, only useful for debug.
                currentChunk->length.setLength(isHorizontal? currentChunk->boundingBox.width(): currentChunk->boundingBox.height());
            }
        }
    }
    lineOffset += lineHeightOffset(writingMode, result, currentLine, firstLine, resHandler);
    currentPos = lineOffset;
}

References KoSvgText::AnchorEnd, KoSvgText::AnchorMiddle, KoSvgText::AnchorStart, applyInlineSizeAnchoring(), LineBox::chunks, LineBox::firstLine, handleCollapseAndHang(), KoSvgText::HorizontalTB, LineBox::justifyLine, lineHeightOffset(), and LineBox::textIndent.

findLineBoxesForFirstPos()

static QVector< QLineF > KoSvgTextShapeLayoutFunc::findLineBoxesForFirstPos ( QPainterPath shape, QPointF firstPos, const QRectF wordBox, KoSvgText::WritingMode writingMode )

static

Definition at line 259 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    QVector<QLineF> lines;
 
    QLineF baseLine;
    QPointF lineTop;
    QPointF lineBottom;
    QRectF word = wordBox.normalized();
    word.adjust(SHAPE_PRECISION, SHAPE_PRECISION, -SHAPE_PRECISION, -SHAPE_PRECISION);
 
    if (writingMode == KoSvgText::HorizontalTB) {
        baseLine = QLineF(shape.boundingRect().left()-5, firstPos.y(), shape.boundingRect().right()+5, firstPos.y());
        lineTop = QPointF(0, word.top());
        lineBottom = QPointF(0, word.bottom());
    } else {
        baseLine = QLineF(firstPos.x(), shape.boundingRect().top()-5, firstPos.x(), shape.boundingRect().bottom()+5);
        if (writingMode == KoSvgText::VerticalRL) {
            lineTop = QPointF(word.left(), 0);
            lineBottom = QPointF(word.right(), 0);
        } else {
            lineTop = QPointF(word.right(), 0);
            lineBottom = QPointF(word.left(), 0);
        }
    }
 
    QPolygonF polygon = shape.toFillPolygon();
    QList<QPointF> intersects;
    QLineF topLine = baseLine.translated(lineTop);
    QLineF bottomLine = baseLine.translated(lineBottom);
    for(int i = 0; i < polygon.size()-1; i++) {
        QLineF line(polygon.at(i), polygon.at(i+1));
        bool addedA = false;
        QPointF intersectA;
        QPointF intersectB;
        QPointF intersect;
        if (topLine.intersects(line, &intersect) == QLineF::BoundedIntersection) {
            intersectA = intersect-lineTop;
            intersects.append(intersectA);
            addedA = true;
        }
        if (bottomLine.intersects(line, &intersect) == QLineF::BoundedIntersection) {
            intersectB = intersect-lineBottom;
            if (intersectA != intersectB || !addedA) {
                intersects.append(intersectB);
            }
        }
    }
    if (!intersects.isEmpty()) {
        intersects.append(baseLine.p1());
        intersects.append(baseLine.p2());
    }
    if (writingMode == KoSvgText::HorizontalTB) {
        std::sort(intersects.begin(), intersects.end(), pointLessThan);
    } else {
        std::sort(intersects.begin(), intersects.end(), pointLessThanVertical);
    }
 
 
    for (int i = 0; i< intersects.size()-1; i++) {
        QLineF line(intersects.at(i), intersects.at(i+1));
 
        if (!(shape.contains(line.translated(lineTop).center())
              && shape.contains(line.translated(lineBottom).center()))
                || line.length() == 0) {
            continue;
        }
 
        QRectF lineBox = QRectF(line.p1() + lineTop, line.p2() + lineBottom).normalized();
 
        QVector<QPointF> relevant;
        for(int i = 0; i < polygon.size()-1; i++) {
 
            QLineF edgeLine(polygon.at(i), polygon.at(i+1));
 
            if (lineBox.contains(polygon.at(i))) {
                relevant.append(polygon.at(i));
            }
        }
        qreal start = writingMode == KoSvgText::HorizontalTB? lineBox.left(): lineBox.top();
        qreal end = writingMode == KoSvgText::HorizontalTB? lineBox.right(): lineBox.bottom();
        for(int j = 0; j < relevant.size(); j++) {
            QPointF current = relevant.at(j);
 
            if (writingMode == KoSvgText::HorizontalTB) {
                if (current.x() < line.center().x()) {
                    start = qMax(current.x(), start);
                } else if (current.x() > line.center().x()) {
                    end = qMin(current.x(), end);
                }
            } else {
                if (current.y() < line.center().y()) {
                    start = qMax(current.y(), start);
                } else if (current.y() > line.center().y()) {
                    end = qMin(current.y(), end);
                }
            }
        }
        if (writingMode == KoSvgText::HorizontalTB) {
 
            QLineF newLine(start, line.p1().y(), end, line.p2().y());
            if (!lines.isEmpty()) {
                if (lines.last().p2() == intersects.at(i)) {
                    newLine.setP1(lines.last().p1());
                    lines.removeLast();
                }
            }
            lines.append(newLine);
        } else {
            QLineF newLine(line.p1().x(), start, line.p2().x(), end);
            if (!lines.isEmpty()) {
                if (lines.last().p2() == intersects.at(i)) {
                    newLine.setP1(lines.last().p1());
                    lines.removeLast();
                }
            }
            lines.append(newLine);
        }
    }
 
    return lines;
}

References KoSvgText::HorizontalTB, pointLessThan(), pointLessThanVertical(), SHAPE_PRECISION, and KoSvgText::VerticalRL.

flowTextInShapes()

QVector< LineBox > KoSvgTextShapeLayoutFunc::flowTextInShapes	(	const KoSvgTextProperties &	properties,
		const QMap< int, int > &	logicalToVisual,
		QVector< CharacterResult > &	result,
		QList< QPainterPath >	shapes,
		QPointF &	startPos,
		const KoSvgText::ResolutionHandler &	resHandler )

< The textIndent.

< 'word' in this case meaning characters inbetween softbreaks.

< Approximated box of the current word;

< First line will be created proper after we get our first wordbox, this tracks if it's the first.

< Current position with advances of each character.

< Current line offset.

< Whether to break a line.

< The textIndent.

< 'word' in this case meaning characters inbetween softbreaks.

< Approximated box of the current word;

< First line will be created proper after we get our first wordbox, this tracks if it's the first.

< Current position with advances of each character.

< Current line offset.

< Whether to break a line.

Definition at line 441 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    QVector<LineBox> lineBoxes;
    KoSvgText::WritingMode writingMode = KoSvgText::WritingMode(properties.propertyOrDefault(KoSvgTextProperties::WritingModeId).toInt());
    KoSvgText::Direction direction = KoSvgText::Direction(properties.propertyOrDefault(KoSvgTextProperties::DirectionId).toInt());
    bool ltr = direction == KoSvgText::DirectionLeftToRight;
    bool isHorizontal = writingMode == KoSvgText::HorizontalTB;
    KoSvgText::TextAlign align = KoSvgText::TextAlign(properties.propertyOrDefault(KoSvgTextProperties::TextAlignAllId).toInt());
    KoSvgText::TextAlign alignLast = KoSvgText::TextAlign(properties.propertyOrDefault(KoSvgTextProperties::TextAlignLastId).toInt());
    KoSvgText::TextAnchor anchor = textAnchorForTextAlign(align, alignLast, ltr);
 
    QPointF textIndent; 
    KoSvgText::TextIndentInfo textIndentInfo = properties.propertyOrDefault(KoSvgTextProperties::TextIndentId).value<KoSvgText::TextIndentInfo>();
 
    QVector<int> wordIndices; 
    QRectF wordBox; 
    QPointF wordAdvance;
 
    LineBox currentLine;
    bool firstLine = true; 
    bool indentLine = true;
 
    QPointF currentPos = writingMode == KoSvgText::VerticalRL? shapes.at(0).boundingRect().topRight()
                                                             :shapes.at(0).boundingRect().topLeft(); 
    QPointF lineOffset = currentPos; 
 
    QListIterator<int> it(logicalToVisual.keys());
    QListIterator<QPainterPath> shapesIt(shapes);
    if (shapes.isEmpty()) {
        return lineBoxes;
    }
    {
        // Calculate the default pos.
        qreal fontSize = properties.fontSize().value;
        QRectF wordBox = isHorizontal? QRectF(0, fontSize * -0.8, SHAPE_PRECISION, fontSize)
                                     : QRectF(fontSize * -0.5, 0, fontSize, SHAPE_PRECISION);
        getFirstPosition(startPos, shapes.first(), wordBox, currentPos, writingMode, ltr);
    }
    QPainterPath currentShape;
    while (it.hasNext()) {
        int index = it.next();
        result[index].calculateAndApplyTabsize(wordAdvance + currentPos, isHorizontal, resHandler);
        CharacterResult charResult = result.at(index);
        if (!charResult.addressable) {
            continue;
        }
 
        bool softBreak = false; 
        bool doNotCountAdvance =
            ((charResult.lineEnd != LineEdgeBehaviour::NoChange)
             && !(currentLine.isEmpty() && wordIndices.isEmpty()));
        if (!doNotCountAdvance) {
            if (wordIndices.isEmpty()) {
                wordBox = charResult.lineHeightBox().translated(charResult.totalBaselineOffset());
                wordAdvance = charResult.advance;
            } else {
                wordBox |= charResult.lineHeightBox().translated(wordAdvance+charResult.totalBaselineOffset());
                wordAdvance += charResult.advance;
            }
        }
        wordIndices.append(index);
        currentLine.lastLine = !it.hasNext();
        if (currentLine.lastLine) {
            currentLine.justifyLine = alignLast == KoSvgText::AlignJustify;
        }
 
        if (charResult.breakType != BreakType::NoBreak || currentLine.lastLine) {
            if (currentLine.chunks.isEmpty() || currentLine.lastLine) {
                softBreak = true;
            }
 
            for (int i = currentLine.currentChunk; i < currentLine.chunks.size(); i++) {
                if (i == -1) {
                    currentLine.currentChunk = 0;
                    i = 0;
                }
                QLineF line = currentLine.chunks.value(i).length;
                qreal lineLength = isHorizontal ? (currentPos - line.p1() + wordAdvance).x()
                                                : (currentPos - line.p1() + wordAdvance).y();
                if (qRound((abs(lineLength) - line.length())) > 0) {
                    if (i == currentLine.chunks.size()-1) {
                        softBreak = true;
                        break;
                    } else {
                        QLineF nextLine = currentLine.chunks.value(i+1).length;
                        if (isHorizontal) {
                            currentPos.setX(ltr? qMax(nextLine.p1().x(), currentPos.x()):
                                                 qMin(nextLine.p1().x(), currentPos.x()));
                        } else {
                            currentPos.setY(nextLine.p1().y());
                        }
                    }
                } else {
                    currentLine.currentChunk = i;
                    addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
                    break;
                }
            }
        }
 
        if (softBreak) {
            if (!currentLine.isEmpty()) {
                finalizeLine(result, currentPos, currentLine, lineOffset, anchor, writingMode, ltr, true, true, resHandler);
                lineBoxes.append(currentLine);
                firstLine = false;
                indentLine = false;
            }
            // Not adding indent to the (first) word box means it'll overflow if there's no room,
            // but being too strict might end with the whole text disappearing. Given Krita's text layout is
            // in an interactive context, ugly result might be more communicative than all text disappearing.
            bool ind = textIndentInfo.hanging? !indentLine: indentLine;
            QPointF indent = ind? textIndent: QPointF();
            bool foundFirst = false;
            bool needNewLine = true;
            // add text indent to wordbox.
            if (!currentShape.isEmpty()) {
                // we're going to try and get an offset line first before trying get first pos.
                // This gives more stable results on curved shapes.
                getEstimatedHeight(result, index, wordBox, currentShape.boundingRect(), writingMode);
                currentPos -= writingMode == KoSvgText::VerticalRL? wordBox.topRight(): wordBox.topLeft();
 
                currentLine = LineBox(findLineBoxesForFirstPos(currentShape, currentPos, wordBox, writingMode), ltr, indent, resHandler);
                qreal length = isHorizontal? wordBox.width(): wordBox.height();
                for (int i = 0; i < currentLine.chunks.size(); i++) {
                    if (currentLine.chunks.at(i).length.length() > length) {
                        currentLine.currentChunk = i;
                        foundFirst = true;
                        needNewLine = false;
                        break;
                    }
                }
            }
            /*
             * In theory we could have overflow wrap for shapes, but it'd require either generalizing
             * the line-filling portion above and this new line seeking portion, or somehow reverting
             * the iterator over the results to be on the last fitted glyph (which'd still require
             * generalizing the line-filling portion about), and I am unsure how to do that.
             * Either way, this place here is where you'd check for overflow wrap.
             */
            while(!foundFirst) {
                foundFirst = getFirstPosition(currentPos, currentShape, wordBox, lineOffset, writingMode, ltr);
                if (foundFirst || !shapesIt.hasNext()) {
                    break;
                }
                currentShape = shapesIt.next();
                getEstimatedHeight(result, index, wordBox, currentShape.boundingRect(), writingMode);
                bool indentPercent = textIndentInfo.length.unit == KoSvgText::CssLengthPercentage::Percentage;
                qreal textIdentValue = textIndentInfo.length.value;
                if (isHorizontal) {
                    if (indentPercent) {
                        textIdentValue *= currentShape.boundingRect().width();
                    }
                    textIndent = resHandler.adjust(QPointF(textIdentValue, 0));
                } else {
                    if (indentPercent) {
                        textIdentValue *= currentShape.boundingRect().height();
                    }
                    textIndent = resHandler.adjust(QPointF(0, textIdentValue));
                }
                bool ind = textIndentInfo.hanging? !indentLine: indentLine;
                indent = ind? textIndent: QPointF();
                currentPos = writingMode == KoSvgText::VerticalRL? currentShape.boundingRect().topRight(): currentShape.boundingRect().topLeft();
                lineOffset = currentPos;
            }
 
            bool lastDitch = false;
            if (!foundFirst && firstLine && !wordIndices.isEmpty() && !currentShape.isEmpty()) {
                // Last-ditch attempt to get any kind of positioning to happen.
                // This typically happens when wrapping has been disabled.
                wordBox = result[wordIndices.first()].lineHeightBox().translated(result[wordIndices.first()].totalBaselineOffset());
                foundFirst = getFirstPosition(currentPos, currentShape, wordBox, lineOffset, writingMode, ltr);
                lastDitch = true;
            }
 
            if (foundFirst) {
 
                if (needNewLine) {
                    currentLine = LineBox(findLineBoxesForFirstPos(currentShape, currentPos, wordBox, writingMode), ltr, indent, resHandler);
                    // We could set this to find the first fitting width, but it's better to try and improve the precision of the firstpos algorithm,
                    // as this gives more stable results.
                    currentLine.setCurrentChunkForPos(currentPos, isHorizontal);
                }
                const qreal expectedLineT = isHorizontal? wordBox.top():
                                                          writingMode == KoSvgText::VerticalRL? wordBox.right(): wordBox.left();
 
                currentLine.firstLine = firstLine;
                currentLine.expectedLineTop = expectedLineT;
                currentLine.justifyLine = align == KoSvgText::AlignJustify;
                currentPos = currentLine.chunk().length.p1() + indent;
                lineOffset = currentPos;
 
                if (lastDitch) {
                    QVector<int> wordNew;
                    QPointF advance = currentPos;
                    Q_FOREACH(const int i, wordIndices) {
                        advance += result[i].advance;
                        if (currentShape.contains(advance)) {
                            wordNew.append(i);
                        } else {
                            result[i].hidden = true;
                            result[i].cssPosition = advance-result[i].advance;
                        }
                        wordIndices = wordNew;
                    }
                }
                addWordToLine(result, currentPos, wordIndices, currentLine, ltr, isHorizontal);
            } else {
                currentLine = LineBox();
                QPointF advance = currentPos;
                Q_FOREACH (const int j, wordIndices) {
                    result[j].cssPosition = advance;
                    advance += result[j].advance;
                    result[j].hidden = true;
                }
            }
        }
 
        if (charResult.breakType == BreakType::HardBreak) {
            finalizeLine(result, currentPos, currentLine, lineOffset, anchor, writingMode, ltr, true, true, resHandler);
            lineBoxes.append(currentLine);
            currentLine = LineBox();
            indentLine = textIndentInfo.hanging? false: textIndentInfo.eachLine;
        }
    }
    finalizeLine(result, currentPos, currentLine, lineOffset, anchor, writingMode, ltr, true, true, resHandler);
    lineBoxes.append(currentLine);
    return lineBoxes;
}

References CharacterResult::addressable, addWordToLine(), KoSvgText::ResolutionHandler::adjust(), CharacterResult::advance, KoSvgText::AlignJustify, CharacterResult::breakType, LineBox::chunk(), LineBox::chunks, LineBox::currentChunk, KoSvgTextProperties::DirectionId, KoSvgText::DirectionLeftToRight, KoSvgText::TextIndentInfo::eachLine, LineBox::expectedLineTop, finalizeLine(), findLineBoxesForFirstPos(), LineBox::firstLine, KoSvgTextProperties::fontSize(), getEstimatedHeight(), getFirstPosition(), KoSvgText::TextIndentInfo::hanging, HardBreak, KoSvgText::HorizontalTB, LineBox::isEmpty(), LineBox::justifyLine, LineBox::lastLine, KoSvgText::TextIndentInfo::length, LineChunk::length, length(), CharacterResult::lineEnd, CharacterResult::lineHeightBox(), NoBreak, NoChange, KoSvgText::CssLengthPercentage::Percentage, KoSvgTextProperties::propertyOrDefault(), LineBox::setCurrentChunkForPos(), SHAPE_PRECISION, KoSvgTextProperties::TextAlignAllId, KoSvgTextProperties::TextAlignLastId, textAnchorForTextAlign(), KoSvgTextProperties::TextIndentId, CharacterResult::totalBaselineOffset(), KoSvgText::CssLengthPercentage::unit, KoSvgText::CssLengthPercentage::value, KoSvgText::VerticalRL, and KoSvgTextProperties::WritingModeId.

getEstimatedHeight()

static void KoSvgTextShapeLayoutFunc::getEstimatedHeight ( QVector< CharacterResult > & result, const int index, QRectF & wordBox, const QRectF boundingBox, KoSvgText::WritingMode writingMode )

static

getEstimatedHeight Adjust the wordbox with the estimated height.

Definition at line 386 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    bool isHorizontal = writingMode == KoSvgText::HorizontalTB;
    QPointF totalAdvance = wordBox.bottomRight() - wordBox.topLeft();
    qreal maxAscent = isHorizontal? wordBox.top(): wordBox.right();
    qreal maxDescent = isHorizontal? wordBox.bottom(): wordBox.left();
 
    for (int i=index; i<result.size(); i++) {
        if (!result.at(i).addressable || result.at(i).hidden) {
            continue;
        }
        totalAdvance += result.at(i).advance;
        if ((totalAdvance.x() > boundingBox.width() && isHorizontal) ||
                (totalAdvance.y() > boundingBox.height() && !isHorizontal)) {
            break;
        }
        calculateLineHeight(result.at(i), maxAscent, maxDescent, isHorizontal, true);
    }
    if (writingMode == KoSvgText::HorizontalTB) {
        wordBox.setTop(maxAscent);
        wordBox.setBottom(maxDescent);
    } else {
        // vertical lr has top at the right even though block flow is also to the right.
        wordBox.setRight(maxAscent);
        wordBox.setLeft(maxDescent);
    }
}

References calculateLineHeight(), and KoSvgText::HorizontalTB.

getFirstPosition()

static bool KoSvgTextShapeLayoutFunc::getFirstPosition ( QPointF & firstPoint, QPainterPath p, QRectF wordBox, QPointF terminator, KoSvgText::WritingMode writingMode, bool ltr )

static

Precision of fitting the word box into the polygon to account for floating-point precision error.

Definition at line 90 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    if (wordBox.isEmpty()) {
        // line-height: 0 will give us empty rects, make them slightly tall/wide
        // to avoid issues with complex QRectF operations.
        if (writingMode == KoSvgText::HorizontalTB) {
            wordBox.setHeight(1e-3);
        } else {
            wordBox.setWidth(1e-3);
        }
    }
 
 
    QVector<QPointF> candidatePositions;
    QRectF word = wordBox.normalized();
    word.translate(-wordBox.topLeft());
    // Slightly shrink the box to account for precision error.
    word.adjust(SHAPE_PRECISION, SHAPE_PRECISION, -SHAPE_PRECISION, -SHAPE_PRECISION);
 
    QPointF terminatorAdjusted = terminator;
    Q_FOREACH(const QPolygonF polygon, p.toFillPolygons()) {
        QVector<QLineF> offsetPoly;
        for(int i = 0; i < polygon.size()-1; i++) {
            QLineF line;
            line.setP1(polygon.at(i));
            line.setP2(polygon.at(i+1));
 
            if (line.angle() == 0.0 || line.angle() == 180.0) {
                qreal offset = word.center().y();
                offsetPoly.append(line.translated(0, offset));
                offsetPoly.append(line.translated(0, -offset));
            } else if (line.angle() == 90.0 || line.angle() == 270.0) {
                qreal offset = word.center().x();
                offsetPoly.append(line.translated(offset, 0));
                offsetPoly.append(line.translated(-offset, 0));
            } else {
                qreal tAngle = fmod(line.angle(), 180.0);
                QPointF cPos = tAngle > 90? line.center() + QPointF(-word.center().x(), word.center().y()): line.center() + word.center();
                qreal offset = kisDistanceToLine(cPos, line);
                const QPointF vectorT(qCos(qDegreesToRadians(tAngle)), -qSin(qDegreesToRadians(tAngle)));
                QPointF vectorN(-vectorT.y(), vectorT.x());
                QPointF offsetP = QPointF() - (0.0 * vectorT) + (offset * vectorN);
                offsetPoly.append(line.translated(offsetP));
                offsetPoly.append(line.translated(-offsetP));
            }
        }
        if (writingMode == KoSvgText::HorizontalTB) {
            terminatorAdjusted = terminator + word.center();
            QLineF top(polygon.boundingRect().topLeft(), polygon.boundingRect().topRight());
            offsetPoly.append(top.translated(0, terminatorAdjusted.y()));
        } else if (writingMode == KoSvgText::VerticalRL) {
            terminatorAdjusted = terminator - word.center();
            QLineF top(terminatorAdjusted.x(), polygon.boundingRect().top(),
                       terminatorAdjusted.x(), polygon.boundingRect().bottom());
            offsetPoly.append(top);
        } else{
            terminatorAdjusted = terminator + word.center();
            QLineF top(terminatorAdjusted.x(), polygon.boundingRect().top(),
                       terminatorAdjusted.x(), polygon.boundingRect().bottom());
            offsetPoly.append(top);
        }
        for (int i=0; i < offsetPoly.size(); i++) {
            QLineF line = offsetPoly.at(i);
            for (int j=i; j< offsetPoly.size(); j++){
                QLineF line2 = offsetPoly.at(j);
                QPointF intersectPoint;
                QLineF::IntersectType intersect = line.intersects(line2, &intersectPoint);
                if (intersect != QLineF::NoIntersection) {
                    // should proly handle 'reflex' vertices better.
                    if (!p.contains(intersectPoint)) {
                        continue;
                    }
                    if(!p.contains(word.translated(intersectPoint-word.center()))) {
                        continue;
                    }
                    if (!candidatePositions.contains(intersectPoint)) {
                        candidatePositions.append(intersectPoint);
                    }
                }
            }
        }
    }
    if (candidatePositions.isEmpty()) {
        return false;
    }
 
    QPointF firstPointC = writingMode == KoSvgText::VerticalRL? p.boundingRect().bottomLeft(): p.boundingRect().bottomRight();
    Q_FOREACH(const QPointF candidate, candidatePositions) {
        if (writingMode == KoSvgText::HorizontalTB) {
            if (terminatorAdjusted.y() - candidate.y() < SHAPE_PRECISION) {
 
                if (firstPointC.y() - candidate.y() > SHAPE_PRECISION) {
                    firstPointC = candidate;
                } else if (firstPointC.y() - candidate.y() > -SHAPE_PRECISION) {
                    if (ltr) {
                        if (candidate.x() < firstPointC.x()) {
                            firstPointC = candidate;
                        }
                    } else {
                        if (candidate.x() > firstPointC.x()) {
                            firstPointC = candidate;
                        }
                    }
                }
            }
        } else if (writingMode == KoSvgText::VerticalRL) {
            if (terminatorAdjusted.x() - candidate.x() >= -SHAPE_PRECISION) {
 
                if (firstPointC.x() - candidate.x() < -SHAPE_PRECISION) {
                    firstPointC = candidate;
                } else if (firstPointC.x() - candidate.x() < SHAPE_PRECISION) {
                    if (ltr) {
                        if (candidate.y() < firstPointC.y()) {
                            firstPointC = candidate;
                        }
                    } else {
                        if (candidate.y() > firstPointC.y()) {
                            firstPointC = candidate;
                        }
                    }
                }
            }
        } else {
            if (terminatorAdjusted.x() - candidate.x() < SHAPE_PRECISION) {
 
                if (firstPointC.x() - candidate.x() > SHAPE_PRECISION) {
                    firstPointC = candidate;
                } else if (firstPointC.x() - candidate.x() > -SHAPE_PRECISION) {
                    if (ltr) {
                        if (candidate.y() < firstPointC.y()) {
                            firstPointC = candidate;
                        }
                    } else {
                        if (candidate.y() > firstPointC.y()) {
                            firstPointC = candidate;
                        }
                    }
                }
            }
        }
    }
    if (!p.contains(firstPointC)) {
        return false;
    }
    firstPointC -= word.center();
    firstPointC -= wordBox.topLeft();
    firstPoint = firstPointC;
 
    return true;
}

References KoSvgText::HorizontalTB, kisDistanceToLine(), p, SHAPE_PRECISION, and KoSvgText::VerticalRL.

getShapes()

QList< QPainterPath > KoSvgTextShapeLayoutFunc::getShapes	(	QList< KoShape * >	shapesInside,
		QList< KoShape * >	shapesSubtract,
		const KoSvgTextProperties &	properties )

Definition at line 26 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    // the boost polygon method requires (and gives best result) on a inter-based polygon,
    // so we need to scale up. The scale selected here is the size freetype coordinates give to a single pixel.
    qreal scale = 64.0;
    QTransform precisionTF = QTransform::fromScale(scale, scale);
 
    qreal shapePadding = scale * properties.propertyOrDefault(KoSvgTextProperties::ShapePaddingId).toReal();
    qreal shapeMargin = scale * properties.propertyOrDefault(KoSvgTextProperties::ShapeMarginId).toReal();
 
    QPainterPath subtract;
    Q_FOREACH(const KoShape *shape, shapesSubtract) {
        const KoPathShape *path = dynamic_cast<const KoPathShape*>(shape);
        if (path) {
            QPainterPath p = path->transformation().map(path->outline());
            p.setFillRule(path->fillRule());
            // grow each polygon here with the shape margin size.
            if (shapeMargin > 0) {
                QList<QPolygon> subpathPolygons;
                Q_FOREACH(QPolygonF subPath, p.toSubpathPolygons()) {
                    subpathPolygons.append(precisionTF.map(subPath).toPolygon());
                }
                subpathPolygons = KoPolygonUtils::offsetPolygons(subpathPolygons, shapeMargin);
                p.clear();
                Q_FOREACH (const QPolygon poly, subpathPolygons) {
                    p.addPolygon(poly);
                }
            } else {
                p = precisionTF.map(p);
            }
            subtract.addPath(p);
        }
    }
 
    QList<QPainterPath> shapes;
    Q_FOREACH(const KoShape *shape, shapesInside) {
        const KoPathShape *path = dynamic_cast<const KoPathShape*>(shape);
        if (path) {
            QPainterPath p = path->transformation().map(path->outline());
            p.setFillRule(path->fillRule());
            QPainterPath p2;
            p2.setFillRule(path->fillRule());
 
            QList<QPolygon> subpathPolygons;
            Q_FOREACH(QPolygonF subPath, p.toSubpathPolygons()) {
                subpathPolygons.append(precisionTF.map(subPath).toPolygon());
            }
            subpathPolygons = KoPolygonUtils::offsetPolygons(subpathPolygons, -shapePadding);
 
            for (int i=0; i < subpathPolygons.size(); i++) {
                QPolygonF subpathPoly = subpathPolygons.at(i);
                Q_FOREACH(QPolygonF subtractPoly, subtract.toSubpathPolygons()) {
                    if (subpathPoly.intersects(subtractPoly)) {
                        subpathPoly = subpathPoly.subtracted(subtractPoly);
                    }
                }
                p2.addPolygon(subpathPoly);
            }
            shapes.append(precisionTF.inverted().map(p2));
        }
    }
    return shapes;
}

References KoPolygonUtils::offsetPolygons(), p, p2, KoSvgTextProperties::propertyOrDefault(), KoSvgTextProperties::ShapeMarginId, KoSvgTextProperties::ShapePaddingId, and KoShape::transformation().

handleCollapseAndHang()

static void KoSvgTextShapeLayoutFunc::handleCollapseAndHang ( QVector< CharacterResult > & result, LineChunk & chunk, bool ltr, bool isHorizontal )

static

Definition at line 194 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    QVector<int> lineIndices = chunk.chunkIndices;
    QPointF endPos = chunk.length.p2();
 
    if (!lineIndices.isEmpty()) {
        QVectorIterator<int> it(lineIndices);
        it.toBack();
        while (it.hasPrevious()) {
            int lastIndex = it.previous();
            if (result.at(lastIndex).lineEnd == LineEdgeBehaviour::Collapse) {
                result[lastIndex].hidden = true;
                // We literally collapse the advance of the last collapsed white-space to ensure it may
                // still be possible to track it by cursor movement.
                result[lastIndex].advance = QPointF();
                if (isHorizontal) {
                    result[lastIndex].inkBoundingBox.setWidth(0);
                } else {
                    result[lastIndex].inkBoundingBox.setHeight(0);
                }
            } else if (result.at(lastIndex).lineEnd == LineEdgeBehaviour::ConditionallyHang) {
                if (ltr) {
                    QPointF hangPos = result[lastIndex].cssPosition + result[lastIndex].advance;
                    if (isHorizontal) {
                        if (hangPos.x() > endPos.x()) {
                            result[lastIndex].isHanging = true;
                            chunk.conditionalHangEnd = hangPos - endPos;
                        }
                    } else {
                        if (hangPos.y() > endPos.y()) {
                            result[lastIndex].isHanging = true;
                            chunk.conditionalHangEnd = hangPos - endPos;
                        }
                    }
                } else {
                    QPointF hangPos = result[lastIndex].cssPosition;
                    if (hangPos.x() < endPos.x()) {
                        result[lastIndex].isHanging = true;
                        chunk.conditionalHangEnd = hangPos - endPos;
                    }
                }
 
            } else if (result.at(lastIndex).lineEnd == LineEdgeBehaviour::ForceHang) {
                result[lastIndex].isHanging = true;
                chunk.conditionalHangEnd = result[lastIndex].advance;
            }
            if (result.at(lastIndex).lineEnd != LineEdgeBehaviour::Collapse) {
                break;
            }
        }
    }
}

References LineChunk::chunkIndices, Collapse, LineChunk::conditionalHangEnd, ConditionallyHang, ForceHang, and LineChunk::length.

lineHeightOffset()

static QPointF KoSvgTextShapeLayoutFunc::lineHeightOffset ( KoSvgText::WritingMode writingMode, QVector< CharacterResult > & result, LineBox & currentLine, const bool firstLine, const KoSvgText::ResolutionHandler resHandler )

static

This offsets the last line by it's ascent, and then returns the last line's descent.

< This is for determining the difference between a predicted line-height (for text-in-shape) and the actual line-height. Note: this is required to be positive.

When the line is empty, but caused by a hardbreak, we will need to use that hardbreak to space the line. This can only be done at this point as it would otherwise need to use visible characters.

Definition at line 103 of file KoSvgTextShapeLayoutFunc_lines.cpp.

{
    QPointF lineTop;
    QPointF lineBottom;
    QPointF correctionOffset; 
 
    if (currentLine.chunks.isEmpty()) {
        return QPointF();
    } else if (currentLine.chunks.size() == 1 && currentLine.actualLineTop == 0 &&
               currentLine.actualLineBottom == 0){
        QVector<int> chunkIndices = currentLine.chunks[0].chunkIndices;
        if (chunkIndices.size() > 0) {
            CharacterResult cr = result[chunkIndices.first()];
            calculateLineHeight(cr,
                                currentLine.actualLineTop,
                                currentLine.actualLineBottom,
                                writingMode == KoSvgText::HorizontalTB,
                                false);
            result[chunkIndices.first()].anchored_chunk = true;
        }
    }
 
    // We do qmin/qmax here so that later, the correction offset will not go below either value.
    const qreal expectedLineTop = writingMode == KoSvgText::HorizontalTB? qMin(currentLine.expectedLineTop, currentLine.actualLineTop):
                                                                          qMax(currentLine.expectedLineTop, currentLine.actualLineTop);
    if (writingMode == KoSvgText::HorizontalTB) {
        currentLine.baselineTop = QPointF(0, currentLine.actualLineTop);
        currentLine.baselineBottom = QPointF(0, currentLine.actualLineBottom);
        correctionOffset = QPointF(0, -expectedLineTop) + currentLine.baselineTop;
        lineTop = -currentLine.baselineTop;
        lineBottom = currentLine.baselineBottom;
    } else if (writingMode == KoSvgText::VerticalLR) {
        currentLine.baselineTop = QPointF(currentLine.actualLineTop, 0);
        currentLine.baselineBottom = QPointF(currentLine.actualLineBottom, 0);
        correctionOffset = QPointF(-expectedLineTop, 0) + currentLine.baselineTop;
        // Note: while Vertical LR goes left-to-right in its lines, its lines themselves are
        // oriented with the top pointed in the positive x direction.
        lineBottom = currentLine.baselineTop;
        lineTop = -currentLine.baselineBottom;
    } else {
        currentLine.baselineTop = QPointF(currentLine.actualLineTop, 0);
        currentLine.baselineBottom = QPointF(currentLine.actualLineBottom, 0);
        correctionOffset = QPointF(expectedLineTop, 0) - currentLine.baselineTop;
        lineTop = -currentLine.baselineTop;
        lineBottom = currentLine.baselineBottom;
    }
    bool returnDescent = firstLine;
    QPointF offset = resHandler.adjust(lineTop + lineBottom);
    if (resHandler.roundToPixelHorizontal || resHandler.roundToPixelVertical) {
        lineTop = offset - resHandler.adjust(lineBottom);
        correctionOffset = resHandler.adjust(correctionOffset);
    }
 
    if (!returnDescent) {
        for (auto chunk = currentLine.chunks.begin(); chunk != currentLine.chunks.end(); chunk++) {
            Q_FOREACH (int j, chunk->chunkIndices) {
                result[j].cssPosition += lineTop;
                result[j].cssPosition += result[j].totalBaselineOffset();
                result[j].finalPosition = result.at(j).cssPosition;
            }
            chunk->length.translate(lineTop);
            chunk->boundingBox.translate(lineTop);
        }
    } else {
        offset = lineBottom - correctionOffset;
        for (auto chunk = currentLine.chunks.begin(); chunk != currentLine.chunks.end(); chunk++) {
            Q_FOREACH (int j, chunk->chunkIndices) {
                result[j].cssPosition -= correctionOffset;
                result[j].cssPosition = result[j].cssPosition + result[j].totalBaselineOffset();
                result[j].finalPosition = result.at(j).cssPosition;
            }
            chunk->length.translate(-correctionOffset);
            chunk->boundingBox.translate(-correctionOffset);
        }
    }
    return resHandler.adjust(offset);
}

References LineBox::actualLineBottom, LineBox::actualLineTop, KoSvgText::ResolutionHandler::adjust(), LineBox::baselineBottom, LineBox::baselineTop, calculateLineHeight(), LineBox::chunks, LineBox::expectedLineTop, KoSvgText::HorizontalTB, KoSvgText::ResolutionHandler::roundToPixelHorizontal, KoSvgText::ResolutionHandler::roundToPixelVertical, and KoSvgText::VerticalLR.

pointLessThan()

static bool KoSvgTextShapeLayoutFunc::pointLessThan ( const QPointF & a, const QPointF & b )

static

Definition at line 248 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    return a.x() < b.x();
}

pointLessThanVertical()

static bool KoSvgTextShapeLayoutFunc::pointLessThanVertical ( const QPointF & a, const QPointF & b )

static

Definition at line 253 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    return a.y() < b.y();
}

textAnchorForTextAlign()

static KoSvgText::TextAnchor KoSvgTextShapeLayoutFunc::textAnchorForTextAlign ( KoSvgText::TextAlign align, KoSvgText::TextAlign alignLast, bool ltr )

static

Definition at line 419 of file KoSvgTextShapeLayoutFunc_inShape.cpp.

{
    KoSvgText::TextAlign compare = align;
    if (align == KoSvgText::AlignJustify) {
        compare = alignLast;
    }
    if (compare == KoSvgText::AlignStart) {
        return KoSvgText::AnchorStart;
    } else if (compare == KoSvgText::AlignCenter) {
        return KoSvgText::AnchorMiddle;
    } else if (compare == KoSvgText::AlignEnd) {
        return KoSvgText::AnchorEnd;
    } else if (compare == KoSvgText::AlignLeft) {
        return ltr? KoSvgText::AnchorStart: KoSvgText::AnchorEnd;
    } else if (compare == KoSvgText::AlignRight) {
        return ltr? KoSvgText::AnchorEnd: KoSvgText::AnchorStart;
    } else if (align == KoSvgText::AlignJustify) {
        return KoSvgText::AnchorMiddle;
    }
    return KoSvgText::AnchorStart;
}

References KoSvgText::AlignCenter, KoSvgText::AlignEnd, KoSvgText::AlignJustify, KoSvgText::AlignLeft, KoSvgText::AlignRight, KoSvgText::AlignStart, KoSvgText::AnchorEnd, KoSvgText::AnchorMiddle, and KoSvgText::AnchorStart.