diff options
Diffstat (limited to 'layout/generic/BlockReflowState.cpp')
| -rw-r--r-- | layout/generic/BlockReflowState.cpp | 1090 |
1 files changed, 1090 insertions, 0 deletions
diff --git a/layout/generic/BlockReflowState.cpp b/layout/generic/BlockReflowState.cpp new file mode 100644 index 0000000000..0060487c9e --- /dev/null +++ b/layout/generic/BlockReflowState.cpp @@ -0,0 +1,1090 @@ +/* -*- 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/. */ + +/* state used in reflow of block frames */ + +#include "BlockReflowState.h" + +#include <algorithm> +#include "LayoutLogging.h" +#include "nsBlockFrame.h" +#include "nsLineLayout.h" +#include "nsPresContext.h" +#include "nsIFrameInlines.h" +#include "mozilla/AutoRestore.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_layout.h" +#include "TextOverflow.h" + +#ifdef DEBUG +# include "nsBlockDebugFlags.h" +#endif + +using namespace mozilla; +using namespace mozilla::layout; + +BlockReflowState::BlockReflowState(const ReflowInput& aReflowInput, + nsPresContext* aPresContext, + nsBlockFrame* aFrame, bool aBStartMarginRoot, + bool aBEndMarginRoot, + bool aBlockNeedsFloatManager, + const nscoord aConsumedBSize, + const nscoord aEffectiveContentBoxBSize) + : mBlock(aFrame), + mPresContext(aPresContext), + mReflowInput(aReflowInput), + mContentArea(aReflowInput.GetWritingMode()), + mPushedFloats(nullptr), + mOverflowTracker(nullptr), + mBorderPadding( + mReflowInput + .ComputedLogicalBorderPadding(mReflowInput.GetWritingMode()) + .ApplySkipSides(aFrame->PreReflowBlockLevelLogicalSkipSides())), + mPrevBEndMargin(), + mMinLineHeight(aReflowInput.GetLineHeight()), + mLineNumber(0), + mTrailingClearFromPIF(StyleClear::None), + mConsumedBSize(aConsumedBSize) { + NS_ASSERTION(mConsumedBSize != NS_UNCONSTRAINEDSIZE, + "The consumed block-size should be constrained!"); + + WritingMode wm = aReflowInput.GetWritingMode(); + + // Note that mContainerSize is the physical size, needed to + // convert logical block-coordinates in vertical-rl writing mode + // (measured from a RHS origin) to physical coordinates within the + // containing block. + // If aReflowInput doesn't have a constrained ComputedWidth(), we set + // mContainerSize.width to zero, which means lines will be positioned + // (physically) incorrectly; we will fix them up at the end of + // nsBlockFrame::Reflow, after we know the total block-size of the + // frame. + mContainerSize.width = aReflowInput.ComputedWidth(); + if (mContainerSize.width == NS_UNCONSTRAINEDSIZE) { + mContainerSize.width = 0; + } + + mContainerSize.width += mBorderPadding.LeftRight(wm); + + // For now at least, we don't do that fix-up for mContainerHeight. + // It's only used in nsBidiUtils::ReorderFrames for vertical rtl + // writing modes, which aren't fully supported for the time being. + mContainerSize.height = + aReflowInput.ComputedHeight() + mBorderPadding.TopBottom(wm); + + if (aBStartMarginRoot || 0 != mBorderPadding.BStart(wm)) { + mFlags.mIsBStartMarginRoot = true; + mFlags.mShouldApplyBStartMargin = true; + } + if (aBEndMarginRoot || 0 != mBorderPadding.BEnd(wm)) { + mFlags.mIsBEndMarginRoot = true; + } + if (aBlockNeedsFloatManager) { + mFlags.mBlockNeedsFloatManager = true; + } + + mFlags.mCanHaveOverflowMarkers = css::TextOverflow::CanHaveOverflowMarkers( + mBlock, css::TextOverflow::BeforeReflow::Yes); + + MOZ_ASSERT(FloatManager(), + "Float manager should be valid when creating BlockReflowState!"); + + // Save the coordinate system origin for later. + FloatManager()->GetTranslation(mFloatManagerI, mFloatManagerB); + FloatManager()->PushState(&mFloatManagerStateBefore); // never popped + + mNextInFlow = static_cast<nsBlockFrame*>(mBlock->GetNextInFlow()); + + LAYOUT_WARN_IF_FALSE(NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedISize(), + "have unconstrained width; this should only result " + "from very large sizes, not attempts at intrinsic " + "width calculation"); + mContentArea.ISize(wm) = aReflowInput.ComputedISize(); + + // Compute content area block-size. Unlike the inline-size, if we have a + // specified style block-size, we ignore it since extra content is managed by + // the "overflow" property. When we don't have a specified style block-size, + // then we may end up limiting our block-size if the available block-size is + // constrained (this situation occurs when we are paginated). + if (const nscoord availableBSize = aReflowInput.AvailableBSize(); + availableBSize != NS_UNCONSTRAINEDSIZE) { + // We are in a paginated situation. The block-end edge of the available + // space to reflow the children is within our block-end border and padding. + // If we're cloning our border and padding, and we're going to request + // additional continuations because of our excessive content-box block-size, + // then reserve some of our available space for our (cloned) block-end + // border and padding. + const bool reserveSpaceForBlockEndBP = + mReflowInput.mStyleBorder->mBoxDecorationBreak == + StyleBoxDecorationBreak::Clone && + (aEffectiveContentBoxBSize == NS_UNCONSTRAINEDSIZE || + aEffectiveContentBoxBSize + mBorderPadding.BStartEnd(wm) > + availableBSize); + const nscoord bp = reserveSpaceForBlockEndBP ? mBorderPadding.BStartEnd(wm) + : mBorderPadding.BStart(wm); + mContentArea.BSize(wm) = std::max(0, availableBSize - bp); + } else { + // When we are not in a paginated situation, then we always use a + // unconstrained block-size. + mContentArea.BSize(wm) = NS_UNCONSTRAINEDSIZE; + } + mContentArea.IStart(wm) = mBorderPadding.IStart(wm); + mBCoord = mContentArea.BStart(wm) = mBorderPadding.BStart(wm); + + mPrevChild = nullptr; + mCurrentLine = aFrame->LinesEnd(); +} + +void BlockReflowState::ComputeFloatAvoidingOffsets( + nsIFrame* aFloatAvoidingBlock, const LogicalRect& aFloatAvailableSpace, + nscoord& aIStartResult, nscoord& aIEndResult) const { + WritingMode wm = mReflowInput.GetWritingMode(); + // The frame is clueless about the float manager and therefore we + // only give it free space. An example is a table frame - the + // tables do not flow around floats. + // However, we can let its margins intersect floats. + NS_ASSERTION(aFloatAvailableSpace.IStart(wm) >= mContentArea.IStart(wm), + "bad avail space rect inline-coord"); + NS_ASSERTION(aFloatAvailableSpace.ISize(wm) == 0 || + aFloatAvailableSpace.IEnd(wm) <= mContentArea.IEnd(wm), + "bad avail space rect inline-size"); + + nscoord iStartOffset, iEndOffset; + if (aFloatAvailableSpace.ISize(wm) == mContentArea.ISize(wm)) { + // We don't need to compute margins when there are no floats around. + iStartOffset = 0; + iEndOffset = 0; + } else { + const LogicalMargin frameMargin = + SizeComputationInput(aFloatAvoidingBlock, + mReflowInput.mRenderingContext, wm, + mContentArea.ISize(wm)) + .ComputedLogicalMargin(wm); + + nscoord iStartFloatIOffset = + aFloatAvailableSpace.IStart(wm) - mContentArea.IStart(wm); + iStartOffset = std::max(iStartFloatIOffset, frameMargin.IStart(wm)) - + frameMargin.IStart(wm); + iStartOffset = std::max(iStartOffset, 0); // in case of negative margin + nscoord iEndFloatIOffset = + mContentArea.IEnd(wm) - aFloatAvailableSpace.IEnd(wm); + iEndOffset = + std::max(iEndFloatIOffset, frameMargin.IEnd(wm)) - frameMargin.IEnd(wm); + iEndOffset = std::max(iEndOffset, 0); // in case of negative margin + } + aIStartResult = iStartOffset; + aIEndResult = iEndOffset; +} + +LogicalRect BlockReflowState::ComputeBlockAvailSpace( + nsIFrame* aFrame, const nsFlowAreaRect& aFloatAvailableSpace, + bool aBlockAvoidsFloats) { +#ifdef REALLY_NOISY_REFLOW + printf("CBAS frame=%p has floats %d\n", aFrame, + aFloatAvailableSpace.HasFloats()); +#endif + WritingMode wm = mReflowInput.GetWritingMode(); + LogicalRect result(wm); + result.BStart(wm) = mBCoord; + // Note: ContentBSize() and ContentBEnd() are not our content-box size and its + // block-end edge. They really mean "the available block-size for children", + // and "the block-end edge of the available space for children". + result.BSize(wm) = ContentBSize() == NS_UNCONSTRAINEDSIZE + ? NS_UNCONSTRAINEDSIZE + : ContentBEnd() - mBCoord; + // mBCoord might be greater than ContentBEnd() if the block's top margin + // pushes it off the page/column. Negative available block-size can confuse + // other code and is nonsense in principle. + + // XXX Do we really want this condition to be this restrictive (i.e., + // more restrictive than it used to be)? The |else| here is allowed + // by the CSS spec, but only out of desperation given implementations, + // and the behavior it leads to is quite undesirable (it can cause + // things to become extremely narrow when they'd fit quite well a + // little bit lower). Should the else be a quirk or something that + // applies to a specific set of frame classes and no new ones? + // If we did that, then for those frames where the condition below is + // true but nsBlockFrame::BlockCanIntersectFloats is false, + // nsBlockFrame::ISizeToClearPastFloats would need to use the + // shrink-wrap formula, max(MinISize, min(avail width, PrefISize)) + // rather than just using MinISize. + NS_ASSERTION( + nsBlockFrame::BlockCanIntersectFloats(aFrame) == !aBlockAvoidsFloats, + "unexpected replaced width"); + if (!aBlockAvoidsFloats) { + if (aFloatAvailableSpace.HasFloats()) { + // Use the float-edge property to determine how the child block + // will interact with the float. + const nsStyleBorder* borderStyle = aFrame->StyleBorder(); + switch (borderStyle->mFloatEdge) { + default: + case StyleFloatEdge::ContentBox: // content and only content does + // runaround of floats + // The child block will flow around the float. Therefore + // give it all of the available space. + result.IStart(wm) = mContentArea.IStart(wm); + result.ISize(wm) = mContentArea.ISize(wm); + break; + case StyleFloatEdge::MarginBox: { + // The child block's margins should be placed adjacent to, + // but not overlap the float. + result.IStart(wm) = aFloatAvailableSpace.mRect.IStart(wm); + result.ISize(wm) = aFloatAvailableSpace.mRect.ISize(wm); + } break; + } + } else { + // Since there are no floats present the float-edge property + // doesn't matter therefore give the block element all of the + // available space since it will flow around the float itself. + result.IStart(wm) = mContentArea.IStart(wm); + result.ISize(wm) = mContentArea.ISize(wm); + } + } else { + nscoord iStartOffset, iEndOffset; + ComputeFloatAvoidingOffsets(aFrame, aFloatAvailableSpace.mRect, + iStartOffset, iEndOffset); + result.IStart(wm) = mContentArea.IStart(wm) + iStartOffset; + result.ISize(wm) = mContentArea.ISize(wm) - iStartOffset - iEndOffset; + } + +#ifdef REALLY_NOISY_REFLOW + printf(" CBAS: result %d %d %d %d\n", result.IStart(wm), result.BStart(wm), + result.ISize(wm), result.BSize(wm)); +#endif + + return result; +} + +LogicalSize BlockReflowState::ComputeAvailableSizeForFloat() const { + const auto wm = mReflowInput.GetWritingMode(); + const nscoord availBSize = ContentBSize() == NS_UNCONSTRAINEDSIZE + ? NS_UNCONSTRAINEDSIZE + : std::max(0, ContentBEnd() - mBCoord); + return LogicalSize(wm, ContentISize(), availBSize); +} + +bool BlockReflowState::FloatAvoidingBlockFitsInAvailSpace( + nsIFrame* aFloatAvoidingBlock, + const nsFlowAreaRect& aFloatAvailableSpace) const { + if (!aFloatAvailableSpace.HasFloats()) { + // If there aren't any floats here, then we always fit. + // We check this before calling ISizeToClearPastFloats, which is + // somewhat expensive. + return true; + } + + // |aFloatAvailableSpace| was computed as having a negative size, which means + // there are floats on both sides pushing inwards past each other, and + // |aFloatAvoidingBlock| would necessarily intersect a float if we put it + // here. So, it doesn't fit. + if (aFloatAvailableSpace.ISizeIsActuallyNegative()) { + return false; + } + + WritingMode wm = mReflowInput.GetWritingMode(); + nsBlockFrame::FloatAvoidingISizeToClear replacedISize = + nsBlockFrame::ISizeToClearPastFloats(*this, aFloatAvailableSpace.mRect, + aFloatAvoidingBlock); + // The inline-start side of the replaced element should be offset by + // the larger of the float intrusion or the replaced element's own + // start margin. The inline-end side is similar, except for Web + // compatibility we ignore the margin. + return std::max( + aFloatAvailableSpace.mRect.IStart(wm) - mContentArea.IStart(wm), + replacedISize.marginIStart) + + replacedISize.borderBoxISize + + (mContentArea.IEnd(wm) - aFloatAvailableSpace.mRect.IEnd(wm)) <= + mContentArea.ISize(wm); +} + +nsFlowAreaRect BlockReflowState::GetFloatAvailableSpaceWithState( + nscoord aBCoord, ShapeType aShapeType, + nsFloatManager::SavedState* aState) const { + WritingMode wm = mReflowInput.GetWritingMode(); +#ifdef DEBUG + // Verify that the caller setup the coordinate system properly + nscoord wI, wB; + FloatManager()->GetTranslation(wI, wB); + + NS_ASSERTION((wI == mFloatManagerI) && (wB == mFloatManagerB), + "bad coord system"); +#endif + + nscoord blockSize = (mContentArea.BSize(wm) == nscoord_MAX) + ? nscoord_MAX + : std::max(mContentArea.BEnd(wm) - aBCoord, 0); + nsFlowAreaRect result = FloatManager()->GetFlowArea( + wm, aBCoord, blockSize, BandInfoType::BandFromPoint, aShapeType, + mContentArea, aState, ContainerSize()); + // Keep the inline size >= 0 for compatibility with nsSpaceManager. + if (result.mRect.ISize(wm) < 0) { + result.mRect.ISize(wm) = 0; + } + +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow) { + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("%s: band=%d,%d,%d,%d hasfloats=%d\n", __func__, + result.mRect.IStart(wm), result.mRect.BStart(wm), + result.mRect.ISize(wm), result.mRect.BSize(wm), result.HasFloats()); + } +#endif + return result; +} + +nsFlowAreaRect BlockReflowState::GetFloatAvailableSpaceForBSize( + nscoord aBCoord, nscoord aBSize, nsFloatManager::SavedState* aState) const { + WritingMode wm = mReflowInput.GetWritingMode(); +#ifdef DEBUG + // Verify that the caller setup the coordinate system properly + nscoord wI, wB; + FloatManager()->GetTranslation(wI, wB); + + NS_ASSERTION((wI == mFloatManagerI) && (wB == mFloatManagerB), + "bad coord system"); +#endif + nsFlowAreaRect result = FloatManager()->GetFlowArea( + wm, aBCoord, aBSize, BandInfoType::WidthWithinHeight, + ShapeType::ShapeOutside, mContentArea, aState, ContainerSize()); + // Keep the width >= 0 for compatibility with nsSpaceManager. + if (result.mRect.ISize(wm) < 0) { + result.mRect.ISize(wm) = 0; + } + +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow) { + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("%s: space=%d,%d,%d,%d hasfloats=%d\n", __func__, + result.mRect.IStart(wm), result.mRect.BStart(wm), + result.mRect.ISize(wm), result.mRect.BSize(wm), result.HasFloats()); + } +#endif + return result; +} + +/* + * Reconstruct the vertical margin before the line |aLine| in order to + * do an incremental reflow that begins with |aLine| without reflowing + * the line before it. |aLine| may point to the fencepost at the end of + * the line list, and it is used this way since we (for now, anyway) + * always need to recover margins at the end of a block. + * + * The reconstruction involves walking backward through the line list to + * find any collapsed margins preceding the line that would have been in + * the reflow input's |mPrevBEndMargin| when we reflowed that line in + * a full reflow (under the rule in CSS2 that all adjacent vertical + * margins of blocks collapse). + */ +void BlockReflowState::ReconstructMarginBefore(nsLineList::iterator aLine) { + mPrevBEndMargin.Zero(); + nsBlockFrame* block = mBlock; + + nsLineList::iterator firstLine = block->LinesBegin(); + for (;;) { + --aLine; + if (aLine->IsBlock()) { + mPrevBEndMargin = aLine->GetCarriedOutBEndMargin(); + break; + } + if (!aLine->IsEmpty()) { + break; + } + if (aLine == firstLine) { + // If the top margin was carried out (and thus already applied), + // set it to zero. Either way, we're done. + if (!mFlags.mIsBStartMarginRoot) { + mPrevBEndMargin.Zero(); + } + break; + } + } +} + +void BlockReflowState::SetupPushedFloatList() { + MOZ_ASSERT(!mFlags.mIsFloatListInBlockPropertyTable == !mPushedFloats, + "flag mismatch"); + if (!mFlags.mIsFloatListInBlockPropertyTable) { + // If we're being re-Reflow'd without our next-in-flow having been + // reflowed, some pushed floats from our previous reflow might + // still be on our pushed floats list. However, that's + // actually fine, since they'll all end up being stolen and + // reordered into the correct order again. + // (nsBlockFrame::ReflowDirtyLines ensures that any lines with + // pushed floats are reflowed.) + mPushedFloats = mBlock->EnsurePushedFloats(); + mFlags.mIsFloatListInBlockPropertyTable = true; + } +} + +void BlockReflowState::AppendPushedFloatChain(nsIFrame* aFloatCont) { + SetupPushedFloatList(); + while (true) { + aFloatCont->AddStateBits(NS_FRAME_IS_PUSHED_FLOAT); + mPushedFloats->AppendFrame(mBlock, aFloatCont); + aFloatCont = aFloatCont->GetNextInFlow(); + if (!aFloatCont || aFloatCont->GetParent() != mBlock) { + break; + } + mBlock->StealFrame(aFloatCont); + } +} + +/** + * Restore information about floats into the float manager for an + * incremental reflow, and simultaneously push the floats by + * |aDeltaBCoord|, which is the amount |aLine| was pushed relative to its + * parent. The recovery of state is one of the things that makes + * incremental reflow O(N^2) and this state should really be kept + * around, attached to the frame tree. + */ +void BlockReflowState::RecoverFloats(nsLineList::iterator aLine, + nscoord aDeltaBCoord) { + WritingMode wm = mReflowInput.GetWritingMode(); + if (aLine->HasFloats()) { + // Place the floats into the float manager again. Also slide + // them, just like the regular frames on the line. + for (nsIFrame* floatFrame : aLine->Floats()) { + if (aDeltaBCoord != 0) { + floatFrame->MovePositionBy(nsPoint(0, aDeltaBCoord)); + nsContainerFrame::PositionFrameView(floatFrame); + nsContainerFrame::PositionChildViews(floatFrame); + } +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow || nsBlockFrame::gNoisyFloatManager) { + nscoord tI, tB; + FloatManager()->GetTranslation(tI, tB); + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("RecoverFloats: tIB=%d,%d (%d,%d) ", tI, tB, mFloatManagerI, + mFloatManagerB); + floatFrame->ListTag(stdout); + LogicalRect region = + nsFloatManager::GetRegionFor(wm, floatFrame, ContainerSize()); + printf(" aDeltaBCoord=%d region={%d,%d,%d,%d}\n", aDeltaBCoord, + region.IStart(wm), region.BStart(wm), region.ISize(wm), + region.BSize(wm)); + } +#endif + FloatManager()->AddFloat( + floatFrame, + nsFloatManager::GetRegionFor(wm, floatFrame, ContainerSize()), wm, + ContainerSize()); + } + } else if (aLine->IsBlock()) { + nsBlockFrame::RecoverFloatsFor(aLine->mFirstChild, *FloatManager(), wm, + ContainerSize()); + } +} + +/** + * Everything done in this function is done O(N) times for each pass of + * reflow so it is O(N*M) where M is the number of incremental reflow + * passes. That's bad. Don't do stuff here. + * + * When this function is called, |aLine| has just been slid by |aDeltaBCoord| + * and the purpose of RecoverStateFrom is to ensure that the + * BlockReflowState is in the same state that it would have been in + * had the line just been reflowed. + * + * Most of the state recovery that we have to do involves floats. + */ +void BlockReflowState::RecoverStateFrom(nsLineList::iterator aLine, + nscoord aDeltaBCoord) { + // Make the line being recovered the current line + mCurrentLine = aLine; + + // Place floats for this line into the float manager + if (aLine->HasFloats() || aLine->IsBlock()) { + RecoverFloats(aLine, aDeltaBCoord); + +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow || nsBlockFrame::gNoisyFloatManager) { + FloatManager()->List(stdout); + } +#endif + } +} + +// This is called by the line layout's AddFloat method when a +// place-holder frame is reflowed in a line. If the float is a +// left-most child (it's x coordinate is at the line's left margin) +// then the float is place immediately, otherwise the float +// placement is deferred until the line has been reflowed. + +// XXXldb This behavior doesn't quite fit with CSS1 and CSS2 -- +// technically we're supposed let the current line flow around the +// float as well unless it won't fit next to what we already have. +// But nobody else implements it that way... +bool BlockReflowState::AddFloat(nsLineLayout* aLineLayout, nsIFrame* aFloat, + nscoord aAvailableISize) { + MOZ_ASSERT(aLineLayout, "must have line layout"); + MOZ_ASSERT(mBlock->LinesEnd() != mCurrentLine, "null ptr"); + MOZ_ASSERT(aFloat->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW), + "aFloat must be an out-of-flow frame"); + + MOZ_ASSERT(aFloat->GetParent(), "float must have parent"); + MOZ_ASSERT(aFloat->GetParent()->IsBlockFrameOrSubclass(), + "float's parent must be block"); + if (aFloat->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT) || + aFloat->GetParent() != mBlock) { + MOZ_ASSERT(aFloat->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT | + NS_FRAME_FIRST_REFLOW), + "float should be in this block unless it was marked as " + "pushed float, or just inserted"); + MOZ_ASSERT(aFloat->GetParent()->FirstContinuation() == + mBlock->FirstContinuation()); + // If, in a previous reflow, the float was pushed entirely to + // another column/page, we need to steal it back. (We might just + // push it again, though.) Likewise, if that previous reflow + // reflowed this block but not its next continuation, we might need + // to steal it from our own float-continuations list. + // + // For more about pushed floats, see the comment above + // nsBlockFrame::DrainPushedFloats. + auto* floatParent = static_cast<nsBlockFrame*>(aFloat->GetParent()); + floatParent->StealFrame(aFloat); + + aFloat->RemoveStateBits(NS_FRAME_IS_PUSHED_FLOAT); + + // Appending is fine, since if a float was pushed to the next + // page/column, all later floats were also pushed. + mBlock->mFloats.AppendFrame(mBlock, aFloat); + } + + // Because we are in the middle of reflowing a placeholder frame + // within a line (and possibly nested in an inline frame or two + // that's a child of our block) we need to restore the space + // manager's translation to the space that the block resides in + // before placing the float. + nscoord oI, oB; + FloatManager()->GetTranslation(oI, oB); + nscoord dI = oI - mFloatManagerI; + nscoord dB = oB - mFloatManagerB; + FloatManager()->Translate(-dI, -dB); + + bool placed = false; + + // Now place the float immediately if possible. Otherwise stash it + // away in mBelowCurrentLineFloats and place it later. + // If one or more floats has already been pushed to the next line, + // don't let this one go on the current line, since that would violate + // float ordering. + bool shouldPlaceFloatBelowCurrentLine = false; + if (mBelowCurrentLineFloats.IsEmpty()) { + // If the current line is empty, we don't impose any inline-size constraint + // from the line layout. + Maybe<nscoord> availableISizeInCurrentLine = + aLineLayout->LineIsEmpty() ? Nothing() : Some(aAvailableISize); + PlaceFloatResult result = + FlowAndPlaceFloat(aFloat, availableISizeInCurrentLine); + if (result == PlaceFloatResult::Placed) { + placed = true; + // Pass on updated available space to the current inline reflow engine + WritingMode wm = mReflowInput.GetWritingMode(); + // If we have mLineBSize, we are reflowing the line again due to + // LineReflowStatus::RedoMoreFloats. We should use mLineBSize to query the + // correct available space. + nsFlowAreaRect floatAvailSpace = + mLineBSize.isNothing() ? GetFloatAvailableSpace(mBCoord) + : GetFloatAvailableSpaceForBSize( + mBCoord, mLineBSize.value(), nullptr); + LogicalRect availSpace(wm, floatAvailSpace.mRect.IStart(wm), mBCoord, + floatAvailSpace.mRect.ISize(wm), + floatAvailSpace.mRect.BSize(wm)); + aLineLayout->UpdateBand(wm, availSpace, aFloat); + // Record this float in the current-line list + mCurrentLineFloats.AppendElement(aFloat); + } else if (result == PlaceFloatResult::ShouldPlaceInNextContinuation) { + (*aLineLayout->GetLine())->SetHadFloatPushed(); + } else { + MOZ_ASSERT(result == PlaceFloatResult::ShouldPlaceBelowCurrentLine); + shouldPlaceFloatBelowCurrentLine = true; + } + } else { + shouldPlaceFloatBelowCurrentLine = true; + } + + if (shouldPlaceFloatBelowCurrentLine) { + // Always claim to be placed; we don't know whether we fit yet, so we + // deal with this in PlaceBelowCurrentLineFloats + placed = true; + // This float will be placed after the line is done (it is a + // below-current-line float). + mBelowCurrentLineFloats.AppendElement(aFloat); + } + + // Restore coordinate system + FloatManager()->Translate(dI, dB); + + return placed; +} + +bool BlockReflowState::CanPlaceFloat( + nscoord aFloatISize, const nsFlowAreaRect& aFloatAvailableSpace) { + // A float fits at a given block-dir position if there are no floats + // at its inline-dir position (no matter what its inline size) or if + // its inline size fits in the space remaining after prior floats have + // been placed. + // FIXME: We should allow overflow by up to half a pixel here (bug 21193). + return !aFloatAvailableSpace.HasFloats() || + aFloatAvailableSpace.mRect.ISize(mReflowInput.GetWritingMode()) >= + aFloatISize; +} + +// Return the inline-size that the float (including margins) will take up +// in the writing mode of the containing block. If this returns +// NS_UNCONSTRAINEDSIZE, we're dealing with an orthogonal block that +// has block-size:auto, and we'll need to actually reflow it to find out +// how much inline-size it will occupy in the containing block's mode. +static nscoord FloatMarginISize(WritingMode aCBWM, + const ReflowInput& aFloatRI) { + if (aFloatRI.ComputedSize(aCBWM).ISize(aCBWM) == NS_UNCONSTRAINEDSIZE) { + return NS_UNCONSTRAINEDSIZE; // reflow is needed to get the true size + } + return aFloatRI.ComputedSizeWithMarginBorderPadding(aCBWM).ISize(aCBWM); +} + +// A frame property that stores the last shape source / margin / etc. if there's +// any shape, in order to invalidate the float area properly when it changes. +// +// TODO(emilio): This could really belong to GetRegionFor / StoreRegionFor, but +// when I tried it was a bit awkward because of the logical -> physical +// conversion that happens there. +// +// Maybe all this code could be refactored to make this cleaner, but keeping the +// two properties separated was slightly nicer. +struct ShapeInvalidationData { + StyleShapeOutside mShapeOutside{StyleShapeOutside::None()}; + float mShapeImageThreshold = 0.0; + LengthPercentage mShapeMargin; + + ShapeInvalidationData() = default; + + explicit ShapeInvalidationData(const nsStyleDisplay& aDisplay) { + Update(aDisplay); + } + + static bool IsNeeded(const nsStyleDisplay& aDisplay) { + return !aDisplay.mShapeOutside.IsNone(); + } + + void Update(const nsStyleDisplay& aDisplay) { + MOZ_ASSERT(IsNeeded(aDisplay)); + mShapeOutside = aDisplay.mShapeOutside; + mShapeImageThreshold = aDisplay.mShapeImageThreshold; + mShapeMargin = aDisplay.mShapeMargin; + } + + bool Matches(const nsStyleDisplay& aDisplay) const { + return mShapeOutside == aDisplay.mShapeOutside && + mShapeImageThreshold == aDisplay.mShapeImageThreshold && + mShapeMargin == aDisplay.mShapeMargin; + } +}; + +NS_DECLARE_FRAME_PROPERTY_DELETABLE(ShapeInvalidationDataProperty, + ShapeInvalidationData) + +BlockReflowState::PlaceFloatResult BlockReflowState::FlowAndPlaceFloat( + nsIFrame* aFloat, Maybe<nscoord> aAvailableISizeInCurrentLine) { + MOZ_ASSERT(aFloat->GetParent() == mBlock, "Float frame has wrong parent"); + + WritingMode wm = mReflowInput.GetWritingMode(); + // Save away the block-dir coordinate before placing the float. We will + // restore mBCoord at the end after placing the float. This is + // necessary because any adjustments to mBCoord during the float + // placement are for the float only, not for any non-floating + // content. + AutoRestore<nscoord> restoreBCoord(mBCoord); + + // Whether the block-direction position available to place a float has been + // pushed down due to the presence of other floats. + auto HasFloatPushedDown = [this, &restoreBCoord]() { + return mBCoord != restoreBCoord.SavedValue(); + }; + + // Grab the float's display information + const nsStyleDisplay* floatDisplay = aFloat->StyleDisplay(); + + // The float's old region, so we can propagate damage. + LogicalRect oldRegion = + nsFloatManager::GetRegionFor(wm, aFloat, ContainerSize()); + + ShapeInvalidationData* invalidationData = + aFloat->GetProperty(ShapeInvalidationDataProperty()); + + // Enforce CSS2 9.5.1 rule [2], i.e., make sure that a float isn't + // ``above'' another float that preceded it in the flow. + mBCoord = std::max(FloatManager()->LowestFloatBStart(), mBCoord); + + // See if the float should clear any preceding floats... + // XXX We need to mark this float somehow so that it gets reflowed + // when floats are inserted before it. + if (StyleClear::None != floatDisplay->mClear) { + // XXXldb Does this handle vertical margins correctly? + auto [bCoord, result] = ClearFloats(mBCoord, floatDisplay->mClear); + if (result == ClearFloatsResult::FloatsPushedOrSplit) { + PushFloatPastBreak(aFloat); + return PlaceFloatResult::ShouldPlaceInNextContinuation; + } + mBCoord = bCoord; + } + + LogicalSize availSize = ComputeAvailableSizeForFloat(); + const WritingMode floatWM = aFloat->GetWritingMode(); + Maybe<ReflowInput> floatRI(std::in_place, mPresContext, mReflowInput, aFloat, + availSize.ConvertTo(floatWM, wm)); + + nscoord floatMarginISize = FloatMarginISize(wm, *floatRI); + LogicalMargin floatMargin = floatRI->ComputedLogicalMargin(wm); + nsReflowStatus reflowStatus; + + // If it's a floating first-letter, we need to reflow it before we + // know how wide it is (since we don't compute which letters are part + // of the first letter until reflow!). + // We also need to do this early reflow if FloatMarginISize returned + // an unconstrained inline-size, which can occur if the float had an + // orthogonal writing mode and 'auto' block-size (in its mode). + bool earlyFloatReflow = + aFloat->IsLetterFrame() || floatMarginISize == NS_UNCONSTRAINEDSIZE; + if (earlyFloatReflow) { + mBlock->ReflowFloat(*this, *floatRI, aFloat, reflowStatus); + floatMarginISize = aFloat->ISize(wm) + floatMargin.IStartEnd(wm); + NS_ASSERTION(reflowStatus.IsComplete(), + "letter frames and orthogonal floats with auto block-size " + "shouldn't break, and if they do now, then they're breaking " + "at the wrong point"); + } + + // Now we've computed the float's margin inline-size. + if (aAvailableISizeInCurrentLine && + floatMarginISize > *aAvailableISizeInCurrentLine) { + // The float cannot fit in the available inline-size of the current line. + // Let's notify our caller to place it later. + return PlaceFloatResult::ShouldPlaceBelowCurrentLine; + } + + // Find a place to place the float. The CSS2 spec doesn't want + // floats overlapping each other or sticking out of the containing + // block if possible (CSS2 spec section 9.5.1, see the rule list). + StyleFloat floatStyle = floatDisplay->mFloat; + MOZ_ASSERT(StyleFloat::Left == floatStyle || StyleFloat::Right == floatStyle, + "Invalid float type!"); + + // Are we required to place at least part of the float because we're + // at the top of the page (to avoid an infinite loop of pushing and + // breaking). + bool mustPlaceFloat = + mReflowInput.mFlags.mIsTopOfPage && IsAdjacentWithBStart(); + + // Get the band of available space with respect to margin box. + nsFlowAreaRect floatAvailableSpace = + GetFloatAvailableSpaceForPlacingFloat(mBCoord); + + for (;;) { + if (mReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE && + floatAvailableSpace.mRect.BSize(wm) <= 0 && !mustPlaceFloat) { + // No space, nowhere to put anything. + PushFloatPastBreak(aFloat); + return PlaceFloatResult::ShouldPlaceInNextContinuation; + } + + if (CanPlaceFloat(floatMarginISize, floatAvailableSpace)) { + // We found an appropriate place. + break; + } + + // Nope. try to advance to the next band. + mBCoord += floatAvailableSpace.mRect.BSize(wm); + floatAvailableSpace = GetFloatAvailableSpaceForPlacingFloat(mBCoord); + mustPlaceFloat = false; + } + + // If the float is continued, it will get the same absolute x value as its + // prev-in-flow + + // We don't worry about the geometry of the prev in flow, let the continuation + // place and size itself as required. + + // Assign inline and block dir coordinates to the float. We don't use + // LineLeft() and LineRight() here, because we would only have to + // convert the result back into this block's writing mode. + LogicalPoint floatPos(wm); + bool leftFloat = floatStyle == StyleFloat::Left; + + if (leftFloat == wm.IsBidiLTR()) { + floatPos.I(wm) = floatAvailableSpace.mRect.IStart(wm); + } else { + floatPos.I(wm) = floatAvailableSpace.mRect.IEnd(wm) - floatMarginISize; + } + // CSS2 spec, 9.5.1 rule [4]: "A floating box's outer top may not + // be higher than the top of its containing block." (Since the + // containing block is the content edge of the block box, this + // means the margin edge of the float can't be higher than the + // content edge of the block that contains it.) + floatPos.B(wm) = std::max(mBCoord, ContentBStart()); + + // Reflow the float after computing its vertical position so it knows + // where to break. + if (!earlyFloatReflow) { + const LogicalSize oldAvailSize = availSize; + availSize = ComputeAvailableSizeForFloat(); + if (oldAvailSize != availSize) { + floatRI.reset(); + floatRI.emplace(mPresContext, mReflowInput, aFloat, + availSize.ConvertTo(floatWM, wm)); + } + // Normally the mIsTopOfPage state is copied from the parent reflow input. + // However, when reflowing a float, if we've placed other floats that force + // this float being pushed down, we should unset the mIsTopOfPage bit. + if (floatRI->mFlags.mIsTopOfPage && HasFloatPushedDown()) { + // HasFloatPushedDown() implies that we increased mBCoord, and we + // should've turned off mustPlaceFloat when we did that. + NS_ASSERTION(!mustPlaceFloat, + "mustPlaceFloat shouldn't be set if we're not at the " + "top-of-page!"); + floatRI->mFlags.mIsTopOfPage = false; + } + mBlock->ReflowFloat(*this, *floatRI, aFloat, reflowStatus); + } + if (aFloat->GetPrevInFlow()) { + floatMargin.BStart(wm) = 0; + } + if (reflowStatus.IsIncomplete()) { + floatMargin.BEnd(wm) = 0; + } + + // If the float cannot fit (e.g. via fragmenting itself if applicable), or if + // we're forced to break before it for CSS break-* reasons, then it needs to + // be pushed in its entirety to the next column/page. + // + // Note we use the available block-size in floatRI rather than use + // availSize.BSize() because nsBlockReflowContext::ReflowBlock() might adjust + // floatRI's available size. + const nscoord availBSize = floatRI->AvailableSize(floatWM).BSize(floatWM); + const bool isTruncated = + availBSize != NS_UNCONSTRAINEDSIZE && aFloat->BSize(floatWM) > availBSize; + if ((!floatRI->mFlags.mIsTopOfPage && isTruncated) || + reflowStatus.IsInlineBreakBefore()) { + PushFloatPastBreak(aFloat); + return PlaceFloatResult::ShouldPlaceInNextContinuation; + } + + // We can't use aFloat->ShouldAvoidBreakInside(mReflowInput) here since + // its mIsTopOfPage may be true even though the float isn't at the + // top when floatPos.B(wm) > 0. + if (ContentBSize() != NS_UNCONSTRAINEDSIZE && !mustPlaceFloat && + (!mReflowInput.mFlags.mIsTopOfPage || floatPos.B(wm) > 0) && + StyleBreakWithin::Avoid == aFloat->StyleDisplay()->mBreakInside && + (!reflowStatus.IsFullyComplete() || + aFloat->BSize(wm) + floatMargin.BStartEnd(wm) > + ContentBEnd() - floatPos.B(wm)) && + !aFloat->GetPrevInFlow()) { + PushFloatPastBreak(aFloat); + return PlaceFloatResult::ShouldPlaceInNextContinuation; + } + + // Calculate the actual origin of the float frame's border rect + // relative to the parent block; the margin must be added in + // to get the border rect + LogicalPoint origin(wm, floatMargin.IStart(wm) + floatPos.I(wm), + floatMargin.BStart(wm) + floatPos.B(wm)); + + // If float is relatively positioned, factor that in as well + const LogicalMargin floatOffsets = floatRI->ComputedLogicalOffsets(wm); + ReflowInput::ApplyRelativePositioning(aFloat, wm, floatOffsets, &origin, + ContainerSize()); + + // Position the float and make sure and views are properly + // positioned. We need to explicitly position its child views as + // well, since we're moving the float after flowing it. + bool moved = aFloat->GetLogicalPosition(wm, ContainerSize()) != origin; + if (moved) { + aFloat->SetPosition(wm, origin, ContainerSize()); + nsContainerFrame::PositionFrameView(aFloat); + nsContainerFrame::PositionChildViews(aFloat); + } + + // Update the float combined area state + // XXX Floats should really just get invalidated here if necessary + mFloatOverflowAreas.UnionWith(aFloat->GetOverflowAreasRelativeToParent()); + + // Place the float in the float manager + // calculate region + LogicalRect region = nsFloatManager::CalculateRegionFor( + wm, aFloat, floatMargin, ContainerSize()); + // if the float split, then take up all of the vertical height + if (reflowStatus.IsIncomplete() && (NS_UNCONSTRAINEDSIZE != ContentBSize())) { + region.BSize(wm) = + std::max(region.BSize(wm), ContentBSize() - floatPos.B(wm)); + } + FloatManager()->AddFloat(aFloat, region, wm, ContainerSize()); + + // store region + nsFloatManager::StoreRegionFor(wm, aFloat, region, ContainerSize()); + + const bool invalidationDataNeeded = + ShapeInvalidationData::IsNeeded(*floatDisplay); + + // If the float's dimensions or shape have changed, note the damage in the + // float manager. + if (!region.IsEqualEdges(oldRegion) || + !!invalidationData != invalidationDataNeeded || + (invalidationData && !invalidationData->Matches(*floatDisplay))) { + // XXXwaterson conservative: we could probably get away with noting + // less damage; e.g., if only height has changed, then only note the + // area into which the float has grown or from which the float has + // shrunk. + nscoord blockStart = std::min(region.BStart(wm), oldRegion.BStart(wm)); + nscoord blockEnd = std::max(region.BEnd(wm), oldRegion.BEnd(wm)); + FloatManager()->IncludeInDamage(blockStart, blockEnd); + } + + if (invalidationDataNeeded) { + if (invalidationData) { + invalidationData->Update(*floatDisplay); + } else { + aFloat->SetProperty(ShapeInvalidationDataProperty(), + new ShapeInvalidationData(*floatDisplay)); + } + } else if (invalidationData) { + invalidationData = nullptr; + aFloat->RemoveProperty(ShapeInvalidationDataProperty()); + } + + if (!reflowStatus.IsFullyComplete()) { + mBlock->SplitFloat(*this, aFloat, reflowStatus); + } else { + MOZ_ASSERT(!aFloat->GetNextInFlow()); + } + +#ifdef DEBUG + if (nsBlockFrame::gNoisyFloatManager) { + nscoord tI, tB; + FloatManager()->GetTranslation(tI, tB); + mBlock->ListTag(stdout); + printf(": FlowAndPlaceFloat: AddFloat: tIB=%d,%d (%d,%d) {%d,%d,%d,%d}\n", + tI, tB, mFloatManagerI, mFloatManagerB, region.IStart(wm), + region.BStart(wm), region.ISize(wm), region.BSize(wm)); + } + + if (nsBlockFrame::gNoisyReflow) { + nsRect r = aFloat->GetRect(); + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("placed float: "); + aFloat->ListTag(stdout); + printf(" %d,%d,%d,%d\n", r.x, r.y, r.width, r.height); + } +#endif + + return PlaceFloatResult::Placed; +} + +void BlockReflowState::PushFloatPastBreak(nsIFrame* aFloat) { + // This ensures that we: + // * don't try to place later but smaller floats (which CSS says + // must have their tops below the top of this float) + // * don't waste much time trying to reflow this float again until + // after the break + StyleFloat floatStyle = aFloat->StyleDisplay()->mFloat; + if (floatStyle == StyleFloat::Left) { + FloatManager()->SetPushedLeftFloatPastBreak(); + } else { + MOZ_ASSERT(floatStyle == StyleFloat::Right, "Unexpected float value!"); + FloatManager()->SetPushedRightFloatPastBreak(); + } + + // Put the float on the pushed floats list, even though it + // isn't actually a continuation. + mBlock->StealFrame(aFloat); + AppendPushedFloatChain(aFloat); + mReflowStatus.SetOverflowIncomplete(); +} + +/** + * Place below-current-line floats. + */ +void BlockReflowState::PlaceBelowCurrentLineFloats(nsLineBox* aLine) { + MOZ_ASSERT(!mBelowCurrentLineFloats.IsEmpty()); + nsTArray<nsIFrame*> floatsPlacedInLine; + for (nsIFrame* f : mBelowCurrentLineFloats) { +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow) { + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("placing bcl float: "); + f->ListTag(stdout); + printf("\n"); + } +#endif + // Place the float + PlaceFloatResult result = FlowAndPlaceFloat(f); + MOZ_ASSERT(result != PlaceFloatResult::ShouldPlaceBelowCurrentLine, + "We are already dealing with below current line floats!"); + if (result == PlaceFloatResult::Placed) { + floatsPlacedInLine.AppendElement(f); + } + } + if (floatsPlacedInLine.Length() != mBelowCurrentLineFloats.Length()) { + // We have some floats having ShouldPlaceInNextContinuation result. + aLine->SetHadFloatPushed(); + } + aLine->AppendFloats(std::move(floatsPlacedInLine)); + mBelowCurrentLineFloats.Clear(); +} + +std::tuple<nscoord, BlockReflowState::ClearFloatsResult> +BlockReflowState::ClearFloats(nscoord aBCoord, StyleClear aClearType, + nsIFrame* aFloatAvoidingBlock) { +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow) { + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("clear floats: in: aBCoord=%d\n", aBCoord); + } +#endif + + if (!FloatManager()->HasAnyFloats()) { + return {aBCoord, ClearFloatsResult::BCoordNoChange}; + } + + nscoord newBCoord = aBCoord; + + if (aClearType != StyleClear::None) { + newBCoord = FloatManager()->ClearFloats(newBCoord, aClearType); + + if (FloatManager()->ClearContinues(aClearType)) { + return {newBCoord, ClearFloatsResult::FloatsPushedOrSplit}; + } + } + + if (aFloatAvoidingBlock) { + for (;;) { + nsFlowAreaRect floatAvailableSpace = GetFloatAvailableSpace(newBCoord); + if (FloatAvoidingBlockFitsInAvailSpace(aFloatAvoidingBlock, + floatAvailableSpace)) { + break; + } + // See the analogous code for inlines in + // nsBlockFrame::DoReflowInlineFrames + if (!AdvanceToNextBand(floatAvailableSpace.mRect, &newBCoord)) { + // Stop trying to clear here; we'll just get pushed to the + // next column or page and try again there. + break; + } + } + } + +#ifdef DEBUG + if (nsBlockFrame::gNoisyReflow) { + nsIFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent); + printf("clear floats: out: y=%d\n", newBCoord); + } +#endif + + ClearFloatsResult result = newBCoord == aBCoord + ? ClearFloatsResult::BCoordNoChange + : ClearFloatsResult::BCoordAdvanced; + return {newBCoord, result}; +} |