0e06f65d1db6edb053757b476a02a87e22b35227
[WebKit-https.git] / Source / WebCore / rendering / RenderListItem.cpp
1 /**
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
5  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #include "config.h"
25 #include "RenderListItem.h"
26
27 #include "ElementTraversal.h"
28 #include "HTMLNames.h"
29 #include "HTMLOListElement.h"
30 #include "HTMLUListElement.h"
31 #include "InlineElementBox.h"
32 #include "PseudoElement.h"
33 #include "RenderChildIterator.h"
34 #include "RenderInline.h"
35 #include "RenderListMarker.h"
36 #include "RenderMultiColumnFlowThread.h"
37 #include "RenderRuby.h"
38 #include "RenderTable.h"
39 #include "RenderView.h"
40 #include "StyleInheritedData.h"
41 #if !ASSERT_DISABLED
42 #include <wtf/SetForScope.h>
43 #endif
44 #include <wtf/StackStats.h>
45 #include <wtf/StdLibExtras.h>
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50
51 RenderListItem::RenderListItem(Element& element, RenderStyle&& style)
52     : RenderBlockFlow(element, WTFMove(style))
53     , m_marker(nullptr)
54     , m_hasExplicitValue(false)
55     , m_isValueUpToDate(false)
56     , m_notInList(false)
57 {
58     setInline(false);
59 }
60
61 RenderListItem::~RenderListItem()
62 {
63     // Do not add any code here. Add it to willBeDestroyed() instead.
64 }
65
66 void RenderListItem::willBeDestroyed()
67 {
68     if (m_marker) {
69         m_marker->destroy();
70         ASSERT(!m_marker);
71     }
72     RenderBlockFlow::willBeDestroyed();
73 }
74
75 void RenderListItem::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
76 {
77     RenderBlockFlow::styleDidChange(diff, oldStyle);
78
79     if (style().listStyleType() == NoneListStyle && (!style().listStyleImage() || style().listStyleImage()->errorOccurred())) {
80         if (m_marker) {
81             m_marker->destroy();
82             ASSERT(!m_marker);
83         }
84         return;
85     }
86
87     auto newStyle = RenderStyle::create();
88     // The marker always inherits from the list item, regardless of where it might end
89     // up (e.g., in some deeply nested line box). See CSS3 spec.
90     newStyle.inheritFrom(style());
91     if (!m_marker) {
92         m_marker = createRenderer<RenderListMarker>(*this, WTFMove(newStyle)).leakPtr();
93         m_marker->initializeStyle();
94     } else {
95         // Do not alter our marker's style unless our style has actually changed.
96         if (diff != StyleDifferenceEqual)
97             m_marker->setStyle(WTFMove(newStyle));
98     }
99 }
100
101 void RenderListItem::insertedIntoTree()
102 {
103     RenderBlockFlow::insertedIntoTree();
104
105     updateListMarkerNumbers();
106 }
107
108 void RenderListItem::willBeRemovedFromTree()
109 {
110     RenderBlockFlow::willBeRemovedFromTree();
111
112     updateListMarkerNumbers();
113 }
114
115 static inline bool isHTMLListElement(const Node& node)
116 {
117     return is<HTMLUListElement>(node) || is<HTMLOListElement>(node);
118 }
119
120 // Returns the enclosing list with respect to the DOM order.
121 static Element* enclosingList(const RenderListItem& listItem)
122 {
123     Element& listItemElement = listItem.element();
124     Element* parent = is<PseudoElement>(listItemElement) ? downcast<PseudoElement>(listItemElement).hostElement() : listItemElement.parentElement();
125     Element* firstNode = parent;
126     // We use parentNode because the enclosing list could be a ShadowRoot that's not Element.
127     for (; parent; parent = parent->parentElement()) {
128         if (isHTMLListElement(*parent))
129             return parent;
130     }
131
132     // If there's no actual <ul> or <ol> list element, then the first found
133     // node acts as our list for purposes of determining what other list items
134     // should be numbered as part of the same list.
135     return firstNode;
136 }
137
138 // Returns the next list item with respect to the DOM order.
139 static RenderListItem* nextListItem(const Element& listNode, const Element& element)
140 {
141     for (const Element* next = ElementTraversal::nextIncludingPseudo(element, &listNode); next; ) {
142         auto* renderer = next->renderer();
143         if (!renderer || isHTMLListElement(*next)) {
144             // We've found a nested, independent list or an unrendered Element : nothing to do here.
145             next = ElementTraversal::nextIncludingPseudoSkippingChildren(*next, &listNode);
146             continue;
147         }
148
149         if (is<RenderListItem>(*renderer))
150             return downcast<RenderListItem>(renderer);
151
152         next = ElementTraversal::nextIncludingPseudo(*next, &listNode);
153     }
154
155     return nullptr;
156 }
157
158 static inline RenderListItem* nextListItem(const Element& listNode, const RenderListItem& item)
159 {
160     return nextListItem(listNode, item.element());
161 }
162
163 static inline RenderListItem* nextListItem(const Element& listNode)
164 {
165     return nextListItem(listNode, listNode);
166 }
167
168 // Returns the previous list item with respect to the DOM order.
169 static RenderListItem* previousListItem(const Element* listNode, const RenderListItem& item)
170 {
171     for (const Element* current = ElementTraversal::previousIncludingPseudo(item.element(), listNode); current; current = ElementTraversal::previousIncludingPseudo(*current, listNode)) {
172         RenderElement* renderer = current->renderer();
173         if (!is<RenderListItem>(renderer))
174             continue;
175         Element* otherList = enclosingList(downcast<RenderListItem>(*renderer));
176         // This item is part of our current list, so it's what we're looking for.
177         if (listNode == otherList)
178             return downcast<RenderListItem>(renderer);
179         // We found ourself inside another list; lets skip the rest of it.
180         // Use nextIncludingPseudo() here because the other list itself may actually
181         // be a list item itself. We need to examine it, so we do this to counteract
182         // the previousIncludingPseudo() that will be done by the loop.
183         if (otherList)
184             current = ElementTraversal::nextIncludingPseudo(*otherList);
185     }
186     return nullptr;
187 }
188
189 void RenderListItem::updateItemValuesForOrderedList(const HTMLOListElement& listNode)
190 {
191     for (RenderListItem* listItem = nextListItem(listNode); listItem; listItem = nextListItem(listNode, *listItem))
192         listItem->updateValue();
193 }
194
195 unsigned RenderListItem::itemCountForOrderedList(const HTMLOListElement& listNode)
196 {
197     unsigned itemCount = 0;
198     for (RenderListItem* listItem = nextListItem(listNode); listItem; listItem = nextListItem(listNode, *listItem))
199         ++itemCount;
200     return itemCount;
201 }
202
203 inline int RenderListItem::calcValue() const
204 {
205     if (m_hasExplicitValue)
206         return m_explicitValue;
207
208     Element* list = enclosingList(*this);
209     HTMLOListElement* oListElement = is<HTMLOListElement>(list) ? downcast<HTMLOListElement>(list) : nullptr;
210     int valueStep = 1;
211     if (oListElement && oListElement->isReversed())
212         valueStep = -1;
213
214     // FIXME: This recurses to a possible depth of the length of the list.
215     // That's not good -- we need to change this to an iterative algorithm.
216     if (RenderListItem* previousItem = previousListItem(list, *this))
217         return previousItem->value() + valueStep;
218
219     if (oListElement)
220         return oListElement->start();
221
222     return 1;
223 }
224
225 void RenderListItem::updateValueNow() const
226 {
227     m_value = calcValue();
228     m_isValueUpToDate = true;
229 }
230
231 static RenderBlock* getParentOfFirstLineBox(RenderBlock& current, RenderObject& marker)
232 {
233     bool inQuirksMode = current.document().inQuirksMode();
234     for (auto& child : childrenOfType<RenderObject>(current)) {
235         if (&child == &marker)
236             continue;
237
238         if (child.isInline() && (!is<RenderInline>(child) || current.generatesLineBoxesForInlineChild(&child)))
239             return &current;
240
241         if (child.isFloating() || child.isOutOfFlowPositioned())
242             continue;
243
244         if (!is<RenderBlock>(child) || is<RenderTable>(child) || is<RenderRubyAsBlock>(child))
245             break;
246
247         if (is<RenderBox>(child) && downcast<RenderBox>(child).isWritingModeRoot())
248             break;
249
250         if (is<RenderListItem>(current) && inQuirksMode && child.node() && isHTMLListElement(*child.node()))
251             break;
252
253         if (RenderBlock* lineBox = getParentOfFirstLineBox(downcast<RenderBlock>(child), marker))
254             return lineBox;
255     }
256
257     return nullptr;
258 }
259
260 void RenderListItem::updateValue()
261 {
262     if (!m_hasExplicitValue) {
263         m_isValueUpToDate = false;
264         if (m_marker)
265             m_marker->setNeedsLayoutAndPrefWidthsRecalc();
266     }
267 }
268
269 static RenderObject* firstNonMarkerChild(RenderBlock& parent)
270 {
271     RenderObject* child = parent.firstChild();
272     while (is<RenderListMarker>(child))
273         child = child->nextSibling();
274     return child;
275 }
276
277 void RenderListItem::insertOrMoveMarkerRendererIfNeeded()
278 {
279     // Sanity check the location of our marker.
280     if (!m_marker)
281         return;
282
283     // FIXME: Do not even try to reposition the marker when we are not in layout
284     // until after we fixed webkit.org/b/163789.
285     if (!view().frameView().isInRenderTreeLayout())
286         return;
287
288     RenderElement* currentParent = m_marker->parent();
289     RenderBlock* newParent = getParentOfFirstLineBox(*this, *m_marker);
290     if (!newParent) {
291         // If the marker is currently contained inside an anonymous box,
292         // then we are the only item in that anonymous box (since no line box
293         // parent was found). It's ok to just leave the marker where it is
294         // in this case.
295         if (currentParent && currentParent->isAnonymousBlock())
296             return;
297         if (multiColumnFlowThread())
298             newParent = multiColumnFlowThread();
299         else
300             newParent = this;
301     }
302
303     if (newParent != currentParent) {
304         // Removing and adding the marker can trigger repainting in
305         // containers other than ourselves, so we need to disable LayoutState.
306         LayoutStateDisabler layoutStateDisabler(view());
307         // Mark the parent dirty so that when the marker gets inserted into the tree
308         // and dirties ancestors, it stops at the parent.
309         newParent->setChildNeedsLayout(MarkOnlyThis);
310         m_marker->setNeedsLayout(MarkOnlyThis);
311
312         m_marker->removeFromParent();
313         newParent->addChild(m_marker, firstNonMarkerChild(*newParent));
314         m_marker->updateMarginsAndContent();
315         // If current parent is an anonymous block that has lost all its children, destroy it.
316         if (currentParent && currentParent->isAnonymousBlock() && !currentParent->firstChild() && !downcast<RenderBlock>(*currentParent).continuation())
317             currentParent->destroy();
318     }
319
320 }
321
322 void RenderListItem::layout()
323 {
324     StackStats::LayoutCheckPoint layoutCheckPoint;
325     ASSERT(needsLayout()); 
326
327     insertOrMoveMarkerRendererIfNeeded();
328 #if !ASSERT_DISABLED
329     SetForScope<bool> inListItemLayout(m_inLayout, true);
330 #endif
331     RenderBlockFlow::layout();
332 }
333
334 void RenderListItem::addOverflowFromChildren()
335 {
336     positionListMarker();
337     RenderBlockFlow::addOverflowFromChildren();
338 }
339
340 void RenderListItem::computePreferredLogicalWidths()
341 {
342 #ifndef NDEBUG
343     // FIXME: We shouldn't be modifying the tree in computePreferredLogicalWidths.
344     // Instead, we should insert the marker soon after the tree construction.
345     // This is similar case to RenderCounter::computePreferredLogicalWidths()
346     // See https://bugs.webkit.org/show_bug.cgi?id=104829
347     SetLayoutNeededForbiddenScope layoutForbiddenScope(this, false);
348 #endif
349     insertOrMoveMarkerRendererIfNeeded();
350     RenderBlockFlow::computePreferredLogicalWidths();
351 }
352
353 void RenderListItem::positionListMarker()
354 {
355     if (!m_marker || !m_marker->parent() || !m_marker->parent()->isBox())
356         return;
357
358     if (m_marker->isInside() || !m_marker->inlineBoxWrapper())
359         return;
360
361     LayoutUnit markerOldLogicalLeft = m_marker->logicalLeft();
362     LayoutUnit blockOffset = 0;
363     LayoutUnit lineOffset = 0;
364     for (RenderBox* o = m_marker->parentBox(); o != this; o = o->parentBox()) {
365         blockOffset += o->logicalTop();
366         lineOffset += o->logicalLeft();
367     }
368
369     bool adjustOverflow = false;
370     LayoutUnit markerLogicalLeft;
371     bool hitSelfPaintingLayer = false;
372
373     const RootInlineBox& rootBox = m_marker->inlineBoxWrapper()->root();
374     LayoutUnit lineTop = rootBox.lineTop();
375     LayoutUnit lineBottom = rootBox.lineBottom();
376
377     // FIXME: Need to account for relative positioning in the layout overflow.
378     if (style().isLeftToRightDirection()) {
379         markerLogicalLeft = m_marker->lineOffsetForListItem() - lineOffset - paddingStart() - borderStart() + m_marker->marginStart();
380         m_marker->inlineBoxWrapper()->adjustLineDirectionPosition(markerLogicalLeft - markerOldLogicalLeft);
381         for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
382             LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
383             LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
384             if (markerLogicalLeft < newLogicalVisualOverflowRect.x() && !hitSelfPaintingLayer) {
385                 newLogicalVisualOverflowRect.setWidth(newLogicalVisualOverflowRect.maxX() - markerLogicalLeft);
386                 newLogicalVisualOverflowRect.setX(markerLogicalLeft);
387                 if (box == &rootBox)
388                     adjustOverflow = true;
389             }
390             if (markerLogicalLeft < newLogicalLayoutOverflowRect.x()) {
391                 newLogicalLayoutOverflowRect.setWidth(newLogicalLayoutOverflowRect.maxX() - markerLogicalLeft);
392                 newLogicalLayoutOverflowRect.setX(markerLogicalLeft);
393                 if (box == &rootBox)
394                     adjustOverflow = true;
395             }
396             box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
397             if (box->renderer().hasSelfPaintingLayer())
398                 hitSelfPaintingLayer = true;
399         }
400     } else {
401         markerLogicalLeft = m_marker->lineOffsetForListItem() - lineOffset + paddingStart() + borderStart() + m_marker->marginEnd();
402         m_marker->inlineBoxWrapper()->adjustLineDirectionPosition(markerLogicalLeft - markerOldLogicalLeft);
403         for (InlineFlowBox* box = m_marker->inlineBoxWrapper()->parent(); box; box = box->parent()) {
404             LayoutRect newLogicalVisualOverflowRect = box->logicalVisualOverflowRect(lineTop, lineBottom);
405             LayoutRect newLogicalLayoutOverflowRect = box->logicalLayoutOverflowRect(lineTop, lineBottom);
406             if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalVisualOverflowRect.maxX() && !hitSelfPaintingLayer) {
407                 newLogicalVisualOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalVisualOverflowRect.x());
408                 if (box == &rootBox)
409                     adjustOverflow = true;
410             }
411             if (markerLogicalLeft + m_marker->logicalWidth() > newLogicalLayoutOverflowRect.maxX()) {
412                 newLogicalLayoutOverflowRect.setWidth(markerLogicalLeft + m_marker->logicalWidth() - newLogicalLayoutOverflowRect.x());
413                 if (box == &rootBox)
414                     adjustOverflow = true;
415             }
416             box->setOverflowFromLogicalRects(newLogicalLayoutOverflowRect, newLogicalVisualOverflowRect, lineTop, lineBottom);
417                 
418             if (box->renderer().hasSelfPaintingLayer())
419                 hitSelfPaintingLayer = true;
420         }
421     }
422
423     if (adjustOverflow) {
424         LayoutRect markerRect(markerLogicalLeft + lineOffset, blockOffset, m_marker->width(), m_marker->height());
425         if (!style().isHorizontalWritingMode())
426             markerRect = markerRect.transposedRect();
427         RenderBox* o = m_marker;
428         bool propagateVisualOverflow = true;
429         bool propagateLayoutOverflow = true;
430         do {
431             o = o->parentBox();
432             if (o->hasOverflowClip())
433                 propagateVisualOverflow = false;
434             if (is<RenderBlock>(*o)) {
435                 if (propagateVisualOverflow)
436                     downcast<RenderBlock>(*o).addVisualOverflow(markerRect);
437                 if (propagateLayoutOverflow)
438                     downcast<RenderBlock>(*o).addLayoutOverflow(markerRect);
439             }
440             if (o->hasOverflowClip())
441                 propagateLayoutOverflow = false;
442             if (o->hasSelfPaintingLayer())
443                 propagateVisualOverflow = false;
444             markerRect.moveBy(-o->location());
445         } while (o != this && propagateVisualOverflow && propagateLayoutOverflow);
446     }
447 }
448
449 void RenderListItem::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
450 {
451     if (!logicalHeight() && hasOverflowClip())
452         return;
453
454     RenderBlockFlow::paint(paintInfo, paintOffset);
455 }
456
457 const String& RenderListItem::markerText() const
458 {
459     if (m_marker)
460         return m_marker->text();
461     return nullAtom.string();
462 }
463
464 String RenderListItem::markerTextWithSuffix() const
465 {
466     if (!m_marker)
467         return String();
468
469     // Append the suffix for the marker in the right place depending
470     // on the direction of the text (right-to-left or left-to-right).
471     if (m_marker->style().isLeftToRightDirection())
472         return m_marker->text() + m_marker->suffix();
473     return m_marker->suffix() + m_marker->text();
474 }
475
476 void RenderListItem::explicitValueChanged()
477 {
478     if (m_marker)
479         m_marker->setNeedsLayoutAndPrefWidthsRecalc();
480
481     updateValue();
482     Element* listNode = enclosingList(*this);
483     if (!listNode)
484         return;
485     for (RenderListItem* item = nextListItem(*listNode, *this); item; item = nextListItem(*listNode, *item))
486         item->updateValue();
487 }
488
489 void RenderListItem::setExplicitValue(int value)
490 {
491     if (m_hasExplicitValue && m_explicitValue == value)
492         return;
493     m_explicitValue = value;
494     m_value = value;
495     m_hasExplicitValue = true;
496     explicitValueChanged();
497 }
498
499 void RenderListItem::clearExplicitValue()
500 {
501     if (!m_hasExplicitValue)
502         return;
503     m_hasExplicitValue = false;
504     m_isValueUpToDate = false;
505     explicitValueChanged();
506 }
507
508 static inline RenderListItem* previousOrNextItem(bool isListReversed, Element& list, RenderListItem& item)
509 {
510     return isListReversed ? previousListItem(&list, item) : nextListItem(list, item);
511 }
512
513 void RenderListItem::updateListMarkerNumbers()
514 {
515     Element* listNode = enclosingList(*this);
516     // The list node can be the shadow root which has no renderer.
517     if (!listNode)
518         return;
519
520     bool isListReversed = false;
521     if (is<HTMLOListElement>(*listNode)) {
522         HTMLOListElement& oListElement = downcast<HTMLOListElement>(*listNode);
523         oListElement.itemCountChanged();
524         isListReversed = oListElement.isReversed();
525     }
526     for (RenderListItem* item = previousOrNextItem(isListReversed, *listNode, *this); item; item = previousOrNextItem(isListReversed, *listNode, *item)) {
527         if (!item->m_isValueUpToDate) {
528             // If an item has been marked for update before, we can safely
529             // assume that all the following ones have too.
530             // This gives us the opportunity to stop here and avoid
531             // marking the same nodes again.
532             break;
533         }
534         item->updateValue();
535     }
536 }
537
538 } // namespace WebCore