static void revertRuns(Layout::RunVector& runs, unsigned length, float width) { while (length) { ASSERT(runs.size()); Run& lastRun = runs.last(); unsigned lastRunLength = lastRun.end - lastRun.start; if (lastRunLength > length) { lastRun.logicalRight -= width; lastRun.end -= length; break; } length -= lastRunLength; width -= (lastRun.logicalRight - lastRun.logicalLeft); runs.removeLast(); } }
static void closeLineEndingAndAdjustRuns(LineState& line, Layout::RunVector& runs, unsigned previousRunCount, unsigned& lineCount, const TextFragmentIterator& textFragmentIterator) { if (previousRunCount == runs.size()) return; ASSERT(runs.size()); removeTrailingWhitespace(line, runs, textFragmentIterator); if (!runs.size()) return; // Adjust runs' position by taking line's alignment into account. if (float lineLogicalLeft = computeLineLeft(textFragmentIterator.style().textAlign, line.availableWidth(), line.width(), line.logicalLeftOffset())) { for (unsigned i = previousRunCount; i < runs.size(); ++i) { runs[i].logicalLeft += lineLogicalLeft; runs[i].logicalRight += lineLogicalLeft; } } runs.last().isEndOfLine = true; ++lineCount; }
void appendFragmentAndCreateRunIfNeeded(const TextFragmentIterator::TextFragment& fragment, Layout::RunVector& runs) { // Adjust end position while collapsing. unsigned endPosition = fragment.isCollapsed() ? fragment.start() + 1 : fragment.end(); // New line needs new run. if (!m_runsWidth) runs.append(Run(fragment.start(), endPosition, m_runsWidth, m_runsWidth + fragment.width(), false)); else { const auto& lastFragment = m_fragments.last(); // Advance last completed fragment when the previous fragment is all set (including multiple parts across renderers) if ((lastFragment.type() != fragment.type()) || !lastFragment.overlapsToNextRenderer()) m_lastCompleteFragment = lastFragment; // Collapse neighbouring whitespace, if they are across multiple renderers and are not collapsed yet. if (lastFragment.isCollapsible() && fragment.isCollapsible()) { ASSERT(lastFragment.isLastInRenderer()); if (!lastFragment.isCollapsed()) { // Line width needs to be reset so that now it takes collapsing into consideration. m_runsWidth -= (lastFragment.width() - m_collapsedWhitespaceWidth); } // This fragment is collapsed completely. No run is needed. return; } if (lastFragment.isLastInRenderer() || lastFragment.isCollapsed()) runs.append(Run(fragment.start(), endPosition, m_runsWidth, m_runsWidth + fragment.width(), false)); else { Run& lastRun = runs.last(); lastRun.end = endPosition; lastRun.logicalRight += fragment.width(); } } m_fragments.append(fragment); m_runsWidth += fragment.width(); if (fragment.type() == TextFragmentIterator::TextFragment::Whitespace) { m_trailingWhitespaceLength += endPosition - fragment.start(); m_trailingWhitespaceWidth += fragment.width(); } else { m_trailingWhitespaceLength = 0; m_trailingWhitespaceWidth = 0; } if (!m_firstCharacterFits) m_firstCharacterFits = fragment.start() + 1 > endPosition || m_runsWidth <= m_availableWidth; }
static void createTextRuns(Layout::RunVector& runs, RenderBlockFlow& flow, unsigned& lineCount) { LayoutUnit borderAndPaddingBefore = flow.borderAndPaddingBefore(); LayoutUnit lineHeight = lineHeightFromFlow(flow); LineState line; bool isEndOfContent = false; TextFragmentIterator textFragmentIterator = TextFragmentIterator(flow); do { flow.setLogicalHeight(lineHeight * lineCount + borderAndPaddingBefore); LineState previousLine = line; unsigned previousRunCount = runs.size(); line = LineState(); updateLineConstrains(flow, line, !lineCount); isEndOfContent = createLineRuns(line, previousLine, runs, textFragmentIterator); closeLineEndingAndAdjustRuns(line, runs, previousRunCount, lineCount, textFragmentIterator); } while (!isEndOfContent); }
void createTextRuns(Layout::RunVector& runs, unsigned& lineCount, RenderBlockFlow& flow, RenderText& textRenderer) { const Style style(flow.style()); const CharacterType* text = textRenderer.text()->characters<CharacterType>(); const unsigned textLength = textRenderer.textLength(); LayoutUnit borderAndPaddingBefore = flow.borderAndPaddingBefore(); LayoutUnit lineHeight = lineHeightFromFlow(flow); LazyLineBreakIterator lineBreakIterator(textRenderer.text(), flow.style().locale()); unsigned lineEnd = 0; while (lineEnd < textLength) { if (style.collapseWhitespace) lineEnd = skipWhitespaces(text, lineEnd, textLength, style.preserveNewline); unsigned lineStart = lineEnd; // LineWidth reads the current y position from the flow so keep it updated. flow.setLogicalHeight(lineHeight * lineCount + borderAndPaddingBefore); LineWidth lineWidth(flow, false, DoNotIndentText); auto lineRuns = createLineRuns(lineStart, lineWidth, lineBreakIterator, style, text, textLength, textRenderer); lineEnd = lineRuns.last().end; if (lineStart == lineEnd) continue; lineRuns.last().isEndOfLine = true; float lineLeft = computeLineLeft(style.textAlign, lineWidth); adjustRunOffsets(lineRuns, lineLeft); for (unsigned i = 0; i < lineRuns.size(); ++i) runs.append(lineRuns[i]); ++lineCount; } }
std::unique_ptr<Layout> create(RenderBlockFlow& flow) { RenderText& textRenderer = toRenderText(*flow.firstChild()); ASSERT(!textRenderer.firstTextBox()); const RenderStyle& style = flow.style(); const unsigned textLength = textRenderer.textLength(); ETextAlign textAlign = style.textAlign(); float wordTrailingSpaceWidth = style.font().width(TextRun(&space, 1)); LazyLineBreakIterator lineBreakIterator(textRenderer.text(), style.locale()); int nextBreakable = -1; Layout::RunVector runs; unsigned lineCount = 0; unsigned lineEndOffset = 0; while (lineEndOffset < textLength) { lineEndOffset = skipWhitespaces(textRenderer, lineEndOffset, textLength); unsigned lineStartOffset = lineEndOffset; unsigned wordEndOffset = lineEndOffset; LineWidth lineWidth(flow, false, DoNotIndentText); Vector<Run, 4> lineRuns; lineRuns.uncheckedAppend(Run(lineStartOffset, 0)); while (wordEndOffset < textLength) { ASSERT(!isWhitespace(textRenderer.characterAt(wordEndOffset))); bool previousWasSpaceBetweenWords = wordEndOffset > lineStartOffset && isWhitespace(textRenderer.characterAt(wordEndOffset - 1)); unsigned wordStartOffset = previousWasSpaceBetweenWords ? wordEndOffset - 1 : wordEndOffset; ++wordEndOffset; while (wordEndOffset < textLength) { if (wordEndOffset > lineStartOffset && isBreakable(lineBreakIterator, wordEndOffset, nextBreakable, false)) break; ++wordEndOffset; } unsigned wordLength = wordEndOffset - wordStartOffset; bool includeEndSpace = wordEndOffset < textLength && textRenderer.characterAt(wordEndOffset) == ' '; float wordWidth; if (includeEndSpace) wordWidth = textWidth(textRenderer, wordStartOffset, wordLength + 1, lineWidth.committedWidth(), style) - wordTrailingSpaceWidth; else wordWidth = textWidth(textRenderer, wordStartOffset, wordLength, lineWidth.committedWidth(), style); lineWidth.addUncommittedWidth(wordWidth); // Move to the next line if the current one is full and we have something on it. if (!lineWidth.fitsOnLine() && lineWidth.committedWidth()) break; if (wordStartOffset > lineEndOffset) { // There were more than one consecutive whitespace. ASSERT(previousWasSpaceBetweenWords); // Include space to the end of the previous run. lineRuns.last().textLength++; lineRuns.last().right += wordTrailingSpaceWidth; // Start a new run on the same line. lineRuns.append(Run(wordStartOffset + 1, lineRuns.last().right)); } lineWidth.commit(); lineRuns.last().right = lineWidth.committedWidth(); lineRuns.last().textLength = wordEndOffset - lineRuns.last().textOffset; lineEndOffset = wordEndOffset; wordEndOffset = skipWhitespaces(textRenderer, wordEndOffset, textLength); if (!lineWidth.fitsOnLine()) { // The first run on the line overflows. ASSERT(lineRuns.size() == 1); break; } } if (lineStartOffset == lineEndOffset) continue; adjustRunOffsets(lineRuns, textAlign, lineWidth.committedWidth(), lineWidth.availableWidth()); for (unsigned i = 0; i < lineRuns.size(); ++i) runs.append(lineRuns[i]); runs.last().isEndOfLine = true; ++lineCount; } textRenderer.clearNeedsLayout(); return Layout::create(runs, lineCount); }