blob: bd0243ad940a8f8323190152ae7c1d218fe84139 [file] [log] [blame]
/*
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "RenderTextLineBoxes.h"
#include "EllipsisBox.h"
#include "InlineTextBox.h"
#include "RenderBlock.h"
#include "RenderStyle.h"
#include "RenderView.h"
#include "RootInlineBox.h"
namespace WebCore {
RenderTextLineBoxes::RenderTextLineBoxes()
: m_first(nullptr)
, m_last(nullptr)
{
}
InlineTextBox* RenderTextLineBoxes::createAndAppendLineBox(RenderText& renderText)
{
auto textBox = renderText.createTextBox();
if (!m_first) {
m_first = textBox.get();
m_last = textBox.get();
} else {
m_last->setNextTextBox(textBox.get());
textBox->setPreviousTextBox(m_last);
m_last = textBox.get();
}
return textBox.release();
}
void RenderTextLineBoxes::extract(InlineTextBox& box)
{
checkConsistency();
m_last = box.prevTextBox();
if (&box == m_first)
m_first = nullptr;
if (box.prevTextBox())
box.prevTextBox()->setNextTextBox(nullptr);
box.setPreviousTextBox(nullptr);
for (auto* current = &box; current; current = current->nextTextBox())
current->setExtracted();
checkConsistency();
}
void RenderTextLineBoxes::attach(InlineTextBox& box)
{
checkConsistency();
if (m_last) {
m_last->setNextTextBox(&box);
box.setPreviousTextBox(m_last);
} else
m_first = &box;
InlineTextBox* last = nullptr;
for (auto* current = &box; current; current = current->nextTextBox()) {
current->setExtracted(false);
last = current;
}
m_last = last;
checkConsistency();
}
void RenderTextLineBoxes::remove(InlineTextBox& box)
{
checkConsistency();
if (&box == m_first)
m_first = box.nextTextBox();
if (&box == m_last)
m_last = box.prevTextBox();
if (box.nextTextBox())
box.nextTextBox()->setPreviousTextBox(box.prevTextBox());
if (box.prevTextBox())
box.prevTextBox()->setNextTextBox(box.nextTextBox());
checkConsistency();
}
void RenderTextLineBoxes::removeAllFromParent(RenderText& renderer)
{
if (!m_first) {
if (renderer.parent())
renderer.parent()->dirtyLinesFromChangedChild(renderer);
return;
}
for (auto* box = m_first; box; box = box->nextTextBox())
box->removeFromParent();
}
void RenderTextLineBoxes::deleteAll()
{
if (!m_first)
return;
InlineTextBox* next;
for (auto* current = m_first; current; current = next) {
next = current->nextTextBox();
delete current;
}
m_first = nullptr;
m_last = nullptr;
}
InlineTextBox* RenderTextLineBoxes::findNext(int offset, int& position) const
{
if (!m_first)
return nullptr;
// FIXME: This looks buggy. The function is only used for debugging purposes.
auto current = m_first;
int currentOffset = current->len();
while (offset > currentOffset && current->nextTextBox()) {
current = current->nextTextBox();
currentOffset = current->start() + current->len();
}
// we are now in the correct text run
position = (offset > currentOffset ? current->len() : current->len() - (currentOffset - offset));
return current;
}
IntRect RenderTextLineBoxes::boundingBox(const RenderText& renderer) const
{
if (!m_first)
return IntRect();
// Return the width of the minimal left side and the maximal right side.
float logicalLeftSide = 0;
float logicalRightSide = 0;
for (auto* current = m_first; current; current = current->nextTextBox()) {
if (current == m_first || current->logicalLeft() < logicalLeftSide)
logicalLeftSide = current->logicalLeft();
if (current == m_first || current->logicalRight() > logicalRightSide)
logicalRightSide = current->logicalRight();
}
bool isHorizontal = renderer.style().isHorizontalWritingMode();
float x = isHorizontal ? logicalLeftSide : m_first->x();
float y = isHorizontal ? m_first->y() : logicalLeftSide;
float width = isHorizontal ? logicalRightSide - logicalLeftSide : m_last->logicalBottom() - x;
float height = isHorizontal ? m_last->logicalBottom() - y : logicalRightSide - logicalLeftSide;
return enclosingIntRect(FloatRect(x, y, width, height));
}
IntPoint RenderTextLineBoxes::firstRunLocation() const
{
if (!m_first)
return IntPoint();
return IntPoint(m_first->topLeft());
}
LayoutRect RenderTextLineBoxes::visualOverflowBoundingBox(const RenderText& renderer) const
{
if (!m_first)
return LayoutRect();
// Return the width of the minimal left side and the maximal right side.
auto logicalLeftSide = LayoutUnit::max();
auto logicalRightSide = LayoutUnit::min();
for (auto* current = m_first; current; current = current->nextTextBox()) {
logicalLeftSide = std::min(logicalLeftSide, current->logicalLeftVisualOverflow());
logicalRightSide = std::max(logicalRightSide, current->logicalRightVisualOverflow());
}
auto logicalTop = m_first->logicalTopVisualOverflow();
auto logicalWidth = logicalRightSide - logicalLeftSide;
auto logicalHeight = m_last->logicalBottomVisualOverflow() - logicalTop;
LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
if (!renderer.style().isHorizontalWritingMode())
rect = rect.transposedRect();
return rect;
}
bool RenderTextLineBoxes::hasRenderedText() const
{
for (auto* box = m_first; box; box = box->nextTextBox()) {
if (box->len())
return true;
}
return false;
}
int RenderTextLineBoxes::caretMinOffset() const
{
auto box = m_first;
if (!box)
return 0;
int minOffset = box->start();
for (box = box->nextTextBox(); box; box = box->nextTextBox())
minOffset = std::min<int>(minOffset, box->start());
return minOffset;
}
int RenderTextLineBoxes::caretMaxOffset(const RenderText& renderer) const
{
auto box = m_last;
if (!box)
return renderer.text().length();
int maxOffset = box->start() + box->len();
for (box = box->prevTextBox(); box; box = box->prevTextBox())
maxOffset = std::max<int>(maxOffset, box->start() + box->len());
return maxOffset;
}
bool RenderTextLineBoxes::containsOffset(const RenderText& renderer, unsigned offset, OffsetType type) const
{
for (auto* box = m_first; box; box = box->nextTextBox()) {
if (offset < box->start() && !renderer.containsReversedText())
return false;
unsigned boxEnd = box->start() + box->len();
if (offset >= box->start() && offset <= boxEnd) {
if (offset == boxEnd && (type == CharacterOffset || box->isLineBreak()))
continue;
if (type == CharacterOffset)
return true;
// Return false for offsets inside composed characters.
return !offset || offset == static_cast<unsigned>(renderer.nextOffset(renderer.previousOffset(offset)));
}
}
return false;
}
unsigned RenderTextLineBoxes::countCharacterOffsetsUntil(unsigned offset) const
{
unsigned result = 0;
for (auto* box = m_first; box; box = box->nextTextBox()) {
if (offset < box->start())
return result;
if (offset <= box->start() + box->len()) {
result += offset - box->start();
return result;
}
result += box->len();
}
return result;
}
enum ShouldAffinityBeDownstream { AlwaysDownstream, AlwaysUpstream, UpstreamIfPositionIsNotAtStart };
static bool lineDirectionPointFitsInBox(int pointLineDirection, const InlineTextBox& box, ShouldAffinityBeDownstream& shouldAffinityBeDownstream)
{
shouldAffinityBeDownstream = AlwaysDownstream;
// the x coordinate is equal to the left edge of this box
// the affinity must be downstream so the position doesn't jump back to the previous line
// except when box is the first box in the line
if (pointLineDirection <= box.logicalLeft()) {
shouldAffinityBeDownstream = !box.prevLeafChild() ? UpstreamIfPositionIsNotAtStart : AlwaysDownstream;
return true;
}
#if !PLATFORM(IOS)
// and the x coordinate is to the left of the right edge of this box
// check to see if position goes in this box
if (pointLineDirection < box.logicalRight()) {
shouldAffinityBeDownstream = UpstreamIfPositionIsNotAtStart;
return true;
}
#endif
// box is first on line
// and the x coordinate is to the left of the first text box left edge
if (!box.prevLeafChildIgnoringLineBreak() && pointLineDirection < box.logicalLeft())
return true;
if (!box.nextLeafChildIgnoringLineBreak()) {
// box is last on line
// and the x coordinate is to the right of the last text box right edge
// generate VisiblePosition, use UPSTREAM affinity if possible
shouldAffinityBeDownstream = UpstreamIfPositionIsNotAtStart;
return true;
}
return false;
}
static VisiblePosition createVisiblePositionForBox(const InlineBox& box, int offset, ShouldAffinityBeDownstream shouldAffinityBeDownstream)
{
EAffinity affinity = VP_DEFAULT_AFFINITY;
switch (shouldAffinityBeDownstream) {
case AlwaysDownstream:
affinity = DOWNSTREAM;
break;
case AlwaysUpstream:
affinity = VP_UPSTREAM_IF_POSSIBLE;
break;
case UpstreamIfPositionIsNotAtStart:
affinity = offset > box.caretMinOffset() ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM;
break;
}
return box.renderer().createVisiblePosition(offset, affinity);
}
static VisiblePosition createVisiblePositionAfterAdjustingOffsetForBiDi(const InlineTextBox& box, int offset, ShouldAffinityBeDownstream shouldAffinityBeDownstream)
{
ASSERT(offset >= 0);
if (offset && static_cast<unsigned>(offset) < box.len())
return createVisiblePositionForBox(box, box.start() + offset, shouldAffinityBeDownstream);
bool positionIsAtStartOfBox = !offset;
if (positionIsAtStartOfBox == box.isLeftToRightDirection()) {
// offset is on the left edge
const InlineBox* prevBox = box.prevLeafChildIgnoringLineBreak();
if ((prevBox && prevBox->bidiLevel() == box.bidiLevel())
|| box.renderer().containingBlock()->style().direction() == box.direction()) // FIXME: left on 12CBA
return createVisiblePositionForBox(box, box.caretLeftmostOffset(), shouldAffinityBeDownstream);
if (prevBox && prevBox->bidiLevel() > box.bidiLevel()) {
// e.g. left of B in aDC12BAb
const InlineBox* leftmostBox;
do {
leftmostBox = prevBox;
prevBox = leftmostBox->prevLeafChildIgnoringLineBreak();
} while (prevBox && prevBox->bidiLevel() > box.bidiLevel());
return createVisiblePositionForBox(*leftmostBox, leftmostBox->caretRightmostOffset(), shouldAffinityBeDownstream);
}
if (!prevBox || prevBox->bidiLevel() < box.bidiLevel()) {
// e.g. left of D in aDC12BAb
const InlineBox* rightmostBox;
const InlineBox* nextBox = &box;
do {
rightmostBox = nextBox;
nextBox = rightmostBox->nextLeafChildIgnoringLineBreak();
} while (nextBox && nextBox->bidiLevel() >= box.bidiLevel());
return createVisiblePositionForBox(*rightmostBox,
box.isLeftToRightDirection() ? rightmostBox->caretMaxOffset() : rightmostBox->caretMinOffset(), shouldAffinityBeDownstream);
}
return createVisiblePositionForBox(box, box.caretRightmostOffset(), shouldAffinityBeDownstream);
}
const InlineBox* nextBox = box.nextLeafChildIgnoringLineBreak();
if ((nextBox && nextBox->bidiLevel() == box.bidiLevel())
|| box.renderer().containingBlock()->style().direction() == box.direction())
return createVisiblePositionForBox(box, box.caretRightmostOffset(), shouldAffinityBeDownstream);
// offset is on the right edge
if (nextBox && nextBox->bidiLevel() > box.bidiLevel()) {
// e.g. right of C in aDC12BAb
const InlineBox* rightmostBox;
do {
rightmostBox = nextBox;
nextBox = rightmostBox->nextLeafChildIgnoringLineBreak();
} while (nextBox && nextBox->bidiLevel() > box.bidiLevel());
return createVisiblePositionForBox(*rightmostBox, rightmostBox->caretLeftmostOffset(), shouldAffinityBeDownstream);
}
if (!nextBox || nextBox->bidiLevel() < box.bidiLevel()) {
// e.g. right of A in aDC12BAb
const InlineBox* leftmostBox;
const InlineBox* prevBox = &box;
do {
leftmostBox = prevBox;
prevBox = leftmostBox->prevLeafChildIgnoringLineBreak();
} while (prevBox && prevBox->bidiLevel() >= box.bidiLevel());
return createVisiblePositionForBox(*leftmostBox,
box.isLeftToRightDirection() ? leftmostBox->caretMinOffset() : leftmostBox->caretMaxOffset(), shouldAffinityBeDownstream);
}
return createVisiblePositionForBox(box, box.caretLeftmostOffset(), shouldAffinityBeDownstream);
}
VisiblePosition RenderTextLineBoxes::positionForPoint(const RenderText& renderer, const LayoutPoint& point) const
{
if (!m_first || !renderer.text().length())
return renderer.createVisiblePosition(0, DOWNSTREAM);
LayoutUnit pointLineDirection = m_first->isHorizontal() ? point.x() : point.y();
LayoutUnit pointBlockDirection = m_first->isHorizontal() ? point.y() : point.x();
bool blocksAreFlipped = renderer.style().isFlippedBlocksWritingMode();
InlineTextBox* lastBox = nullptr;
for (auto* box = m_first; box; box = box->nextTextBox()) {
if (box->isLineBreak() && !box->prevLeafChild() && box->nextLeafChild() && !box->nextLeafChild()->isLineBreak())
box = box->nextTextBox();
auto& rootBox = box->root();
LayoutUnit top = std::min(rootBox.selectionTop(), rootBox.lineTop());
if (pointBlockDirection > top || (!blocksAreFlipped && pointBlockDirection == top)) {
LayoutUnit bottom = rootBox.selectionBottom();
if (rootBox.nextRootBox())
bottom = std::min(bottom, rootBox.nextRootBox()->lineTop());
if (pointBlockDirection < bottom || (blocksAreFlipped && pointBlockDirection == bottom)) {
ShouldAffinityBeDownstream shouldAffinityBeDownstream;
#if PLATFORM(IOS)
if (pointLineDirection != box->logicalLeft() && point.x() < box->x() + box->logicalWidth()) {
int half = box->x() + box->logicalWidth() / 2;
EAffinity affinity = point.x() < half ? DOWNSTREAM : VP_UPSTREAM_IF_POSSIBLE;
return renderer.createVisiblePosition(box->offsetForPosition(pointLineDirection) + box->start(), affinity);
}
#endif
if (lineDirectionPointFitsInBox(pointLineDirection, *box, shouldAffinityBeDownstream))
return createVisiblePositionAfterAdjustingOffsetForBiDi(*box, box->offsetForPosition(pointLineDirection), shouldAffinityBeDownstream);
}
}
lastBox = box;
}
if (lastBox) {
ShouldAffinityBeDownstream shouldAffinityBeDownstream;
lineDirectionPointFitsInBox(pointLineDirection, *lastBox, shouldAffinityBeDownstream);
return createVisiblePositionAfterAdjustingOffsetForBiDi(*lastBox, lastBox->offsetForPosition(pointLineDirection) + lastBox->start(), shouldAffinityBeDownstream);
}
return renderer.createVisiblePosition(0, DOWNSTREAM);
}
void RenderTextLineBoxes::setSelectionState(RenderText& renderer, RenderObject::SelectionState state)
{
if (state == RenderObject::SelectionInside || state == RenderObject::SelectionNone) {
for (auto* box = m_first; box; box = box->nextTextBox())
box->root().setHasSelectedChildren(state == RenderObject::SelectionInside);
return;
}
auto start = renderer.view().selection().startPosition();
auto end = renderer.view().selection().endPosition();
if (state == RenderObject::SelectionStart) {
end = renderer.text().length();
// to handle selection from end of text to end of line
if (start && start == end)
start = end - 1;
} else if (state == RenderObject::SelectionEnd)
start = 0;
for (auto* box = m_first; box; box = box->nextTextBox()) {
if (box->isSelected(start, end))
box->root().setHasSelectedChildren(true);
}
}
static IntRect ellipsisRectForBox(const InlineTextBox& box, unsigned start, unsigned end)
{
unsigned short truncation = box.truncation();
if (truncation == cNoTruncation)
return IntRect();
auto ellipsis = box.root().ellipsisBox();
if (!ellipsis)
return IntRect();
IntRect rect;
int ellipsisStartPosition = std::max<int>(start - box.start(), 0);
int ellipsisEndPosition = std::min<int>(end - box.start(), box.len());
// The ellipsis should be considered to be selected if the end of
// the selection is past the beginning of the truncation and the
// beginning of the selection is before or at the beginning of the truncation.
if (ellipsisEndPosition < truncation && ellipsisStartPosition > truncation)
return IntRect();
return ellipsis->selectionRect();
}
LayoutRect RenderTextLineBoxes::selectionRectForRange(unsigned start, unsigned end)
{
LayoutRect rect;
for (auto* box = m_first; box; box = box->nextTextBox()) {
rect.unite(box->localSelectionRect(start, end));
rect.unite(ellipsisRectForBox(*box, start, end));
}
return rect;
}
void RenderTextLineBoxes::collectSelectionRectsForRange(unsigned start, unsigned end, Vector<LayoutRect>& rects)
{
for (auto* box = m_first; box; box = box->nextTextBox()) {
LayoutRect rect;
rect.unite(box->localSelectionRect(start, end));
rect.unite(ellipsisRectForBox(*box, start, end));
if (!rect.size().isEmpty())
rects.append(rect);
}
}
Vector<IntRect> RenderTextLineBoxes::absoluteRects(const LayoutPoint& accumulatedOffset) const
{
Vector<IntRect> rects;
for (auto* box = m_first; box; box = box->nextTextBox())
rects.append(enclosingIntRect(FloatRect(accumulatedOffset + box->topLeft(), box->size())));
return rects;
}
static FloatRect localQuadForTextBox(const InlineTextBox& box, unsigned start, unsigned end, bool useSelectionHeight)
{
unsigned realEnd = std::min(box.end() + 1, end);
LayoutRect boxSelectionRect = box.localSelectionRect(start, realEnd);
if (!boxSelectionRect.height())
return FloatRect();
if (useSelectionHeight)
return boxSelectionRect;
// Change the height and y position (or width and x for vertical text)
// because selectionRect uses selection-specific values.
if (box.isHorizontal()) {
boxSelectionRect.setHeight(box.height());
boxSelectionRect.setY(box.y());
} else {
boxSelectionRect.setWidth(box.width());
boxSelectionRect.setX(box.x());
}
return boxSelectionRect;
}
Vector<IntRect> RenderTextLineBoxes::absoluteRectsForRange(const RenderText& renderer, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed) const
{
Vector<IntRect> rects;
for (auto* box = m_first; box; box = box->nextTextBox()) {
// Note: box->end() returns the index of the last character, not the index past it
if (start <= box->start() && box->end() < end) {
FloatRect boundaries = box->calculateBoundaries();
if (useSelectionHeight) {
LayoutRect selectionRect = box->localSelectionRect(start, end);
if (box->isHorizontal()) {
boundaries.setHeight(selectionRect.height());
boundaries.setY(selectionRect.y());
} else {
boundaries.setWidth(selectionRect.width());
boundaries.setX(selectionRect.x());
}
}
rects.append(renderer.localToAbsoluteQuad(boundaries, UseTransforms, wasFixed).enclosingBoundingBox());
continue;
}
FloatRect rect = localQuadForTextBox(*box, start, end, useSelectionHeight);
if (!rect.isZero())
rects.append(renderer.localToAbsoluteQuad(rect, UseTransforms, wasFixed).enclosingBoundingBox());
}
return rects;
}
Vector<FloatQuad> RenderTextLineBoxes::absoluteQuads(const RenderText& renderer, bool* wasFixed, ClippingOption option) const
{
Vector<FloatQuad> quads;
for (auto* box = m_first; box; box = box->nextTextBox()) {
FloatRect boundaries = box->calculateBoundaries();
// Shorten the width of this text box if it ends in an ellipsis.
// FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
IntRect ellipsisRect = (option == ClipToEllipsis) ? ellipsisRectForBox(*box, 0, renderer.text().length()) : IntRect();
if (!ellipsisRect.isEmpty()) {
if (renderer.style().isHorizontalWritingMode())
boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
else
boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
}
quads.append(renderer.localToAbsoluteQuad(boundaries, UseTransforms, wasFixed));
}
return quads;
}
Vector<FloatQuad> RenderTextLineBoxes::absoluteQuadsForRange(const RenderText& renderer, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed) const
{
Vector<FloatQuad> quads;
for (auto* box = m_first; box; box = box->nextTextBox()) {
// Note: box->end() returns the index of the last character, not the index past it
if (start <= box->start() && box->end() < end) {
FloatRect boundaries = box->calculateBoundaries();
if (useSelectionHeight) {
LayoutRect selectionRect = box->localSelectionRect(start, end);
if (box->isHorizontal()) {
boundaries.setHeight(selectionRect.height());
boundaries.setY(selectionRect.y());
} else {
boundaries.setWidth(selectionRect.width());
boundaries.setX(selectionRect.x());
}
}
quads.append(renderer.localToAbsoluteQuad(boundaries, UseTransforms, wasFixed));
continue;
}
FloatRect rect = localQuadForTextBox(*box, start, end, useSelectionHeight);
if (!rect.isZero())
quads.append(renderer.localToAbsoluteQuad(rect, UseTransforms, wasFixed));
}
return quads;
}
void RenderTextLineBoxes::dirtyAll()
{
for (auto* box = m_first; box; box = box->nextTextBox())
box->dirtyLineBoxes();
}
bool RenderTextLineBoxes::dirtyRange(RenderText& renderer, unsigned start, unsigned end, int lengthDelta)
{
RootInlineBox* firstRootBox = nullptr;
RootInlineBox* lastRootBox = nullptr;
// Dirty all text boxes that include characters in between offset and offset+len.
bool dirtiedLines = false;
for (auto* current = m_first; current; current = current->nextTextBox()) {
// FIXME: This shouldn't rely on the end of a dirty line box. See https://bugs.webkit.org/show_bug.cgi?id=97264
// Text run is entirely before the affected range.
if (current->end() < start)
continue;
// Text run is entirely after the affected range.
if (current->start() > end) {
current->offsetRun(lengthDelta);
auto& rootBox = current->root();
if (!firstRootBox) {
firstRootBox = &rootBox;
if (!dirtiedLines) {
// The affected area was in between two runs. Mark the root box of the run after the affected area as dirty.
firstRootBox->markDirty();
dirtiedLines = true;
}
}
lastRootBox = &rootBox;
continue;
}
if (current->end() >= start && current->end() <= end) {
// Text run overlaps with the left end of the affected range.
current->dirtyLineBoxes();
dirtiedLines = true;
continue;
}
if (current->start() <= start && current->end() >= end) {
// Text run subsumes the affected range.
current->dirtyLineBoxes();
dirtiedLines = true;
continue;
}
if (current->start() <= end && current->end() >= end) {
// Text run overlaps with right end of the affected range.
current->dirtyLineBoxes();
dirtiedLines = true;
continue;
}
}
// Now we have to walk all of the clean lines and adjust their cached line break information
// to reflect our updated offsets.
if (lastRootBox)
lastRootBox = lastRootBox->nextRootBox();
if (firstRootBox) {
auto previousRootBox = firstRootBox->prevRootBox();
if (previousRootBox)
firstRootBox = previousRootBox;
} else if (m_last) {
ASSERT(!lastRootBox);
firstRootBox = &m_last->root();
firstRootBox->markDirty();
dirtiedLines = true;
}
for (auto* current = firstRootBox; current && current != lastRootBox; current = current->nextRootBox()) {
if (current->lineBreakObj() == &renderer && current->lineBreakPos() > end)
current->setLineBreakPos(current->lineBreakPos() + lengthDelta);
}
// If the text node is empty, dirty the line where new text will be inserted.
if (!m_first && renderer.parent()) {
renderer.parent()->dirtyLinesFromChangedChild(renderer);
dirtiedLines = true;
}
return dirtiedLines;
}
inline void RenderTextLineBoxes::checkConsistency() const
{
#if !ASSERT_DISABLED
#ifdef CHECK_CONSISTENCY
const InlineTextBox* prev = nullptr;
for (auto* child = m_first; child; child = child->nextTextBox()) {
ASSERT(child->renderer() == this);
ASSERT(child->prevTextBox() == prev);
prev = child;
}
ASSERT(prev == m_last);
#endif
#endif
}
#if !ASSERT_DISABLED
RenderTextLineBoxes::~RenderTextLineBoxes()
{
ASSERT(!m_first);
ASSERT(!m_last);
}
#endif
#if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
void RenderTextLineBoxes::invalidateParentChildLists()
{
for (auto* box = m_first; box; box = box->nextTextBox())
box->invalidateParentChildList();
}
#endif
}