void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, LineLayoutSVGInlineText textLineLayout, const ComputedStyle& style)
{
if (m_inPathLayout && !m_textPathCalculator)
return;
// Find the start of the current text box in the metrics list.
m_visualMetricsIterator.advanceToTextStart(&textLineLayout, textBox->start());
const Font& font = style.font();
SVGTextLayoutEngineSpacing spacingLayout(font, style.effectiveZoom());
SVGTextLayoutEngineBaseline baselineLayout(font, style.effectiveZoom());
bool didStartTextFragment = false;
bool applySpacingToNextCharacter = false;
float lastAngle = 0;
float baselineShift = baselineLayout.calculateBaselineShift(style);
baselineShift -= baselineLayout.calculateAlignmentBaselineShift(m_isVerticalText, textLineLayout);
// Main layout algorithm.
const unsigned boxEndOffset = textBox->start() + textBox->len();
while (!m_visualMetricsIterator.isAtEnd() && m_visualMetricsIterator.characterOffset() < boxEndOffset) {
const SVGTextMetrics& visualMetrics = m_visualMetricsIterator.metrics();
if (visualMetrics.isEmpty()) {
m_visualMetricsIterator.next();
continue;
}
SVGTextLayoutAttributes* logicalAttributes = nullptr;
if (!currentLogicalCharacterAttributes(logicalAttributes))
break;
ASSERT(logicalAttributes);
SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
break;
SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
SVGCharacterData data;
SVGCharacterDataMap::iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
if (it != characterDataMap.end())
data = it->value;
float x = data.x;
float y = data.y;
// 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_visualMetricsIterator.characterOffset() == textBox->start())
textBox->setStartsNewTextChunk(logicalAttributes->context()->characterStartsNewTextChunk(m_logicalCharacterOffset));
float angle = SVGTextLayoutAttributes::isEmptyValue(data.rotate) ? 0 : data.rotate;
// Calculate glyph orientation angle.
// Font::width() calculates the resolved FontOrientation for each character,
// but is not exposed today to avoid the API complexity.
UChar32 currentCharacter = textLineLayout.codepointAt(m_visualMetricsIterator.characterOffset());
FontOrientation fontOrientation = font.fontDescription().orientation();
fontOrientation = adjustOrientationForCharacterInMixedVertical(fontOrientation, currentCharacter);
// Calculate glyph advance.
// Shaping engine takes care of x/y orientation shifts for different fontOrientation values.
float glyphAdvance = visualMetrics.advance(fontOrientation);
// Assign current text position to x/y values, if needed.
updateCharacterPositionIfNeeded(x, y);
// Apply dx/dy value adjustments to current text position, if needed.
updateRelativePositionAdjustmentsIfNeeded(data.dx, data.dy);
// Calculate CSS 'letter-spacing' and 'word-spacing' for next character, if needed.
float spacing = spacingLayout.calculateCSSSpacing(currentCharacter);
float textPathOffset = 0;
float textPathShiftX = 0;
float textPathShiftY = 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 (!SVGTextLayoutAttributes::isEmptyValue(y))
m_textPathCurrentOffset = y + m_textPathStartOffset;
m_textPathCurrentOffset += m_dy;
m_dy = 0;
// Apply dx/dy correction and setup translations that move to the glyph midpoint.
textPathShiftX += m_dx + baselineShift;
textPathShiftY -= scaledGlyphAdvance / 2;
} else {
// If there's an absolute x position available, it marks the beginning of a new position along the path.
if (!SVGTextLayoutAttributes::isEmptyValue(x))
m_textPathCurrentOffset = x + m_textPathStartOffset;
m_textPathCurrentOffset += m_dx;
m_dx = 0;
// Apply dx/dy correction and setup translations that move to the glyph midpoint.
textPathShiftX -= scaledGlyphAdvance / 2;
textPathShiftY += 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);
m_visualMetricsIterator.next();
continue;
}
// Stop processing, if the next character lies behind the path.
if (textPathOffset > m_textPathLength)
break;
FloatPoint point;
bool ok = m_textPathCalculator->pointAndNormalAtLength(textPathOffset, point, angle);
ASSERT_UNUSED(ok, ok);
x = point.x();
y = point.y();
// 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;
else
y -= baselineShift;
x += m_dx;
y += m_dy;
}
// Determine whether we have to start a new fragment.
bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
|| applySpacingToNextCharacter || m_textLengthSpacingInEffect;
// If we already started a fragment, close it now.
if (didStartTextFragment && shouldStartNewFragment) {
applySpacingToNextCharacter = false;
recordTextFragment(textBox);
}
// 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_visualMetricsIterator.characterOffset();
m_currentTextFragment.metricsListOffset = m_visualMetricsIterator.metricsListOffset();
m_currentTextFragment.x = x;
m_currentTextFragment.y = y;
// Build fragment transformation.
if (angle)
m_currentTextFragment.transform.rotate(angle);
if (textPathShiftX || textPathShiftY)
m_currentTextFragment.transform.translate(textPathShiftX, textPathShiftY);
// In vertical text, always rotate by 90 degrees regardless of fontOrientation.
// Shaping engine takes care of the necessary orientation.
if (m_isVerticalText)
m_currentTextFragment.transform.rotate(90);
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);
m_visualMetricsIterator.next();
lastAngle = angle;
}
if (!didStartTextFragment)
return;
// Close last open fragment, if needed.
recordTextFragment(textBox);
}
void SVGTextLayoutEngine::layoutTextOnLineOrPath(SVGInlineTextBox* textBox, RenderSVGInlineText* text, const RenderStyle* style)
{
if (m_inPathLayout && m_textPath.isEmpty())
return;
SVGElement* lengthContext = toSVGElement(text->parent()->element());
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>& visualMetricsValues = text->layoutAttributes()->textMetricsValues();
ASSERT(!visualMetricsValues.isEmpty());
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::SkippedSpaceMetrics);
if (!currentVisualCharacterMetrics(textBox, visualMetricsValues, visualMetrics))
break;
if (visualMetrics.isEmpty()) {
advanceToNextVisualCharacter(visualMetrics);
continue;
}
SVGTextLayoutAttributes* logicalAttributes = 0;
if (!currentLogicalCharacterAttributes(logicalAttributes))
break;
ASSERT(logicalAttributes);
SVGTextMetrics logicalMetrics(SVGTextMetrics::SkippedSpaceMetrics);
if (!currentLogicalCharacterMetrics(logicalAttributes, logicalMetrics))
break;
SVGCharacterDataMap& characterDataMap = logicalAttributes->characterDataMap();
SVGCharacterData data;
SVGCharacterDataMap::iterator it = characterDataMap.find(m_logicalCharacterOffset + 1);
if (it != characterDataMap.end())
data = it->value;
float x = data.x;
float y = data.y;
// 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 = data.rotate == SVGTextLayoutAttributes::emptyValue() ? 0 : data.rotate;
// 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(data.dx, data.dy);
// 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 whether we have to start a new fragment.
bool shouldStartNewFragment = m_dx || m_dy || m_isVerticalText || m_inPathLayout || angle || angle != lastAngle
|| orientationAngle || kerning || applySpacingToNextCharacter || definesTextLength;
// If we already started a fragment, close it now.
if (didStartTextFragment && shouldStartNewFragment) {
applySpacingToNextCharacter = false;
recordTextFragment(textBox, visualMetricsValues);
}
// 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, visualMetricsValues);
}