/* 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/. */ /* struct containing the input to nsIFrame::Reflow */ #include "mozilla/ReflowInput.h" #include #include "AnchorPositioningUtils.h" #include "CounterStyleManager.h" #include "LayoutLogging.h" #include "PresShell.h" #include "StickyScrollContainer.h" #include "mozilla/ScrollContainerFrame.h" #include "mozilla/WritingModes.h" #include "mozilla/dom/HTMLInputElement.h" #include "nsBlockFrame.h" #include "nsFlexContainerFrame.h" #include "nsFontInflationData.h" #include "nsFontMetrics.h" #include "nsGkAtoms.h" #include "nsGridContainerFrame.h" #include "nsIContent.h" #include "nsIFrame.h" #include "nsIFrameInlines.h" #include "nsIPercentBSizeObserver.h" #include "nsImageFrame.h" #include "nsLayoutUtils.h" #include "nsLineBox.h" #include "nsPresContext.h" #include "nsStyleConsts.h" #include "nsTableFrame.h" using namespace mozilla; using namespace mozilla::css; using namespace mozilla::dom; using namespace mozilla::layout; AnchorPosResolutionParams AnchorPosResolutionParams::From( const mozilla::SizeComputationInput* aSizingInput, bool aIgnorePositionArea) { auto override = AutoResolutionOverrideParams{ aSizingInput->mFrame, aSizingInput->mAnchorPosResolutionCache}; if (aIgnorePositionArea) { override.mPositionAreaInUse = false; } return {aSizingInput->mFrame, aSizingInput->mFrame->StyleDisplay()->mPosition, aSizingInput->mAnchorPosResolutionCache, override}; } static bool CheckNextInFlowParenthood(nsIFrame* aFrame, nsIFrame* aParent) { nsIFrame* frameNext = aFrame->GetNextInFlow(); nsIFrame* parentNext = aParent->GetNextInFlow(); return frameNext && parentNext && frameNext->GetParent() == parentNext; } /** * Adjusts the margin for a list (ol, ul), if necessary, depending on * font inflation settings. Unfortunately, because bullets from a list are * placed in the margin area, we only have ~40px in which to place the * bullets. When they are inflated, however, this causes problems, since * the text takes up more space than is available in the margin. * * This method will return a small amount (in app units) by which the * margin can be adjusted, so that the space is available for list * bullets to be rendered with font inflation enabled. */ static nscoord FontSizeInflationListMarginAdjustment(const nsIFrame* aFrame) { // As an optimization we check this block frame specific bit up front before // we even check if the frame is a block frame. That's only valid so long as // we also have the `IsBlockFrameOrSubclass()` call below. Calling that is // expensive though, and we want to avoid it if we know `HasMarker()` would // return false. if (!aFrame->HasAnyStateBits(NS_BLOCK_HAS_MARKER)) { return 0; } // On desktop font inflation is disabled, so this will always early exit // quickly, but checking the frame state bit is still quicker then this call // and very likely to early exit on its own so we check this second. float inflation = nsLayoutUtils::FontSizeInflationFor(aFrame); if (inflation <= 1.0f) { return 0; } if (!aFrame->IsBlockFrameOrSubclass()) { return 0; } // We only want to adjust the margins if we're dealing with an ordered list. // We already checked this above. MOZ_ASSERT(static_cast(aFrame)->HasMarker()); const auto* list = aFrame->StyleList(); if (list->mListStyleType.IsNone()) { return 0; } // The HTML spec states that the default padding for ordered lists // begins at 40px, indicating that we have 40px of space to place a // bullet. When performing font inflation calculations, we add space // equivalent to this, but simply inflated at the same amount as the // text, in app units. auto margin = nsPresContext::CSSPixelsToAppUnits(40) * (inflation - 1); if (!list->mListStyleType.IsName()) { return margin; } nsAtom* type = list->mListStyleType.AsName().AsAtom(); if (type != nsGkAtoms::disc && type != nsGkAtoms::circle && type != nsGkAtoms::square && type != nsGkAtoms::disclosure_closed && type != nsGkAtoms::disclosure_open) { return margin; } return 0; } SizeComputationInput::SizeComputationInput( nsIFrame* aFrame, gfxContext* aRenderingContext, AnchorPosResolutionCache* aAnchorPosResolutionCache) : mFrame(aFrame), mRenderingContext(aRenderingContext), mAnchorPosResolutionCache(aAnchorPosResolutionCache), mWritingMode(aFrame->GetWritingMode()), mIsThemed(aFrame->IsThemed()), mComputedMargin(mWritingMode), mComputedBorderPadding(mWritingMode), mComputedPadding(mWritingMode) { MOZ_ASSERT(mFrame); } SizeComputationInput::SizeComputationInput( nsIFrame* aFrame, gfxContext* aRenderingContext, WritingMode aContainingBlockWritingMode, nscoord aContainingBlockISize, const Maybe& aBorder, const Maybe& aPadding) : SizeComputationInput(aFrame, aRenderingContext) { MOZ_ASSERT(!mFrame->IsTableColFrame()); InitOffsets(aContainingBlockWritingMode, aContainingBlockISize, mFrame->Type(), {}, aBorder, aPadding); } // Initialize a root reflow input with a rendering context to // use for measuring things. ReflowInput::ReflowInput(nsPresContext* aPresContext, nsIFrame* aFrame, gfxContext* aRenderingContext, const LogicalSize& aAvailableSpace, InitFlags aFlags) : SizeComputationInput(aFrame, aRenderingContext), mAvailableSize(aAvailableSpace) { MOZ_ASSERT(aRenderingContext, "no rendering context"); MOZ_ASSERT(aPresContext, "no pres context"); MOZ_ASSERT(aFrame, "no frame"); MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context"); if (aFlags.contains(InitFlag::DummyParentReflowInput)) { mFlags.mDummyParentReflowInput = true; } if (aFlags.contains(InitFlag::StaticPosIsCBOrigin)) { mFlags.mStaticPosIsCBOrigin = true; } if (!aFlags.contains(InitFlag::CallerWillInit)) { Init(aPresContext); } // When we encounter a PageContent frame this will be set to true. mFlags.mCanHaveClassABreakpoints = false; } static nsSize GetICBSize(const nsPresContext* aPresContext, const nsIFrame* aFrame) { if (!aPresContext->IsPaginated()) { return aPresContext->GetVisibleArea().Size(); } for (const nsIFrame* f = aFrame->GetParent(); f; f = f->GetParent()) { if (f->IsPageContentFrame()) { return f->GetSize(); } } return aPresContext->GetPageSize(); } // Initialize a reflow input for a child frame's reflow. Some state // is copied from the parent reflow input; the remaining state is // computed. ReflowInput::ReflowInput(nsPresContext* aPresContext, const ReflowInput& aParentReflowInput, nsIFrame* aFrame, const LogicalSize& aAvailableSpace, const Maybe& aContainingBlockSize, InitFlags aFlags, const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aComputeSizeFlags, AnchorPosResolutionCache* aAnchorPosResolutionCache) : SizeComputationInput(aFrame, aParentReflowInput.mRenderingContext, aAnchorPosResolutionCache), mParentReflowInput(&aParentReflowInput), mFloatManager(aParentReflowInput.mFloatManager), mLineLayout(mFrame->IsLineParticipant() ? aParentReflowInput.mLineLayout : nullptr), mBreakType(aParentReflowInput.mBreakType), mPercentBSizeObserver( (aParentReflowInput.mPercentBSizeObserver && aParentReflowInput.mPercentBSizeObserver->NeedsToObserve(*this)) ? aParentReflowInput.mPercentBSizeObserver : nullptr), mFlags(aParentReflowInput.mFlags), mStyleSizeOverrides(aSizeOverrides), mComputeSizeFlags(aComputeSizeFlags), mReflowDepth(aParentReflowInput.mReflowDepth + 1), mAvailableSize(aAvailableSpace) { MOZ_ASSERT(aPresContext, "no pres context"); MOZ_ASSERT(aFrame, "no frame"); MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context"); MOZ_ASSERT(!mFlags.mSpecialBSizeReflow || !aFrame->IsSubtreeDirty(), "frame should be clean when getting special bsize reflow"); if (mWritingMode.IsOrthogonalTo(mParentReflowInput->GetWritingMode())) { // If the block establishes an orthogonal flow, set up its AvailableISize // per https://drafts.csswg.org/css-writing-modes/#orthogonal-auto auto GetISizeConstraint = [this](const nsIFrame* aFrame, bool* aFixed = nullptr) -> nscoord { nscoord limit = NS_UNCONSTRAINEDSIZE; const auto* pos = aFrame->StylePosition(); // Don't add to anchor resolution cache, since this function is called for // other frames. const auto anchorResolutionParams = AnchorPosResolutionParams::From(aFrame); if (auto size = nsLayoutUtils::GetAbsoluteSize( *pos->ISize(mWritingMode, anchorResolutionParams))) { limit = size.value(); if (aFixed) { *aFixed = true; } } else if (auto maxSize = nsLayoutUtils::GetAbsoluteSize( *pos->MaxISize(mWritingMode, anchorResolutionParams))) { limit = maxSize.value(); } if (limit != NS_UNCONSTRAINEDSIZE) { if (auto minSize = nsLayoutUtils::GetAbsoluteSize( *pos->MinISize(mWritingMode, anchorResolutionParams))) { limit = std::max(limit, minSize.value()); } } return limit; }; // See if the containing block has a fixed size we should respect: const nsIFrame* cb = mFrame->GetContainingBlock(); bool isFixed = false; nscoord cbLimit = aContainingBlockSize ? aContainingBlockSize->ISize(mWritingMode) : NS_UNCONSTRAINEDSIZE; if (cbLimit != NS_UNCONSTRAINEDSIZE) { isFixed = true; } else { cbLimit = GetISizeConstraint(cb, &isFixed); } if (isFixed) { SetAvailableISize(cbLimit); } else { // If the CB size wasn't fixed, we consider the nearest scroll container // and the ICB. nscoord scLimit = NS_UNCONSTRAINEDSIZE; // If the containing block was not a scroll container itself, look up the // parent chain for a scroller size that we should respect. // XXX Could maybe use nsLayoutUtils::GetNearestScrollContainerFrame here, // but unsure if we need the additional complexity it supports? if (!cb->IsScrollContainerFrame()) { for (const nsIFrame* p = mFrame->GetParent(); p; p = p->GetParent()) { if (p->IsScrollContainerFrame()) { scLimit = GetISizeConstraint(p); // Only the closest ancestor scroller is relevant, so quit as soon // as we've found one (whether or not it had fixed sizing). break; } } } LogicalSize icbSize(mWritingMode, GetICBSize(aPresContext, mFrame)); nscoord icbLimit = icbSize.ISize(mWritingMode); SetAvailableISize(std::min(icbLimit, std::min(scLimit, cbLimit))); // Record that this frame needs to be invalidated on a resize reflow. mFrame->PresShell()->AddOrthogonalFlow(mFrame); } } // Note: mFlags was initialized as a copy of aParentReflowInput.mFlags up in // this constructor's init list, so the only flags that we need to explicitly // initialize here are those that may need a value other than our parent's. mFlags.mNextInFlowUntouched = aParentReflowInput.mFlags.mNextInFlowUntouched && CheckNextInFlowParenthood(aFrame, aParentReflowInput.mFrame); mFlags.mAssumingHScrollbar = mFlags.mAssumingVScrollbar = false; mFlags.mIsColumnBalancing = false; mFlags.mColumnSetWrapperHasNoBSizeLeft = false; mFlags.mTreatBSizeAsIndefinite = false; mFlags.mDummyParentReflowInput = false; mFlags.mStaticPosIsCBOrigin = aFlags.contains(InitFlag::StaticPosIsCBOrigin); mFlags.mIOffsetsNeedCSSAlign = mFlags.mBOffsetsNeedCSSAlign = false; // We don't want the mOrthogonalCellFinalReflow flag to be inherited; it's up // to the table row frame to set it for its direct children as needed. mFlags.mOrthogonalCellFinalReflow = false; // aPresContext->IsPaginated() and the named pages pref should have been // checked when constructing the root ReflowInput. if (aParentReflowInput.mFlags.mCanHaveClassABreakpoints) { MOZ_ASSERT(aPresContext->IsPaginated(), "mCanHaveClassABreakpoints set during non-paginated reflow."); } { switch (mFrame->Type()) { case LayoutFrameType::PageContent: // PageContent requires paginated reflow. MOZ_ASSERT(aPresContext->IsPaginated(), "nsPageContentFrame should not be in non-paginated reflow"); MOZ_ASSERT(!mFlags.mCanHaveClassABreakpoints, "mFlags.mCanHaveClassABreakpoints should have been " "initalized to false before we found nsPageContentFrame"); mFlags.mCanHaveClassABreakpoints = true; break; case LayoutFrameType::Block: // FALLTHROUGH case LayoutFrameType::Canvas: // FALLTHROUGH case LayoutFrameType::FlexContainer: // FALLTHROUGH case LayoutFrameType::GridContainer: if (mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { // Never allow breakpoints inside of out-of-flow frames. mFlags.mCanHaveClassABreakpoints = false; break; } // This frame type can have class A breakpoints, inherit this flag // from the parent (this is done for all flags during construction). // This also includes Canvas frames, as each PageContent frame always // has exactly one child which is a Canvas frame. // Do NOT include the subclasses of BlockFrame here, as the ones for // which this could be applicable (ColumnSetWrapper and the MathML // frames) cannot have class A breakpoints. MOZ_ASSERT(mFlags.mCanHaveClassABreakpoints == aParentReflowInput.mFlags.mCanHaveClassABreakpoints); break; default: mFlags.mCanHaveClassABreakpoints = false; break; } } if (aFlags.contains(InitFlag::DummyParentReflowInput) || (mParentReflowInput->mFlags.mDummyParentReflowInput && mFrame->IsTableFrame())) { mFlags.mDummyParentReflowInput = true; } if (!aFlags.contains(InitFlag::CallerWillInit)) { Init(aPresContext, aContainingBlockSize); } } template nscoord SizeComputationInput::ComputeISizeValue( const LogicalSize& aContainingBlockSize, StyleBoxSizing aBoxSizing, const SizeOrMaxSize& aSize) const { WritingMode wm = GetWritingMode(); const auto borderPadding = ComputedLogicalBorderPadding(wm); const auto margin = ComputedLogicalMargin(wm); const LogicalSize contentEdgeToBoxSizing = aBoxSizing == StyleBoxSizing::BorderBox ? borderPadding.Size(wm) : LogicalSize(wm); const nscoord boxSizingToMarginEdgeISize = borderPadding.IStartEnd(wm) + margin.IStartEnd(wm) - contentEdgeToBoxSizing.ISize(wm); // Get the bSize with anchor functions resolved, and manually resolve // 'stretch'-like sizes as well (we should do this a bit cleaner, // see bug 2000035): auto bSize = mFrame->StylePosition()->BSize( wm, AnchorPosResolutionParams::From(mFrame, mAnchorPosResolutionCache)); if (bSize->BehavesLikeStretchOnBlockAxis()) { if (NS_UNCONSTRAINEDSIZE == aContainingBlockSize.BSize(wm)) { bSize = AnchorResolvedSizeHelper::Auto(); } else { nscoord stretchBSize = nsLayoutUtils::ComputeStretchBSize( aContainingBlockSize.BSize(wm), margin.BStartEnd(wm), borderPadding.BStartEnd(wm), aBoxSizing); bSize = AnchorResolvedSizeHelper::LengthPercentage( StyleLengthPercentage::FromAppUnits(stretchBSize)); } } return mFrame ->ComputeISizeValue(mRenderingContext, wm, aContainingBlockSize, contentEdgeToBoxSizing, boxSizingToMarginEdgeISize, aSize, *bSize, mFrame->GetAspectRatio()) .mISize; } template nscoord SizeComputationInput::ComputeBSizeValueHandlingStretch( nscoord aContainingBlockBSize, StyleBoxSizing aBoxSizing, const SizeOrMaxSize& aSize) const { if (aSize.BehavesLikeStretchOnBlockAxis()) { WritingMode wm = GetWritingMode(); return nsLayoutUtils::ComputeStretchContentBoxBSize( aContainingBlockBSize, ComputedLogicalMargin(wm).Size(wm).BSize(wm), ComputedLogicalBorderPadding(wm).Size(wm).BSize(wm)); } return ComputeBSizeValue(aContainingBlockBSize, aBoxSizing, aSize.AsLengthPercentage()); } nscoord SizeComputationInput::ComputeBSizeValue( nscoord aContainingBlockBSize, StyleBoxSizing aBoxSizing, const LengthPercentage& aSize) const { WritingMode wm = GetWritingMode(); nscoord inside = 0; if (aBoxSizing == StyleBoxSizing::BorderBox) { inside = ComputedLogicalBorderPadding(wm).BStartEnd(wm); } return nsLayoutUtils::ComputeBSizeValue(aContainingBlockBSize, inside, aSize); } WritingMode ReflowInput::GetCBWritingMode() const { return mCBReflowInput ? mCBReflowInput->GetWritingMode() : mFrame->GetContainingBlock()->GetWritingMode(); } // Return the physical border-box size by combining aContentBoxSize and // aBorderPadding, with unconstrained dimensions replaced by zero. static nsSize BorderBoxSizeAsContainerIfConstrained( WritingMode aWM, const LogicalSize& aContentBoxSize, const LogicalMargin& aBorderPadding) { LogicalSize size = aContentBoxSize; if (size.ISize(aWM) == NS_UNCONSTRAINEDSIZE) { size.ISize(aWM) = 0; } else { size.ISize(aWM) += aBorderPadding.IStartEnd(aWM); } if (size.BSize(aWM) == NS_UNCONSTRAINEDSIZE) { size.BSize(aWM) = 0; } else { size.BSize(aWM) += aBorderPadding.BStartEnd(aWM); } return size.GetPhysicalSize(aWM); } nsSize ReflowInput::ComputedSizeAsContainerIfConstrained() const { return BorderBoxSizeAsContainerIfConstrained(mWritingMode, ComputedSize(), mComputedBorderPadding); } bool ReflowInput::ShouldReflowAllKids() const { // Note that we could make a stronger optimization for IsBResize if // we use it in a ShouldReflowChild test that replaces the current // checks of NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN, if it // were tested there along with NS_FRAME_CONTAINS_RELATIVE_BSIZE. // This would need to be combined with a slight change in which // frames NS_FRAME_CONTAINS_RELATIVE_BSIZE is marked on. return mFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY) || IsIResize() || (IsBResize() && mFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) || mFlags.mIsInLastColumnBalancingReflow; } void ReflowInput::SetComputedISize(nscoord aComputedISize, ResetResizeFlags aFlags) { // It'd be nice to assert that |frame| is not in reflow, but this fails // because viewport frames reset the computed isize on a copy of their reflow // input when reflowing fixed-pos kids. In that case we actually don't want // to mess with the resize flags, because comparing the frame's rect to the // munged computed isize is pointless. NS_WARNING_ASSERTION(aComputedISize >= 0, "Invalid computed inline-size!"); if (ComputedISize() != aComputedISize) { mComputedSize.ISize(mWritingMode) = std::max(0, aComputedISize); if (aFlags == ResetResizeFlags::Yes) { InitResizeFlags(mFrame->PresContext(), mFrame->Type()); } } } void ReflowInput::SetComputedBSize(nscoord aComputedBSize, ResetResizeFlags aFlags) { // It'd be nice to assert that |frame| is not in reflow, but this fails // for the same reason as above. NS_WARNING_ASSERTION(aComputedBSize >= 0, "Invalid computed block-size!"); if (ComputedBSize() != aComputedBSize) { mComputedSize.BSize(mWritingMode) = std::max(0, aComputedBSize); if (aFlags == ResetResizeFlags::Yes) { InitResizeFlags(mFrame->PresContext(), mFrame->Type()); } } } void ReflowInput::Init(nsPresContext* aPresContext, const Maybe& aContainingBlockSize, const Maybe& aBorder, const Maybe& aPadding) { LAYOUT_WARN_IF_FALSE(AvailableISize() != NS_UNCONSTRAINEDSIZE, "have unconstrained inline-size; this should only " "result from very large sizes, not attempts at " "intrinsic inline-size calculation"); mStylePosition = mFrame->StylePosition(); mStyleDisplay = mFrame->StyleDisplay(); mStyleBorder = mFrame->StyleBorder(); mStyleMargin = mFrame->StyleMargin(); InitCBReflowInput(); LayoutFrameType type = mFrame->Type(); if (type == LayoutFrameType::Placeholder) { // Placeholders have a no-op Reflow method that doesn't need the rest of // this initialization, so we bail out early. mComputedSize.SizeTo(mWritingMode, 0, 0); return; } mFlags.mIsReplaced = mFrame->IsReplaced(); InitConstraints(aPresContext, aContainingBlockSize, aBorder, aPadding, type); InitResizeFlags(aPresContext, type); InitDynamicReflowRoot(); nsIFrame* parent = mFrame->GetParent(); if (parent && parent->HasAnyStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE) && !(parent->IsScrollContainerFrame() && parent->StyleDisplay()->mOverflowY != StyleOverflow::Hidden)) { mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); } else if (type == LayoutFrameType::SVGForeignObject) { // An SVG foreignObject frame is inherently constrained block-size. mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); } else { const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); const auto bSizeCoord = mStylePosition->BSize(mWritingMode, anchorResolutionParams); const auto maxBSizeCoord = mStylePosition->MaxBSize(mWritingMode, anchorResolutionParams); if ((!bSizeCoord->BehavesLikeInitialValueOnBlockAxis() || !maxBSizeCoord->BehavesLikeInitialValueOnBlockAxis()) && // Don't set NS_FRAME_IN_CONSTRAINED_BSIZE on body or html elements. (mFrame->GetContent() && !(mFrame->GetContent()->IsAnyOfHTMLElements( nsGkAtoms::body, nsGkAtoms::html)))) { // If our block-size was specified as a percentage, then this could // actually resolve to 'auto', based on: // http://www.w3.org/TR/CSS21/visudet.html#the-height-property nsIFrame* containingBlk = mFrame; while (containingBlk) { const nsStylePosition* stylePos = containingBlk->StylePosition(); // It's for containing block, so don't add to anchor resolution cache const auto containingBlkAnchorResolutionParams = AnchorPosResolutionParams::From(containingBlk); const auto bSizeCoord = stylePos->BSize(mWritingMode, containingBlkAnchorResolutionParams); const auto& maxBSizeCoord = stylePos->MaxBSize( mWritingMode, containingBlkAnchorResolutionParams); if ((bSizeCoord->IsLengthPercentage() && !bSizeCoord->HasPercent()) || (maxBSizeCoord->IsLengthPercentage() && !maxBSizeCoord->HasPercent())) { mFrame->AddStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); break; } else if (bSizeCoord->HasPercent() || maxBSizeCoord->HasPercent()) { if (!(containingBlk = containingBlk->GetContainingBlock())) { // If we've reached the top of the tree, then we don't have // a constrained block-size. mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); break; } continue; } else { mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); break; } } } else { mFrame->RemoveStateBits(NS_FRAME_IN_CONSTRAINED_BSIZE); } } if (mParentReflowInput && mParentReflowInput->GetWritingMode().IsOrthogonalTo(mWritingMode)) { // Orthogonal frames are always reflowed with an unconstrained // dimension to avoid incomplete reflow across an orthogonal // boundary. Normally this is the block-size, but for column sets // with auto-height it's the inline-size, so that they can add // columns in the container's block direction if (type == LayoutFrameType::ColumnSet && mStylePosition ->ISize(mWritingMode, AnchorPosResolutionParams::From(this)) ->IsAuto()) { SetComputedISize(NS_UNCONSTRAINEDSIZE, ResetResizeFlags::No); } else { SetAvailableBSize(NS_UNCONSTRAINEDSIZE); } } if (mFrame->GetContainSizeAxes().mBContained) { // In the case that a box is size contained in block axis, we want to ensure // that it is also monolithic. We do this by setting AvailableBSize() to an // unconstrained size to avoid fragmentation. SetAvailableBSize(NS_UNCONSTRAINEDSIZE); } LAYOUT_WARN_IF_FALSE( (mStyleDisplay->IsInlineOutsideStyle() && !mFrame->IsReplaced()) || type == LayoutFrameType::Text || ComputedISize() != NS_UNCONSTRAINEDSIZE, "have unconstrained inline-size; this should only " "result from very large sizes, not attempts at " "intrinsic inline-size calculation"); } static bool MightBeContainingBlockFor(nsIFrame* aMaybeContainingBlock, nsIFrame* aFrame, const nsStyleDisplay* aStyleDisplay) { // Keep this in sync with nsIFrame::GetContainingBlock. if (aFrame->IsAbsolutelyPositioned(aStyleDisplay) && aMaybeContainingBlock == aFrame->GetParent()) { return true; } return aMaybeContainingBlock->IsBlockContainer(); } void ReflowInput::InitCBReflowInput() { mCBReflowInput = mParentReflowInput; if (!mCBReflowInput || mParentReflowInput->mFlags.mDummyParentReflowInput) { return; } // To avoid a long walk up the frame tree check if the parent frame can be a // containing block for mFrame. if (MightBeContainingBlockFor(mCBReflowInput->mFrame, mFrame, mStyleDisplay) && mCBReflowInput->mFrame == mFrame->GetContainingBlock(0, mStyleDisplay)) { // Inner table frames need to use the containing block of the outer // table frame. if (mFrame->IsTableFrame()) { MOZ_ASSERT(mParentReflowInput->mCBReflowInput, "Inner table frames shouldn't be reflow roots"); mCBReflowInput = mParentReflowInput->mCBReflowInput; } } else if (mParentReflowInput->mCBReflowInput) { mCBReflowInput = mParentReflowInput->mCBReflowInput; } } /* Check whether CalcQuirkContainingBlockHeight would stop on the * given reflow input, using its block as a height. (essentially * returns false for any case in which CalcQuirkContainingBlockHeight * has a "continue" in its main loop.) * * XXX Maybe refactor CalcQuirkContainingBlockHeight so it uses * this function as well */ static bool IsQuirkContainingBlockHeight(const ReflowInput* rs, LayoutFrameType aFrameType) { if (LayoutFrameType::Block == aFrameType || LayoutFrameType::ScrollContainer == aFrameType) { // Note: This next condition could change due to a style change, // but that would cause a style reflow anyway, which means we're ok. if (NS_UNCONSTRAINEDSIZE == rs->ComputedHeight()) { if (!rs->mFrame->IsAbsolutelyPositioned(rs->mStyleDisplay)) { return false; } } } return true; } void ReflowInput::InitResizeFlags(nsPresContext* aPresContext, LayoutFrameType aFrameType) { SetIResize(false); SetBResize(false); SetBResizeForPercentages(false); const WritingMode wm = mWritingMode; // just a shorthand // We should report that we have a resize in the inline dimension if // *either* the border-box size or the content-box size in that // dimension has changed. It might not actually be necessary to do // this if the border-box size has changed and the content-box size // has not changed, but since we've historically used the flag to mean // border-box size change, continue to do that. It's possible for // the content-box size to change without a border-box size change or // a style change given (1) a fixed width (possibly fixed by max-width // or min-width), box-sizing:border-box, and percentage padding; // (2) box-sizing:content-box, M% width, and calc(Npx - M%) padding. // // However, we don't actually have the information at this point to tell // whether the content-box size has changed, since both style data and the // UsedPaddingProperty() have already been updated in // SizeComputationInput::InitOffsets(). So, we check the HasPaddingChange() // bit for the cases where it's possible for the content-box size to have // changed without either (a) a change in the border-box size or (b) an // nsChangeHint_NeedDirtyReflow change hint due to change in border or // padding. // // We don't clear the HasPaddingChange() bit here, since sometimes we // construct reflow input (e.g. in nsBlockFrame::ReflowBlockFrame to compute // margin collapsing) without reflowing the frame. Instead, we clear it in // nsIFrame::DidReflow(). bool isIResize = // is the border-box resizing? mFrame->ISize(wm) != ComputedISize() + ComputedLogicalBorderPadding(wm).IStartEnd(wm) || // or is the content-box resizing? (see comment above) mFrame->HasPaddingChange(); if (mFrame->HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT) && nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) { // Create our font inflation data if we don't have it already, and // give it our current width information. bool dirty = nsFontInflationData::UpdateFontInflationDataISizeFor(*this) && // Avoid running this at the box-to-block interface // (where we shouldn't be inflating anyway, and where // reflow input construction is probably to construct a // dummy parent reflow input anyway). !mFlags.mDummyParentReflowInput; if (dirty || (!mFrame->GetParent() && isIResize)) { // When font size inflation is enabled, a change in either: // * the effective width of a font inflation flow root // * the width of the frame // needs to cause a dirty reflow since they change the font size // inflation calculations, which in turn change the size of text, // line-heights, etc. This is relatively similar to a classic // case of style change reflow, except that because inflation // doesn't affect the intrinsic sizing codepath, there's no need // to invalidate intrinsic sizes. // // Note that this makes horizontal resizing a good bit more // expensive. However, font size inflation is targeted at a set of // devices (zoom-and-pan devices) where the main use case for // horizontal resizing needing to be efficient (window resizing) is // not present. It does still increase the cost of dynamic changes // caused by script where a style or content change in one place // causes a resize in another (e.g., rebalancing a table). // FIXME: This isn't so great for the cases where // ReflowInput::SetComputedWidth is called, if the first time // we go through InitResizeFlags we set IsHResize() to true, and then // the second time we'd set it to false even without the // NS_FRAME_IS_DIRTY bit already set. if (mFrame->IsSVGForeignObjectFrame()) { // Foreign object frames use dirty bits in a special way. mFrame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN); nsIFrame* kid = mFrame->PrincipalChildList().FirstChild(); if (kid) { kid->MarkSubtreeDirty(); } } else { mFrame->MarkSubtreeDirty(); } // Mark intrinsic widths on all descendants dirty. We need to do // this (1) since we're changing the size of text and need to // clear text runs on text frames and (2) since we actually are // changing some intrinsic widths, but only those that live inside // of containers. // It makes sense to do this for descendants but not ancestors // (which is unusual) because we're only changing the unusual // inflation-dependent intrinsic widths (i.e., ones computed with // nsPresContext::mInflationDisabledForShrinkWrap set to false), // which should never affect anything outside of their inflation // flow root (or, for that matter, even their inflation // container). // This is also different from what PresShell::FrameNeedsReflow // does because it doesn't go through placeholders. It doesn't // need to because we're actually doing something that cares about // frame tree geometry (the width on an ancestor) rather than // style. AutoTArray stack; stack.AppendElement(mFrame); do { nsIFrame* f = stack.PopLastElement(); for (const auto& childList : f->ChildLists()) { for (nsIFrame* kid : childList.mList) { kid->MarkIntrinsicISizesDirty(); stack.AppendElement(kid); } } } while (stack.Length() != 0); } } SetIResize(!mFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY) && isIResize); const auto anchorResolutionParams = AnchorPosOffsetResolutionParams::UseCBFrameSize( AnchorPosResolutionParams::From(this)); const auto bSize = mStylePosition->BSize(wm, anchorResolutionParams.mBaseParams); const auto minBSize = mStylePosition->MinBSize(wm, anchorResolutionParams.mBaseParams); const auto maxBSize = mStylePosition->MaxBSize(wm, anchorResolutionParams.mBaseParams); // XXX Should we really need to null check mCBReflowInput? (We do for // at least nsBoxFrame). if (mFrame->HasBSizeChange()) { // When we have an nsChangeHint_UpdateComputedBSize, we'll set a bit // on the frame to indicate we're resizing. This might catch cases, // such as a change between auto and a length, where the box doesn't // actually resize but children with percentages resize (since those // percentages become auto if their containing block is auto). SetBResize(true); SetBResizeForPercentages(true); // We don't clear the HasBSizeChange state here, since sometimes we // construct a ReflowInput (e.g. in nsBlockFrame::ReflowBlockFrame to // compute margin collapsing) without reflowing the frame. Instead, we // clear it in nsIFrame::DidReflow. } else if (mCBReflowInput && mCBReflowInput->IsBResizeForPercentagesForWM(wm) && (bSize->HasPercent() || minBSize->HasPercent() || maxBSize->HasPercent())) { // We have a percentage (or calc-with-percentage) block-size, and the // value it's relative to has changed. SetBResize(true); SetBResizeForPercentages(true); } else if (aFrameType == LayoutFrameType::TableCell && (mFlags.mSpecialBSizeReflow || mFrame->FirstInFlow()->HasAnyStateBits( NS_TABLE_CELL_HAD_SPECIAL_REFLOW)) && mFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) { // Need to set the bit on the cell so that // mCBReflowInput->IsBResize() is set correctly below when // reflowing descendant. SetBResize(true); SetBResizeForPercentages(true); } else if (mCBReflowInput && mFrame->IsBlockWrapper()) { // XXX Is this problematic for relatively positioned inlines acting // as containing block for absolutely positioned elements? // Possibly; in that case we should at least be checking // IsSubtreeDirty(), I'd think. SetBResize(mCBReflowInput->IsBResizeForWM(wm)); SetBResizeForPercentages(mCBReflowInput->IsBResizeForPercentagesForWM(wm)); } else if (ComputedBSize() == NS_UNCONSTRAINEDSIZE) { // We have an 'auto' block-size. if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() && mCBReflowInput) { // FIXME: This should probably also check IsIResize(). SetBResize(mCBReflowInput->IsBResizeForWM(wm)); } else { SetBResize(IsIResize()); } SetBResize(IsBResize() || mFrame->IsSubtreeDirty() || // For an inner table frame, copy IsBResize from its wrapper. (aFrameType == LayoutFrameType::Table && mParentReflowInput->IsBResize())); } else { // We have a non-'auto' block-size, i.e., a length. Set the BResize // flag to whether the size is actually different. SetBResize(mFrame->BSize(wm) != ComputedBSize() + ComputedLogicalBorderPadding(wm).BStartEnd(wm)); } bool dependsOnCBBSize = (nsStylePosition::BSizeDependsOnContainer(bSize) && // FIXME: condition this on not-abspos? !bSize->IsAuto()) || nsStylePosition::MinBSizeDependsOnContainer(minBSize) || nsStylePosition::MaxBSizeDependsOnContainer(maxBSize) || mStylePosition ->GetAnchorResolvedInset(LogicalSide::BStart, wm, anchorResolutionParams) ->HasPercent() || !mStylePosition ->GetAnchorResolvedInset(LogicalSide::BEnd, wm, anchorResolutionParams) ->IsAuto() || // We assume orthogonal flows depend on the containing-block's BSize, // as that will commonly provide the available inline size. This is not // always strictly needed, but orthogonal flows are rare enough that // attempting to be more precise seems overly complex. (mCBReflowInput && mCBReflowInput->GetWritingMode().IsOrthogonalTo(wm)); // If mFrame is a flex item, and mFrame's block axis is the flex container's // main axis (e.g. in a column-oriented flex container with same // writing-mode), then its block-size depends on its CB size, if its // flex-basis has a percentage. if (mFrame->IsFlexItem() && !nsFlexContainerFrame::IsItemInlineAxisMainAxis(mFrame)) { const auto& flexBasis = mStylePosition->mFlexBasis; dependsOnCBBSize |= (flexBasis.IsSize() && flexBasis.AsSize().HasPercent()); } // If we're the descendant of a table cell that performs special bsize // reflows and we could be the child that requires them, always set // the block-axis resize in case this is the first pass before the // special bsize reflow. However, don't do this if it actually is // the special bsize reflow, since in that case it will already be // set correctly above if we need it set. if (!IsBResize() && mCBReflowInput && (mCBReflowInput->mFrame->IsTableCellFrame() || mCBReflowInput->mFlags.mHeightDependsOnAncestorCell) && !mCBReflowInput->mFlags.mSpecialBSizeReflow && dependsOnCBBSize) { SetBResize(true); mFlags.mHeightDependsOnAncestorCell = true; } // Set NS_FRAME_CONTAINS_RELATIVE_BSIZE if it's needed. // It would be nice to check that |ComputedBSize != NS_UNCONSTRAINEDSIZE| // &&ed with the percentage bsize check. However, this doesn't get // along with table special bsize reflows, since a special bsize // reflow (a quirk that makes such percentage height work on children // of table cells) can cause not just a single percentage height to // become fixed, but an entire descendant chain of percentage height // to become fixed. if (dependsOnCBBSize && mCBReflowInput) { const ReflowInput* rs = this; bool hitCBReflowInput = false; do { rs = rs->mParentReflowInput; if (!rs) { break; } if (rs->mFrame->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) { break; // no need to go further } rs->mFrame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); // Keep track of whether we've hit the containing block, because // we need to go at least that far. if (rs == mCBReflowInput) { hitCBReflowInput = true; } // XXX What about orthogonal flows? It doesn't make sense to // keep propagating this bit across an orthogonal boundary, // where the meaning of BSize changes. Bug 1175517. } while (!hitCBReflowInput || (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() && !IsQuirkContainingBlockHeight(rs, rs->mFrame->Type()))); // Note: We actually don't need to set the // NS_FRAME_CONTAINS_RELATIVE_BSIZE bit for the cases // where we hit the early break statements in // CalcQuirkContainingBlockHeight. But it doesn't hurt // us to set the bit in these cases. } if (mFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY)) { // If we're reflowing everything, then we'll find out if we need // to re-set this. mFrame->RemoveStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); } } void ReflowInput::InitDynamicReflowRoot() { if (mFrame->CanBeDynamicReflowRoot()) { mFrame->AddStateBits(NS_FRAME_DYNAMIC_REFLOW_ROOT); } else { mFrame->RemoveStateBits(NS_FRAME_DYNAMIC_REFLOW_ROOT); } } bool ReflowInput::ShouldApplyAutomaticMinimumOnBlockAxis() const { MOZ_ASSERT(!mFrame->HasReplacedSizing()); return mFlags.mIsBSizeSetByAspectRatio && !mStyleDisplay->IsScrollableOverflow() && mStylePosition ->MinBSize(GetWritingMode(), AnchorPosResolutionParams::From(this)) ->IsAuto() && !mFrame->GetContainSizeAxes().mBContained; } bool ReflowInput::IsInFragmentedContext() const { // We consider mFrame with a prev-in-flow being in a fragmented context // because nsColumnSetFrame can reflow its last column with an unconstrained // available block-size. return AvailableBSize() != NS_UNCONSTRAINEDSIZE || mFrame->GetPrevInFlow(); } /* static */ LogicalMargin ReflowInput::ComputeRelativeOffsets(WritingMode aWM, nsIFrame* aFrame, const LogicalSize& aCBSize) { // In relative positioning, anchor functions are always invalid; // anchor-resolved insets should no longer contain any reference to anchor // functions. LogicalMargin offsets(aWM); const nsStylePosition* position = aFrame->StylePosition(); const auto anchorResolutionParams = AnchorPosOffsetResolutionParams::UseCBFrameSize( AnchorPosResolutionParams::From(aFrame)); // Compute the 'inlineStart' and 'inlineEnd' values. 'inlineStart' // moves the boxes to the end of the line, and 'inlineEnd' moves the // boxes to the start of the line. The computed values are always: // inlineStart=-inlineEnd const auto inlineStart = position->GetAnchorResolvedInset( LogicalSide::IStart, aWM, anchorResolutionParams); const auto inlineEnd = position->GetAnchorResolvedInset( LogicalSide::IEnd, aWM, anchorResolutionParams); bool inlineStartIsAuto = inlineStart->IsAuto(); bool inlineEndIsAuto = inlineEnd->IsAuto(); // If neither 'inlineStart' nor 'inlineEnd' is auto, then we're // over-constrained and we ignore one of them if (!inlineStartIsAuto && !inlineEndIsAuto) { inlineEndIsAuto = true; } if (inlineStartIsAuto) { if (inlineEndIsAuto) { // If both are 'auto' (their initial values), the computed values are 0 offsets.IStart(aWM) = offsets.IEnd(aWM) = 0; } else { // 'inlineEnd' isn't being treated as 'auto' so compute its value offsets.IEnd(aWM) = inlineEnd->IsAuto() ? 0 : nsLayoutUtils::ComputeCBDependentValue( aCBSize.ISize(aWM), inlineEnd); // Computed value for 'inlineStart' is minus the value of 'inlineEnd' offsets.IStart(aWM) = -offsets.IEnd(aWM); } } else { NS_ASSERTION(inlineEndIsAuto, "unexpected specified constraint"); // 'InlineStart' isn't 'auto' so compute its value offsets.IStart(aWM) = nsLayoutUtils::ComputeCBDependentValue(aCBSize.ISize(aWM), inlineStart); // Computed value for 'inlineEnd' is minus the value of 'inlineStart' offsets.IEnd(aWM) = -offsets.IStart(aWM); } // Compute the 'blockStart' and 'blockEnd' values. The 'blockStart' // and 'blockEnd' properties move relatively positioned elements in // the block progression direction. They also must be each other's // negative const auto blockStart = position->GetAnchorResolvedInset( LogicalSide::BStart, aWM, anchorResolutionParams); const auto blockEnd = position->GetAnchorResolvedInset( LogicalSide::BEnd, aWM, anchorResolutionParams); bool blockStartIsAuto = blockStart->IsAuto(); bool blockEndIsAuto = blockEnd->IsAuto(); // Check for percentage based values and a containing block block-size // that depends on the content block-size. Treat them like 'auto' if (NS_UNCONSTRAINEDSIZE == aCBSize.BSize(aWM)) { if (blockStart->HasPercent()) { blockStartIsAuto = true; } if (blockEnd->HasPercent()) { blockEndIsAuto = true; } } // If neither is 'auto', 'block-end' is ignored if (!blockStartIsAuto && !blockEndIsAuto) { blockEndIsAuto = true; } if (blockStartIsAuto) { if (blockEndIsAuto) { // If both are 'auto' (their initial values), the computed values are 0 offsets.BStart(aWM) = offsets.BEnd(aWM) = 0; } else { // 'blockEnd' isn't being treated as 'auto' so compute its value offsets.BEnd(aWM) = blockEnd->IsAuto() ? 0 : nsLayoutUtils::ComputeCBDependentValue( aCBSize.BSize(aWM), blockEnd); // Computed value for 'blockStart' is minus the value of 'blockEnd' offsets.BStart(aWM) = -offsets.BEnd(aWM); } } else { NS_ASSERTION(blockEndIsAuto, "unexpected specified constraint"); // 'blockStart' isn't 'auto' so compute its value offsets.BStart(aWM) = nsLayoutUtils::ComputeCBDependentValue(aCBSize.BSize(aWM), blockStart); // Computed value for 'blockEnd' is minus the value of 'blockStart' offsets.BEnd(aWM) = -offsets.BStart(aWM); } // Convert the offsets to physical coordinates and store them on the frame const nsMargin physicalOffsets = offsets.GetPhysicalMargin(aWM); if (nsMargin* prop = aFrame->GetProperty(nsIFrame::ComputedOffsetProperty())) { *prop = physicalOffsets; } else { aFrame->AddProperty(nsIFrame::ComputedOffsetProperty(), new nsMargin(physicalOffsets)); } NS_ASSERTION(offsets.IStart(aWM) == -offsets.IEnd(aWM) && offsets.BStart(aWM) == -offsets.BEnd(aWM), "ComputeRelativeOffsets should return valid results!"); return offsets; } /* static */ void ReflowInput::ApplyRelativePositioning(nsIFrame* aFrame, const nsMargin& aComputedOffsets, nsPoint* aPosition) { if (!aFrame->IsRelativelyOrStickyPositioned()) { NS_ASSERTION(!aFrame->HasProperty(nsIFrame::NormalPositionProperty()), "We assume that changing the 'position' property causes " "frame reconstruction. If that ever changes, this code " "should call " "aFrame->RemoveProperty(nsIFrame::NormalPositionProperty())"); return; } // Store the normal position aFrame->SetProperty(nsIFrame::NormalPositionProperty(), *aPosition); const nsStyleDisplay* display = aFrame->StyleDisplay(); if (StylePositionProperty::Relative == display->mPosition) { *aPosition += nsPoint(aComputedOffsets.left, aComputedOffsets.top); } // For sticky positioned elements, we'll leave them until the scroll container // reflows and calls StickyScrollContainer::UpdatePositions() to update their // positions. } // static void ReflowInput::ComputeAbsPosInlineAutoMargin(nscoord aAvailMarginSpace, WritingMode aContainingBlockWM, bool aIsMarginIStartAuto, bool aIsMarginIEndAuto, LogicalMargin& aMargin) { if (aIsMarginIStartAuto) { if (aIsMarginIEndAuto) { if (aAvailMarginSpace < 0) { // Note that this case is different from the neither-'auto' // case below, where the spec says to ignore 'left'/'right'. // Ignore the specified value for 'margin-right'. aMargin.IEnd(aContainingBlockWM) = aAvailMarginSpace; } else { // Both 'margin-left' and 'margin-right' are 'auto', so they get // equal values aMargin.IStart(aContainingBlockWM) = aAvailMarginSpace / 2; aMargin.IEnd(aContainingBlockWM) = aAvailMarginSpace - aMargin.IStart(aContainingBlockWM); } } else { // Just 'margin-left' is 'auto' aMargin.IStart(aContainingBlockWM) = aAvailMarginSpace; } } else { if (aIsMarginIEndAuto) { // Just 'margin-right' is 'auto' aMargin.IEnd(aContainingBlockWM) = aAvailMarginSpace; } // Else, both margins are non-auto. This margin box would align to the // inset-reduced containing block, so it's not overconstrained. } } // static void ReflowInput::ComputeAbsPosBlockAutoMargin(nscoord aAvailMarginSpace, WritingMode aContainingBlockWM, bool aIsMarginBStartAuto, bool aIsMarginBEndAuto, LogicalMargin& aMargin) { if (aIsMarginBStartAuto) { if (aIsMarginBEndAuto) { // Both 'margin-top' and 'margin-bottom' are 'auto', so they get // equal values aMargin.BStart(aContainingBlockWM) = aAvailMarginSpace / 2; aMargin.BEnd(aContainingBlockWM) = aAvailMarginSpace - aMargin.BStart(aContainingBlockWM); } else { // Just margin-block-start is 'auto' aMargin.BStart(aContainingBlockWM) = aAvailMarginSpace; } } else { if (aIsMarginBEndAuto) { // Just margin-block-end is 'auto' aMargin.BEnd(aContainingBlockWM) = aAvailMarginSpace; } // Else, both margins are non-auto. See comment in the inline version. } } void ReflowInput::ApplyRelativePositioning( nsIFrame* aFrame, WritingMode aWritingMode, const LogicalMargin& aComputedOffsets, LogicalPoint* aPosition, const nsSize& aContainerSize) { // Subtract the size of the frame from the container size that we // use for converting between the logical and physical origins of // the frame. This accounts for the fact that logical origins in RTL // coordinate systems are at the top right of the frame instead of // the top left. nsSize frameSize = aFrame->GetSize(); nsPoint pos = aPosition->GetPhysicalPoint(aWritingMode, aContainerSize - frameSize); ApplyRelativePositioning( aFrame, aComputedOffsets.GetPhysicalMargin(aWritingMode), &pos); *aPosition = LogicalPoint(aWritingMode, pos, aContainerSize - frameSize); } ReflowInput::HypotheticalBoxContainerInfo ReflowInput::GetHypotheticalBoxContainer(const nsIFrame* aFrame) const { nsIFrame* cb = aFrame->GetContainingBlock(); NS_ASSERTION(cb != mFrame, "How did that happen?"); // If cb is currently being reflowed, find its ReflowInput. const ReflowInput* ri = nullptr; if (cb->HasAnyStateBits(NS_FRAME_IN_REFLOW)) { ri = mParentReflowInput; while (ri && ri->mFrame != cb) { ri = ri->mParentReflowInput; } } const WritingMode wm = cb->GetWritingMode(); if (ri) { return {cb, ri->ComputedLogicalBorderPadding(wm), ri->ComputedSize(wm)}; } // Didn't find a ReflowInput for cb. Just compute the information we want, on // the assumption that cb already knows its size. This really ought to be true // by now. NS_ASSERTION(!cb->HasAnyStateBits(NS_FRAME_IN_REFLOW), "cb shouldn't be in reflow; we'll lie if it is"); return {cb, cb->GetLogicalUsedBorderAndPadding(wm), cb->ContentSize(wm)}; } struct nsHypotheticalPosition { // offset from inline-start edge of containing block (which is a padding edge) nscoord mIStart = 0; // offset from block-start edge of containing block (which is a padding edge) nscoord mBStart = 0; WritingMode mWritingMode; }; /** * aInsideBoxSizing returns the part of the padding, border, and margin * in the aAxis dimension that goes inside the edge given by box-sizing; * aOutsideBoxSizing returns the rest. */ void ReflowInput::CalculateBorderPaddingMargin( LogicalAxis aAxis, nscoord aContainingBlockSize, nscoord* aInsideBoxSizing, nscoord* aOutsideBoxSizing) const { WritingMode wm = GetWritingMode(); Side startSide = wm.PhysicalSide(MakeLogicalSide(aAxis, LogicalEdge::Start)); Side endSide = wm.PhysicalSide(MakeLogicalSide(aAxis, LogicalEdge::End)); nsMargin styleBorder = mStyleBorder->GetComputedBorder(); nscoord borderStartEnd = styleBorder.Side(startSide) + styleBorder.Side(endSide); nscoord paddingStartEnd, marginStartEnd; // See if the style system can provide us the padding directly const auto* stylePadding = mFrame->StylePadding(); if (nsMargin padding; stylePadding->GetPadding(padding)) { paddingStartEnd = padding.Side(startSide) + padding.Side(endSide); } else { // We have to compute the start and end values const nscoord start = nsLayoutUtils::ComputeCBDependentValue( aContainingBlockSize, stylePadding->mPadding.Get(startSide)); const nscoord end = nsLayoutUtils::ComputeCBDependentValue( aContainingBlockSize, stylePadding->mPadding.Get(endSide)); paddingStartEnd = start + end; } // See if the style system can provide us the margin directly if (nsMargin margin; mStyleMargin->GetMargin(margin)) { marginStartEnd = margin.Side(startSide) + margin.Side(endSide); } else { // If the margin is 'auto', ComputeCBDependentValue() will return 0. The // correct margin value will be computed later in InitAbsoluteConstraints // (which is caller of this function, via CalculateHypotheticalPosition). const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); const nscoord start = nsLayoutUtils::ComputeCBDependentValue( aContainingBlockSize, mStyleMargin->GetMargin(startSide, anchorResolutionParams)); const nscoord end = nsLayoutUtils::ComputeCBDependentValue( aContainingBlockSize, mStyleMargin->GetMargin(endSide, anchorResolutionParams)); marginStartEnd = start + end; } nscoord outside = paddingStartEnd + borderStartEnd + marginStartEnd; nscoord inside = 0; if (mStylePosition->mBoxSizing == StyleBoxSizing::BorderBox) { inside = borderStartEnd + paddingStartEnd; } outside -= inside; *aInsideBoxSizing = inside; *aOutsideBoxSizing = outside; } /** * Returns true iff a pre-order traversal of the normal child * frames rooted at aFrame finds no non-empty frame before aDescendant. */ static bool AreAllEarlierInFlowFramesEmpty(nsIFrame* aFrame, nsIFrame* aDescendant, bool* aFound) { if (aFrame == aDescendant) { *aFound = true; return true; } if (aFrame->IsPlaceholderFrame()) { auto ph = static_cast(aFrame); MOZ_ASSERT(ph->IsSelfEmpty() && ph->PrincipalChildList().IsEmpty()); ph->SetLineIsEmptySoFar(true); } else { if (!aFrame->IsSelfEmpty()) { *aFound = false; return false; } for (nsIFrame* f : aFrame->PrincipalChildList()) { bool allEmpty = AreAllEarlierInFlowFramesEmpty(f, aDescendant, aFound); if (*aFound || !allEmpty) { return allEmpty; } } } *aFound = false; return true; } // In the code below, |aCBReflowInput->mFrame| is the absolute containing block, // while |blockContainer| is the nearest block container of the placeholder // frame, which may be different from the absolute containing block. void ReflowInput::CalculateHypotheticalPosition( nsPlaceholderFrame* aPlaceholderFrame, const ReflowInput* aCBReflowInput, const LogicalSize& aCBPaddingBoxSize, nsHypotheticalPosition& aHypotheticalPos) const { NS_ASSERTION(mStyleDisplay->mOriginalDisplay != StyleDisplay::None, "mOriginalDisplay has not been properly initialized"); WritingMode cbwm = aCBReflowInput->GetWritingMode(); const auto [blockContainer, blockContainerBP, blockContainerContentBoxSize] = GetHypotheticalBoxContainer(aPlaceholderFrame); WritingMode wm = blockContainer->GetWritingMode(); const nscoord blockContainerContentIStart = blockContainerBP.IStart(wm); const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); const auto styleISize = mStylePosition->ISize(wm, anchorResolutionParams); bool isAutoISize = styleISize->IsAuto(); // If it's a replaced element and it has a 'auto' value for 'inline size', see // if we can get the intrinsic size. This will allow us to exactly determine // both the inline edges. Maybe intrinsicSize; if (mFlags.mIsReplaced && isAutoISize) { intrinsicSize = mFrame->GetIntrinsicSize().ToSize(); } // See if we can calculate what the box inline size would have been if // the element had been in the flow Maybe boxISize; if (mStyleDisplay->IsOriginalDisplayInlineOutside() && !mFlags.mIsReplaced) { // For non-replaced inline-level elements the 'inline size' property // doesn't apply, so we don't know what the inline size would have // been without reflowing it } else { // It's either a replaced inline-level element or a block-level element // Determine the total amount of inline direction // border/padding/margin that the element would have had if it had // been in the flow. Note that we ignore any 'auto' and 'inherit' // values nscoord contentEdgeToBoxSizingISize, boxSizingToMarginEdgeISize; CalculateBorderPaddingMargin( LogicalAxis::Inline, blockContainerContentBoxSize.ISize(wm), &contentEdgeToBoxSizingISize, &boxSizingToMarginEdgeISize); if (mFlags.mIsReplaced && isAutoISize) { // It's a replaced element with an 'auto' inline size so the box inline // size is its intrinsic size plus any border/padding/margin if (intrinsicSize) { boxISize.emplace(LogicalSize(wm, *intrinsicSize).ISize(wm) + contentEdgeToBoxSizingISize + boxSizingToMarginEdgeISize); } } else if (isAutoISize) { // The box inline size is the block container's inline size boxISize.emplace(blockContainerContentBoxSize.ISize(wm)); } else { // We need to compute it. It's important we do this, because if it's // percentage based this computed value may be different from the computed // value calculated using the absolute containing block width nscoord contentEdgeToBoxSizingBSize, dummy; CalculateBorderPaddingMargin(LogicalAxis::Block, blockContainerContentBoxSize.ISize(wm), &contentEdgeToBoxSizingBSize, &dummy); const auto contentISize = mFrame ->ComputeISizeValue( mRenderingContext, wm, blockContainerContentBoxSize, LogicalSize(wm, contentEdgeToBoxSizingISize, contentEdgeToBoxSizingBSize), boxSizingToMarginEdgeISize, *styleISize, *mStylePosition->BSize(wm, anchorResolutionParams), mFrame->GetAspectRatio()) .mISize; boxISize.emplace(contentISize + contentEdgeToBoxSizingISize + boxSizingToMarginEdgeISize); } } // Get the placeholder offset in the coordinate space of its block container. // XXXbz the placeholder is not fully reflowed yet if our containing block is // relatively positioned... const nsSize blockContainerSize = BorderBoxSizeAsContainerIfConstrained( wm, blockContainerContentBoxSize, blockContainerBP); LogicalPoint placeholderOffset( wm, aPlaceholderFrame->GetOffsetToIgnoringScrolling(blockContainer), blockContainerSize); // First, determine the hypothetical box's mBStart. We want to check the // content insertion frame of blockContainer for block-ness, but make // sure to compute all coordinates in the coordinate system of // blockContainer. nsBlockFrame* blockFrame = do_QueryFrame(blockContainer->GetContentInsertionFrame()); if (blockFrame) { // Use a null containerSize to convert a LogicalPoint functioning as a // vector into a physical nsPoint vector. const nsSize nullContainerSize; LogicalPoint blockOffset( wm, blockFrame->GetOffsetToIgnoringScrolling(blockContainer), nullContainerSize); bool isValid; nsBlockInFlowLineIterator iter(blockFrame, aPlaceholderFrame, &isValid); if (!isValid) { // Give up. We're probably dealing with somebody using // position:absolute inside native-anonymous content anyway. aHypotheticalPos.mBStart = placeholderOffset.B(wm); } else { NS_ASSERTION(iter.GetContainer() == blockFrame, "Found placeholder in wrong block!"); nsBlockFrame::LineIterator lineBox = iter.GetLine(); // How we determine the hypothetical box depends on whether the element // would have been inline-level or block-level LogicalRect lineBounds = lineBox->GetBounds().ConvertTo( wm, lineBox->mWritingMode, lineBox->mContainerSize); if (mStyleDisplay->IsOriginalDisplayInlineOutside()) { // Use the block-start of the inline box which the placeholder lives in // as the hypothetical box's block-start. aHypotheticalPos.mBStart = lineBounds.BStart(wm) + blockOffset.B(wm); } else { // The element would have been block-level which means it would // be below the line containing the placeholder frame, unless // all the frames before it are empty. In that case, it would // have been just before this line. // XXXbz the line box is not fully reflowed yet if our // containing block is relatively positioned... if (lineBox != iter.End()) { nsIFrame* firstFrame = lineBox->mFirstChild; bool allEmpty = false; if (firstFrame == aPlaceholderFrame) { aPlaceholderFrame->SetLineIsEmptySoFar(true); allEmpty = true; } else { auto* prev = aPlaceholderFrame->GetPrevSibling(); if (prev && prev->IsPlaceholderFrame()) { auto* ph = static_cast(prev); if (ph->GetLineIsEmptySoFar(&allEmpty)) { aPlaceholderFrame->SetLineIsEmptySoFar(allEmpty); } } } if (!allEmpty) { bool found = false; while (firstFrame) { // See bug 223064 allEmpty = AreAllEarlierInFlowFramesEmpty( firstFrame, aPlaceholderFrame, &found); if (found || !allEmpty) { break; } firstFrame = firstFrame->GetNextSibling(); } aPlaceholderFrame->SetLineIsEmptySoFar(allEmpty); } NS_ASSERTION(firstFrame, "Couldn't find placeholder!"); if (allEmpty) { // The top of the hypothetical box is the top of the line // containing the placeholder, since there is nothing in the // line before our placeholder except empty frames. aHypotheticalPos.mBStart = lineBounds.BStart(wm) + blockOffset.B(wm); } else { // The top of the hypothetical box is just below the line // containing the placeholder. aHypotheticalPos.mBStart = lineBounds.BEnd(wm) + blockOffset.B(wm); } } else { // Just use the placeholder's block-offset wrt the containing block aHypotheticalPos.mBStart = placeholderOffset.B(wm); } } } } else { // blockContainer is not a block, so it's probably something like a XUL box, // etc. Just use the placeholder's block-offset aHypotheticalPos.mBStart = placeholderOffset.B(wm); } // Second, determine the hypothetical box's mIStart. // How we determine the hypothetical box depends on whether the element // would have been inline-level or block-level if (mStyleDisplay->IsOriginalDisplayInlineOutside() || mFlags.mIOffsetsNeedCSSAlign) { // The placeholder represents the IStart edge of the hypothetical box. // (Or if mFlags.mIOffsetsNeedCSSAlign is set, it represents the IStart // edge of the Alignment Container.) aHypotheticalPos.mIStart = placeholderOffset.I(wm); } else { aHypotheticalPos.mIStart = blockContainerContentIStart; } // The current coordinate space is that of the nearest block to the // placeholder. Convert to the coordinate space of the absolute containing // block. const nsIFrame* cbFrame = aCBReflowInput->mFrame; nsPoint cbOffset = blockContainer->GetOffsetToIgnoringScrolling(cbFrame); nsSize cbSize; if (cbFrame->IsViewportFrame()) { // When the containing block is the ViewportFrame, i.e. we are calculating // the static position for a fixed-positioned frame, we need to adjust the // origin to exclude the scrollbar or scrollbar-gutter area. The // ViewportFrame's containing block rect is adjusted in // AbsoluteContainingBlock::ReflowAbsoluteFrame(), and it will add the // rect's origin to the fixed-positioned frame's final position if needed. // // Note: The origin of the containing block rect is adjusted in // ViewportFrame::AdjustReflowInputForScrollbars(). Ensure the code there // remains in sync with the logic here. if (ScrollContainerFrame* sf = do_QueryFrame(cbFrame->PrincipalChildList().FirstChild())) { const nsMargin scrollbarSizes = sf->GetActualScrollbarSizes(); cbOffset.MoveBy(-scrollbarSizes.left, -scrollbarSizes.top); } // ViewportFrame has no border or padding, so the padding-box size is equal // to the border-box size (cbSize) that we are computing. cbSize = aCBPaddingBoxSize.GetPhysicalSize(cbwm); } else { cbSize = aCBReflowInput->ComputedSizeAsContainerIfConstrained(); } LogicalPoint logCBOffs(wm, cbOffset, cbSize - blockContainerSize); aHypotheticalPos.mIStart += logCBOffs.I(wm); aHypotheticalPos.mBStart += logCBOffs.B(wm); // If block direction doesn't match (whether orthogonal or antiparallel), // we'll have to convert aHypotheticalPos to be in terms of cbwm. // This upcoming conversion must be taken into account for border offsets. const bool hypotheticalPosWillUseCbwm = cbwm.GetBlockDir() != wm.GetBlockDir(); // The specified offsets are relative to the absolute containing block's // padding edge and our current values are relative to the border edge, so // translate. const LogicalMargin border = aCBReflowInput->ComputedLogicalBorder(wm); if (hypotheticalPosWillUseCbwm && !wm.ParallelAxisStartsOnSameSide(LogicalAxis::Inline, cbwm)) { aHypotheticalPos.mIStart += border.IEnd(wm); } else { aHypotheticalPos.mIStart -= border.IStart(wm); } if (hypotheticalPosWillUseCbwm && !wm.ParallelAxisStartsOnSameSide(LogicalAxis::Block, cbwm)) { aHypotheticalPos.mBStart += border.BEnd(wm); } else { aHypotheticalPos.mBStart -= border.BStart(wm); } // At this point, we have computed aHypotheticalPos using the writing mode // of the placeholder's block container. if (hypotheticalPosWillUseCbwm) { // If the block direction we used in calculating aHypotheticalPos does not // match the absolute containing block's, we need to convert here so that // aHypotheticalPos is usable in relation to the absolute containing block. // This requires computing or measuring the abspos frame's block-size, // which is not otherwise required/used here (as aHypotheticalPos // records only the block-start coordinate). // This is similar to the inline-size calculation for a replaced // inline-level element or a block-level element (above), except that // 'auto' sizing is handled differently in the block direction for non- // replaced elements and replaced elements lacking an intrinsic size. // Determine the total amount of block direction // border/padding/margin that the element would have had if it had // been in the flow. Note that we ignore any 'auto' and 'inherit' // values. nscoord insideBoxSizing, outsideBoxSizing; CalculateBorderPaddingMargin(LogicalAxis::Block, blockContainerContentBoxSize.BSize(wm), &insideBoxSizing, &outsideBoxSizing); nscoord boxBSize; const auto styleBSize = mStylePosition->BSize(wm, anchorResolutionParams); const bool isAutoBSize = nsLayoutUtils::IsAutoBSize( *styleBSize, blockContainerContentBoxSize.BSize(wm)); if (isAutoBSize) { if (mFlags.mIsReplaced && intrinsicSize) { // It's a replaced element with an 'auto' block size so the box // block size is its intrinsic size plus any border/padding/margin boxBSize = LogicalSize(wm, *intrinsicSize).BSize(wm) + outsideBoxSizing + insideBoxSizing; } else { // XXX Bug 1191801 // Figure out how to get the correct boxBSize here (need to reflow the // positioned frame?) boxBSize = 0; } } else if (styleBSize->BehavesLikeStretchOnBlockAxis()) { MOZ_ASSERT(blockContainerContentBoxSize.BSize(wm) != NS_UNCONSTRAINEDSIZE, "If we're 'stretch' with unconstrained size, isAutoBSize " "should be true which should make us skip this code"); // TODO(dholbert) The 'insideBoxSizing' and 'outsideBoxSizing' usages // here aren't quite right, because we're supposed to be passing margin // and borderPadding specifically. The arithmetic seems to work out in // testcases though. boxBSize = nsLayoutUtils::ComputeStretchContentBoxBSize( blockContainerContentBoxSize.BSize(wm), outsideBoxSizing, insideBoxSizing); } else { // We need to compute it. It's important we do this, because if it's // percentage-based this computed value may be different from the // computed value calculated using the absolute containing block height. boxBSize = nsLayoutUtils::ComputeBSizeValue( blockContainerContentBoxSize.BSize(wm), insideBoxSizing, styleBSize->AsLengthPercentage()) + insideBoxSizing + outsideBoxSizing; } LogicalSize boxSize(wm, boxISize.valueOr(0), boxBSize); LogicalPoint origin(wm, aHypotheticalPos.mIStart, aHypotheticalPos.mBStart); origin = origin.ConvertRectOriginTo(cbwm, wm, boxSize.GetPhysicalSize(wm), cbSize); aHypotheticalPos.mIStart = origin.I(cbwm); aHypotheticalPos.mBStart = origin.B(cbwm); aHypotheticalPos.mWritingMode = cbwm; } else { aHypotheticalPos.mWritingMode = wm; } } void ReflowInput::InitAbsoluteConstraints(const ReflowInput* aCBReflowInput, const LogicalSize& aCBSize) { WritingMode wm = GetWritingMode(); WritingMode cbwm = aCBReflowInput->GetWritingMode(); NS_WARNING_ASSERTION(aCBSize.BSize(cbwm) != NS_UNCONSTRAINEDSIZE, "containing block bsize must be constrained"); NS_ASSERTION(!mFrame->IsTableFrame(), "InitAbsoluteConstraints should not be called on table frames"); MOZ_ASSERT( mFrame->IsAbsolutelyPositioned(mStyleDisplay), "InitAbsoluteConstraints should be called on abspos or fixedpos frames!"); const auto anchorResolutionParams = AnchorPosOffsetResolutionParams::ExplicitCBFrameSize( AnchorPosResolutionParams::From(this), &aCBSize); const auto iStartOffset = mStylePosition->GetAnchorResolvedInset( LogicalSide::IStart, cbwm, anchorResolutionParams); const auto iEndOffset = mStylePosition->GetAnchorResolvedInset( LogicalSide::IEnd, cbwm, anchorResolutionParams); const auto bStartOffset = mStylePosition->GetAnchorResolvedInset( LogicalSide::BStart, cbwm, anchorResolutionParams); const auto bEndOffset = mStylePosition->GetAnchorResolvedInset( LogicalSide::BEnd, cbwm, anchorResolutionParams); bool iStartIsAuto = iStartOffset->IsAuto(); bool iEndIsAuto = iEndOffset->IsAuto(); bool bStartIsAuto = bStartOffset->IsAuto(); bool bEndIsAuto = bEndOffset->IsAuto(); // If both 'inline-start' and 'inline-end' are 'auto' or both 'block-start' // and 'block-end' are 'auto', then compute the hypothetical box position // where the element would have if it were in the flow. nsHypotheticalPosition hypotheticalPos; if ((iStartIsAuto && iEndIsAuto) || (bStartIsAuto && bEndIsAuto)) { nsPlaceholderFrame* placeholderFrame = mFrame->GetPlaceholderFrame(); MOZ_ASSERT(placeholderFrame, "no placeholder frame"); nsIFrame* placeholderParent = placeholderFrame->GetParent(); MOZ_ASSERT(placeholderParent, "shouldn't have unparented placeholders"); if (placeholderFrame->HasAnyStateBits( PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN)) { MOZ_ASSERT(placeholderParent->IsFlexOrGridContainer(), "This flag should only be set on grid/flex children"); // If the (as-yet unknown) static position will determine the inline // and/or block offsets, set flags to note those offsets aren't valid // until we can do CSS Box Alignment on the OOF frame. mFlags.mIOffsetsNeedCSSAlign = (iStartIsAuto && iEndIsAuto); mFlags.mBOffsetsNeedCSSAlign = (bStartIsAuto && bEndIsAuto); } if (mFlags.mStaticPosIsCBOrigin) { hypotheticalPos.mWritingMode = cbwm; if (placeholderParent->IsGridContainerFrame() && placeholderParent->HasAnyStateBits(NS_STATE_GRID_IS_COL_MASONRY | NS_STATE_GRID_IS_ROW_MASONRY)) { // Disable CSS alignment in Masonry layout since we don't have real grid // areas in that axis. We'll use the placeholder position instead as it // was calculated by nsGridContainerFrame::MasonryLayout. auto cbsz = aCBSize.GetPhysicalSize(cbwm); LogicalPoint pos = placeholderFrame->GetLogicalPosition(cbwm, cbsz); if (placeholderParent->HasAnyStateBits(NS_STATE_GRID_IS_COL_MASONRY)) { mFlags.mIOffsetsNeedCSSAlign = false; hypotheticalPos.mIStart = pos.I(cbwm); } else { mFlags.mBOffsetsNeedCSSAlign = false; hypotheticalPos.mBStart = pos.B(cbwm); } } } else { // XXXmats all this is broken for orthogonal writing-modes: bug 1521988. CalculateHypotheticalPosition(placeholderFrame, aCBReflowInput, aCBSize, hypotheticalPos); if (aCBReflowInput->mFrame->IsGridContainerFrame()) { // 'hypotheticalPos' is relative to the padding rect of the CB *frame*. // In grid layout the CB is the grid area rectangle, so we translate // 'hypotheticalPos' to be relative that rectangle here. nsRect cb = nsGridContainerFrame::GridItemCB(mFrame); nscoord left(0); nscoord right(0); if (cbwm.IsBidiLTR()) { left = cb.X(); } else { right = aCBReflowInput->ComputedWidth() + aCBReflowInput->ComputedPhysicalPadding().LeftRight() - cb.XMost(); } LogicalMargin offsets(cbwm, nsMargin(cb.Y(), right, nscoord(0), left)); hypotheticalPos.mIStart -= offsets.IStart(cbwm); hypotheticalPos.mBStart -= offsets.BStart(cbwm); } } } LogicalMargin offsets(cbwm); // Handle auto inset values, as per [1]. // Technically superceded by a new section [2], but none of the browsers seem // to follow this behaviour. // // [1] https://drafts.csswg.org/css-position-3/#abspos-old // [2] https://drafts.csswg.org/css-position-3/#resolving-insets if (iStartIsAuto) { offsets.IStart(cbwm) = 0; } else { offsets.IStart(cbwm) = nsLayoutUtils::ComputeCBDependentValue( aCBSize.ISize(cbwm), iStartOffset); } if (iEndIsAuto) { offsets.IEnd(cbwm) = 0; } else { offsets.IEnd(cbwm) = nsLayoutUtils::ComputeCBDependentValue(aCBSize.ISize(cbwm), iEndOffset); } if (iStartIsAuto && iEndIsAuto) { if (cbwm.IsInlineReversed() != hypotheticalPos.mWritingMode.IsInlineReversed()) { offsets.IEnd(cbwm) = hypotheticalPos.mIStart; iEndIsAuto = false; } else { offsets.IStart(cbwm) = hypotheticalPos.mIStart; iStartIsAuto = false; } } if (bStartIsAuto) { offsets.BStart(cbwm) = 0; } else { offsets.BStart(cbwm) = nsLayoutUtils::ComputeCBDependentValue( aCBSize.BSize(cbwm), bStartOffset); } if (bEndIsAuto) { offsets.BEnd(cbwm) = 0; } else { offsets.BEnd(cbwm) = nsLayoutUtils::ComputeCBDependentValue(aCBSize.BSize(cbwm), bEndOffset); } if (bStartIsAuto && bEndIsAuto) { // Treat 'top' like 'static-position' offsets.BStart(cbwm) = hypotheticalPos.mBStart; bStartIsAuto = false; } SetComputedLogicalOffsets(cbwm, offsets); const bool isOrthogonal = wm.IsOrthogonalTo(cbwm); if (isOrthogonal) { if (bStartIsAuto || bEndIsAuto) { mComputeSizeFlags += ComputeSizeFlag::ShrinkWrap; } } else { if (iStartIsAuto || iEndIsAuto) { mComputeSizeFlags += ComputeSizeFlag::ShrinkWrap; } } { AutoMaybeDisableFontInflation an(mFrame); auto size = mFrame->ComputeSize( *this, wm, aCBSize.ConvertTo(wm, cbwm), aCBSize.ConvertTo(wm, cbwm).ISize(wm), // XXX or AvailableISize()? ComputedLogicalMargin(wm).Size(wm) + ComputedLogicalOffsets(wm).Size(wm), ComputedLogicalBorderPadding(wm).Size(wm), {}, mComputeSizeFlags); mComputedSize = size.mLogicalSize; NS_ASSERTION(ComputedISize() >= 0, "Bogus inline-size"); NS_ASSERTION( ComputedBSize() == NS_UNCONSTRAINEDSIZE || ComputedBSize() >= 0, "Bogus block-size"); mFlags.mIsBSizeSetByAspectRatio = size.mAspectRatioUsage == nsIFrame::AspectRatioUsage::ToComputeBSize; } LogicalMargin margin = ComputedLogicalMargin(cbwm); const LogicalMargin borderPadding = ComputedLogicalBorderPadding(cbwm); const LogicalSize computedSize = mComputedSize.ConvertTo(cbwm, wm); bool iSizeIsAuto = mStylePosition->ISize(cbwm, anchorResolutionParams.mBaseParams)->IsAuto(); if (iStartIsAuto) { // We know 'inset-inline-end' is not 'auto' anymore thanks to the // hypothetical box code above. Solve for 'inset-inline-start'. if (iSizeIsAuto) { offsets.IStart(cbwm) = NS_AUTOOFFSET; } else { offsets.IStart(cbwm) = aCBSize.ISize(cbwm) - offsets.IEnd(cbwm) - computedSize.ISize(cbwm) - margin.IStartEnd(cbwm) - borderPadding.IStartEnd(cbwm); } } else if (iEndIsAuto) { // We know 'inset-inline-start' is not 'auto' anymore thanks to the // hypothetical box code above. Solve for 'inset-inline-end'. if (iSizeIsAuto) { offsets.IEnd(cbwm) = NS_AUTOOFFSET; } else { offsets.IEnd(cbwm) = aCBSize.ISize(cbwm) - offsets.IStart(cbwm) - computedSize.ISize(cbwm) - margin.IStartEnd(cbwm) - borderPadding.IStartEnd(cbwm); } } bool bSizeIsAuto = mStylePosition->BSize(cbwm, anchorResolutionParams.mBaseParams) ->BehavesLikeInitialValueOnBlockAxis(); if (bStartIsAuto) { // Solve for 'inset-block-start'. if (bSizeIsAuto) { offsets.BStart(cbwm) = NS_AUTOOFFSET; } else { offsets.BStart(cbwm) = aCBSize.BSize(cbwm) - margin.BStartEnd(cbwm) - borderPadding.BStartEnd(cbwm) - computedSize.BSize(cbwm) - offsets.BEnd(cbwm); } } else if (bEndIsAuto) { // Solve for 'inset-block-end'. if (bSizeIsAuto) { offsets.BEnd(cbwm) = NS_AUTOOFFSET; } else { offsets.BEnd(cbwm) = aCBSize.BSize(cbwm) - margin.BStartEnd(cbwm) - borderPadding.BStartEnd(cbwm) - computedSize.BSize(cbwm) - offsets.BStart(cbwm); } } SetComputedLogicalOffsets(cbwm, offsets); } // This will not be converted to abstract coordinates because it's only // used in CalcQuirkContainingBlockHeight static nscoord GetBlockMarginBorderPadding(const ReflowInput* aReflowInput) { nscoord result = 0; if (!aReflowInput) { return result; } // zero auto margins nsMargin margin = aReflowInput->ComputedPhysicalMargin(); if (NS_AUTOMARGIN == margin.top) { margin.top = 0; } if (NS_AUTOMARGIN == margin.bottom) { margin.bottom = 0; } result += margin.top + margin.bottom; result += aReflowInput->ComputedPhysicalBorderPadding().top + aReflowInput->ComputedPhysicalBorderPadding().bottom; return result; } /* Get the height based on the viewport of the containing block specified * in aReflowInput when the containing block has mComputedHeight == * NS_UNCONSTRAINEDSIZE This will walk up the chain of containing blocks looking * for a computed height until it finds the canvas frame, or it encounters a * frame that is not a block, area, or scroll frame. This handles compatibility * with IE (see bug 85016 and bug 219693) * * When we encounter scrolledContent block frames, we skip over them, * since they are guaranteed to not be useful for computing the containing * block. * * See also IsQuirkContainingBlockHeight. */ static nscoord CalcQuirkContainingBlockHeight( const ReflowInput* aCBReflowInput) { const ReflowInput* firstAncestorRI = nullptr; // a candidate for html frame const ReflowInput* secondAncestorRI = nullptr; // a candidate for body frame // initialize the default to NS_UNCONSTRAINEDSIZE as this is the containings // block computed height when this function is called. It is possible that we // don't alter this height especially if we are restricted to one level nscoord result = NS_UNCONSTRAINEDSIZE; const ReflowInput* ri = aCBReflowInput; for (; ri; ri = ri->mParentReflowInput) { LayoutFrameType frameType = ri->mFrame->Type(); // if the ancestor is auto height then skip it and continue up if it // is the first block frame and possibly the body/html if (LayoutFrameType::Block == frameType || LayoutFrameType::ScrollContainer == frameType) { secondAncestorRI = firstAncestorRI; firstAncestorRI = ri; // If the current frame we're looking at is positioned, we don't want to // go any further (see bug 221784). The behavior we want here is: 1) If // not auto-height, use this as the percentage base. 2) If auto-height, // or treating the height as indefinite, keep looking, unless the frame is // positioned. if (ri->ComputedHeight() == NS_UNCONSTRAINEDSIZE || ri->mFlags.mTreatBSizeAsIndefinite) { if (ri->mFrame->IsAbsolutelyPositioned(ri->mStyleDisplay)) { break; } else { continue; } } } else if (LayoutFrameType::Canvas == frameType) { // Always continue on to the height calculation } else if (LayoutFrameType::PageContent == frameType) { nsIFrame* prevInFlow = ri->mFrame->GetPrevInFlow(); // only use the page content frame for a height basis if it is the first // in flow if (prevInFlow) { break; } } else { break; } // if the ancestor is the page content frame then the percent base is // the avail height, otherwise it is the computed height result = (LayoutFrameType::PageContent == frameType) ? ri->AvailableHeight() : ri->ComputedHeight(); // if unconstrained - don't sutract borders - would result in huge height if (NS_UNCONSTRAINEDSIZE == result) { return result; } // if we got to the canvas or page content frame, then subtract out // margin/border/padding for the BODY and HTML elements if ((LayoutFrameType::Canvas == frameType) || (LayoutFrameType::PageContent == frameType)) { result -= GetBlockMarginBorderPadding(firstAncestorRI); result -= GetBlockMarginBorderPadding(secondAncestorRI); #ifdef DEBUG // make sure the first ancestor is the HTML and the second is the BODY if (firstAncestorRI) { nsIContent* frameContent = firstAncestorRI->mFrame->GetContent(); if (frameContent) { NS_ASSERTION(frameContent->IsHTMLElement(nsGkAtoms::html), "First ancestor is not HTML"); } } if (secondAncestorRI) { nsIContent* frameContent = secondAncestorRI->mFrame->GetContent(); if (frameContent) { NS_ASSERTION(frameContent->IsHTMLElement(nsGkAtoms::body), "Second ancestor is not BODY"); } } #endif } // if we got to the html frame (a block child of the canvas) ... else if (LayoutFrameType::Block == frameType && ri->mParentReflowInput && ri->mParentReflowInput->mFrame->IsCanvasFrame()) { // ... then subtract out margin/border/padding for the BODY element result -= GetBlockMarginBorderPadding(secondAncestorRI); } break; } // Make sure not to return a negative height here! return std::max(result, 0); } LogicalSize ReflowInput::ComputeContainingBlockRectangle( nsPresContext* aPresContext, const ReflowInput* aContainingBlockRI) const { LogicalSize cbSize = aContainingBlockRI->ComputedSize(); WritingMode wm = aContainingBlockRI->GetWritingMode(); if (aContainingBlockRI->mFlags.mTreatBSizeAsIndefinite) { cbSize.BSize(wm) = NS_UNCONSTRAINEDSIZE; } else if (aContainingBlockRI->mPercentageBasisInBlockAxis) { MOZ_ASSERT(cbSize.BSize(wm) == NS_UNCONSTRAINEDSIZE, "Why provide a percentage basis when the containing block's " "block-size is definite?"); cbSize.BSize(wm) = *aContainingBlockRI->mPercentageBasisInBlockAxis; } auto IsQuirky = [](const StyleSize& aSize) -> bool { return aSize.ConvertsToPercentage() || aSize.BehavesLikeStretchOnBlockAxis(); }; const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); // In quirks mode, if an element has a percent height (or a 'stretch' height, // which is kinda like a special version of 100%), then it gets its // containing block by looking for an ancestor with a non-auto height. // Note: We don't emulate this quirk for percents in calc(), or in vertical // writing modes, or if the containing block is a flex or grid item. if (!wm.IsVertical() && NS_UNCONSTRAINEDSIZE == cbSize.BSize(wm)) { if (eCompatibility_NavQuirks == aPresContext->CompatibilityMode() && !aContainingBlockRI->mFrame->IsFlexOrGridItem() && (IsQuirky(*mStylePosition->GetHeight(anchorResolutionParams)) || (mFrame->IsTableWrapperFrame() && IsQuirky(*mFrame->PrincipalChildList() .FirstChild() ->StylePosition() ->GetHeight(anchorResolutionParams))))) { cbSize.BSize(wm) = CalcQuirkContainingBlockHeight(aContainingBlockRI); } } return cbSize.ConvertTo(GetWritingMode(), wm); } // XXX refactor this code to have methods for each set of properties // we are computing: width,height,line-height; margin; offsets void ReflowInput::InitConstraints( nsPresContext* aPresContext, const Maybe& aContainingBlockSize, const Maybe& aBorder, const Maybe& aPadding, LayoutFrameType aFrameType) { WritingMode wm = GetWritingMode(); LogicalSize cbSize = aContainingBlockSize.valueOr( LogicalSize(mWritingMode, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)); // If this is a reflow root, then set the computed width and // height equal to the available space if (nullptr == mParentReflowInput || mFlags.mDummyParentReflowInput) { // XXXldb This doesn't mean what it used to! InitOffsets(wm, cbSize.ISize(wm), aFrameType, mComputeSizeFlags, aBorder, aPadding, mStyleDisplay); // Override mComputedMargin since reflow roots start from the // frame's boundary, which is inside the margin. SetComputedLogicalMargin(wm, LogicalMargin(wm)); SetComputedLogicalOffsets(wm, LogicalMargin(wm)); const auto borderPadding = ComputedLogicalBorderPadding(wm); SetComputedISize( std::max(0, AvailableISize() - borderPadding.IStartEnd(wm)), ResetResizeFlags::No); SetComputedBSize( AvailableBSize() != NS_UNCONSTRAINEDSIZE ? std::max(0, AvailableBSize() - borderPadding.BStartEnd(wm)) : NS_UNCONSTRAINEDSIZE, ResetResizeFlags::No); mComputedMinSize.SizeTo(mWritingMode, 0, 0); mComputedMaxSize.SizeTo(mWritingMode, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE); } else { // Get the containing block's reflow input const ReflowInput* cbri = mCBReflowInput; MOZ_ASSERT(cbri, "no containing block"); MOZ_ASSERT(mFrame->GetParent()); // If we weren't given a containing block size, then compute one. if (aContainingBlockSize.isNothing()) { cbSize = ComputeContainingBlockRectangle(aPresContext, cbri); } // See if the containing block height is based on the size of its // content if (NS_UNCONSTRAINEDSIZE == cbSize.BSize(wm)) { // See if the containing block is a cell frame which needs // to use the mComputedHeight of the cell instead of what the cell block // passed in. // XXX It seems like this could lead to bugs with min-height and friends if (cbri->mParentReflowInput && cbri->mFrame->IsTableCellFrame()) { cbSize.BSize(wm) = cbri->ComputedSize(wm).BSize(wm); } } // XXX Might need to also pass the CB height (not width) for page boxes, // too, if we implement them. // For calculating positioning offsets, margins, borders and // padding, we use the writing mode of the containing block WritingMode cbwm = cbri->GetWritingMode(); InitOffsets(cbwm, cbSize.ConvertTo(cbwm, wm).ISize(cbwm), aFrameType, mComputeSizeFlags, aBorder, aPadding, mStyleDisplay); // For calculating the size of this box, we use its own writing mode auto blockSize = mStylePosition->BSize(wm, AnchorPosResolutionParams::From(this)); if (blockSize->BehavesLikeStretchOnBlockAxis()) { // Resolve 'stretch' to either 'auto' or the stretched bsize, depending // on whether our containing block has a definite bsize. // TODO(dholbert): remove this in bug 2000035. if (NS_UNCONSTRAINEDSIZE == cbSize.BSize(wm)) { blockSize = AnchorResolvedSizeHelper::Auto(); } else { nscoord stretchBSize = nsLayoutUtils::ComputeStretchBSize( cbSize.BSize(wm), ComputedLogicalMargin(wm).BStartEnd(wm), ComputedLogicalBorderPadding(wm).BStartEnd(wm), mStylePosition->mBoxSizing); blockSize = AnchorResolvedSizeHelper::LengthPercentage( StyleLengthPercentage::FromAppUnits(stretchBSize)); } } bool isAutoBSize = blockSize->BehavesLikeInitialValueOnBlockAxis(); // Check for a percentage based block size and a containing block // block size that depends on the content block size if (blockSize->HasPercent()) { if (NS_UNCONSTRAINEDSIZE == cbSize.BSize(wm)) { // this if clause enables %-blockSize on replaced inline frames, // such as images. See bug 54119. The else clause "blockSizeUnit = // eStyleUnit_Auto;" used to be called exclusively. if (mFlags.mIsReplaced && mStyleDisplay->IsInlineOutsideStyle()) { // Get the containing block's reflow input NS_ASSERTION(cbri, "no containing block"); // in quirks mode, get the cb height using the special quirk method if (!wm.IsVertical() && eCompatibility_NavQuirks == aPresContext->CompatibilityMode()) { if (!cbri->mFrame->IsTableCellFrame() && !cbri->mFrame->IsFlexOrGridItem()) { cbSize.BSize(wm) = CalcQuirkContainingBlockHeight(cbri); if (cbSize.BSize(wm) == NS_UNCONSTRAINEDSIZE) { isAutoBSize = true; } } else { isAutoBSize = true; } } // in standard mode, use the cb block size. if it's "auto", // as will be the case by default in BODY, use auto block size // as per CSS2 spec. else { nscoord computedBSize = cbri->ComputedSize(wm).BSize(wm); if (NS_UNCONSTRAINEDSIZE != computedBSize) { cbSize.BSize(wm) = computedBSize; } else { isAutoBSize = true; } } } else { // default to interpreting the blockSize like 'auto' isAutoBSize = true; } } } // Compute our offsets if the element is relatively positioned. We // need the correct containing block inline-size and block-size // here, which is why we need to do it after all the quirks-n-such // above. (If the element is sticky positioned, we need to wait // until the scroll container knows its size, so we compute offsets // from StickyScrollContainer::UpdatePositions.) if (mStyleDisplay->IsRelativelyPositioned(mFrame)) { const LogicalMargin offsets = ComputeRelativeOffsets(cbwm, mFrame, cbSize.ConvertTo(cbwm, wm)); SetComputedLogicalOffsets(cbwm, offsets); } else { // Initialize offsets to 0 SetComputedLogicalOffsets(wm, LogicalMargin(wm)); } // Calculate the computed values for min and max properties. Note that // this MUST come after we've computed our border and padding. ComputeMinMaxValues(cbSize); // Calculate the computed inlineSize and blockSize. // This varies by frame type. if (IsInternalTableFrame()) { // Internal table elements. The rules vary depending on the type. // Calculate the computed isize bool rowOrRowGroup = false; const auto inlineSize = mStylePosition->ISize(wm, AnchorPosResolutionParams::From(this)); bool isAutoISize = inlineSize->IsAuto(); if ((StyleDisplay::TableRow == mStyleDisplay->mDisplay) || (StyleDisplay::TableRowGroup == mStyleDisplay->mDisplay)) { // 'inlineSize' property doesn't apply to table rows and row groups isAutoISize = true; rowOrRowGroup = true; } // calc() with both percentages and lengths act like auto on internal // table elements if (isAutoISize || inlineSize->HasLengthAndPercentage()) { if (AvailableISize() != NS_UNCONSTRAINEDSIZE && !rowOrRowGroup) { // Internal table elements don't have margins. Only tables and // cells have border and padding SetComputedISize( std::max(0, AvailableISize() - ComputedLogicalBorderPadding(wm).IStartEnd(wm)), ResetResizeFlags::No); } else { SetComputedISize(AvailableISize(), ResetResizeFlags::No); } NS_ASSERTION(ComputedISize() >= 0, "Bogus computed isize"); } else { SetComputedISize( ComputeISizeValue(cbSize, mStylePosition->mBoxSizing, *inlineSize), ResetResizeFlags::No); } // Calculate the computed block size if (StyleDisplay::TableColumn == mStyleDisplay->mDisplay || StyleDisplay::TableColumnGroup == mStyleDisplay->mDisplay) { // 'blockSize' property doesn't apply to table columns and column groups isAutoBSize = true; } // calc() with both percentages and lengths acts like 'auto' on internal // table elements if (isAutoBSize || blockSize->HasLengthAndPercentage()) { SetComputedBSize(NS_UNCONSTRAINEDSIZE, ResetResizeFlags::No); } else { SetComputedBSize( ComputeBSizeValue(cbSize.BSize(wm), mStylePosition->mBoxSizing, blockSize->AsLengthPercentage()), ResetResizeFlags::No); } // Doesn't apply to internal table elements mComputedMinSize.SizeTo(mWritingMode, 0, 0); mComputedMaxSize.SizeTo(mWritingMode, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE); } else if (mFrame->IsAbsolutelyPositioned(mStyleDisplay) && // The absolute constraints are needed only for abspos // first-in-flow, not continuations. !mFrame->GetPrevInFlow()) { InitAbsoluteConstraints(cbri, cbSize.ConvertTo(cbri->GetWritingMode(), wm)); } else { AutoMaybeDisableFontInflation an(mFrame); auto* const alignCB = [&] { auto* cb = mFrame->GetParent(); if (cb->IsTableWrapperFrame()) { auto* alignCBParent = cb->GetParent(); if (alignCBParent && alignCBParent->IsGridContainerFrame()) { return alignCBParent; } } if (cb->Style()->GetPseudoType() == PseudoStyleType::MozColumnSpanWrapper) { MOZ_ASSERT(mFrame->StyleColumn()->mColumnSpan != StyleColumnSpan::None); // Note(dshin, bug 2013429): `:-moz-column-span-wrapper` is a // non-inheriting anon box, so it doesn't inherit writing-mode either. auto* p = cb->GetParent(); while (p) { if (p->Style()->GetPseudoType() != PseudoStyleType::MozColumnSpanWrapper) { return p; } p = p->GetParent(); } MOZ_ASSERT_UNREACHABLE("No parent above :-moz-column-span-wrapper?"); } return cb; }(); const bool isInlineLevel = [&] { if (mFrame->IsTableFrame()) { // An inner table frame is not inline-level, even if it happens to // have 'display:inline-table'. (That makes its table-wrapper frame be // inline-level, but not the inner table frame) return false; } if (mStyleDisplay->IsInlineOutsideStyle()) { return true; } if (mFlags.mIsReplaced && (mStyleDisplay->IsInnerTableStyle() || mStyleDisplay->DisplayOutside() == StyleDisplayOutside::TableCaption)) { // Internal table values on replaced elements behave as inline // https://drafts.csswg.org/css-tables-3/#table-structure // // ... it is handled instead as though the author had declared // either 'block' (for 'table' display) or 'inline' (for all // other values)" // // FIXME(emilio): The only test that covers this is // table-anonymous-objects-211.xht, which fails on other browsers (but // differently to us, if you just remove this condition). return true; } if (mFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) && !mStyleDisplay->IsAbsolutelyPositionedStyle()) { // Floats are treated as inline-level and also shrink-wrap. return true; } return false; }(); if (mParentReflowInput->mFlags.mOrthogonalCellFinalReflow) { // This is the "extra" reflow for the inner content of an orthogonal // table cell, after the row size has been determined; so we want to // respect the cell's size without further adjustment. Its rect may // not yet be correct, however, so we base our size on the parent // reflow input's available size, adjusted for border widths. MOZ_ASSERT(mFrame->GetParent()->IsTableCellFrame(), "unexpected mOrthogonalCellFinalReflow flag!"); cbSize = mParentReflowInput->AvailableSize().ConvertTo( wm, mParentReflowInput->GetWritingMode()); cbSize -= mParentReflowInput->ComputedLogicalBorder(wm).Size(wm); SetAvailableISize(cbSize.ISize(wm)); } else { const bool shouldShrinkWrap = [&] { if (isInlineLevel) { return true; } if (mFlags.mIsReplaced && !alignCB->IsFlexOrGridContainer()) { // Shrink-wrap replaced elements when in-flow (out of flows are // handled above). We exclude replaced elements in grid or flex // contexts, where we don't want to shrink-wrap unconditionally (so // that stretching can happen). When grid/flex explicitly want // shrink-wrapping, they can request it directly using the relevant // flag. return true; } if (!alignCB->IsGridContainerFrame() && mWritingMode.IsOrthogonalTo(alignCB->GetWritingMode())) { // Shrink-wrap blocks that are orthogonal to their container (unless // we're in a grid?) return true; } return false; }(); if (shouldShrinkWrap) { mComputeSizeFlags += ComputeSizeFlag::ShrinkWrap; } if (cbSize.ISize(wm) == NS_UNCONSTRAINEDSIZE) { // For orthogonal flows, where we found a parent orthogonal-limit for // AvailableISize() in Init(), we'll use the same here as well. cbSize.ISize(wm) = AvailableISize(); } } auto size = mFrame->ComputeSize(*this, wm, cbSize, AvailableISize(), ComputedLogicalMargin(wm).Size(wm), ComputedLogicalBorderPadding(wm).Size(wm), mStyleSizeOverrides, mComputeSizeFlags); mComputedSize = size.mLogicalSize; NS_ASSERTION(ComputedISize() >= 0, "Bogus inline-size"); NS_ASSERTION( ComputedBSize() == NS_UNCONSTRAINEDSIZE || ComputedBSize() >= 0, "Bogus block-size"); mFlags.mIsBSizeSetByAspectRatio = size.mAspectRatioUsage == nsIFrame::AspectRatioUsage::ToComputeBSize; const bool shouldCalculateBlockSideMargins = [&]() { if (isInlineLevel) { return false; } if (mFrame->IsTableFrame()) { return false; } if (alignCB->IsFlexOrGridContainer()) { // Exclude flex and grid items. return false; } const auto pseudoType = mFrame->Style()->GetPseudoType(); if (pseudoType == PseudoStyleType::Marker && mFrame->GetParent()->StyleList()->mListStylePosition == StyleListStylePosition::Outside) { // Exclude outside ::markers. return false; } if (pseudoType == PseudoStyleType::MozColumnContent) { // Exclude -moz-column-content since it cannot have any margin. return false; } return true; }(); if (shouldCalculateBlockSideMargins) { CalculateBlockSideMargins(); } } } // Save our containing block dimensions mContainingBlockSize = cbSize; } static void UpdateProp(nsIFrame* aFrame, const FramePropertyDescriptor* aProperty, bool aNeeded, const nsMargin& aNewValue) { if (aNeeded) { if (nsMargin* propValue = aFrame->GetProperty(aProperty)) { *propValue = aNewValue; } else { aFrame->AddProperty(aProperty, new nsMargin(aNewValue)); } } else { aFrame->RemoveProperty(aProperty); } } void SizeComputationInput::InitOffsets(WritingMode aCBWM, nscoord aPercentBasis, LayoutFrameType aFrameType, ComputeSizeFlags aFlags, const Maybe& aBorder, const Maybe& aPadding, const nsStyleDisplay* aDisplay) { nsPresContext* presContext = mFrame->PresContext(); // Compute margins from the specified margin style information. These // become the default computed values, and may be adjusted below // XXX fix to provide 0,0 for the top&bottom margins for // inline-non-replaced elements bool needMarginProp = ComputeMargin(aCBWM, aPercentBasis, aFrameType); // Note that ComputeMargin() simplistically resolves 'auto' margins to 0. // In formatting contexts where this isn't correct, some later code will // need to update the UsedMargin() property with the actual resolved value. // One example of this is ::CalculateBlockSideMargins(). ::UpdateProp(mFrame, nsIFrame::UsedMarginProperty(), needMarginProp, ComputedPhysicalMargin()); const WritingMode wm = GetWritingMode(); const nsStyleDisplay* disp = mFrame->StyleDisplayWithOptionalParam(aDisplay); bool needPaddingProp; LayoutDeviceIntMargin widgetPadding; if (mIsThemed && presContext->Theme()->GetWidgetPadding( presContext->DeviceContext(), mFrame, disp->EffectiveAppearance(), &widgetPadding)) { const nsMargin padding = LayoutDevicePixel::ToAppUnits( widgetPadding, presContext->AppUnitsPerDevPixel()); SetComputedLogicalPadding(wm, LogicalMargin(wm, padding)); needPaddingProp = false; } else if (mFrame->IsInSVGTextSubtree()) { SetComputedLogicalPadding(wm, LogicalMargin(wm)); needPaddingProp = false; } else if (aPadding) { // padding is an input arg SetComputedLogicalPadding(wm, *aPadding); nsMargin stylePadding; // If the caller passes a padding that doesn't match our style (like // nsTextControlFrame might due due to theming), then we also need a // padding prop. needPaddingProp = !mFrame->StylePadding()->GetPadding(stylePadding) || aPadding->GetPhysicalMargin(wm) != stylePadding; } else { needPaddingProp = ComputePadding(aCBWM, aPercentBasis, aFrameType); } // Add [align|justify]-content:baseline padding contribution. typedef const FramePropertyDescriptor>* Prop; auto ApplyBaselinePadding = [this, wm, &needPaddingProp](LogicalAxis aAxis, Prop aProp) { bool found; nscoord val = mFrame->GetProperty(aProp, &found); if (found) { NS_ASSERTION(val != nscoord(0), "zero in this property is useless"); LogicalSide side; if (val > 0) { side = MakeLogicalSide(aAxis, LogicalEdge::Start); } else { side = MakeLogicalSide(aAxis, LogicalEdge::End); val = -val; } mComputedPadding.Side(side, wm) += val; needPaddingProp = true; if (aAxis == LogicalAxis::Block && val > 0) { // We have a baseline-adjusted block-axis start padding, so // we need this to mark lines dirty when mIsBResize is true: this->mFrame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); } } }; if (!aFlags.contains(ComputeSizeFlag::IsGridMeasuringReflow)) { ApplyBaselinePadding(LogicalAxis::Block, nsIFrame::BBaselinePadProperty()); } if (!aFlags.contains(ComputeSizeFlag::ShrinkWrap)) { ApplyBaselinePadding(LogicalAxis::Inline, nsIFrame::IBaselinePadProperty()); } LogicalMargin border(wm); if (mIsThemed) { const LayoutDeviceIntMargin widgetBorder = presContext->Theme()->GetWidgetBorder( presContext->DeviceContext(), mFrame, disp->EffectiveAppearance()); border = LogicalMargin( wm, LayoutDevicePixel::ToAppUnits(widgetBorder, presContext->AppUnitsPerDevPixel())); } else if (mFrame->IsInSVGTextSubtree()) { // Do nothing since the border local variable is initialized all zero. } else if (aBorder) { // border is an input arg border = *aBorder; } else { border = LogicalMargin(wm, mFrame->StyleBorder()->GetComputedBorder()); } SetComputedLogicalBorderPadding(wm, border + ComputedLogicalPadding(wm)); if (aFrameType == LayoutFrameType::Scrollbar) { // scrollbars may have had their width or height smashed to zero // by the associated scrollframe, in which case we must not report // any padding or border. nsSize size(mFrame->GetSize()); if (size.width == 0 || size.height == 0) { SetComputedLogicalPadding(wm, LogicalMargin(wm)); SetComputedLogicalBorderPadding(wm, LogicalMargin(wm)); } } bool hasPaddingChange; if (nsMargin* oldPadding = mFrame->GetProperty(nsIFrame::UsedPaddingProperty())) { // Note: If a padding change is already detectable without resolving the // percentage, e.g. a padding is changing from 50px to 50%, // nsIFrame::DidSetComputedStyle() will cache the old padding in // UsedPaddingProperty(). hasPaddingChange = *oldPadding != ComputedPhysicalPadding(); } else { // Our padding may have changed, but we can't tell at this point. hasPaddingChange = needPaddingProp; } // Keep mHasPaddingChange bit set until we've done reflow. We'll clear it in // nsIFrame::DidReflow() mFrame->SetHasPaddingChange(mFrame->HasPaddingChange() || hasPaddingChange); ::UpdateProp(mFrame, nsIFrame::UsedPaddingProperty(), needPaddingProp, ComputedPhysicalPadding()); } // This code enforces section 10.3.3 of the CSS2 spec for this formula: // // 'margin-left' + 'border-left-width' + 'padding-left' + 'width' + // 'padding-right' + 'border-right-width' + 'margin-right' // = width of containing block // // Note: the width unit is not auto when this is called void ReflowInput::CalculateBlockSideMargins() { MOZ_ASSERT(!mFrame->IsTableFrame(), "Inner table frame cannot have computed margins!"); // Calculations here are done in the containing block's writing mode, // which is where margins will eventually be applied: we're calculating // margins that will be used by the container in its inline direction, // which in the case of an orthogonal contained block will correspond to // the block direction of this reflow input. So in the orthogonal-flow // case, "CalculateBlock*Side*Margins" will actually end up adjusting // the BStart/BEnd margins; those are the "sides" of the block from its // container's point of view. WritingMode cbWM = GetCBWritingMode(); nscoord availISizeCBWM = AvailableSize(cbWM).ISize(cbWM); nscoord computedISizeCBWM = ComputedSize(cbWM).ISize(cbWM); if (availISizeCBWM == NS_UNCONSTRAINEDSIZE || computedISizeCBWM == NS_UNCONSTRAINEDSIZE) { // For orthogonal flows, where we found a parent orthogonal-limit // for AvailableISize() in Init(), we don't have meaningful sizes to // adjust. Act like the sum is already correct (below). return; } LAYOUT_WARN_IF_FALSE(NS_UNCONSTRAINEDSIZE != computedISizeCBWM && NS_UNCONSTRAINEDSIZE != availISizeCBWM, "have unconstrained inline-size; this should only " "result from very large sizes, not attempts at " "intrinsic inline-size calculation"); LogicalMargin margin = ComputedLogicalMargin(cbWM); LogicalMargin borderPadding = ComputedLogicalBorderPadding(cbWM); nscoord sum = margin.IStartEnd(cbWM) + borderPadding.IStartEnd(cbWM) + computedISizeCBWM; if (sum == availISizeCBWM) { // The sum is already correct return; } // Determine the start and end margin values. The isize value // remains constant while we do this. // Calculate how much space is available for margins nscoord availMarginSpace = availISizeCBWM - sum; // If the available margin space is negative, then don't follow the // usual overconstraint rules. if (availMarginSpace < 0) { margin.IEnd(cbWM) += availMarginSpace; SetComputedLogicalMargin(cbWM, margin); return; } const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); // The css2 spec clearly defines how block elements should behave // in section 10.3.3. bool isAutoStartMargin = mStyleMargin->GetMargin(LogicalSide::IStart, cbWM, anchorResolutionParams) ->IsAuto(); bool isAutoEndMargin = mStyleMargin->GetMargin(LogicalSide::IEnd, cbWM, anchorResolutionParams) ->IsAuto(); if (!isAutoStartMargin && !isAutoEndMargin) { // Neither margin is 'auto' so we're over constrained. Use the // 'direction' property of the parent to tell which margin to // ignore // First check if there is an HTML alignment that we should honor const StyleTextAlign* textAlign = mParentReflowInput ? &mParentReflowInput->mFrame->StyleText()->mTextAlign : nullptr; if (textAlign && (*textAlign == StyleTextAlign::MozLeft || *textAlign == StyleTextAlign::MozCenter || *textAlign == StyleTextAlign::MozRight)) { if (mParentReflowInput->mWritingMode.IsBidiLTR()) { isAutoStartMargin = *textAlign != StyleTextAlign::MozLeft; isAutoEndMargin = *textAlign != StyleTextAlign::MozRight; } else { isAutoStartMargin = *textAlign != StyleTextAlign::MozRight; isAutoEndMargin = *textAlign != StyleTextAlign::MozLeft; } } // Otherwise apply the CSS rules, and ignore one margin by forcing // it to 'auto', depending on 'direction'. else { isAutoEndMargin = true; } } // Logic which is common to blocks and tables // The computed margins need not be zero because the 'auto' could come from // overconstraint or from HTML alignment so values need to be accumulated if (isAutoStartMargin) { if (isAutoEndMargin) { // Both margins are 'auto' so the computed addition should be equal nscoord forStart = availMarginSpace / 2; margin.IStart(cbWM) += forStart; margin.IEnd(cbWM) += availMarginSpace - forStart; } else { margin.IStart(cbWM) += availMarginSpace; } } else if (isAutoEndMargin) { margin.IEnd(cbWM) += availMarginSpace; } SetComputedLogicalMargin(cbWM, margin); if (isAutoStartMargin || isAutoEndMargin) { // Update the UsedMargin property if we were tracking it already. nsMargin* propValue = mFrame->GetProperty(nsIFrame::UsedMarginProperty()); if (propValue) { *propValue = margin.GetPhysicalMargin(cbWM); } } } // For "normal" we use the font's normal line height (em height + leading). // If both internal leading and external leading specified by font itself are // zeros, we should compensate this by creating extra (external) leading. // This is necessary because without this compensation, normal line height might // look too tight. static nscoord GetNormalLineHeight(nsFontMetrics* aFontMetrics) { MOZ_ASSERT(aFontMetrics, "no font metrics"); nscoord externalLeading = aFontMetrics->ExternalLeading(); nscoord internalLeading = aFontMetrics->InternalLeading(); nscoord emHeight = aFontMetrics->EmHeight(); if (!internalLeading && !externalLeading) { return NSToCoordRound(static_cast(emHeight) * ReflowInput::kNormalLineHeightFactor); } return emHeight + internalLeading + externalLeading; } static inline nscoord ComputeLineHeight(const StyleLineHeight& aLh, const nsFont& aFont, nsAtom* aLanguage, bool aExplicitLanguage, nsPresContext* aPresContext, bool aIsVertical, float aFontSizeInflation) { if (aLh.IsLength()) { nscoord result = aLh.AsLength().ToAppUnits(); if (aFontSizeInflation != 1.0f) { result = NSToCoordRound(static_cast(result) * aFontSizeInflation); } return result; } if (aLh.IsNumber()) { // For factor units the computed value of the line-height property // is found by multiplying the factor by the font's computed size // (adjusted for min-size prefs and text zoom). return aFont.size.ScaledBy(aLh.AsNumber() * aFontSizeInflation) .ToAppUnits(); } MOZ_ASSERT(aLh.IsNormal()); auto size = aFont.size; size.ScaleBy(aFontSizeInflation); if (aPresContext) { nsFont font = aFont; font.size = size; nsFontMetrics::Params params; params.language = aLanguage; params.explicitLanguage = aExplicitLanguage; params.orientation = aIsVertical ? nsFontMetrics::eVertical : nsFontMetrics::eHorizontal; params.userFontSet = aPresContext->GetUserFontSet(); params.textPerf = aPresContext->GetTextPerfMetrics(); params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup(); RefPtr fm = aPresContext->GetMetricsFor(font, params); return GetNormalLineHeight(fm); } // If we don't have a pres context, use a 1.2em fallback. size.ScaleBy(ReflowInput::kNormalLineHeightFactor); return size.ToAppUnits(); } nscoord ReflowInput::GetLineHeight() const { if (mLineHeight != NS_UNCONSTRAINEDSIZE) { return mLineHeight; } mLineHeight = CalcLineHeight(*mFrame->Style(), mFrame->PresContext(), mFrame->GetContent(), nsLayoutUtils::FontSizeInflationFor(mFrame)); return mLineHeight; } void ReflowInput::SetLineHeight(nscoord aLineHeight) { MOZ_ASSERT(aLineHeight >= 0, "aLineHeight must be >= 0!"); if (mLineHeight != aLineHeight) { mLineHeight = aLineHeight; // Setting used line height can change a frame's block-size if mFrame's // block-size behaves as auto. InitResizeFlags(mFrame->PresContext(), mFrame->Type()); } } /* static */ nscoord ReflowInput::CalcLineHeight(const ComputedStyle& aStyle, nsPresContext* aPresContext, const nsIContent* aContent, float aFontSizeInflation) { const StyleLineHeight& lh = aStyle.StyleFont()->mLineHeight; WritingMode wm(&aStyle); const bool vertical = wm.IsVertical() && !wm.IsSideways(); return CalcLineHeight(lh, *aStyle.StyleFont(), aPresContext, vertical, aContent, aFontSizeInflation); } nscoord ReflowInput::CalcLineHeight(const StyleLineHeight& aLh, const nsStyleFont& aRelativeToFont, nsPresContext* aPresContext, bool aIsVertical, const nsIContent* aContent, float aFontSizeInflation) { nscoord lineHeight = ComputeLineHeight(aLh, aRelativeToFont.mFont, aRelativeToFont.mLanguage, aRelativeToFont.mExplicitLanguage, aPresContext, aIsVertical, aFontSizeInflation); NS_ASSERTION(lineHeight >= 0, "ComputeLineHeight screwed up"); const auto* input = HTMLInputElement::FromNodeOrNull(aContent); if (input && input->IsSingleLineTextControl()) { // For Web-compatibility, single-line text input elements cannot // have a line-height smaller than 'normal'. if (!aLh.IsNormal()) { nscoord normal = ComputeLineHeight( StyleLineHeight::Normal(), aRelativeToFont.mFont, aRelativeToFont.mLanguage, aRelativeToFont.mExplicitLanguage, aPresContext, aIsVertical, aFontSizeInflation); if (lineHeight < normal) { lineHeight = normal; } } } return lineHeight; } nscoord ReflowInput::CalcLineHeightForCanvas(const StyleLineHeight& aLh, const nsFont& aRelativeToFont, nsAtom* aLanguage, bool aExplicitLanguage, nsPresContext* aPresContext, WritingMode aWM) { return ComputeLineHeight(aLh, aRelativeToFont, aLanguage, aExplicitLanguage, aPresContext, aWM.IsVertical() && !aWM.IsSideways(), 1.0f); } bool SizeComputationInput::ComputeMargin(WritingMode aCBWM, nscoord aPercentBasis, LayoutFrameType aFrameType) { // SVG text frames have no margin. if (mFrame->IsInSVGTextSubtree()) { return false; } if (aFrameType == LayoutFrameType::Table) { // Table frame's margin is inherited to the table wrapper frame via the // ::-moz-table-wrapper rule in ua.css, so don't set any margins for it. SetComputedLogicalMargin(mWritingMode, LogicalMargin(mWritingMode)); return false; } // If style style can provide us the margin directly, then use it. const nsStyleMargin* styleMargin = mFrame->StyleMargin(); nsMargin margin; const bool isLayoutDependent = !styleMargin->GetMargin(margin); if (isLayoutDependent) { // We have to compute the value. Note that this calculation is // performed according to the writing mode of the containing block // (http://dev.w3.org/csswg/css-writing-modes-3/#orthogonal-flows) if (aPercentBasis == NS_UNCONSTRAINEDSIZE) { aPercentBasis = 0; } LogicalMargin m(aCBWM); const auto anchorResolutionParams = AnchorPosResolutionParams::From(mFrame, mAnchorPosResolutionCache); for (const LogicalSide side : LogicalSides::All) { m.Side(side, aCBWM) = nsLayoutUtils::ComputeCBDependentValue( aPercentBasis, styleMargin->GetMargin(side, aCBWM, anchorResolutionParams)); } SetComputedLogicalMargin(aCBWM, m); } else { SetComputedLogicalMargin(mWritingMode, LogicalMargin(mWritingMode, margin)); } // ... but font-size-inflation-based margin adjustment uses the // frame's writing mode nscoord marginAdjustment = FontSizeInflationListMarginAdjustment(mFrame); if (marginAdjustment > 0) { LogicalMargin m = ComputedLogicalMargin(mWritingMode); m.IStart(mWritingMode) += marginAdjustment; SetComputedLogicalMargin(mWritingMode, m); } return isLayoutDependent; } bool SizeComputationInput::ComputePadding(WritingMode aCBWM, nscoord aPercentBasis, LayoutFrameType aFrameType) { // If style can provide us the padding directly, then use it. const nsStylePadding* stylePadding = mFrame->StylePadding(); nsMargin padding; bool isCBDependent = !stylePadding->GetPadding(padding); // a table row/col group, row/col doesn't have padding // XXXldb Neither do border-collapse tables. if (LayoutFrameType::TableRowGroup == aFrameType || LayoutFrameType::TableColGroup == aFrameType || LayoutFrameType::TableRow == aFrameType || LayoutFrameType::TableCol == aFrameType) { SetComputedLogicalPadding(mWritingMode, LogicalMargin(mWritingMode)); } else if (isCBDependent) { // We have to compute the value. This calculation is performed // according to the writing mode of the containing block // (http://dev.w3.org/csswg/css-writing-modes-3/#orthogonal-flows) // clamp negative calc() results to 0 if (aPercentBasis == NS_UNCONSTRAINEDSIZE) { aPercentBasis = 0; } LogicalMargin p(aCBWM); for (const LogicalSide side : LogicalSides::All) { p.Side(side, aCBWM) = std::max( 0, nsLayoutUtils::ComputeCBDependentValue( aPercentBasis, stylePadding->mPadding.Get(side, aCBWM))); } SetComputedLogicalPadding(aCBWM, p); } else { SetComputedLogicalPadding(mWritingMode, LogicalMargin(mWritingMode, padding)); } return isCBDependent; } void ReflowInput::ComputeMinMaxValues(const LogicalSize& aCBSize) { WritingMode wm = GetWritingMode(); const auto anchorResolutionParams = AnchorPosResolutionParams::From(this); const auto minISize = mStylePosition->MinISize(wm, anchorResolutionParams); const auto maxISize = mStylePosition->MaxISize(wm, anchorResolutionParams); const auto minBSize = mStylePosition->MinBSize(wm, anchorResolutionParams); const auto maxBSize = mStylePosition->MaxBSize(wm, anchorResolutionParams); LogicalSize minWidgetSize(wm); if (mIsThemed) { nsPresContext* pc = mFrame->PresContext(); const LayoutDeviceIntSize widget = pc->Theme()->GetMinimumWidgetSize( pc, mFrame, mStyleDisplay->EffectiveAppearance()); // Convert themed widget's physical dimensions to logical coords. minWidgetSize = { wm, LayoutDeviceIntSize::ToAppUnits(widget, pc->AppUnitsPerDevPixel())}; // GetMinimumWidgetSize() returns border-box; we need content-box. minWidgetSize -= ComputedLogicalBorderPadding(wm).Size(wm); } // NOTE: min-width:auto resolves to 0, except on a flex item. (But // even there, it's supposed to be ignored (i.e. treated as 0) until // the flex container explicitly resolves & considers it.) if (minISize->IsAuto()) { SetComputedMinISize(0); } else { SetComputedMinISize( ComputeISizeValue(aCBSize, mStylePosition->mBoxSizing, *minISize)); } if (mIsThemed) { SetComputedMinISize(std::max(ComputedMinISize(), minWidgetSize.ISize(wm))); } if (maxISize->IsNone()) { // Specified value of 'none' SetComputedMaxISize(NS_UNCONSTRAINEDSIZE); } else { SetComputedMaxISize( ComputeISizeValue(aCBSize, mStylePosition->mBoxSizing, *maxISize)); } // If the computed value of 'min-width' is greater than the value of // 'max-width', 'max-width' is set to the value of 'min-width' if (ComputedMinISize() > ComputedMaxISize()) { SetComputedMaxISize(ComputedMinISize()); } // Check for percentage based values and a containing block height that // depends on the content height. Treat them like the initial value. // Likewise, check for calc() with percentages on internal table elements; // that's treated as the initial value too. const bool isInternalTableFrame = IsInternalTableFrame(); const nscoord& bPercentageBasis = aCBSize.BSize(wm); auto BSizeBehavesAsInitialValue = [&](const auto& aBSize) { if (nsLayoutUtils::IsAutoBSize(aBSize, bPercentageBasis)) { return true; } if (isInternalTableFrame) { return aBSize.HasLengthAndPercentage(); } return false; }; // NOTE: min-height:auto resolves to 0, except on a flex item. (But // even there, it's supposed to be ignored (i.e. treated as 0) until // the flex container explicitly resolves & considers it.) if (BSizeBehavesAsInitialValue(*minBSize)) { SetComputedMinBSize(0); } else { SetComputedMinBSize(ComputeBSizeValueHandlingStretch( bPercentageBasis, mStylePosition->mBoxSizing, *minBSize)); } if (mIsThemed) { SetComputedMinBSize(std::max(ComputedMinBSize(), minWidgetSize.BSize(wm))); } if (BSizeBehavesAsInitialValue(*maxBSize)) { // Specified value of 'none' SetComputedMaxBSize(NS_UNCONSTRAINEDSIZE); } else { SetComputedMaxBSize(ComputeBSizeValueHandlingStretch( bPercentageBasis, mStylePosition->mBoxSizing, *maxBSize)); } // If the computed value of 'min-height' is greater than the value of // 'max-height', 'max-height' is set to the value of 'min-height' if (ComputedMinBSize() > ComputedMaxBSize()) { SetComputedMaxBSize(ComputedMinBSize()); } } bool ReflowInput::IsInternalTableFrame() const { return mFrame->IsTableRowGroupFrame() || mFrame->IsTableColGroupFrame() || mFrame->IsTableRowFrame() || mFrame->IsTableCellFrame(); }