RenderListItem.cpp [plain text]
#include "config.h"
#include "RenderListItem.h"
#include "ElementTraversal.h"
#include "HTMLNames.h"
#include "HTMLOListElement.h"
#include "HTMLUListElement.h"
#include "InlineElementBox.h"
#include "PseudoElement.h"
#include "RenderChildIterator.h"
#include "RenderInline.h"
#include "RenderListMarker.h"
#include "RenderMultiColumnFlowThread.h"
#include "RenderRuby.h"
#include "RenderTable.h"
#include "RenderView.h"
#include "StyleInheritedData.h"
#include <wtf/StackStats.h>
#include <wtf/StdLibExtras.h>
namespace WebCore {
using namespace HTMLNames;
RenderListItem::RenderListItem(Element& element, RenderStyle&& style)
: RenderBlockFlow(element, WTFMove(style))
, m_marker(nullptr)
, m_hasExplicitValue(false)
, m_isValueUpToDate(false)
, m_notInList(false)
{
setInline(false);
}
RenderListItem::~RenderListItem()
{
ASSERT(!m_marker || !m_marker->parent());
if (m_marker) {
m_marker->destroy();
ASSERT(!m_marker);
}
}
void RenderListItem::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlockFlow::styleDidChange(diff, oldStyle);
if (style().listStyleType() == NoneListStyle && (!style().listStyleImage() || style().listStyleImage()->errorOccurred())) {
if (m_marker) {
m_marker->destroy();
ASSERT(!m_marker);
}
return;
}
auto newStyle = RenderStyle::create();
newStyle.inheritFrom(style());
if (!m_marker) {
m_marker = createRenderer<RenderListMarker>(*this, WTFMove(newStyle)).leakPtr();
m_marker->initializeStyle();
} else {
if (diff != StyleDifferenceEqual)
m_marker->setStyle(WTFMove(newStyle));
}
}
void RenderListItem::insertedIntoTree()
{
RenderBlockFlow::insertedIntoTree();
updateListMarkerNumbers();
}
void RenderListItem::willBeRemovedFromTree()
{
RenderBlockFlow::willBeRemovedFromTree();
updateListMarkerNumbers();
}
static inline bool isHTMLListElement(const Node& node)
{
return is<HTMLUListElement>(node) || is<HTMLOListElement>(node);
}
static Element* enclosingList(const RenderListItem& listItem)
{
Element& listItemElement = listItem.element();
Element* parent = is<PseudoElement>(listItemElement) ? downcast<PseudoElement>(listItemElement).hostElement() : listItemElement.parentElement();
Element* firstNode = parent;
for (; parent; parent = parent->parentElement()) {
if (isHTMLListElement(*parent))
return parent;
}
return firstNode;
}
static RenderListItem* nextListItem(const Element& listNode, const Element& element)
{
for (const Element* next = ElementTraversal::nextIncludingPseudo(element, &listNode); next; ) {
auto* renderer = next->renderer();
if (!renderer || isHTMLListElement(*next)) {
next = ElementTraversal::nextIncludingPseudoSkippingChildren(*next, &listNode);
continue;
}
if (is<RenderListItem>(*renderer))
return downcast<RenderListItem>(renderer);
next = ElementTraversal::nextIncludingPseudo(*next, &listNode);
}
return nullptr;
}
static inline RenderListItem* nextListItem(const Element& listNode, const RenderListItem& item)
{
return nextListItem(listNode, item.element());
}
static inline RenderListItem* nextListItem(const Element& listNode)
{
return nextListItem(listNode, listNode);
}
static RenderListItem* previousListItem(const Element* listNode, const RenderListItem& item)
{
for (const Element* current = ElementTraversal::previousIncludingPseudo(item.element(), listNode); current; current = ElementTraversal::previousIncludingPseudo(*current, listNode)) {
RenderElement* renderer = current->renderer();
if (!is<RenderListItem>(renderer))
continue;
Element* otherList = enclosingList(downcast<RenderListItem>(*renderer));
if (listNode == otherList)
return downcast<RenderListItem>(renderer);
if (otherList)
current = ElementTraversal::nextIncludingPseudo(*otherList);
}
return nullptr;
}
void RenderListItem::updateItemValuesForOrderedList(const HTMLOListElement& listNode)
{
for (RenderListItem* listItem = nextListItem(listNode); listItem; listItem = nextListItem(listNode, *listItem))
listItem->updateValue();
}
unsigned RenderListItem::itemCountForOrderedList(const HTMLOListElement& listNode)
{
unsigned itemCount = 0;
for (RenderListItem* listItem = nextListItem(listNode); listItem; listItem = nextListItem(listNode, *listItem))
++itemCount;
return itemCount;
}
inline int RenderListItem::calcValue() const
{
if (m_hasExplicitValue)
return m_explicitValue;
Element* list = enclosingList(*this);
HTMLOListElement* oListElement = is<HTMLOListElement>(list) ? downcast<HTMLOListElement>(list) : nullptr;
int valueStep = 1;
if (oListElement && oListElement->isReversed())
valueStep = -1;
if (RenderListItem* previousItem = previousListItem(list, *this))
return previousItem->value() + valueStep;
if (oListElement)
return oListElement->start();
return 1;
}
void RenderListItem::updateValueNow() const
{
m_value = calcValue();
m_isValueUpToDate = true;
}
static RenderBlock* getParentOfFirstLineBox(RenderBlock& current, RenderObject& marker)
{
bool inQuirksMode = current.document().inQuirksMode();
for (auto& child : childrenOfType<RenderObject>(current)) {
if (&child == &marker)
continue;
if (child.isInline() && (!is<RenderInline>(child) || current.generatesLineBoxesForInlineChild(&child)))
return ¤t;
if (child.isFloating() || child.isOutOfFlowPositioned())
continue;
if (!is<RenderBlock>(child) || is<RenderTable>(child) || is<RenderRubyAsBlock>(child))
break;
if (is<RenderBox>(child) && downcast<RenderBox>(child).isWritingModeRoot())
break;
if (is<RenderListItem>(current) && inQuirksMode && child.node() && isHTMLListElement(*child.node()))
break;
if (RenderBlock* lineBox = getParentOfFirstLineBox(downcast<RenderBlock>(child), marker))
return lineBox;
}
return nullptr;
}
void RenderListItem::updateValue()
{
if (!m_hasExplicitValue) {
m_isValueUpToDate = false;
if (m_marker)
m_marker->setNeedsLayoutAndPrefWidthsRecalc();
}
}
static RenderObject* firstNonMarkerChild(RenderBlock& parent)
{
RenderObject* child = parent.firstChild();
while (is<RenderListMarker>(child))
child = child->nextSibling();
return child;
}
void RenderListItem::insertOrMoveMarkerRendererIfNeeded()
{
if (!m_marker)
return;
if (!view().frameView().isInRenderTreeLayout())
return;
RenderElement* currentParent = m_marker->parent();
RenderBlock* newParent = getParentOfFirstLineBox(*this, *m_marker);
if (!newParent) {
if (currentParent && currentParent->isAnonymousBlock())
return;
if (multiColumnFlowThread())
newParent = multiColumnFlowThread();
else
newParent = this;
}
if (newParent != currentParent) {
LayoutStateDisabler layoutStateDisabler(view());
newParent->setChildNeedsLayout(MarkOnlyThis);
m_marker->setNeedsLayout(MarkOnlyThis);
m_marker->removeFromParent();
newParent->addChild(m_marker, firstNonMarkerChild(*newParent));
m_marker->updateMarginsAndContent();
if (currentParent && currentParent->isAnonymousBlock() && !currentParent->firstChild() && !downcast<RenderBlock>(*currentParent).continuation())
currentParent->destroy();
}
}
void RenderListItem::layout()
{
StackStats::LayoutCheckPoint layoutCheckPoint;
ASSERT(needsLayout());
insertOrMoveMarkerRendererIfNeeded();
RenderBlockFlow::layout();
}
void RenderListItem::addOverflowFromChildren()
{
positionListMarker();
RenderBlockFlow::addOverflowFromChildren();
}
void RenderListItem::computePreferredLogicalWidths()
{
#ifndef NDEBUG
SetLayoutNeededForbiddenScope layoutForbiddenScope(this, false);
#endif
insertOrMoveMarkerRendererIfNeeded();
RenderBlockFlow::computePreferredLogicalWidths();
}
void RenderListItem::positionListMarker()
{
if (m_marker && m_marker->parent()->isBox() && !m_marker->isInside() && m_marker->inlineBoxWrapper()) {
LayoutUnit markerOldLogicalLeft = m_marker->logicalLeft();
LayoutUnit blockOffset = 0;
LayoutUnit lineOffset = 0;
for (RenderBox* o = m_marker->parentBox(); o != this; o = o->parentBox()) {
blockOffset += o->logicalTop();
lineOffset += o->logicalLeft();
}
bool adjustOverflow = false;
LayoutUnit markerLogicalLeft;
bool hitSelfPaintingLayer = false;
const RootInlineBox& rootBox = m_marker->inlineBoxWrapper()->root();
LayoutUnit lineTop = rootBox.lineTop();
LayoutUnit lineBottom = rootBox.lineBottom();
if (style().isLeftToRightDirection()) {
LayoutUnit leftLineOffset = logicalLeftOffsetForLine(blockOffset, logicalLeftOffsetForLine(blockOffset, DoNotIndentText), false);
markerLogicalLeft = leftLineOffset - lineOffset - paddingStart() - borderStart() + m_marker->marginStart();
m_marker->inlineBoxWrapper()->adjustLineDirectionPosition(markerLogicalLeft - markerOldLogicalLeft);
for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
if (markerLogicalLeft < newLogicalVisualOverflowRect.x() && !hitSelfPaintingLayer) {
newLogicalVisualOverflowRect.setWidth(newLogicalVisualOverflowRect.maxX() - markerLogicalLeft);
newLogicalVisualOverflowRect.setX(markerLogicalLeft);
if (box == &rootBox)
adjustOverflow = true;
}
if (markerLogicalLeft < newLogicalLayoutOverflowRect.x()) {
newLogicalLayoutOverflowRect.setWidth(newLogicalLayoutOverflowRect.maxX() - markerLogicalLeft);
newLogicalLayoutOverflowRect.setX(markerLogicalLeft);
if (box == &rootBox)
adjustOverflow = true;
}
box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
if (box->renderer().hasSelfPaintingLayer())
hitSelfPaintingLayer = true;
}
} else {
LayoutUnit rightLineOffset = logicalRightOffsetForLine(blockOffset, logicalRightOffsetForLine(blockOffset, DoNotIndentText), false);
markerLogicalLeft = rightLineOffset - lineOffset + paddingStart() + borderStart() + m_marker->marginEnd();
m_marker->inlineBoxWrapper()->adjustLineDirectionPosition(markerLogicalLeft - markerOldLogicalLeft);
for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalVisualOverflowRect.maxX() && !hitSelfPaintingLayer) {
newLogicalVisualOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalVisualOverflowRect.x());
if (box == &rootBox)
adjustOverflow = true;
}
if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalLayoutOverflowRect.maxX()) {
newLogicalLayoutOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalLayoutOverflowRect.x());
if (box == &rootBox)
adjustOverflow = true;
}
box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
if (box->renderer().hasSelfPaintingLayer())
hitSelfPaintingLayer = true;
}
}
if (adjustOverflow) {
LayoutRect markerRect(markerLogicalLeft + lineOffset, blockOffset, m_marker->width(), m_marker->height());
if (!style().isHorizontalWritingMode())
markerRect = markerRect.transposedRect();
RenderBox* o = m_marker;
bool propagateVisualOverflow = true;
bool propagateLayoutOverflow = true;
do {
o = o->parentBox();
if (o->hasOverflowClip())
propagateVisualOverflow = false;
if (is<RenderBlock>(*o)) {
if (propagateVisualOverflow)
downcast<RenderBlock>(*o).addVisualOverflow(markerRect);
if (propagateLayoutOverflow)
downcast<RenderBlock>(*o).addLayoutOverflow(markerRect);
}
if (o->hasOverflowClip())
propagateLayoutOverflow = false;
if (o->hasSelfPaintingLayer())
propagateVisualOverflow = false;
markerRect.moveBy(-o->location());
} while (o != this && propagateVisualOverflow && propagateLayoutOverflow);
}
}
}
void RenderListItem::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (!logicalHeight() && hasOverflowClip())
return;
RenderBlockFlow::paint(paintInfo, paintOffset);
}
const String& RenderListItem::markerText() const
{
if (m_marker)
return m_marker->text();
return nullAtom.string();
}
String RenderListItem::markerTextWithSuffix() const
{
if (!m_marker)
return String();
if (m_marker->style().isLeftToRightDirection())
return m_marker->text() + m_marker->suffix();
return m_marker->suffix() + m_marker->text();
}
void RenderListItem::explicitValueChanged()
{
if (m_marker)
m_marker->setNeedsLayoutAndPrefWidthsRecalc();
updateValue();
Element* listNode = enclosingList(*this);
if (!listNode)
return;
for (RenderListItem* item = nextListItem(*listNode, *this); item; item = nextListItem(*listNode, *item))
item->updateValue();
}
void RenderListItem::setExplicitValue(int value)
{
if (m_hasExplicitValue && m_explicitValue == value)
return;
m_explicitValue = value;
m_value = value;
m_hasExplicitValue = true;
explicitValueChanged();
}
void RenderListItem::clearExplicitValue()
{
if (!m_hasExplicitValue)
return;
m_hasExplicitValue = false;
m_isValueUpToDate = false;
explicitValueChanged();
}
static inline RenderListItem* previousOrNextItem(bool isListReversed, Element& list, RenderListItem& item)
{
return isListReversed ? previousListItem(&list, item) : nextListItem(list, item);
}
void RenderListItem::updateListMarkerNumbers()
{
Element* listNode = enclosingList(*this);
if (!listNode)
return;
bool isListReversed = false;
if (is<HTMLOListElement>(*listNode)) {
HTMLOListElement& oListElement = downcast<HTMLOListElement>(*listNode);
oListElement.itemCountChanged();
isListReversed = oListElement.isReversed();
}
for (RenderListItem* item = previousOrNextItem(isListReversed, *listNode, *this); item; item = previousOrNextItem(isListReversed, *listNode, *item)) {
if (!item->m_isValueUpToDate) {
break;
}
item->updateValue();
}
}
}