summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsBlockFrame.h
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsBlockFrame.h')
-rw-r--r--layout/generic/nsBlockFrame.h1048
1 files changed, 1048 insertions, 0 deletions
diff --git a/layout/generic/nsBlockFrame.h b/layout/generic/nsBlockFrame.h
new file mode 100644
index 0000000000..8d7bcdb8d0
--- /dev/null
+++ b/layout/generic/nsBlockFrame.h
@@ -0,0 +1,1048 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * rendering object for CSS display:block, inline-block, and list-item
+ * boxes, also used for various anonymous boxes
+ */
+
+#ifndef nsBlockFrame_h___
+#define nsBlockFrame_h___
+
+#include "nsContainerFrame.h"
+#include "nsHTMLParts.h"
+#include "nsLineBox.h"
+#include "nsCSSPseudoElements.h"
+#include "nsFloatManager.h"
+
+enum class LineReflowStatus {
+ // The line was completely reflowed and fit in available width, and we should
+ // try to pull up content from the next line if possible.
+ OK,
+ // The line was completely reflowed and fit in available width, but we should
+ // not try to pull up content from the next line.
+ Stop,
+ // We need to reflow the line again at its current vertical position. The
+ // new reflow should not try to pull up any frames from the next line.
+ RedoNoPull,
+ // We need to reflow the line again using the floats from its height
+ // this reflow, since its height made it hit floats that were not
+ // adjacent to its top.
+ RedoMoreFloats,
+ // We need to reflow the line again at a lower vertical postion where there
+ // may be more horizontal space due to different float configuration.
+ RedoNextBand,
+ // The line did not fit in the available vertical space. Try pushing it to
+ // the next page or column if it's not the first line on the current
+ // page/column.
+ Truncated
+};
+
+class nsBlockInFlowLineIterator;
+namespace mozilla {
+class BlockReflowState;
+class PresShell;
+class ServoRestyleState;
+class ServoStyleSet;
+} // namespace mozilla
+
+/**
+ * Some invariants:
+ * -- The overflow out-of-flows list contains the out-of-
+ * flow frames whose placeholders are in the overflow list.
+ * -- A given piece of content has at most one placeholder
+ * frame in a block's normal child list.
+ * -- While a block is being reflowed, and from then until
+ * its next-in-flow is reflowed it may have a
+ * PushedFloatProperty frame property that points to
+ * an nsFrameList. This list contains continuations for
+ * floats whose prev-in-flow is in the block's regular float
+ * list and first-in-flows of floats that did not fit, but
+ * whose placeholders are in the block or one of its
+ * prev-in-flows.
+ * -- In all these frame lists, if there are two frames for
+ * the same content appearing in the list, then the frames
+ * appear with the prev-in-flow before the next-in-flow.
+ * -- While reflowing a block, its overflow line list
+ * will usually be empty but in some cases will have lines
+ * (while we reflow the block at its shrink-wrap width).
+ * In this case any new overflowing content must be
+ * prepended to the overflow lines.
+ */
+
+/*
+ * Base class for block and inline frames.
+ * The block frame has an additional child list, FrameChildListID::Absolute,
+ * which contains the absolutely positioned frames.
+ */
+class nsBlockFrame : public nsContainerFrame {
+ using BlockReflowState = mozilla::BlockReflowState;
+
+ public:
+ NS_DECL_FRAMEARENA_HELPERS(nsBlockFrame)
+
+ typedef nsLineList::iterator LineIterator;
+ typedef nsLineList::const_iterator ConstLineIterator;
+ typedef nsLineList::reverse_iterator ReverseLineIterator;
+ typedef nsLineList::const_reverse_iterator ConstReverseLineIterator;
+
+ LineIterator LinesBegin() { return mLines.begin(); }
+ LineIterator LinesEnd() { return mLines.end(); }
+ ConstLineIterator LinesBegin() const { return mLines.begin(); }
+ ConstLineIterator LinesEnd() const { return mLines.end(); }
+ ReverseLineIterator LinesRBegin() { return mLines.rbegin(); }
+ ReverseLineIterator LinesREnd() { return mLines.rend(); }
+ ConstReverseLineIterator LinesRBegin() const { return mLines.rbegin(); }
+ ConstReverseLineIterator LinesREnd() const { return mLines.rend(); }
+ LineIterator LinesBeginFrom(nsLineBox* aList) { return mLines.begin(aList); }
+ ReverseLineIterator LinesRBeginFrom(nsLineBox* aList) {
+ return mLines.rbegin(aList);
+ }
+
+ // Methods declared to be used in 'range-based-for-loop'
+ nsLineList& Lines() { return mLines; }
+ const nsLineList& Lines() const { return mLines; }
+
+ friend nsBlockFrame* NS_NewBlockFrame(mozilla::PresShell* aPresShell,
+ ComputedStyle* aStyle);
+
+ // nsQueryFrame
+ NS_DECL_QUERYFRAME
+
+ // nsIFrame
+ void Init(nsIContent* aContent, nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow) override;
+ void SetInitialChildList(ChildListID aListID,
+ nsFrameList&& aChildList) override;
+ void AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) override;
+ void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
+ const nsLineList::iterator* aPrevFrameLine,
+ nsFrameList&& aFrameList) override;
+ void RemoveFrame(DestroyContext&, ChildListID, nsIFrame* aOldFrame) override;
+ nsContainerFrame* GetContentInsertionFrame() override;
+ void AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) override;
+ const nsFrameList& GetChildList(ChildListID aListID) const override;
+ void GetChildLists(nsTArray<ChildList>* aLists) const override;
+ nscoord SynthesizeFallbackBaseline(
+ mozilla::WritingMode aWM,
+ BaselineSharingGroup aBaselineGroup) const override;
+ BaselineSharingGroup GetDefaultBaselineSharingGroup() const override {
+ return BaselineSharingGroup::Last;
+ }
+ Maybe<nscoord> GetNaturalBaselineBOffset(
+ mozilla::WritingMode aWM, BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext aExportContext) const override;
+ nscoord GetCaretBaseline() const override;
+ void Destroy(DestroyContext&) override;
+
+ bool IsFloatContainingBlock() const override;
+ void BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsDisplayListSet& aLists) override;
+ bool IsFrameOfType(uint32_t aFlags) const override {
+ return nsContainerFrame::IsFrameOfType(
+ aFlags & ~(nsIFrame::eCanContainOverflowContainers));
+ }
+
+ void InvalidateFrame(uint32_t aDisplayItemKey = 0,
+ bool aRebuildDisplayItems = true) override;
+ void InvalidateFrameWithRect(const nsRect& aRect,
+ uint32_t aDisplayItemKey = 0,
+ bool aRebuildDisplayItems = true) override;
+
+#ifdef DEBUG_FRAME_DUMP
+ void List(FILE* out = stderr, const char* aPrefix = "",
+ ListFlags aFlags = ListFlags()) const override;
+ nsresult GetFrameName(nsAString& aResult) const override;
+#endif
+
+#ifdef DEBUG
+ const char* LineReflowStatusToString(
+ LineReflowStatus aLineReflowStatus) const;
+#endif
+
+#ifdef ACCESSIBILITY
+ mozilla::a11y::AccType AccessibleType() override;
+#endif
+
+ // Line cursor methods to speed up line searching in which one query result
+ // is expected to be close to the next in general. This is mainly for
+ // searching line(s) containing a point. It is also used as a cache for local
+ // computation. The basic idea for the former is that we set the cursor
+ // property if the lines' overflowArea.InkOverflow().ys and
+ // overflowArea.InkOverflow().yMosts are non-decreasing
+ // (considering only non-empty overflowArea.InkOverflow()s; empty
+ // overflowArea.InkOverflow()s never participate in event handling
+ // or painting), and the block has sufficient number of lines. The
+ // cursor property points to a "recently used" line. If we get a
+ // series of requests that work on lines
+ // "near" the cursor, then we can find those nearby lines quickly by
+ // starting our search at the cursor.
+
+ // We have two independent line cursors, one used for display-list building
+ // and the other for a11y or other frame queries. Either or both may be
+ // present at any given time. When we reflow or otherwise munge the lines,
+ // both cursors will be cleared.
+ // The display cursor is only created and used if the lines satisfy the non-
+ // decreasing y-coordinate condition (see SetupLineCursorForDisplay comment
+ // below), whereas the query cursor may be created for any block. The two
+ // are separated so creating a cursor for a11y queries (eg GetRenderedText)
+ // does not risk confusing the display-list building code.
+
+ // Clear out line cursors because we're disturbing the lines (i.e., Reflow)
+ void ClearLineCursors() {
+ if (MaybeHasLineCursor()) {
+ ClearLineCursorForDisplay();
+ ClearLineCursorForQuery();
+ RemoveStateBits(NS_BLOCK_HAS_LINE_CURSOR);
+ }
+ RemoveProperty(LineIteratorProperty());
+ }
+ void ClearLineCursorForDisplay() {
+ RemoveProperty(LineCursorPropertyDisplay());
+ }
+ void ClearLineCursorForQuery() { RemoveProperty(LineCursorPropertyQuery()); }
+
+ // Get the first line that might contain y-coord 'y', or nullptr if you must
+ // search all lines. If nonnull is returned then we guarantee that the lines'
+ // combinedArea.ys and combinedArea.yMosts are non-decreasing.
+ // The actual line returned might not contain 'y', but if not, it is
+ // guaranteed to be before any line which does contain 'y'.
+ nsLineBox* GetFirstLineContaining(nscoord y);
+
+ // Ensure the frame has a display-list line cursor, initializing it to the
+ // first line if it is not already present. (If there's an existing cursor,
+ // it is left untouched.) Only call this if you guarantee that the lines'
+ // combinedArea.ys and combinedArea.yMosts are non-decreasing.
+ void SetupLineCursorForDisplay();
+
+ // Ensure the frame has a query line cursor, initializing it to the first
+ // line if it is not already present. (If there's an existing cursor, it is
+ // left untouched.)
+ void SetupLineCursorForQuery();
+
+ void ChildIsDirty(nsIFrame* aChild) override;
+
+ bool IsEmpty() override;
+ bool CachedIsEmpty() override;
+ bool IsSelfEmpty() override;
+
+ // Given that we have a ::marker frame, does it actually draw something, i.e.,
+ // do we have either a 'list-style-type' or 'list-style-image' that is
+ // not 'none', and no 'content'?
+ bool MarkerIsEmpty() const;
+
+ /**
+ * Return true if this frame has a ::marker frame.
+ */
+ bool HasMarker() const { return HasOutsideMarker() || HasInsideMarker(); }
+
+ /**
+ * @return true if this frame has an inside ::marker frame.
+ */
+ bool HasInsideMarker() const {
+ return HasAnyStateBits(NS_BLOCK_FRAME_HAS_INSIDE_MARKER);
+ }
+
+ /**
+ * @return true if this frame has an outside ::marker frame.
+ */
+ bool HasOutsideMarker() const {
+ return HasAnyStateBits(NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER);
+ }
+
+ /**
+ * @return the ::marker frame or nullptr if we don't have one.
+ */
+ nsIFrame* GetMarker() const {
+ nsIFrame* outside = GetOutsideMarker();
+ return outside ? outside : GetInsideMarker();
+ }
+
+ /**
+ * @return the first-letter frame or nullptr if we don't have one.
+ */
+ nsIFrame* GetFirstLetter() const;
+
+ /**
+ * @return the ::first-line frame or nullptr if we don't have one.
+ */
+ nsIFrame* GetFirstLineFrame() const;
+
+ void MarkIntrinsicISizesDirty() override;
+
+ private:
+ void CheckIntrinsicCacheAgainstShrinkWrapState();
+
+ template <typename LineIteratorType>
+ Maybe<nscoord> GetBaselineBOffset(LineIteratorType aStart,
+ LineIteratorType aEnd,
+ mozilla::WritingMode aWM,
+ BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext aExportContext) const;
+
+ public:
+ nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext* aRenderingContext) override;
+
+ nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override;
+
+ nsresult GetPrefWidthTightBounds(gfxContext* aContext, nscoord* aX,
+ nscoord* aXMost) override;
+
+ /**
+ * Compute the final block size of this frame.
+ *
+ * @param aState BlockReflowState passed from parent during reflow.
+ * Note: aState.mReflowStatus is mostly an "input" parameter. When this
+ * method is called, it should represent what our status would be as if
+ * we were shrinkwrapping our children's block-size. This method will
+ * then adjust it before returning if our status is different in light
+ * of our actual final block-size and current page/column's available
+ * block-size.
+ * @param aBEndEdgeOfChildren The distance between this frame's block-start
+ * border-edge and the block-end edge of our last child's border-box.
+ * This is effectively our block-start border-padding plus the
+ * block-size of our children, precomputed outside of this function.
+ * @return our final block-size with respect to aReflowInput's writing-mode.
+ */
+ nscoord ComputeFinalBSize(BlockReflowState& aState,
+ nscoord aBEndEdgeOfChildren);
+
+ void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus) override;
+
+ /**
+ * Move any frames on our overflow list to the end of our principal list.
+ * @return true if there were any overflow frames
+ */
+ bool DrainSelfOverflowList() override;
+
+ void StealFrame(nsIFrame* aChild) override;
+
+ void DeleteNextInFlowChild(DestroyContext&, nsIFrame* aNextInFlow,
+ bool aDeletingEmptyFrames) override;
+
+ /**
+ * This is a special method that allows a child class of nsBlockFrame to
+ * return a special, customized nsStyleText object to the nsLineLayout
+ * constructor. It is used when the nsBlockFrame child needs to specify its
+ * custom rendering style.
+ */
+ virtual const nsStyleText* StyleTextForLineLayout();
+
+ /**
+ * Determines whether the collapsed margin carried out of the last
+ * line includes the margin-top of a line with clearance (in which
+ * case we must avoid collapsing that margin with our bottom margin)
+ */
+ bool CheckForCollapsedBEndMarginFromClearanceLine();
+
+ static nsresult GetCurrentLine(BlockReflowState* aState,
+ nsLineBox** aOutCurrentLine);
+
+ /**
+ * Determine if this block is a margin root at the top/bottom edges.
+ */
+ void IsMarginRoot(bool* aBStartMarginRoot, bool* aBEndMarginRoot);
+
+ static bool BlockNeedsFloatManager(nsIFrame* aBlock);
+
+ /**
+ * Returns whether aFrame is a block frame that will wrap its contents
+ * around floats intruding on it from the outside. (aFrame need not
+ * be a block frame, but if it's not, the result will be false.)
+ *
+ * Note: We often use the term "float-avoiding block" to refer to
+ * block-level frames for whom this function returns false.
+ */
+ static bool BlockCanIntersectFloats(nsIFrame* aFrame);
+
+ /**
+ * Returns the inline size that needs to be cleared past floats for
+ * blocks that avoid (i.e. cannot intersect) floats. aState must already
+ * have GetFloatAvailableSpace called on it for the block-dir position that
+ * we care about (which need not be its current mBCoord)
+ */
+ struct FloatAvoidingISizeToClear {
+ // Note that we care about the inline-start margin but can ignore
+ // the inline-end margin.
+ nscoord marginIStart, borderBoxISize;
+ };
+ static FloatAvoidingISizeToClear ISizeToClearPastFloats(
+ const BlockReflowState& aState,
+ const mozilla::LogicalRect& aFloatAvailableSpace,
+ nsIFrame* aFloatAvoidingBlock);
+
+ /**
+ * Creates a contination for aFloat and adds it to the list of overflow
+ * floats. Also updates aState.mReflowStatus to include the float's
+ * incompleteness. Must only be called while this block frame is in reflow.
+ * aFloatStatus must be the float's true, unmodified reflow status.
+ */
+ void SplitFloat(BlockReflowState& aState, nsIFrame* aFloat,
+ const nsReflowStatus& aFloatStatus);
+
+ /**
+ * Walks up the frame tree, starting with aCandidate, and returns the first
+ * block frame that it encounters.
+ */
+ static nsBlockFrame* GetNearestAncestorBlock(nsIFrame* aCandidate);
+
+ struct FrameLines {
+ nsLineList mLines;
+ nsFrameList mFrames;
+ };
+
+ /**
+ * Update the styles of our various pseudo-elements (marker, first-line,
+ * etc, but _not_ first-letter).
+ */
+ void UpdatePseudoElementStyles(mozilla::ServoRestyleState& aRestyleState);
+
+ // Update our first-letter styles during stylo post-traversal. This needs to
+ // be done at a slightly different time than our other pseudo-elements.
+ void UpdateFirstLetterStyle(mozilla::ServoRestyleState& aRestyleState);
+
+ protected:
+ explicit nsBlockFrame(ComputedStyle* aStyle, nsPresContext* aPresContext,
+ ClassID aID = kClassID)
+ : nsContainerFrame(aStyle, aPresContext, aID) {
+#ifdef DEBUG
+ InitDebugFlags();
+#endif
+ }
+
+ virtual ~nsBlockFrame();
+
+#ifdef DEBUG
+ already_AddRefed<ComputedStyle> GetFirstLetterStyle(
+ nsPresContext* aPresContext);
+#endif
+
+ NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(LineCursorPropertyDisplay, nsLineBox)
+ NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(LineCursorPropertyQuery, nsLineBox)
+ // Note that the NS_BLOCK_HAS_LINE_CURSOR flag does not necessarily mean the
+ // cursor is present, as it covers both the "display" and "query" cursors,
+ // but may remain set if they have been separately deleted. In such a case,
+ // the Get* accessors will be slightly more expensive, but will still safely
+ // return null if the cursor is absent.
+ bool MaybeHasLineCursor() {
+ return HasAnyStateBits(NS_BLOCK_HAS_LINE_CURSOR);
+ }
+ nsLineBox* GetLineCursorForDisplay() {
+ return MaybeHasLineCursor() ? GetProperty(LineCursorPropertyDisplay())
+ : nullptr;
+ }
+ nsLineBox* GetLineCursorForQuery() {
+ return MaybeHasLineCursor() ? GetProperty(LineCursorPropertyQuery())
+ : nullptr;
+ }
+
+ nsLineBox* NewLineBox(nsIFrame* aFrame, bool aIsBlock) {
+ return NS_NewLineBox(PresShell(), aFrame, aIsBlock);
+ }
+ nsLineBox* NewLineBox(nsLineBox* aFromLine, nsIFrame* aFrame,
+ int32_t aCount) {
+ return NS_NewLineBox(PresShell(), aFromLine, aFrame, aCount);
+ }
+ void FreeLineBox(nsLineBox* aLine) {
+ if (aLine == GetLineCursorForDisplay()) {
+ ClearLineCursorForDisplay();
+ }
+ if (aLine == GetLineCursorForQuery()) {
+ ClearLineCursorForQuery();
+ }
+ aLine->Destroy(PresShell());
+ }
+ /**
+ * Helper method for StealFrame.
+ */
+ void RemoveFrameFromLine(nsIFrame* aChild, nsLineList::iterator aLine,
+ nsFrameList& aFrameList, nsLineList& aLineList);
+
+ void TryAllLines(nsLineList::iterator* aIterator,
+ nsLineList::iterator* aStartIterator,
+ nsLineList::iterator* aEndIterator, bool* aInOverflowLines,
+ FrameLines** aOverflowLines);
+
+ /** move the frames contained by aLine by aDeltaBCoord
+ * if aLine is a block, its child floats are added to the state manager
+ */
+ void SlideLine(BlockReflowState& aState, nsLineBox* aLine,
+ nscoord aDeltaBCoord);
+
+ void UpdateLineContainerSize(nsLineBox* aLine,
+ const nsSize& aNewContainerSize);
+
+ // helper for SlideLine and UpdateLineContainerSize
+ void MoveChildFramesOfLine(nsLineBox* aLine, nscoord aDeltaBCoord);
+
+ void ComputeFinalSize(const ReflowInput& aReflowInput,
+ BlockReflowState& aState, ReflowOutput& aMetrics,
+ nscoord* aBEndEdgeOfChildren);
+
+ /**
+ * Helper method for Reflow(). Computes the overflow areas created by our
+ * children, and includes them into aOverflowAreas.
+ */
+ void ComputeOverflowAreas(mozilla::OverflowAreas& aOverflowAreas,
+ nscoord aBEndEdgeOfChildren,
+ const nsStyleDisplay* aDisplay) const;
+
+ /**
+ * Helper method for ComputeOverflowAreas(). Incorporates aBEndEdgeOfChildren
+ * into the aOverflowAreas.
+ */
+ void ConsiderBlockEndEdgeOfChildren(mozilla::OverflowAreas& aOverflowAreas,
+ nscoord aBEndEdgeOfChildren,
+ const nsStyleDisplay* aDisplay) const;
+
+ /**
+ * Add the frames in aFrameList to this block after aPrevSibling.
+ * This block thinks in terms of lines, but the frame construction code
+ * knows nothing about lines at all so we need to find the line that
+ * contains aPrevSibling and add aFrameList after aPrevSibling on that line.
+ * New lines are created as necessary to handle block data in aFrameList.
+ * This function will clear aFrameList.
+ *
+ * aPrevSiblingLine, if present, must be the line containing aPrevSibling.
+ * Providing it will make this function faster.
+ */
+ void AddFrames(nsFrameList&& aFrameList, nsIFrame* aPrevSibling,
+ const nsLineList::iterator* aPrevSiblingLine);
+
+ // Return the :-moz-block-ruby-content child frame, if any.
+ // (It's non-null only if this block frame is for 'display:block ruby'.)
+ nsContainerFrame* GetRubyContentPseudoFrame();
+
+ /**
+ * Perform Bidi resolution on this frame
+ */
+ nsresult ResolveBidi();
+
+ /**
+ * Test whether the frame is a form control in a visual Bidi page.
+ * This is necessary for backwards-compatibility, because most visual
+ * pages use logical order for form controls so that they will
+ * display correctly on native widgets in OSs with Bidi support
+ * @param aPresContext the pres context
+ * @return whether the frame is a BIDI form control
+ */
+ bool IsVisualFormControl(nsPresContext* aPresContext);
+
+ public:
+ /**
+ * Helper function for the frame ctor to register a ::marker frame.
+ */
+ void SetMarkerFrameForListItem(nsIFrame* aMarkerFrame);
+
+ /**
+ * Does all the real work for removing aDeletedFrame
+ * -- finds the line containing aDeletedFrame
+ * -- removes all aDeletedFrame next-in-flows (or all continuations,
+ * if REMOVE_FIXED_CONTINUATIONS is given)
+ * -- marks lines dirty as needed
+ * -- marks textruns dirty (unless FRAMES_ARE_EMPTY is given, in which
+ * case textruns do not need to be dirtied)
+ * -- destroys all removed frames
+ */
+ enum { REMOVE_FIXED_CONTINUATIONS = 0x02, FRAMES_ARE_EMPTY = 0x04 };
+ void DoRemoveFrame(DestroyContext&, nsIFrame* aDeletedFrame, uint32_t aFlags);
+
+ void ReparentFloats(nsIFrame* aFirstFrame, nsBlockFrame* aOldParent,
+ bool aReparentSiblings);
+
+ bool ComputeCustomOverflow(mozilla::OverflowAreas&) override;
+
+ void UnionChildOverflow(mozilla::OverflowAreas&) override;
+
+ /**
+ * Load all of aFrame's floats into the float manager iff aFrame is not a
+ * block formatting context. Handles all necessary float manager translations;
+ * assumes float manager is in aFrame's parent's coord system.
+ *
+ * Safe to call on non-blocks (does nothing).
+ */
+ static void RecoverFloatsFor(nsIFrame* aFrame, nsFloatManager& aFloatManager,
+ mozilla::WritingMode aWM,
+ const nsSize& aContainerSize);
+
+ /**
+ * Determine if we have any pushed floats from a previous continuation.
+ *
+ * @returns true, if any of the floats at the beginning of our mFloats list
+ * have the NS_FRAME_IS_PUSHED_FLOAT bit set; false otherwise.
+ */
+ bool HasPushedFloatsFromPrevContinuation() const;
+
+ // @see nsIFrame::AddSizeOfExcludingThisForTree
+ void AddSizeOfExcludingThisForTree(nsWindowSizes&) const override;
+
+ /**
+ * Clears any -webkit-line-clamp ellipsis on a line in this block or one
+ * of its descendants.
+ */
+ void ClearLineClampEllipsis();
+
+ /**
+ * Returns whether this block is in a -webkit-line-clamp context. That is,
+ * whether this block is in a block formatting-context whose root block has
+ * -webkit-line-clamp: <n>.
+ */
+ bool IsInLineClampContext() const;
+
+ protected:
+ /** grab overflow lines from this block's prevInFlow, and make them
+ * part of this block's mLines list.
+ * @return true if any lines were drained.
+ */
+ bool DrainOverflowLines();
+
+ /**
+ * @return false iff this block does not have a float on any child list.
+ * This function is O(1).
+ */
+ bool MaybeHasFloats() const {
+ if (!mFloats.IsEmpty()) {
+ return true;
+ }
+ // XXX this could be replaced with HasPushedFloats() if we enforced
+ // removing the property when the frame list becomes empty.
+ nsFrameList* list = GetPushedFloats();
+ if (list && !list->IsEmpty()) {
+ return true;
+ }
+ // For the OverflowOutOfFlowsProperty I think we do enforce that, but it's
+ // a mix of out-of-flow frames, so that's why the method name has "Maybe".
+ return HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS);
+ }
+
+ /**
+ * Moves frames from our PushedFloats list back into our mFloats list.
+ */
+ void DrainSelfPushedFloats();
+
+ /**
+ * First calls DrainSelfPushedFloats() then grabs pushed floats from this
+ * block's prev-in-flow, and splice them into this block's mFloats list too.
+ */
+ void DrainPushedFloats();
+
+ /** Load all our floats into the float manager (without reflowing them).
+ * Assumes float manager is in our own coordinate system.
+ */
+ void RecoverFloats(nsFloatManager& aFloatManager, mozilla::WritingMode aWM,
+ const nsSize& aContainerSize);
+
+ /** Reflow pushed floats
+ */
+ void ReflowPushedFloats(BlockReflowState& aState,
+ mozilla::OverflowAreas& aOverflowAreas);
+
+ /**
+ * Find any trailing BR clear from the last line of this block (or from its
+ * prev-in-flows).
+ */
+ mozilla::StyleClear FindTrailingClear();
+
+ /**
+ * Remove a float from our float list.
+ */
+ void RemoveFloat(nsIFrame* aFloat);
+ /**
+ * Remove a float from the float cache for the line its placeholder is on.
+ */
+ void RemoveFloatFromFloatCache(nsIFrame* aFloat);
+
+ void CollectFloats(nsIFrame* aFrame, nsFrameList& aList,
+ bool aCollectFromSiblings) {
+ if (MaybeHasFloats()) {
+ DoCollectFloats(aFrame, aList, aCollectFromSiblings);
+ }
+ }
+ void DoCollectFloats(nsIFrame* aFrame, nsFrameList& aList,
+ bool aCollectFromSiblings);
+
+ // Remove a float, abs, rel positioned frame from the appropriate block's list
+ static void DoRemoveOutOfFlowFrame(DestroyContext&, nsIFrame*);
+
+ /** set up the conditions necessary for an resize reflow
+ * the primary task is to mark the minimumly sufficient lines dirty.
+ */
+ void PrepareResizeReflow(BlockReflowState& aState);
+
+ /** reflow all lines that have been marked dirty */
+ void ReflowDirtyLines(BlockReflowState& aState);
+
+ /** Mark a given line dirty due to reflow being interrupted on or before it */
+ void MarkLineDirtyForInterrupt(nsLineBox* aLine);
+
+ //----------------------------------------
+ // Methods for line reflow
+ /**
+ * Reflow a line.
+ *
+ * @param aState
+ * the current reflow input
+ * @param aLine
+ * the line to reflow. can contain a single block frame or contain 1 or
+ * more inline frames.
+ * @param aKeepReflowGoing [OUT]
+ * indicates whether the caller should continue to reflow more lines
+ */
+ void ReflowLine(BlockReflowState& aState, LineIterator aLine,
+ bool* aKeepReflowGoing);
+
+ // Return false if it needs another reflow because of reduced space
+ // between floats that are next to it (but not next to its top), and
+ // return true otherwise.
+ bool PlaceLine(BlockReflowState& aState, nsLineLayout& aLineLayout,
+ LineIterator aLine,
+ nsFloatManager::SavedState* aFloatStateBeforeLine,
+ nsFlowAreaRect& aFlowArea, // in-out
+ nscoord& aAvailableSpaceBSize, // in-out
+ bool* aKeepReflowGoing);
+
+ /**
+ * If NS_BLOCK_LOOK_FOR_DIRTY_FRAMES is set, call MarkLineDirty
+ * on any line with a child frame that is dirty.
+ */
+ void LazyMarkLinesDirty();
+
+ /**
+ * Mark |aLine| dirty, and, if necessary because of possible
+ * pull-up, mark the previous line dirty as well. Also invalidates textruns
+ * on those lines because the text in the lines might have changed due to
+ * addition/removal of frames.
+ * @param aLine the line to mark dirty
+ * @param aLineList the line list containing that line
+ */
+ void MarkLineDirty(LineIterator aLine, const nsLineList* aLineList);
+
+ // XXX where to go
+ bool IsLastLine(BlockReflowState& aState, LineIterator aLine);
+
+ void DeleteLine(BlockReflowState& aState, nsLineList::iterator aLine,
+ nsLineList::iterator aLineEnd);
+
+ //----------------------------------------
+ // Methods for individual frame reflow
+
+ bool ShouldApplyBStartMargin(BlockReflowState& aState, nsLineBox* aLine);
+
+ void ReflowBlockFrame(BlockReflowState& aState, LineIterator aLine,
+ bool* aKeepGoing);
+
+ void ReflowInlineFrames(BlockReflowState& aState, LineIterator aLine,
+ bool* aKeepLineGoing);
+
+ void DoReflowInlineFrames(
+ BlockReflowState& aState, nsLineLayout& aLineLayout, LineIterator aLine,
+ nsFlowAreaRect& aFloatAvailableSpace, nscoord& aAvailableSpaceBSize,
+ nsFloatManager::SavedState* aFloatStateBeforeLine, bool* aKeepReflowGoing,
+ LineReflowStatus* aLineReflowStatus, bool aAllowPullUp);
+
+ void ReflowInlineFrame(BlockReflowState& aState, nsLineLayout& aLineLayout,
+ LineIterator aLine, nsIFrame* aFrame,
+ LineReflowStatus* aLineReflowStatus);
+
+ // @param aReflowStatus an incomplete status indicates the float should be
+ // split but only if the available block-size is constrained.
+ void ReflowFloat(BlockReflowState& aState, ReflowInput& aFloatRI,
+ nsIFrame* aFloat, nsReflowStatus& aReflowStatus);
+
+ //----------------------------------------
+ // Methods for pushing/pulling lines/frames
+
+ /**
+ * Create a next-in-flow, if necessary, for aFrame. If a new frame is
+ * created, place it in aLine if aLine is not null.
+ * @param aState the block reflow state
+ * @param aLine where to put a new frame
+ * @param aFrame the frame
+ * @return true if a new frame was created, false if not
+ */
+ bool CreateContinuationFor(BlockReflowState& aState, nsLineBox* aLine,
+ nsIFrame* aFrame);
+
+ /**
+ * Set line-break-before status in aState.mReflowStatus because aLine cannot
+ * be placed on this page/column and we don't want to break within ourselves.
+ * Also, mark the aLine dirty, and set aKeepReflowGoing to false;
+ */
+ void SetBreakBeforeStatusBeforeLine(BlockReflowState& aState,
+ LineIterator aLine,
+ bool* aKeepReflowGoing);
+
+ /**
+ * Push aLine (and any after it), since it cannot be placed on this
+ * page/column. Set aKeepReflowGoing to false and set
+ * flag aState.mReflowStatus as incomplete.
+ */
+ void PushTruncatedLine(BlockReflowState& aState, LineIterator aLine,
+ bool* aKeepReflowGoing);
+
+ void SplitLine(BlockReflowState& aState, nsLineLayout& aLineLayout,
+ LineIterator aLine, nsIFrame* aFrame,
+ LineReflowStatus* aLineReflowStatus);
+
+ /**
+ * Pull a frame from the next available location (one of our lines or
+ * one of our next-in-flows lines).
+ * @return the pulled frame or nullptr
+ */
+ nsIFrame* PullFrame(BlockReflowState& aState, LineIterator aLine);
+
+ /**
+ * Try to pull a frame out of a line pointed at by aFromLine.
+ *
+ * Note: pulling a frame from a line that is a place-holder frame
+ * doesn't automatically remove the corresponding float from the
+ * line's float array. This happens indirectly: either the line gets
+ * emptied (and destroyed) or the line gets reflowed (because we mark
+ * it dirty) and the code at the top of ReflowLine empties the
+ * array. So eventually, it will be removed, just not right away.
+ *
+ * @return the pulled frame or nullptr
+ */
+ nsIFrame* PullFrameFrom(nsLineBox* aLine, nsBlockFrame* aFromContainer,
+ nsLineList::iterator aFromLine);
+
+ /**
+ * Push the line after aLineBefore to the overflow line list.
+ * @param aLineBefore a line in 'mLines' (or LinesBegin() when
+ * pushing the first line)
+ */
+ void PushLines(BlockReflowState& aState, nsLineList::iterator aLineBefore);
+
+ void PropagateFloatDamage(BlockReflowState& aState, nsLineBox* aLine,
+ nscoord aDeltaBCoord);
+
+ void CheckFloats(BlockReflowState& aState);
+
+ //----------------------------------------
+ // List handling kludge
+
+ void ReflowOutsideMarker(nsIFrame* aMarkerFrame, BlockReflowState& aState,
+ ReflowOutput& aMetrics, nscoord aLineTop);
+
+ //----------------------------------------
+
+ NS_DECLARE_FRAME_PROPERTY_DELETABLE(LineIteratorProperty, nsLineIterator);
+
+ bool CanProvideLineIterator() const final { return true; }
+ nsILineIterator* GetLineIterator() final;
+
+ public:
+ bool HasOverflowLines() const {
+ return HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_LINES);
+ }
+ FrameLines* GetOverflowLines() const;
+
+ protected:
+ FrameLines* RemoveOverflowLines();
+ void SetOverflowLines(FrameLines* aOverflowLines);
+ void DestroyOverflowLines();
+
+ /**
+ * This class is useful for efficiently modifying the out of flow
+ * overflow list. It gives the client direct writable access to
+ * the frame list temporarily but ensures that property is only
+ * written back if absolutely necessary.
+ */
+ struct nsAutoOOFFrameList {
+ nsFrameList mList;
+
+ explicit nsAutoOOFFrameList(nsBlockFrame* aBlock)
+ : mPropValue(aBlock->GetOverflowOutOfFlows()), mBlock(aBlock) {
+ if (mPropValue) {
+ mList = std::move(*mPropValue);
+ }
+ }
+ ~nsAutoOOFFrameList() {
+ mBlock->SetOverflowOutOfFlows(std::move(mList), mPropValue);
+ }
+
+ protected:
+ nsFrameList* const mPropValue;
+ nsBlockFrame* const mBlock;
+ };
+ friend struct nsAutoOOFFrameList;
+
+ nsFrameList* GetOverflowOutOfFlows() const;
+
+ // This takes ownership of the frames in aList.
+ void SetOverflowOutOfFlows(nsFrameList&& aList, nsFrameList* aPropValue);
+
+ /**
+ * @return the inside ::marker frame or nullptr if we don't have one.
+ */
+ nsIFrame* GetInsideMarker() const;
+
+ /**
+ * @return the outside ::marker frame or nullptr if we don't have one.
+ */
+ nsIFrame* GetOutsideMarker() const;
+
+ /**
+ * @return the outside ::marker frame list frame property.
+ */
+ nsFrameList* GetOutsideMarkerList() const;
+
+ /**
+ * @return true if this frame has pushed floats.
+ */
+ bool HasPushedFloats() const {
+ return HasAnyStateBits(NS_BLOCK_HAS_PUSHED_FLOATS);
+ }
+
+ // Get the pushed floats list, which is used for *temporary* storage
+ // of floats during reflow, between when we decide they don't fit in
+ // this block until our next continuation takes them.
+ nsFrameList* GetPushedFloats() const;
+ // Get the pushed floats list, or if there is not currently one,
+ // make a new empty one.
+ nsFrameList* EnsurePushedFloats();
+ // Remove and return the pushed floats list.
+ nsFrameList* RemovePushedFloats();
+
+#ifdef DEBUG
+ void VerifyLines(bool aFinalCheckOK);
+ void VerifyOverflowSituation();
+ int32_t GetDepth() const;
+#endif
+
+ nscoord mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ nscoord mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+
+ nsLineList mLines;
+
+ // List of all floats in this block
+ // XXXmats blocks rarely have floats, make it a frame property
+ nsFrameList mFloats;
+
+ friend class mozilla::BlockReflowState;
+ friend class nsBlockInFlowLineIterator;
+
+#ifdef DEBUG
+ public:
+ static bool gLamePaintMetrics;
+ static bool gLameReflowMetrics;
+ static bool gNoisy;
+ static bool gNoisyDamageRepair;
+ static bool gNoisyIntrinsic;
+ static bool gNoisyReflow;
+ static bool gReallyNoisyReflow;
+ static bool gNoisyFloatManager;
+ static bool gVerifyLines;
+ static bool gDisableResizeOpt;
+
+ static int32_t gNoiseIndent;
+
+ static const char* kReflowCommandType[];
+
+ protected:
+ static void InitDebugFlags();
+#endif
+};
+
+#ifdef DEBUG
+class AutoNoisyIndenter {
+ public:
+ explicit AutoNoisyIndenter(bool aDoIndent) : mIndented(aDoIndent) {
+ if (mIndented) {
+ nsBlockFrame::gNoiseIndent++;
+ }
+ }
+ ~AutoNoisyIndenter() {
+ if (mIndented) {
+ nsBlockFrame::gNoiseIndent--;
+ }
+ }
+
+ private:
+ bool mIndented;
+};
+#endif
+
+/**
+ * Iterates over all lines in the prev-in-flows/next-in-flows of this block.
+ */
+class nsBlockInFlowLineIterator {
+ public:
+ typedef nsBlockFrame::LineIterator LineIterator;
+ /**
+ * Set up the iterator to point to aLine which must be a normal line
+ * in aFrame (not an overflow line).
+ */
+ nsBlockInFlowLineIterator(nsBlockFrame* aFrame, LineIterator aLine);
+ /**
+ * Set up the iterator to point to the first line found starting from
+ * aFrame. Sets aFoundValidLine to false if there is no such line.
+ * After aFoundValidLine has returned false, don't call any methods on this
+ * object again.
+ */
+ nsBlockInFlowLineIterator(nsBlockFrame* aFrame, bool* aFoundValidLine);
+ /**
+ * Set up the iterator to point to the line that contains aFindFrame (either
+ * directly or indirectly). If aFrame is out of flow, or contained in an
+ * out-of-flow, finds the line containing the out-of-flow's placeholder. If
+ * the frame is not found, sets aFoundValidLine to false. After
+ * aFoundValidLine has returned false, don't call any methods on this
+ * object again.
+ */
+ nsBlockInFlowLineIterator(nsBlockFrame* aFrame, nsIFrame* aFindFrame,
+ bool* aFoundValidLine);
+
+ // Allow to be uninitialized (and then assigned from another object).
+ nsBlockInFlowLineIterator() : mFrame(nullptr) {}
+
+ LineIterator GetLine() { return mLine; }
+ bool IsLastLineInList();
+ nsBlockFrame* GetContainer() { return mFrame; }
+ bool GetInOverflow() { return mLineList != &mFrame->mLines; }
+
+ /**
+ * Returns the current line list we're iterating, null means
+ * we're iterating |mLines| of the container.
+ */
+ nsLineList* GetLineList() { return mLineList; }
+
+ /**
+ * Returns the end-iterator of whatever line list we're in.
+ */
+ LineIterator End();
+
+ /**
+ * Returns false if there are no more lines. After this has returned false,
+ * don't call any methods on this object again.
+ */
+ bool Next();
+ /**
+ * Returns false if there are no more lines. After this has returned false,
+ * don't call any methods on this object again.
+ */
+ bool Prev();
+
+ // XXX nsBlockFrame uses this internally in one place. Try to remove it.
+ // XXX uhm, and nsBidiPresUtils::Resolve too.
+ nsBlockInFlowLineIterator(nsBlockFrame* aFrame, LineIterator aLine,
+ bool aInOverflow);
+
+ private:
+ nsBlockFrame* mFrame;
+ LineIterator mLine;
+ nsLineList* mLineList; // the line list mLine is in
+
+ /**
+ * Moves iterator to next valid line reachable from the current block.
+ * Returns false if there are no valid lines.
+ */
+ bool FindValidLine();
+};
+
+#endif /* nsBlockFrame_h___ */