The Tor Browser: comparison layout/generic/nsBlockReflowState.h

--1:000000000000
+:418477778ecf
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+/* state used in reflow of block frames */
+#ifndef nsBlockReflowState_h__
+#define nsBlockReflowState_h__
+#include "nsFloatManager.h"
+#include "nsLineBox.h"
+#include "nsHTMLReflowState.h"
+class nsBlockFrame;
+class nsFrameList;
+class nsOverflowContinuationTracker;
+// block reflow state flags
+#define BRS_UNCONSTRAINEDHEIGHT   0x00000001
+#define BRS_ISTOPMARGINROOT       0x00000002  // Is this frame a root for top/bottom margin collapsing?
+#define BRS_ISBOTTOMMARGINROOT    0x00000004
+#define BRS_APPLYTOPMARGIN        0x00000008  // See ShouldApplyTopMargin
+#define BRS_ISFIRSTINFLOW         0x00000010
+// Set when mLineAdjacentToTop is valid
+#define BRS_HAVELINEADJACENTTOTOP 0x00000020
+// Set when the block has the equivalent of NS_BLOCK_FLOAT_MGR
+#define BRS_FLOAT_MGR             0x00000040
+// Set when nsLineLayout::LineIsEmpty was true at the end of reflowing
+// the current line
+#define BRS_LINE_LAYOUT_EMPTY     0x00000080
+#define BRS_ISOVERFLOWCONTAINER   0x00000100
+// Our mPushedFloats list is stored on the blocks' proptable
+#define BRS_PROPTABLE_FLOATCLIST  0x00000200
+#define BRS_LASTFLAG              BRS_PROPTABLE_FLOATCLIST
+class nsBlockReflowState {
+public:
+nsBlockReflowState(const nsHTMLReflowState& aReflowState,
+nsPresContext* aPresContext,
+nsBlockFrame* aFrame,
+bool aTopMarginRoot, bool aBottomMarginRoot,
+bool aBlockNeedsFloatManager,
+nscoord aConsumedHeight = NS_INTRINSICSIZE);
+/**
+* Get the available reflow space (the area not occupied by floats)
+* for the current y coordinate. The available space is relative to
+* our coordinate system, which is the content box, with (0, 0) in the
+* upper left.
+*
+* Returns whether there are floats present at the given vertical
+* coordinate and within the width of the content rect.
+*/
+nsFlowAreaRect GetFloatAvailableSpace() const
+{ return GetFloatAvailableSpace(mY); }
+nsFlowAreaRect GetFloatAvailableSpace(nscoord aY) const
+{ return GetFloatAvailableSpaceWithState(aY, nullptr); }
+nsFlowAreaRect
+GetFloatAvailableSpaceWithState(nscoord aY,
+nsFloatManager::SavedState *aState) const;
+nsFlowAreaRect
+GetFloatAvailableSpaceForHeight(nscoord aY, nscoord aHeight,
+nsFloatManager::SavedState *aState) const;
+/*
+* The following functions all return true if they were able to
+* place the float, false if the float did not fit in available
+* space.
+* aLineLayout is null when we are reflowing pushed floats (because
+* they are not associated with a line box).
+*/
+bool AddFloat(nsLineLayout*       aLineLayout,
+nsIFrame*           aFloat,
+nscoord             aAvailableWidth);
+private:
+bool CanPlaceFloat(nscoord aFloatWidth,
+const nsFlowAreaRect& aFloatAvailableSpace);
+public:
+bool FlowAndPlaceFloat(nsIFrame* aFloat);
+private:
+void PushFloatPastBreak(nsIFrame* aFloat);
+public:
+void PlaceBelowCurrentLineFloats(nsFloatCacheFreeList& aFloats,
+nsLineBox* aLine);
+// Returns the first coordinate >= aY that clears the
+// floats indicated by aBreakType and has enough width between floats
+// (or no floats remaining) to accomodate aReplacedBlock.
+nscoord ClearFloats(nscoord aY, uint8_t aBreakType,
+nsIFrame *aReplacedBlock = nullptr,
+uint32_t aFlags = 0);
+bool IsAdjacentWithTop() const {
+return mY ==
+((mFlags & BRS_ISFIRSTINFLOW) ? mReflowState.ComputedPhysicalBorderPadding().top : 0);
+}
+/**
+* Adjusts the border/padding to return 0 for the top if
+* we are not the first in flow.
+*/
+nsMargin BorderPadding() const {
+nsMargin result = mReflowState.ComputedPhysicalBorderPadding();
+if (!(mFlags & BRS_ISFIRSTINFLOW)) {
+result.top = 0;
+if (mFlags & BRS_ISOVERFLOWCONTAINER) {
+result.bottom = 0;
+}
+}
+return result;
+}
+/**
+* Retrieve the height "consumed" by any previous-in-flows.
+*/
+nscoord GetConsumedHeight();
+// Reconstruct the previous bottom margin that goes above |aLine|.
+void ReconstructMarginAbove(nsLineList::iterator aLine);
+// Caller must have called GetAvailableSpace for the correct position
+// (which need not be the current mY).
+void ComputeReplacedBlockOffsetsForFloats(nsIFrame* aFrame,
+const nsRect& aFloatAvailableSpace,
+nscoord& aLeftResult,
+nscoord& aRightResult);
+// Caller must have called GetAvailableSpace for the current mY
+void ComputeBlockAvailSpace(nsIFrame* aFrame,
+const nsStyleDisplay* aDisplay,
+const nsFlowAreaRect& aFloatAvailableSpace,
+bool aBlockAvoidsFloats,
+nsRect& aResult);
+protected:
+void RecoverFloats(nsLineList::iterator aLine, nscoord aDeltaY);
+public:
+void RecoverStateFrom(nsLineList::iterator aLine, nscoord aDeltaY);
+void AdvanceToNextLine() {
+if (GetFlag(BRS_LINE_LAYOUT_EMPTY)) {
+SetFlag(BRS_LINE_LAYOUT_EMPTY, false);
+} else {
+mLineNumber++;
+}
+}
+//----------------------------------------
+// This state is the "global" state computed once for the reflow of
+// the block.
+// The block frame that is using this object
+nsBlockFrame* mBlock;
+nsPresContext* mPresContext;
+const nsHTMLReflowState& mReflowState;
+nsFloatManager* mFloatManager;
+// The coordinates within the float manager where the block is being
+// placed <b>after</b> taking into account the blocks border and
+// padding. This, therefore, represents the inner "content area" (in
+// spacemanager coordinates) where child frames will be placed,
+// including child blocks and floats.
+nscoord mFloatManagerX, mFloatManagerY;
+// XXX get rid of this
+nsReflowStatus mReflowStatus;
+// The float manager state as it was before the contents of this
+// block.  This is needed for positioning bullets, since we only want
+// to move the bullet to flow around floats that were before this
+// block, not floats inside of it.
+nsFloatManager::SavedState mFloatManagerStateBefore;
+nscoord mBottomEdge;
+// The content area to reflow child frames within.  This is within
+// this frame's coordinate system, which means mContentArea.x ==
+// BorderPadding().left and mContentArea.y == BorderPadding().top.
+// The height may be NS_UNCONSTRAINEDSIZE, which indicates that there
+// is no page/column boundary below (the common case).
+// mContentArea.YMost() should only be called after checking that
+// mContentArea.height is not NS_UNCONSTRAINEDSIZE; otherwise
+// coordinate overflow may occur.
+nsRect mContentArea;
+nscoord mContainerWidth;
+// Continuation out-of-flow float frames that need to move to our
+// next in flow are placed here during reflow.  It's a pointer to
+// a frame list stored in the block's property table.
+nsFrameList *mPushedFloats;
+// This method makes sure pushed floats are accessible to
+// StealFrame. Call it before adding any frames to mPushedFloats.
+void SetupPushedFloatList();
+// Use this method to append to mPushedFloats.
+void AppendPushedFloat(nsIFrame* aFloatCont);
+// Track child overflow continuations.
+nsOverflowContinuationTracker* mOverflowTracker;
+//----------------------------------------
+// This state is "running" state updated by the reflow of each line
+// in the block. This same state is "recovered" when a line is not
+// dirty and is passed over during incremental reflow.
+// The current line being reflowed
+// If it is mBlock->end_lines(), then it is invalid.
+nsLineList::iterator mCurrentLine;
+// When BRS_HAVELINEADJACENTTOTOP is set, this refers to a line
+// which we know is adjacent to the top of the block (in other words,
+// all lines before it are empty and do not have clearance. This line is
+// always before the current line.
+nsLineList::iterator mLineAdjacentToTop;
+// The current Y coordinate in the block
+nscoord mY;
+// The overflow areas of all floats placed so far
+nsOverflowAreas mFloatOverflowAreas;
+nsFloatCacheFreeList mFloatCacheFreeList;
+// Previous child. This is used when pulling up a frame to update
+// the sibling list.
+nsIFrame* mPrevChild;
+// The previous child frames collapsed bottom margin value.
+nsCollapsingMargin mPrevBottomMargin;
+// The current next-in-flow for the block. When lines are pulled
+// from a next-in-flow, this is used to know which next-in-flow to
+// pull from. When a next-in-flow is emptied of lines, we advance
+// this to the next next-in-flow.
+nsBlockFrame* mNextInFlow;
+//----------------------------------------
+// Temporary line-reflow state. This state is used during the reflow
+// of a given line, but doesn't have meaning before or after.
+// The list of floats that are "current-line" floats. These are
+// added to the line after the line has been reflowed, to keep the
+// list fiddling from being N^2.
+nsFloatCacheFreeList mCurrentLineFloats;
+// The list of floats which are "below current-line"
+// floats. These are reflowed/placed after the line is reflowed
+// and placed. Again, this is done to keep the list fiddling from
+// being N^2.
+nsFloatCacheFreeList mBelowCurrentLineFloats;
+nscoord mMinLineHeight;
+int32_t mLineNumber;
+int16_t mFlags;
+uint8_t mFloatBreakType;
+// The amount of computed height "consumed" by previous-in-flows.
+nscoord mConsumedHeight;
+void SetFlag(uint32_t aFlag, bool aValue)
+{
+NS_ASSERTION(aFlag<=BRS_LASTFLAG, "bad flag");
+if (aValue) { // set flag
+mFlags |= aFlag;
+}
+else {        // unset flag
+mFlags &= ~aFlag;
+}
+}
+bool GetFlag(uint32_t aFlag) const
+{
+NS_ASSERTION(aFlag<=BRS_LASTFLAG, "bad flag");
+return !!(mFlags & aFlag);
+}
+};
+#endif // nsBlockReflowState_h__

The Tor Browser / file comparison

comparison: layout/generic/nsBlockReflowState.h

layout/generic/nsBlockReflowState.h