/* * Copyright (C) 1999 Lars Knoll (knoll@kde.org) * (C) 1999 Antti Koivisto (koivisto@kde.org) * (C) 2007 David Smith (catfish.man@gmail.com) * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ #pragma once #include "GapRects.h" #include "LineWidth.h" #include "RenderBox.h" #include "TextRun.h" #include #include namespace WebCore { class LineLayoutState; class LogicalSelectionOffsetCaches; class RenderInline; class RenderText; struct BidiRun; struct PaintInfo; typedef WTF::ListHashSet TrackedRendererListHashSet; enum CaretType { CursorCaret, DragCaret }; enum ContainingBlockState { NewContainingBlock, SameContainingBlock }; enum TextRunFlag { DefaultTextRunFlags = 0, RespectDirection = 1 << 0, RespectDirectionOverride = 1 << 1 }; typedef unsigned TextRunFlags; class RenderBlock : public RenderBox { WTF_MAKE_ISO_ALLOCATED(RenderBlock); public: friend class LineLayoutState; virtual ~RenderBlock(); protected: RenderBlock(Element&, RenderStyle&&, BaseTypeFlags); RenderBlock(Document&, RenderStyle&&, BaseTypeFlags); public: // These two functions are overridden for inline-block. LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const final; LayoutUnit baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override; LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const; // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual void deleteLines(); virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0_lu); virtual void invalidateLineLayoutPath() { } void insertPositionedObject(RenderBox&); static void removePositionedObject(const RenderBox&); void removePositionedObjects(const RenderBlock*, ContainingBlockState = SameContainingBlock); TrackedRendererListHashSet* positionedObjects() const; bool hasPositionedObjects() const { TrackedRendererListHashSet* objects = positionedObjects(); return objects && !objects->isEmpty(); } void addPercentHeightDescendant(RenderBox&); static void removePercentHeightDescendant(RenderBox&); TrackedRendererListHashSet* percentHeightDescendants() const; bool hasPercentHeightDescendants() const { TrackedRendererListHashSet* objects = percentHeightDescendants(); return objects && !objects->isEmpty(); } static bool hasPercentHeightContainerMap(); static bool hasPercentHeightDescendant(RenderBox&); static void clearPercentHeightDescendantsFrom(RenderBox&); static void removePercentHeightDescendantIfNeeded(RenderBox&); bool isContainingBlockAncestorFor(RenderObject&) const; void setHasMarginBeforeQuirk(bool b) { setRenderBlockHasMarginBeforeQuirk(b); } void setHasMarginAfterQuirk(bool b) { setRenderBlockHasMarginAfterQuirk(b); } void setShouldForceRelayoutChildren(bool b) { setRenderBlockShouldForceRelayoutChildren(b); } bool hasMarginBeforeQuirk() const { return renderBlockHasMarginBeforeQuirk(); } bool hasMarginAfterQuirk() const { return renderBlockHasMarginAfterQuirk(); } bool hasBorderOrPaddingLogicalWidthChanged() const { return renderBlockShouldForceRelayoutChildren(); } bool hasMarginBeforeQuirk(const RenderBox& child) const; bool hasMarginAfterQuirk(const RenderBox& child) const; void markPositionedObjectsForLayout(); void markForPaginationRelayoutIfNeeded() override; // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock virtual bool containsFloats() const { return false; } // Versions that can compute line offsets with the fragment and page offset passed in. Used for speed to avoid having to // compute the fragment all over again when you already know it. LayoutUnit availableLogicalWidthForLineInFragment(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderFragmentContainer* fragment, LayoutUnit logicalHeight = 0_lu) const { return std::max(0, logicalRightOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight) - logicalLeftOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight)); } LayoutUnit logicalRightOffsetForLineInFragment(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderFragmentContainer* fragment, LayoutUnit logicalHeight = 0_lu) const { return logicalRightOffsetForLine(position, logicalRightOffsetForContent(fragment), shouldIndentText, logicalHeight); } LayoutUnit logicalLeftOffsetForLineInFragment(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderFragmentContainer* fragment, LayoutUnit logicalHeight = 0_lu) const { return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(fragment), shouldIndentText, logicalHeight); } LayoutUnit startOffsetForLineInFragment(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderFragmentContainer* fragment, LayoutUnit logicalHeight = 0_lu) const { return style().isLeftToRightDirection() ? logicalLeftOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight) : logicalWidth() - logicalRightOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight); } LayoutUnit endOffsetForLineInFragment(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderFragmentContainer* fragment, LayoutUnit logicalHeight = 0_lu) const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight) : logicalWidth() - logicalRightOffsetForLineInFragment(position, shouldIndentText, fragment, logicalHeight); } LayoutUnit availableLogicalWidthForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0_lu) const { return availableLogicalWidthForLineInFragment(position, shouldIndentText, fragmentAtBlockOffset(position), logicalHeight); } LayoutUnit logicalRightOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0_lu) const { return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, logicalHeight); } LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0_lu) const { return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, logicalHeight); } LayoutUnit startOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0_lu) const { return style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight) : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight); } LayoutUnit endOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0_lu) const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight) : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight); } LayoutUnit textIndentOffset() const; VisiblePosition positionForPoint(const LayoutPoint&, const RenderFragmentContainer*) override; GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer); LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, RenderBoxModelObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*); LayoutRect logicalRightSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, RenderBoxModelObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*); void getSelectionGapInfo(HighlightState, bool& leftGap, bool& rightGap); bool isSelectionRoot() const; LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect); void addContinuationWithOutline(RenderInline*); bool paintsContinuationOutline(RenderInline*); static RenderPtr createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, DisplayType = DisplayType::Block); RenderPtr createAnonymousBlock(DisplayType = DisplayType::Block) const; RenderPtr createAnonymousBoxWithSameTypeAs(const RenderBox&) const override; static bool shouldSkipCreatingRunsForObject(RenderObject& obj) { return obj.isFloating() || (obj.isOutOfFlowPositioned() && !obj.style().isOriginalDisplayInlineType() && !obj.container()->isRenderInline()); } static TextRun constructTextRun(StringView, const RenderStyle&, ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags); static TextRun constructTextRun(const String&, const RenderStyle&, ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags); static TextRun constructTextRun(const AtomString&, const RenderStyle&, ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags); static TextRun constructTextRun(const RenderText&, const RenderStyle&, ExpansionBehavior = DefaultExpansion); static TextRun constructTextRun(const RenderText&, unsigned offset, unsigned length, const RenderStyle&, ExpansionBehavior = DefaultExpansion); static TextRun constructTextRun(const LChar* characters, unsigned length, const RenderStyle&, ExpansionBehavior = DefaultExpansion); static TextRun constructTextRun(const UChar* characters, unsigned length, const RenderStyle&, ExpansionBehavior = DefaultExpansion); LayoutUnit paginationStrut() const; void setPaginationStrut(LayoutUnit); // The page logical offset is the object's offset from the top of the page in the page progression // direction (so an x-offset in vertical text and a y-offset for horizontal text). LayoutUnit pageLogicalOffset() const; void setPageLogicalOffset(LayoutUnit); // Fieldset legends that are taller than the fieldset border add in intrinsic border // in order to ensure that content gets properly pushed down across all layout systems // (flexbox, block, etc.) LayoutUnit intrinsicBorderForFieldset() const; void setIntrinsicBorderForFieldset(LayoutUnit); LayoutUnit borderTop() const override; LayoutUnit borderBottom() const override; LayoutUnit borderLeft() const override; LayoutUnit borderRight() const override; LayoutUnit borderBefore() const override; LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const override; LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(std::optional height) const override; void paintExcludedChildrenInBorder(PaintInfo&, const LayoutPoint&); // Accessors for logical width/height and margins in the containing block's block-flow direction. enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta }; LayoutUnit logicalWidthForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.width() : child.height(); } LayoutUnit logicalHeightForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.height() : child.width(); } LayoutSize logicalSizeForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.size() : child.size().transposedSize(); } LayoutUnit logicalTopForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.y() : child.x(); } void setLogicalLeftForChild(RenderBox& child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta); void setLogicalTopForChild(RenderBox& child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta); LayoutUnit marginBeforeForChild(const RenderBoxModelObject& child) const { return child.marginBefore(&style()); } LayoutUnit marginAfterForChild(const RenderBoxModelObject& child) const { return child.marginAfter(&style()); } LayoutUnit marginStartForChild(const RenderBoxModelObject& child) const { return child.marginStart(&style()); } LayoutUnit marginEndForChild(const RenderBoxModelObject& child) const { return child.marginEnd(&style()); } void setMarginStartForChild(RenderBox& child, LayoutUnit value) const { child.setMarginStart(value, &style()); } void setMarginEndForChild(RenderBox& child, LayoutUnit value) const { child.setMarginEnd(value, &style()); } void setMarginBeforeForChild(RenderBox& child, LayoutUnit value) const { child.setMarginBefore(value, &style()); } void setMarginAfterForChild(RenderBox& child, LayoutUnit value) const { child.setMarginAfter(value, &style()); } LayoutUnit collapsedMarginBeforeForChild(const RenderBox& child) const; LayoutUnit collapsedMarginAfterForChild(const RenderBox& child) const; void getFirstLetter(RenderObject*& firstLetter, RenderElement*& firstLetterContainer, RenderObject* skipObject = nullptr); virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { } LayoutUnit logicalLeftOffsetForContent(RenderFragmentContainer*) const; LayoutUnit logicalRightOffsetForContent(RenderFragmentContainer*) const; LayoutUnit availableLogicalWidthForContent(RenderFragmentContainer* fragment) const { return std::max(0, logicalRightOffsetForContent(fragment) - logicalLeftOffsetForContent(fragment)); } LayoutUnit startOffsetForContent(RenderFragmentContainer* fragment) const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent(fragment) : logicalWidth() - logicalRightOffsetForContent(fragment); } LayoutUnit endOffsetForContent(RenderFragmentContainer* fragment) const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent(fragment) : logicalWidth() - logicalRightOffsetForContent(fragment); } LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const { return logicalLeftOffsetForContent(fragmentAtBlockOffset(blockOffset)); } LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const { return logicalRightOffsetForContent(fragmentAtBlockOffset(blockOffset)); } LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const { return availableLogicalWidthForContent(fragmentAtBlockOffset(blockOffset)); } LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const { return startOffsetForContent(fragmentAtBlockOffset(blockOffset)); } LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const { return endOffsetForContent(fragmentAtBlockOffset(blockOffset)); } LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); } LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); } LayoutUnit startOffsetForContent() const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); } LayoutUnit endOffsetForContent() const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); } LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&); LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&); LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderFragmentContainer* = 0); #if ASSERT_ENABLED void checkPositionedObjectsNeedLayout(); #endif void updateHitTestResult(HitTestResult&, const LayoutPoint&) override; bool canHaveChildren() const override { return true; } virtual bool canDropAnonymousBlockChild() const { return true; } RenderFragmentedFlow* cachedEnclosingFragmentedFlow() const; void setCachedEnclosingFragmentedFlowNeedsUpdate(); virtual bool cachedEnclosingFragmentedFlowNeedsUpdate() const; void resetEnclosingFragmentedFlowAndChildInfoIncludingDescendants(RenderFragmentedFlow* = nullptr) final; std::optional availableLogicalHeightForPercentageComputation() const; bool hasDefiniteLogicalHeight() const; virtual bool shouldResetChildLogicalHeightBeforeLayout(const RenderBox&) const { return false; } static String updateSecurityDiscCharacters(const RenderStyle&, String&&); protected: RenderFragmentedFlow* locateEnclosingFragmentedFlow() const override; void willBeDestroyed() override; void layout() override; void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false); virtual void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly); void markFixedPositionObjectForLayoutIfNeeded(RenderBox& child); LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox&) const; void paint(PaintInfo&, const LayoutPoint&) override; void paintObject(PaintInfo&, const LayoutPoint&) override; virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect); enum PaintBlockType { PaintAsBlock, PaintAsInlineBlock }; bool paintChild(RenderBox&, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect, PaintBlockType paintType = PaintAsBlock); LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0_lu) const { return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent); } LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0_lu) const { return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent); } bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override; void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override; void computePreferredLogicalWidths() override; std::optional firstLineBaseline() const override; std::optional inlineBlockBaseline(LineDirectionMode) const override; // Delay updating scrollbars until endAndCommitUpdateScrollInfoAfterLayoutTransaction() is called. These functions are used // when a flexbox is laying out its descendants. If multiple calls are made to beginUpdateScrollInfoAfterLayoutTransaction() // then endAndCommitUpdateScrollInfoAfterLayoutTransaction() will do nothing until it is called the same number of times. void beginUpdateScrollInfoAfterLayoutTransaction(); void endAndCommitUpdateScrollInfoAfterLayoutTransaction(); void removeFromUpdateScrollInfoAfterLayoutTransaction(); void updateScrollInfoAfterLayout(); void styleWillChange(StyleDifference, const RenderStyle& newStyle) override; void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override; virtual bool hasLineIfEmpty() const; virtual bool canPerformSimplifiedLayout() const; bool simplifiedLayout(); virtual void simplifiedNormalFlowLayout(); bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const; public: virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false); void clearLayoutOverflow(); // Adjust from painting offsets to the local coords of this renderer void offsetForContents(LayoutPoint&) const; // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline // children. RenderBlock* firstLineBlock() const override; enum FieldsetFindLegendOption { FieldsetIgnoreFloatingOrOutOfFlow, FieldsetIncludeFloatingOrOutOfFlow }; RenderBox* findFieldsetLegend(FieldsetFindLegendOption = FieldsetIgnoreFloatingOrOutOfFlow) const; virtual void layoutExcludedChildren(bool /*relayoutChildren*/); virtual bool computePreferredWidthsForExcludedChildren(LayoutUnit&, LayoutUnit&) const; void adjustBorderBoxRectForPainting(LayoutRect&) override; LayoutRect paintRectToClipOutFromBorder(const LayoutRect&) override; bool isInlineBlockOrInlineTable() const final { return isInline() && isReplaced(); } void absoluteRects(Vector&, const LayoutPoint& accumulatedOffset) const override; void absoluteQuads(Vector&, bool* wasFixed) const override; // Public for LegacyEllipsisBox Node* nodeForHitTest() const override; protected: virtual void addOverflowFromChildren(); // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow virtual void addOverflowFromInlineChildren() { } void addOverflowFromBlockChildren(); void addOverflowFromPositionedObjects(); void addVisualOverflowFromTheme(); void addFocusRingRects(Vector&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) override; virtual void addFocusRingRectsForInlineChildren(Vector&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer); void computeFragmentRangeForBoxChild(const RenderBox&) const; void estimateFragmentRangeForBoxChild(const RenderBox&) const; bool updateFragmentRangeForBoxChild(const RenderBox&) const; void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox&); void preparePaginationBeforeBlockLayout(bool&); void computeChildPreferredLogicalWidths(RenderObject&, LayoutUnit& minPreferredLogicalWidth, LayoutUnit& maxPreferredLogicalWidth) const; void blockWillBeDestroyed(); virtual void computeChildIntrinsicLogicalWidths(RenderObject&, LayoutUnit& minPreferredLogicalWidth, LayoutUnit& maxPreferredLogicalWidth) const; private: static RenderPtr createAnonymousBlockWithStyleAndDisplay(Document&, const RenderStyle&, DisplayType); // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; }; // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; } LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const; LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const; const char* renderName() const override; bool isSelfCollapsingBlock() const override; virtual bool childrenPreventSelfCollapsing() const; // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { } virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) { } void paintContents(PaintInfo&, const LayoutPoint&); virtual void paintColumnRules(PaintInfo&, const LayoutPoint&) { }; void paintSelection(PaintInfo&, const LayoutPoint&); void paintCaret(PaintInfo&, const LayoutPoint&, CaretType); virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction); // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; } virtual bool hitTestChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& adjustedLocation, HitTestAction); virtual bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) { return false; } bool hitTestExcludedChildrenInBorder(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction); virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset); void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const; LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const final; const RenderStyle& outlineStyleForRepaint() const final; LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) final { return selectionGapRectsForRepaint(repaintContainer); } bool shouldPaintSelectionGaps() const final; GapRects selectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0); // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual GapRects inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*); GapRects blockSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*); LayoutRect blockSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*); // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual void clipOutFloatingObjects(RenderBlock&, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { }; friend class LogicalSelectionOffsetCaches; void paintContinuationOutlines(PaintInfo&, const LayoutPoint&); // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderFragmentContainer*); RenderPtr clone() const; RenderFragmentedFlow* updateCachedEnclosingFragmentedFlow(RenderFragmentedFlow*) const; void removePositionedObjectsIfNeeded(const RenderStyle& oldStyle, const RenderStyle& newStyle); void absoluteQuadsIgnoringContinuation(const FloatRect&, Vector&, bool* wasFixed) const override; private: bool hasRareData() const; protected: void dirtyForLayoutFromPercentageHeightDescendants(); protected: bool recomputeLogicalWidth(); public: LayoutUnit offsetFromLogicalTopOfFirstPage() const override; RenderFragmentContainer* fragmentAtBlockOffset(LayoutUnit) const; // FIXME: This is temporary to allow us to move code from RenderBlock into RenderBlockFlow that accesses member variables that we haven't moved out of // RenderBlock yet. friend class RenderBlockFlow; // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock friend class LineBreaker; // RenderRubyBase objects need to be able to split and merge, moving their children around // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline). friend class RenderRubyBase; private: // Used to store state between styleWillChange and styleDidChange static bool s_canPropagateFloatIntoSibling; }; LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock); LayoutUnit inlineDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock); VisiblePosition positionForPointRespectingEditingBoundaries(RenderBlock&, RenderBox&, const LayoutPoint&); inline RenderPtr RenderBlock::createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, DisplayType display) { return createAnonymousBlockWithStyleAndDisplay(parent.document(), parent.style(), display); } inline RenderPtr RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderBox& renderer) const { return createAnonymousBlockWithStyleAndDisplay(document(), renderer.style(), style().display()); } inline RenderPtr RenderBlock::createAnonymousBlock(DisplayType display) const { return createAnonymousBlockWithStyleAndDisplay(document(), style(), display); } } // namespace WebCore SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderBlock, isRenderBlock())