bool SVGTextLayoutEngine::currentLogicalCharacterMetrics(SVGTextLayoutAttributes*& logicalAttributes, SVGTextMetrics& logicalMetrics)
{
const Vector<SVGTextMetrics>* textMetricsValues = &logicalAttributes->textMetricsValues();
unsigned textMetricsSize = textMetricsValues->size();
while (true) {
if (m_logicalMetricsListOffset == textMetricsSize) {
if (!currentLogicalCharacterAttributes(logicalAttributes))
return false;
textMetricsValues = &logicalAttributes->textMetricsValues();
textMetricsSize = textMetricsValues->size();
continue;
}
ASSERT(textMetricsSize);
ASSERT(m_logicalMetricsListOffset < textMetricsSize);
logicalMetrics = textMetricsValues->at(m_logicalMetricsListOffset);
if (logicalMetrics.isEmpty() || (!logicalMetrics.width() && !logicalMetrics.height())) {
advanceToNextLogicalCharacter(logicalMetrics);
continue;
}
// Stop if we found the next valid logical text metrics object.
return true;
}
ASSERT_NOT_REACHED();
return true;
}
bool SVGTextQuery::endPositionOfCharacterCallback(Data* queryData, const SVGTextFragment& fragment) const
{
EndPositionOfCharacterData* data = static_cast<EndPositionOfCharacterData*>(queryData);
int startPosition = data->position;
int endPosition = startPosition + 1;
if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
return false;
data->endPosition = FloatPoint(fragment.x, fragment.y);
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textRenderer, fragment.characterOffset, startPosition + 1);
if (queryData->isVerticalText)
data->endPosition.move(0, metrics.height());
else
data->endPosition.move(metrics.width(), 0);
AffineTransform fragmentTransform;
fragment.buildFragmentTransform(fragmentTransform, SVGTextFragment::TransformIgnoringTextLength);
if (fragmentTransform.isIdentity())
return true;
data->endPosition = fragmentTransform.mapPoint(data->endPosition);
return true;
}
static void measureTextRenderer(RenderSVGInlineText* text, MeasureTextData* data, bool processRenderer)
{
ASSERT(text);
SVGTextLayoutAttributes* attributes = text->layoutAttributes();
Vector<SVGTextMetrics>* textMetricsValues = &attributes->textMetricsValues();
if (processRenderer) {
if (data->allCharactersMap)
attributes->clear();
else
textMetricsValues->clear();
}
SVGTextMetricsCalculator calculator(text);
bool preserveWhiteSpace = text->style()->whiteSpace() == PRE;
unsigned surrogatePairCharacters = 0;
unsigned skippedCharacters = 0;
unsigned textPosition = 0;
unsigned textLength = calculator.textLength();
SVGTextMetrics currentMetrics;
for (; textPosition < textLength; textPosition += currentMetrics.length()) {
currentMetrics = calculator.computeMetricsForCharacter(textPosition);
if (!currentMetrics.length())
break;
bool characterIsWhiteSpace = calculator.characterIsWhiteSpace(textPosition);
if (characterIsWhiteSpace && !preserveWhiteSpace && data->lastCharacterWasWhiteSpace) {
if (processRenderer)
textMetricsValues->append(SVGTextMetrics(SVGTextMetrics::SkippedSpaceMetrics));
if (data->allCharactersMap)
skippedCharacters += currentMetrics.length();
continue;
}
if (processRenderer) {
if (data->allCharactersMap) {
const SVGCharacterDataMap::const_iterator it = data->allCharactersMap->find(data->valueListPosition + textPosition - skippedCharacters - surrogatePairCharacters + 1);
if (it != data->allCharactersMap->end())
attributes->characterDataMap().set(textPosition + 1, it->value);
}
textMetricsValues->append(currentMetrics);
}
if (data->allCharactersMap && calculator.characterStartsSurrogatePair(textPosition))
surrogatePairCharacters++;
data->lastCharacterWasWhiteSpace = characterIsWhiteSpace;
}
if (!data->allCharactersMap)
return;
data->valueListPosition += textPosition - skippedCharacters;
}
float SVGTextLayoutEngineBaseline::calculateGlyphAdvanceAndOrientation(bool isVerticalText, const SVGTextMetrics& metrics, float angle, float& xOrientationShift, float& yOrientationShift) const
{
bool orientationIsMultiplyOf180Degrees = glyphOrientationIsMultiplyOf180Degrees(angle);
// The function is based on spec requirements:
//
// Spec: If the 'glyph-orientation-horizontal' results in an orientation angle that is not a multiple of
// of 180 degrees, then the current text position is incremented according to the vertical metrics of the glyph.
//
// Spec: If if the 'glyph-orientation-vertical' results in an orientation angle that is not a multiple of
// 180 degrees, then the current text position is incremented according to the horizontal metrics of the glyph.
const FontMetrics& fontMetrics = m_font.fontMetrics();
float ascent = fontMetrics.floatAscent() / m_effectiveZoom;
float descent = fontMetrics.floatDescent() / m_effectiveZoom;
// Vertical orientation handling.
if (isVerticalText) {
float ascentMinusDescent = ascent - descent;
if (!angle) {
xOrientationShift = (ascentMinusDescent - metrics.width()) / 2;
yOrientationShift = ascent;
} else if (angle == 180) {
xOrientationShift = (ascentMinusDescent + metrics.width()) / 2;
} else if (angle == 270) {
yOrientationShift = metrics.width();
xOrientationShift = ascentMinusDescent;
}
// Vertical advance calculation.
if (angle && !orientationIsMultiplyOf180Degrees)
return metrics.width();
return metrics.height();
}
// Horizontal orientation handling.
if (angle == 90) {
yOrientationShift = -metrics.width();
} else if (angle == 180) {
xOrientationShift = metrics.width();
yOrientationShift = -ascent;
} else if (angle == 270) {
xOrientationShift = metrics.width();
}
// Horizontal advance calculation.
if (angle && !orientationIsMultiplyOf180Degrees)
return metrics.height();
return metrics.width();
}
void SVGTextLayoutAttributesBuilder::propagateLayoutAttributes(RenderObject* start, unsigned& atCharacter, UChar& lastCharacter) const
{
for (RenderObject* child = start->firstChild(); child; child = child->nextSibling()) {
if (child->isSVGInlineText()) {
RenderSVGInlineText* text = toRenderSVGInlineText(child);
const UChar* characters = text->characters();
unsigned textLength = text->textLength();
bool preserveWhiteSpace = shouldPreserveAllWhiteSpace(text->style());
SVGTextLayoutAttributes attributes;
attributes.reserveCapacity(textLength);
unsigned valueListPosition = atCharacter;
unsigned metricsLength = 1;
for (unsigned textPosition = 0; textPosition < textLength; textPosition += metricsLength) {
const UChar& currentCharacter = characters[textPosition];
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(text, textPosition, 1);
metricsLength = metrics.length();
if (!preserveWhiteSpace && characterIsSpace(currentCharacter) && characterIsSpaceOrNull(lastCharacter)) {
assignEmptyLayoutAttributesForCharacter(attributes);
attributes.textMetricsValues().append(SVGTextMetrics::emptyMetrics());
continue;
}
assignLayoutAttributesForCharacter(attributes, metrics, valueListPosition);
if (metricsLength > 1) {
for (unsigned i = 0; i < metricsLength - 1; ++i)
assignEmptyLayoutAttributesForCharacter(attributes);
}
lastCharacter = currentCharacter;
valueListPosition += metricsLength;
}
#if DUMP_TEXT_LAYOUT_ATTRIBUTES > 0
fprintf(stderr, "\nDumping layout attributes for RenderSVGInlineText, renderer=%p, node=%p (atCharacter: %i)\n", text, text->node(), atCharacter);
attributes.dump();
#endif
text->storeLayoutAttributes(attributes);
atCharacter = valueListPosition;
continue;
}
if (!child->isSVGInline())
continue;
propagateLayoutAttributes(child, atCharacter, lastCharacter);
}
}
bool SVGTextQuery::subStringLengthCallback(Data* queryData, const SVGTextFragment& fragment) const
{
SubStringLengthData* data = static_cast<SubStringLengthData*>(queryData);
int startPosition = data->startPosition;
int endPosition = startPosition + data->length;
if (!mapStartEndPositionsIntoFragmentCoordinates(queryData, fragment, startPosition, endPosition))
return false;
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textRenderer, fragment.characterOffset + startPosition, endPosition - startPosition);
data->subStringLength += queryData->isVerticalText ? metrics.height() : metrics.width();
return false;
}
SVGTextMetrics SVGTextMetricsCalculator::computeMetricsForCharacter(unsigned textPosition)
{
if (m_bidiRun) {
if (textPosition >= static_cast<unsigned>(m_bidiRun->stop())) {
m_bidiRun = m_bidiRun->next();
// New BiDi run means new reference position for measurements, so reset |m_totalWidth|.
m_totalWidth = 0;
}
ASSERT(m_bidiRun);
ASSERT(static_cast<int>(textPosition) < m_bidiRun->stop());
m_textDirection = m_bidiRun->direction();
}
unsigned metricsLength = characterStartsSurrogatePair(textPosition) ? 2 : 1;
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(m_text, textPosition, metricsLength, m_textDirection);
ASSERT(metrics.length() == metricsLength);
unsigned startPosition = m_bidiRun ? m_bidiRun->start() : 0;
ASSERT(startPosition <= textPosition);
SVGTextMetrics complexStartToCurrentMetrics = SVGTextMetrics::measureCharacterRange(m_text, startPosition, textPosition - startPosition + metricsLength, m_textDirection);
// Frequent case for Arabic text: when measuring a single character the arabic isolated form is taken
// when laying out the glyph "in context" (with it's surrounding characters) it changes due to shaping.
// So whenever currentWidth != currentMetrics.width(), we are processing a text run whose length is
// not equal to the sum of the individual lengths of the glyphs, when measuring them isolated.
float currentWidth = complexStartToCurrentMetrics.width() - m_totalWidth;
if (currentWidth != metrics.width())
metrics.setWidth(currentWidth);
m_totalWidth = complexStartToCurrentMetrics.width();
return metrics;
}
static inline void calculateGlyphBoundaries(SVGTextQuery::Data* queryData, const SVGTextFragment& fragment, int startPosition, FloatRect& extent)
{
float scalingFactor = queryData->textRenderer->scalingFactor();
ASSERT(scalingFactor);
extent.setLocation(FloatPoint(fragment.x, fragment.y - queryData->textRenderer->scaledFont().fontMetrics().floatAscent() / scalingFactor));
if (startPosition) {
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textRenderer, fragment.characterOffset, startPosition);
if (queryData->isVerticalText)
extent.move(0, metrics.height());
else
extent.move(metrics.width(), 0);
}
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textRenderer, fragment.characterOffset + startPosition, 1);
extent.setSize(FloatSize(metrics.width(), metrics.height()));
AffineTransform fragmentTransform;
fragment.buildFragmentTransform(fragmentTransform, SVGTextFragment::TransformIgnoringTextLength);
if (fragmentTransform.isIdentity())
return;
extent = fragmentTransform.mapRect(extent);
}
static FloatPoint calculateGlyphPositionWithoutTransform(const QueryData* queryData, const SVGTextFragment& fragment, int offsetInFragment)
{
float glyphOffsetInDirection = 0;
if (offsetInFragment) {
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(queryData->textLayoutObject, fragment.characterOffset, offsetInFragment, queryData->textBox->direction());
if (queryData->isVerticalText)
glyphOffsetInDirection = metrics.height();
else
glyphOffsetInDirection = metrics.width();
}
if (!queryData->textBox->isLeftToRightDirection()) {
float fragmentExtent = queryData->isVerticalText ? fragment.height : fragment.width;
glyphOffsetInDirection = fragmentExtent - glyphOffsetInDirection;
}
FloatPoint glyphPosition(fragment.x, fragment.y);
if (queryData->isVerticalText)
glyphPosition.move(0, glyphOffsetInDirection);
else
glyphPosition.move(glyphOffsetInDirection, 0);
return glyphPosition;
}
SVGTextMetrics SVGTextMetricsCalculator::computeMetricsForCharacterComplex(unsigned textPosition)
{
unsigned metricsLength = characterStartsSurrogatePair(textPosition) ? 2 : 1;
SVGTextMetrics metrics = SVGTextMetrics::measureCharacterRange(m_text, textPosition, metricsLength, m_textDirection);
ASSERT(metrics.length() == metricsLength);
unsigned startPosition = m_bidiRun ? m_bidiRun->start() : 0;
ASSERT(startPosition <= textPosition);
SVGTextMetrics complexStartToCurrentMetrics = SVGTextMetrics::measureCharacterRange(m_text, startPosition, textPosition - startPosition + metricsLength, m_textDirection);
// Frequent case for Arabic text: when measuring a single character the arabic isolated form is taken
// when rendering the glyph "in context" (with it's surrounding characters) it changes due to shaping.
// So whenever currentWidth != currentMetrics.width(), we are processing a text run whose length is
// not equal to the sum of the individual lengths of the glyphs, when measuring them isolated.
float currentWidth = complexStartToCurrentMetrics.width() - m_totalWidth;
if (currentWidth != metrics.width())
metrics.setWidth(currentWidth);
m_totalWidth = complexStartToCurrentMetrics.width();
return metrics;
}
void SVGTextLayoutEngine::advanceToNextLogicalCharacter(const SVGTextMetrics& logicalMetrics)
{
++m_logicalMetricsListOffset;
m_logicalCharacterOffset += logicalMetrics.length();
}
void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, RenderSVGInlineText* text, const RenderStyle* style)
{
SVGElement* lengthContext = static_cast<SVGElement*>(text->parent()->node());
RenderObject* textParent = text->parent();
bool definesTextLength = textParent ? parentDefinesTextLength(textParent) : false;
const SVGRenderStyle* svgStyle = style->svgStyle();
ASSERT(svgStyle);
m_visualMetricsListOffset = 0;
m_visualCharacterOffset = 0;
Vector<SVGTextMetrics>& textMetricsValues = text->layoutAttributes().textMetricsValues();
const UChar* characters = text->characters();
const Font& font = style->font();
SVGTextLayoutEngineSpacing spacingLayout(font);
SVGTextLayoutEngineBaseline baselineLayout(font);
bool didStartTextFragment = false;
bool applySpacingToNextCharacter = false;
float lastAngle = 0;
float baselineShift = baselineLayout.calculateBaselineShift(svgStyle, lengthContext);
baselineShift -= baselineLayout.calculateAlignmentBaselineShift(m_isVerticalText, text);
// Main layout algorithm.
while (true) {
// Find the start of the current text box in this list, respecting ligatures.
SVGTextMetrics visualMetrics = SVGTextMetrics::emptyMetrics();
if (!currentVisualCharacterMetrics(textBox, text, visualMetrics))
break;
if (visualMetrics == SVGTextMetrics::emptyMetrics()) {
advanceToNextVisualCharacter(visualMetrics);
continue;
}
SVGTextLayoutAttributes logicalAttributes;
if (!currentLogicalCharacterAttributes(logicalAttributes))
break;
SVGTextMetrics logicalMetrics = SVGTextMetrics::emptyMetrics();
if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
break;
Vector<float>& xValues = logicalAttributes.xValues();
Vector<float>& yValues = logicalAttributes.yValues();
Vector<float>& dxValues = logicalAttributes.dxValues();
Vector<float>& dyValues = logicalAttributes.dyValues();
Vector<float>& rotateValues = logicalAttributes.rotateValues();
float x = xValues.at(m_logicalCharacterOffset);
float y = yValues.at(m_logicalCharacterOffset);
// When we've advanced to the box start offset, determine using the original x/y values,
// whether this character starts a new text chunk, before doing any further processing.
if (m_visualCharacterOffset == textBox->start())
textBox->setStartsNewTextChunk(logicalAttributes.context()->characterStartsNewTextChunk(m_logicalCharacterOffset));
float angle = 0;
if (!rotateValues.isEmpty()) {
float newAngle = rotateValues.at(m_logicalCharacterOffset);
if (newAngle != SVGTextLayoutAttributes::emptyValue())
angle = newAngle;
}
// Calculate glyph orientation angle.
const UChar* currentCharacter = characters + m_visualCharacterOffset;
float orientationAngle = baselineLayout.calculateGlyphOrientationAngle(m_isVerticalText, svgStyle, *currentCharacter);
// Calculate glyph advance & x/y orientation shifts.
float xOrientationShift = 0;
float yOrientationShift = 0;
float glyphAdvance = baselineLayout.calculateGlyphAdvanceAndOrientation(m_isVerticalText, visualMetrics, orientationAngle, xOrientationShift, yOrientationShift);
// Assign current text position to x/y values, if needed.
updateCharacerPositionIfNeeded(x, y);
// Apply dx/dy value adjustments to current text position, if needed.
updateRelativePositionAdjustmentsIfNeeded(dxValues, dyValues);
// Calculate SVG Fonts kerning, if needed.
float kerning = spacingLayout.calculateSVGKerning(m_isVerticalText, visualMetrics.glyph());
// Calculate CSS 'kerning', 'letter-spacing' and 'word-spacing' for next character, if needed.
float spacing = spacingLayout.calculateCSSKerningAndSpacing(svgStyle, lengthContext, currentCharacter);
float textPathOffset = 0;
if (m_inPathLayout) {
float scaledGlyphAdvance = glyphAdvance * m_textPathScaling;
if (m_isVerticalText) {
// If there's an absolute y position available, it marks the beginning of a new position along the path.
if (y != SVGTextLayoutAttributes::emptyValue())
m_textPathCurrentOffset = y + m_textPathStartOffset;
m_textPathCurrentOffset += m_dy - kerning;
m_dy = 0;
// Apply dx/dy correction and setup translations that move to the glyph midpoint.
xOrientationShift += m_dx + baselineShift;
yOrientationShift -= scaledGlyphAdvance / 2;
} else {
// If there's an absolute x position available, it marks the beginning of a new position along the path.
if (x != SVGTextLayoutAttributes::emptyValue())
m_textPathCurrentOffset = x + m_textPathStartOffset;
m_textPathCurrentOffset += m_dx - kerning;
m_dx = 0;
// Apply dx/dy correction and setup translations that move to the glyph midpoint.
xOrientationShift -= scaledGlyphAdvance / 2;
yOrientationShift += m_dy - baselineShift;
}
// Calculate current offset along path.
textPathOffset = m_textPathCurrentOffset + scaledGlyphAdvance / 2;
// Move to next character.
m_textPathCurrentOffset += scaledGlyphAdvance + m_textPathSpacing + spacing * m_textPathScaling;
// Skip character, if we're before the path.
if (textPathOffset < 0) {
advanceToNextLogicalCharacter(logicalMetrics);
advanceToNextVisualCharacter(visualMetrics);
continue;
}
// Stop processing, if the next character lies behind the path.
if (textPathOffset > m_textPathLength)
break;
bool ok = false;
FloatPoint point = m_textPath.pointAtLength(textPathOffset, ok);
ASSERT(ok);
x = point.x();
y = point.y();
angle = m_textPath.normalAngleAtLength(textPathOffset, ok);
ASSERT(ok);
// For vertical text on path, the actual angle has to be rotated 90 degrees anti-clockwise, not the orientation angle!
if (m_isVerticalText)
angle -= 90;
} else {
// Apply all previously calculated shift values.
if (m_isVerticalText) {
x += baselineShift;
y -= kerning;
} else {
x -= kerning;
y -= baselineShift;
}
x += m_dx;
y += m_dy;
}
// Determine wheter we have to start a new fragment.
bool shouldStartNewFragment = false;
if (m_dx || m_dy)
shouldStartNewFragment = true;
if (!shouldStartNewFragment && (m_isVerticalText || m_inPathLayout))
shouldStartNewFragment = true;
if (!shouldStartNewFragment && (angle || angle != lastAngle || orientationAngle))
shouldStartNewFragment = true;
if (!shouldStartNewFragment && (kerning || applySpacingToNextCharacter || definesTextLength))
shouldStartNewFragment = true;
// If we already started a fragment, close it now.
if (didStartTextFragment && shouldStartNewFragment) {
applySpacingToNextCharacter = false;
recordTextFragment(textBox, textMetricsValues);
}
// Eventually start a new fragment, if not yet done.
if (!didStartTextFragment || shouldStartNewFragment) {
ASSERT(!m_currentTextFragment.characterOffset);
ASSERT(!m_currentTextFragment.length);
didStartTextFragment = true;
m_currentTextFragment.characterOffset = m_visualCharacterOffset;
m_currentTextFragment.metricsListOffset = m_visualMetricsListOffset;
m_currentTextFragment.x = x;
m_currentTextFragment.y = y;
// Build fragment transformation.
if (angle)
m_currentTextFragment.transform.rotate(angle);
if (xOrientationShift || yOrientationShift)
m_currentTextFragment.transform.translate(xOrientationShift, yOrientationShift);
if (orientationAngle)
m_currentTextFragment.transform.rotate(orientationAngle);
m_currentTextFragment.isTextOnPath = m_inPathLayout && m_textPathScaling != 1;
if (m_currentTextFragment.isTextOnPath) {
if (m_isVerticalText)
m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(1, m_textPathScaling);
else
m_currentTextFragment.lengthAdjustTransform.scaleNonUniform(m_textPathScaling, 1);
}
}
// Update current text position, after processing of the current character finished.
if (m_inPathLayout)
updateCurrentTextPosition(x, y, glyphAdvance);
else {
// Apply CSS 'kerning', 'letter-spacing' and 'word-spacing' to next character, if needed.
if (spacing)
applySpacingToNextCharacter = true;
float xNew = x - m_dx;
float yNew = y - m_dy;
if (m_isVerticalText)
xNew -= baselineShift;
else
yNew += baselineShift;
updateCurrentTextPosition(xNew, yNew, glyphAdvance + spacing);
}
advanceToNextLogicalCharacter(logicalMetrics);
advanceToNextVisualCharacter(visualMetrics);
lastAngle = angle;
}
if (!didStartTextFragment)
return;
// Close last open fragment, if needed.
recordTextFragment(textBox, textMetricsValues);
}
void SVGTextLayoutEngine::advanceToNextVisualCharacter(const SVGTextMetrics& visualMetrics)
{
++m_visualMetricsListOffset;
m_visualCharacterOffset += visualMetrics.length();
}
void SVGTextLayoutAttributesBuilder::propagateLayoutAttributes(RenderObject* start, Vector<SVGTextLayoutAttributes>& allAttributes, unsigned& atCharacter, UChar& lastCharacter) const
{
for (RenderObject* child = start->firstChild(); child; child = child->nextSibling()) {
if (child->isSVGInlineText()) {
RenderSVGInlineText* text = toRenderSVGInlineText(child);
const UChar* characters = text->characters();
unsigned textLength = text->textLength();
bool preserveWhiteSpace = shouldPreserveAllWhiteSpace(text->style());
SVGTextLayoutAttributes attributes(text);
attributes.reserveCapacity(textLength);
unsigned valueListPosition = atCharacter;
unsigned metricsLength = 1;
SVGTextMetrics lastMetrics(SVGTextMetrics::SkippedSpaceMetrics);
for (unsigned textPosition = 0; textPosition < textLength; textPosition += metricsLength) {
const UChar& currentCharacter = characters[textPosition];
SVGTextMetrics startToCurrentMetrics;
SVGTextMetrics currentMetrics;
unsigned valueListAdvance = 0;
if (U16_IS_LEAD(currentCharacter) && (textPosition + 1) < textLength && U16_IS_TRAIL(characters[textPosition + 1])) {
// Handle surrogate pairs.
startToCurrentMetrics = SVGTextMetrics::measureCharacterRange(text, 0, textPosition + 2);
currentMetrics = SVGTextMetrics::measureCharacterRange(text, textPosition, 2);
metricsLength = currentMetrics.length();
valueListAdvance = 1;
} else {
// Handle BMP characters.
startToCurrentMetrics = SVGTextMetrics::measureCharacterRange(text, 0, textPosition + 1);
currentMetrics = SVGTextMetrics::measureCharacterRange(text, textPosition, 1);
metricsLength = currentMetrics.length();
valueListAdvance = metricsLength;
}
if (!metricsLength)
break;
// Frequent case for Arabic text: when measuring a single character the arabic isolated form is taken
// when rendering the glyph "in context" (with it's surrounding characters) it changes due to shaping.
// So whenever runWidthAdvance != currentMetrics.width(), we are processing a text run whose length is
// not equal to the sum of the individual lengths of the glyphs, when measuring them isolated.
float runWidthAdvance = startToCurrentMetrics.width() - lastMetrics.width();
if (runWidthAdvance != currentMetrics.width())
currentMetrics.setWidth(runWidthAdvance);
lastMetrics = startToCurrentMetrics;
if (!preserveWhiteSpace && characterIsSpace(currentCharacter) && characterIsSpaceOrNull(lastCharacter)) {
attributes.positioningLists().appendEmptyValues();
attributes.textMetricsValues().append(SVGTextMetrics(SVGTextMetrics::SkippedSpaceMetrics));
continue;
}
SVGTextLayoutAttributes::PositioningLists& positioningLists = attributes.positioningLists();
positioningLists.appendValuesFromPosition(m_positioningLists, valueListPosition);
attributes.textMetricsValues().append(currentMetrics);
// Pad x/y/dx/dy/rotate value lists with empty values, if the metrics span more than one character.
if (metricsLength > 1) {
for (unsigned i = 0; i < metricsLength - 1; ++i)
positioningLists.appendEmptyValues();
}
lastCharacter = currentCharacter;
valueListPosition += valueListAdvance;
}
#if DUMP_TEXT_LAYOUT_ATTRIBUTES > 0
fprintf(stderr, "\nDumping layout attributes for RenderSVGInlineText, renderer=%p, node=%p (atCharacter: %i)\n", text, text->node(), atCharacter);
fprintf(stderr, "BiDi properties: unicode-bidi=%i, block direction=%i\n", text->style()->unicodeBidi(), text->style()->direction());
attributes.dump();
#endif
text->storeLayoutAttributes(attributes);
allAttributes.append(attributes);
atCharacter = valueListPosition;
continue;
}
if (!child->isSVGInline())
continue;
propagateLayoutAttributes(child, allAttributes, atCharacter, lastCharacter);
}
}