static void restoreIsolatedMidpointStates(
InlineBidiResolver& topResolver,
InlineBidiResolver& isolatedResolver) {
while (!isolatedResolver.isolatedRuns().isEmpty()) {
BidiRun* run = isolatedResolver.isolatedRuns().last();
isolatedResolver.isolatedRuns().removeLast();
topResolver.setMidpointStateForIsolatedRun(
run, isolatedResolver.midpointStateForIsolatedRun(run));
}
}
InlineIterator LineBreaker::nextLineBreak(InlineBidiResolver& resolver, LineInfo& lineInfo,
RenderTextInfo& renderTextInfo, FloatingObject* lastFloatFromPreviousLine,
WordMeasurements& wordMeasurements)
{
reset();
ASSERT(resolver.position().root() == m_block);
bool appliedStartWidth = resolver.position().offset() > 0;
LineWidth width(*m_block, lineInfo.isFirstLine(), requiresIndent(lineInfo.isFirstLine(), lineInfo.previousLineBrokeCleanly(), m_block->style()));
skipLeadingWhitespace(resolver, lineInfo, lastFloatFromPreviousLine, width);
if (resolver.position().atEnd())
return resolver.position();
BreakingContext context(resolver, lineInfo, width, renderTextInfo, lastFloatFromPreviousLine, appliedStartWidth, m_block);
while (context.currentObject()) {
context.initializeForCurrentObject();
if (context.currentObject()->isBR()) {
context.handleBR(m_clear);
} else if (context.currentObject()->isOutOfFlowPositioned()) {
context.handleOutOfFlowPositioned(m_positionedObjects);
} else if (context.currentObject()->isFloating()) {
context.handleFloat();
} else if (context.currentObject()->isRenderInline()) {
context.handleEmptyInline();
} else if (context.currentObject()->isReplaced()) {
context.handleReplaced();
} else if (context.currentObject()->isText()) {
if (context.handleText(wordMeasurements, m_hyphenated)) {
// We've hit a hard text line break. Our line break iterator is updated, so go ahead and early return.
return context.lineBreak();
}
} else {
ASSERT_NOT_REACHED();
}
if (context.atEnd())
return context.handleEndOfLine();
context.commitAndUpdateLineBreakIfNeeded();
if (context.atEnd())
return context.handleEndOfLine();
context.increment();
}
context.clearLineBreakIfFitsOnLine();
return context.handleEndOfLine();
}
TextDirection determinePlaintextDirectionality(LayoutObject* root,
LayoutObject* current, unsigned pos)
{
LayoutObject* firstLayoutObject = firstLayoutObjectForDirectionalityDetermination(root, current);
InlineIterator iter(LineLayoutItem(root), LineLayoutItem(firstLayoutObject), firstLayoutObject == current ? pos : 0);
InlineBidiResolver observer;
observer.setStatus(BidiStatus(root->style()->direction(),
isOverride(root->style()->unicodeBidi())));
observer.setPositionIgnoringNestedIsolates(iter);
return observer.determineParagraphDirectionality();
}
TextDirection determinePlaintextDirectionality(RenderObject* root,
RenderObject* current,
unsigned pos) {
InlineIterator iter(
root, firstRenderObjectForDirectionalityDetermination(root, current),
pos);
InlineBidiResolver observer;
observer.setStatus(BidiStatus(root->style()->direction(),
isOverride(root->style()->unicodeBidi())));
observer.setPositionIgnoringNestedIsolates(iter);
return observer.determineParagraphDirectionality();
}
void LineBreaker::skipLeadingWhitespace(InlineBidiResolver& resolver, LineInfo& lineInfo,
FloatingObject* lastFloatFromPreviousLine, LineWidth& width)
{
while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), lineInfo, LeadingWhitespace)) {
RenderObject* object = resolver.position().object();
if (object->isOutOfFlowPositioned()
&& object->style()->isOriginalDisplayInlineType()) {
resolver.runs().addRun(createRun(0, 1, object, resolver));
lineInfo.incrementRunsFromLeadingWhitespace();
}
resolver.position().increment(&resolver);
}
resolver.commitExplicitEmbedding(resolver.runs());
}
void LineBreaker::skipLeadingWhitespace(InlineBidiResolver& resolver, LineInfo& lineInfo, FloatingObject* lastFloatFromPreviousLine, LineWidth& width)
{
while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), lineInfo, LeadingWhitespace)) {
RenderObject& object = *resolver.position().renderer();
if (object.isOutOfFlowPositioned()) {
setStaticPositions(m_block, downcast<RenderBox>(object));
if (object.style().isOriginalDisplayInlineType()) {
resolver.runs().addRun(new BidiRun(0, 1, object, resolver.context(), resolver.dir()));
lineInfo.incrementRunsFromLeadingWhitespace();
}
} else if (object.isFloating())
m_block.positionNewFloatOnLine(m_block.insertFloatingObject(downcast<RenderBox>(object)), lastFloatFromPreviousLine, lineInfo, width);
else if (is<RenderCombineText>(object) && object.style().hasTextCombine() && !downcast<RenderCombineText>(object).isCombined()) {
downcast<RenderCombineText>(object).combineText();
if (downcast<RenderCombineText>(object).isCombined())
continue;
}
resolver.increment();
}
resolver.commitExplicitEmbedding();
}
void LineBreaker::skipLeadingWhitespace(InlineBidiResolver& resolver, LineInfo& lineInfo, LineWidth& width)
{
while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), lineInfo, LeadingWhitespace)) {
LineLayoutItem lineLayoutItem = resolver.position().getLineLayoutItem();
if (lineLayoutItem.isOutOfFlowPositioned()) {
setStaticPositions(m_block, LineLayoutBox(lineLayoutItem), width.indentText());
if (lineLayoutItem.style()->isOriginalDisplayInlineType()) {
resolver.runs().addRun(createRun(0, 1, LineLayoutItem(lineLayoutItem), resolver));
lineInfo.incrementRunsFromLeadingWhitespace();
}
} else if (lineLayoutItem.isFloating()) {
m_block.insertFloatingObject(LineLayoutBox(lineLayoutItem));
m_block.positionNewFloats(&width);
}
resolver.position().increment(&resolver);
}
resolver.commitExplicitEmbedding(resolver.runs());
}
void LineBreaker::skipLeadingWhitespace(InlineBidiResolver& resolver, LineInfo& lineInfo,
FloatingObject* lastFloatFromPreviousLine, LineWidth& width)
{
while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), lineInfo, LeadingWhitespace)) {
RenderObject* object = resolver.position().object();
if (object->isOutOfFlowPositioned()) {
setStaticPositions(m_block, toRenderBox(object));
if (object->style()->isOriginalDisplayInlineType()) {
resolver.runs().addRun(createRun(0, 1, object, resolver));
lineInfo.incrementRunsFromLeadingWhitespace();
}
} else if (object->isFloating()) {
m_block->positionNewFloatOnLine(m_block->insertFloatingObject(*toRenderBox(object)), lastFloatFromPreviousLine, lineInfo, width);
} else if (object->isText() && object->style()->hasTextCombine() && object->isCombineText() && !toRenderCombineText(object)->isCombined()) {
toRenderCombineText(object)->combineText();
if (toRenderCombineText(object)->isCombined())
continue;
}
resolver.position().increment(&resolver);
}
resolver.commitExplicitEmbedding(resolver.runs());
}
