diff options
Diffstat (limited to 'layout/generic/nsLineLayout.cpp')
| -rw-r--r-- | layout/generic/nsLineLayout.cpp | 3453 |
1 files changed, 3453 insertions, 0 deletions
diff --git a/layout/generic/nsLineLayout.cpp b/layout/generic/nsLineLayout.cpp new file mode 100644 index 0000000000..e072b981b2 --- /dev/null +++ b/layout/generic/nsLineLayout.cpp @@ -0,0 +1,3453 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* state and methods used while laying out a single line of a block frame */ + +#include "nsLineLayout.h" + +#include "mozilla/ComputedStyle.h" +#include "mozilla/SVGTextFrame.h" + +#include "LayoutLogging.h" +#include "nsBlockFrame.h" +#include "nsFontMetrics.h" +#include "nsStyleConsts.h" +#include "nsContainerFrame.h" +#include "nsFloatManager.h" +#include "nsPresContext.h" +#include "nsGkAtoms.h" +#include "nsIContent.h" +#include "nsLayoutUtils.h" +#include "nsTextFrame.h" +#include "nsStyleStructInlines.h" +#include "nsBidiPresUtils.h" +#include "nsRubyFrame.h" +#include "nsRubyTextFrame.h" +#include "RubyUtils.h" +#include <algorithm> + +#ifdef DEBUG +# undef NOISY_INLINEDIR_ALIGN +# undef NOISY_BLOCKDIR_ALIGN +# undef NOISY_REFLOW +# undef REALLY_NOISY_REFLOW +# undef NOISY_PUSHING +# undef REALLY_NOISY_PUSHING +# undef NOISY_CAN_PLACE_FRAME +# undef NOISY_TRIM +# undef REALLY_NOISY_TRIM +#endif + +using namespace mozilla; + +//---------------------------------------------------------------------- + +nsLineLayout::nsLineLayout(nsPresContext* aPresContext, + nsFloatManager* aFloatManager, + const ReflowInput& aLineContainerRI, + const nsLineList::iterator* aLine, + nsLineLayout* aBaseLineLayout) + : mPresContext(aPresContext), + mFloatManager(aFloatManager), + mLineContainerRI(aLineContainerRI), + mBaseLineLayout(aBaseLineLayout), + mLastOptionalBreakFrame(nullptr), + mForceBreakFrame(nullptr), + mLastOptionalBreakPriority(gfxBreakPriority::eNoBreak), + mLastOptionalBreakFrameOffset(-1), + mForceBreakFrameOffset(-1), + mMinLineBSize(0), + mTextIndent(0), + mMaxStartBoxBSize(0), + mMaxEndBoxBSize(0), + mFinalLineBSize(0), + mFirstLetterStyleOK(false), + mIsTopOfPage(false), + mImpactedByFloats(false), + mLastFloatWasLetterFrame(false), + mLineIsEmpty(false), + mLineEndsInBR(false), + mNeedBackup(false), + mInFirstLine(false), + mGotLineBox(false), + mInFirstLetter(false), + mHasMarker(false), + mDirtyNextLine(false), + mLineAtStart(false), + mHasRuby(false), + mSuppressLineWrap(LineContainerFrame()->IsInSVGTextSubtree()) +#ifdef DEBUG + , + mSpansAllocated(0), + mSpansFreed(0), + mFramesAllocated(0), + mFramesFreed(0) +#endif +{ + NS_ASSERTION(aFloatManager || LineContainerFrame()->IsLetterFrame(), + "float manager should be present"); + MOZ_ASSERT( + !!mBaseLineLayout == LineContainerFrame()->IsRubyTextContainerFrame(), + "Only ruby text container frames have a different base line layout"); + MOZ_COUNT_CTOR(nsLineLayout); + + // Stash away some style data that we need + nsBlockFrame* blockFrame = do_QueryFrame(LineContainerFrame()); + mStyleText = blockFrame ? blockFrame->StyleTextForLineLayout() + : LineContainerFrame()->StyleText(); + + mLineNumber = 0; + mTotalPlacedFrames = 0; + mBStartEdge = 0; + mTrimmableISize = 0; + + mInflationMinFontSize = + nsLayoutUtils::InflationMinFontSizeFor(LineContainerFrame()); + + // Instead of always pre-initializing the free-lists for frames and + // spans, we do it on demand so that situations that only use a few + // frames and spans won't waste a lot of time in unneeded + // initialization. + mFrameFreeList = nullptr; + mSpanFreeList = nullptr; + + mCurrentSpan = mRootSpan = nullptr; + mSpanDepth = 0; + + if (aLine) { + mGotLineBox = true; + mLineBox = *aLine; + } +} + +nsLineLayout::~nsLineLayout() { + MOZ_COUNT_DTOR(nsLineLayout); + + NS_ASSERTION(nullptr == mRootSpan, "bad line-layout user"); +} + +// Find out if the frame has a non-null prev-in-flow, i.e., whether it +// is a continuation. +inline bool HasPrevInFlow(nsIFrame* aFrame) { + nsIFrame* prevInFlow = aFrame->GetPrevInFlow(); + return prevInFlow != nullptr; +} + +void nsLineLayout::BeginLineReflow(nscoord aICoord, nscoord aBCoord, + nscoord aISize, nscoord aBSize, + bool aImpactedByFloats, bool aIsTopOfPage, + WritingMode aWritingMode, + const nsSize& aContainerSize) { + NS_ASSERTION(nullptr == mRootSpan, "bad linelayout user"); + LAYOUT_WARN_IF_FALSE(aISize != NS_UNCONSTRAINEDSIZE, + "have unconstrained width; this should only result from " + "very large sizes, not attempts at intrinsic width " + "calculation"); +#ifdef DEBUG + if ((aISize != NS_UNCONSTRAINEDSIZE) && ABSURD_SIZE(aISize) && + !LineContainerFrame()->GetParent()->IsAbsurdSizeAssertSuppressed()) { + LineContainerFrame()->ListTag(stdout); + printf(": Init: bad caller: width WAS %d(0x%x)\n", aISize, aISize); + } + if ((aBSize != NS_UNCONSTRAINEDSIZE) && ABSURD_SIZE(aBSize) && + !LineContainerFrame()->GetParent()->IsAbsurdSizeAssertSuppressed()) { + LineContainerFrame()->ListTag(stdout); + printf(": Init: bad caller: height WAS %d(0x%x)\n", aBSize, aBSize); + } +#endif +#ifdef NOISY_REFLOW + LineContainerFrame()->ListTag(stdout); + printf(": BeginLineReflow: %d,%d,%d,%d impacted=%s %s\n", aICoord, aBCoord, + aISize, aBSize, aImpactedByFloats ? "true" : "false", + aIsTopOfPage ? "top-of-page" : ""); +#endif +#ifdef DEBUG + mSpansAllocated = mSpansFreed = mFramesAllocated = mFramesFreed = 0; +#endif + + mFirstLetterStyleOK = false; + mIsTopOfPage = aIsTopOfPage; + mImpactedByFloats = aImpactedByFloats; + mTotalPlacedFrames = 0; + if (!mBaseLineLayout) { + mLineIsEmpty = true; + mLineAtStart = true; + } else { + mLineIsEmpty = false; + mLineAtStart = false; + } + mLineEndsInBR = false; + mSpanDepth = 0; + mMaxStartBoxBSize = mMaxEndBoxBSize = 0; + + if (mGotLineBox) { + mLineBox->ClearHasMarker(); + } + + PerSpanData* psd = NewPerSpanData(); + mCurrentSpan = mRootSpan = psd; + psd->mReflowInput = &mLineContainerRI; + psd->mIStart = aICoord; + psd->mICoord = aICoord; + psd->mIEnd = aICoord + aISize; + mContainerSize = aContainerSize; + + mBStartEdge = aBCoord; + + psd->mNoWrap = !mStyleText->WhiteSpaceCanWrapStyle() || mSuppressLineWrap; + psd->mWritingMode = aWritingMode; + + // If this is the first line of a block then see if the text-indent + // property amounts to anything. + + if (0 == mLineNumber && !HasPrevInFlow(LineContainerFrame())) { + nscoord pctBasis = mLineContainerRI.ComputedISize(); + mTextIndent = mStyleText->mTextIndent.Resolve(pctBasis); + psd->mICoord += mTextIndent; + } + + PerFrameData* pfd = NewPerFrameData(LineContainerFrame()); + pfd->mAscent = 0; + pfd->mSpan = psd; + psd->mFrame = pfd; + nsIFrame* frame = LineContainerFrame(); + if (frame->IsRubyTextContainerFrame()) { + // Ruby text container won't be reflowed via ReflowFrame, hence the + // relative positioning information should be recorded here. + MOZ_ASSERT(mBaseLineLayout != this); + pfd->mIsRelativelyOrStickyPos = + mLineContainerRI.mStyleDisplay->IsRelativelyOrStickyPositionedStyle(); + if (pfd->mIsRelativelyOrStickyPos) { + MOZ_ASSERT(mLineContainerRI.GetWritingMode() == pfd->mWritingMode, + "mLineContainerRI.frame == frame, " + "hence they should have identical writing mode"); + pfd->mOffsets = + mLineContainerRI.ComputedLogicalOffsets(pfd->mWritingMode); + } + } +} + +void nsLineLayout::EndLineReflow() { +#ifdef NOISY_REFLOW + LineContainerFrame()->ListTag(stdout); + printf(": EndLineReflow: width=%d\n", + mRootSpan->mICoord - mRootSpan->mIStart); +#endif + + NS_ASSERTION(!mBaseLineLayout || + (!mSpansAllocated && !mSpansFreed && !mSpanFreeList && + !mFramesAllocated && !mFramesFreed && !mFrameFreeList), + "Allocated frames or spans on non-base line layout?"); + MOZ_ASSERT(mRootSpan == mCurrentSpan); + + UnlinkFrame(mRootSpan->mFrame); + mCurrentSpan = mRootSpan = nullptr; + + NS_ASSERTION(mSpansAllocated == mSpansFreed, "leak"); + NS_ASSERTION(mFramesAllocated == mFramesFreed, "leak"); + +#if 0 + static int32_t maxSpansAllocated = NS_LINELAYOUT_NUM_SPANS; + static int32_t maxFramesAllocated = NS_LINELAYOUT_NUM_FRAMES; + if (mSpansAllocated > maxSpansAllocated) { + printf("XXX: saw a line with %d spans\n", mSpansAllocated); + maxSpansAllocated = mSpansAllocated; + } + if (mFramesAllocated > maxFramesAllocated) { + printf("XXX: saw a line with %d frames\n", mFramesAllocated); + maxFramesAllocated = mFramesAllocated; + } +#endif +} + +// XXX swtich to a single mAvailLineWidth that we adjust as each frame +// on the line is placed. Each span can still have a per-span mICoord that +// tracks where a child frame is going in its span; they don't need a +// per-span mIStart? + +void nsLineLayout::UpdateBand(WritingMode aWM, + const LogicalRect& aNewAvailSpace, + nsIFrame* aFloatFrame) { + WritingMode lineWM = mRootSpan->mWritingMode; + // need to convert to our writing mode, because we might have a different + // mode from the caller due to dir: auto + LogicalRect availSpace = + aNewAvailSpace.ConvertTo(lineWM, aWM, ContainerSize()); +#ifdef REALLY_NOISY_REFLOW + printf( + "nsLL::UpdateBand %d, %d, %d, %d, (converted to %d, %d, %d, %d); " + "frame=%p\n will set mImpacted to true\n", + aNewAvailSpace.IStart(aWM), aNewAvailSpace.BStart(aWM), + aNewAvailSpace.ISize(aWM), aNewAvailSpace.BSize(aWM), + availSpace.IStart(lineWM), availSpace.BStart(lineWM), + availSpace.ISize(lineWM), availSpace.BSize(lineWM), aFloatFrame); +#endif +#ifdef DEBUG + if ((availSpace.ISize(lineWM) != NS_UNCONSTRAINEDSIZE) && + ABSURD_SIZE(availSpace.ISize(lineWM)) && + !LineContainerFrame()->GetParent()->IsAbsurdSizeAssertSuppressed()) { + LineContainerFrame()->ListTag(stdout); + printf(": UpdateBand: bad caller: ISize WAS %d(0x%x)\n", + availSpace.ISize(lineWM), availSpace.ISize(lineWM)); + } + if ((availSpace.BSize(lineWM) != NS_UNCONSTRAINEDSIZE) && + ABSURD_SIZE(availSpace.BSize(lineWM)) && + !LineContainerFrame()->GetParent()->IsAbsurdSizeAssertSuppressed()) { + LineContainerFrame()->ListTag(stdout); + printf(": UpdateBand: bad caller: BSize WAS %d(0x%x)\n", + availSpace.BSize(lineWM), availSpace.BSize(lineWM)); + } +#endif + + // Compute the difference between last times width and the new width + NS_WARNING_ASSERTION( + mRootSpan->mIEnd != NS_UNCONSTRAINEDSIZE && + availSpace.ISize(lineWM) != NS_UNCONSTRAINEDSIZE, + "have unconstrained inline size; this should only result from very large " + "sizes, not attempts at intrinsic width calculation"); + // The root span's mIStart moves to aICoord + nscoord deltaICoord = availSpace.IStart(lineWM) - mRootSpan->mIStart; + // The inline size of all spans changes by this much (the root span's + // mIEnd moves to aICoord + aISize, its new inline size is aISize) + nscoord deltaISize = + availSpace.ISize(lineWM) - (mRootSpan->mIEnd - mRootSpan->mIStart); +#ifdef NOISY_REFLOW + LineContainerFrame()->ListTag(stdout); + printf(": UpdateBand: %d,%d,%d,%d deltaISize=%d deltaICoord=%d\n", + availSpace.IStart(lineWM), availSpace.BStart(lineWM), + availSpace.ISize(lineWM), availSpace.BSize(lineWM), deltaISize, + deltaICoord); +#endif + + // Update the root span position + mRootSpan->mIStart += deltaICoord; + mRootSpan->mIEnd += deltaICoord; + mRootSpan->mICoord += deltaICoord; + + // Now update the right edges of the open spans to account for any + // change in available space width + for (PerSpanData* psd = mCurrentSpan; psd; psd = psd->mParent) { + psd->mIEnd += deltaISize; + psd->mContainsFloat = true; +#ifdef NOISY_REFLOW + printf(" span %p: oldIEnd=%d newIEnd=%d\n", psd, psd->mIEnd - deltaISize, + psd->mIEnd); +#endif + } + NS_ASSERTION(mRootSpan->mContainsFloat && + mRootSpan->mIStart == availSpace.IStart(lineWM) && + mRootSpan->mIEnd == availSpace.IEnd(lineWM), + "root span was updated incorrectly?"); + + // Update frame bounds + // Note: Only adjust the outermost frames (the ones that are direct + // children of the block), not the ones in the child spans. The reason + // is simple: the frames in the spans have coordinates local to their + // parent therefore they are moved when their parent span is moved. + if (deltaICoord != 0) { + for (PerFrameData* pfd = mRootSpan->mFirstFrame; pfd; pfd = pfd->mNext) { + pfd->mBounds.IStart(lineWM) += deltaICoord; + } + } + + mBStartEdge = availSpace.BStart(lineWM); + mImpactedByFloats = true; + + mLastFloatWasLetterFrame = aFloatFrame->IsLetterFrame(); +} + +nsLineLayout::PerSpanData* nsLineLayout::NewPerSpanData() { + nsLineLayout* outerLineLayout = GetOutermostLineLayout(); + PerSpanData* psd = outerLineLayout->mSpanFreeList; + if (!psd) { + void* mem = outerLineLayout->mArena.Allocate(sizeof(PerSpanData)); + psd = reinterpret_cast<PerSpanData*>(mem); + } else { + outerLineLayout->mSpanFreeList = psd->mNextFreeSpan; + } + psd->mParent = nullptr; + psd->mFrame = nullptr; + psd->mFirstFrame = nullptr; + psd->mLastFrame = nullptr; + psd->mContainsFloat = false; + psd->mHasNonemptyContent = false; + +#ifdef DEBUG + outerLineLayout->mSpansAllocated++; +#endif + return psd; +} + +void nsLineLayout::BeginSpan(nsIFrame* aFrame, + const ReflowInput* aSpanReflowInput, + nscoord aIStart, nscoord aIEnd, + nscoord* aBaseline) { + NS_ASSERTION(aIEnd != NS_UNCONSTRAINEDSIZE, + "should no longer be using unconstrained sizes"); +#ifdef NOISY_REFLOW + nsIFrame::IndentBy(stdout, mSpanDepth + 1); + aFrame->ListTag(stdout); + printf(": BeginSpan leftEdge=%d rightEdge=%d\n", aIStart, aIEnd); +#endif + + PerSpanData* psd = NewPerSpanData(); + // Link up span frame's pfd to point to its child span data + PerFrameData* pfd = mCurrentSpan->mLastFrame; + NS_ASSERTION(pfd->mFrame == aFrame, "huh?"); + pfd->mSpan = psd; + + // Init new span + psd->mFrame = pfd; + psd->mParent = mCurrentSpan; + psd->mReflowInput = aSpanReflowInput; + psd->mIStart = aIStart; + psd->mICoord = aIStart; + psd->mIEnd = aIEnd; + psd->mBaseline = aBaseline; + + nsIFrame* frame = aSpanReflowInput->mFrame; + psd->mNoWrap = !frame->StyleText()->WhiteSpaceCanWrap(frame) || + mSuppressLineWrap || frame->Style()->ShouldSuppressLineBreak(); + psd->mWritingMode = aSpanReflowInput->GetWritingMode(); + + // Switch to new span + mCurrentSpan = psd; + mSpanDepth++; +} + +nscoord nsLineLayout::EndSpan(nsIFrame* aFrame) { + NS_ASSERTION(mSpanDepth > 0, "end-span without begin-span"); +#ifdef NOISY_REFLOW + nsIFrame::IndentBy(stdout, mSpanDepth); + aFrame->ListTag(stdout); + printf(": EndSpan width=%d\n", mCurrentSpan->mICoord - mCurrentSpan->mIStart); +#endif + PerSpanData* psd = mCurrentSpan; + MOZ_ASSERT(psd->mParent, "We never call this on the root"); + + if (psd->mNoWrap && !psd->mParent->mNoWrap) { + FlushNoWrapFloats(); + } + + nscoord iSizeResult = psd->mLastFrame ? (psd->mICoord - psd->mIStart) : 0; + + mSpanDepth--; + mCurrentSpan->mReflowInput = nullptr; // no longer valid so null it out! + mCurrentSpan = mCurrentSpan->mParent; + return iSizeResult; +} + +void nsLineLayout::AttachFrameToBaseLineLayout(PerFrameData* aFrame) { + MOZ_ASSERT(mBaseLineLayout, + "This method must not be called in a base line layout."); + + PerFrameData* baseFrame = mBaseLineLayout->LastFrame(); + MOZ_ASSERT(aFrame && baseFrame); + MOZ_ASSERT(!aFrame->mIsLinkedToBase, + "The frame must not have been linked with the base"); +#ifdef DEBUG + LayoutFrameType baseType = baseFrame->mFrame->Type(); + LayoutFrameType annotationType = aFrame->mFrame->Type(); + MOZ_ASSERT((baseType == LayoutFrameType::RubyBaseContainer && + annotationType == LayoutFrameType::RubyTextContainer) || + (baseType == LayoutFrameType::RubyBase && + annotationType == LayoutFrameType::RubyText)); +#endif + + aFrame->mNextAnnotation = baseFrame->mNextAnnotation; + baseFrame->mNextAnnotation = aFrame; + aFrame->mIsLinkedToBase = true; +} + +int32_t nsLineLayout::GetCurrentSpanCount() const { + NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user"); + int32_t count = 0; + PerFrameData* pfd = mRootSpan->mFirstFrame; + while (nullptr != pfd) { + count++; + pfd = pfd->mNext; + } + return count; +} + +void nsLineLayout::SplitLineTo(int32_t aNewCount) { + NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user"); + +#ifdef REALLY_NOISY_PUSHING + printf("SplitLineTo %d (current count=%d); before:\n", aNewCount, + GetCurrentSpanCount()); + DumpPerSpanData(mRootSpan, 1); +#endif + PerSpanData* psd = mRootSpan; + PerFrameData* pfd = psd->mFirstFrame; + while (nullptr != pfd) { + if (--aNewCount == 0) { + // Truncate list at pfd (we keep pfd, but anything following is freed) + PerFrameData* next = pfd->mNext; + pfd->mNext = nullptr; + psd->mLastFrame = pfd; + + // Now unlink all of the frames following pfd + UnlinkFrame(next); + break; + } + pfd = pfd->mNext; + } +#ifdef NOISY_PUSHING + printf("SplitLineTo %d (current count=%d); after:\n", aNewCount, + GetCurrentSpanCount()); + DumpPerSpanData(mRootSpan, 1); +#endif +} + +void nsLineLayout::PushFrame(nsIFrame* aFrame) { + PerSpanData* psd = mCurrentSpan; + NS_ASSERTION(psd->mLastFrame->mFrame == aFrame, "pushing non-last frame"); + +#ifdef REALLY_NOISY_PUSHING + nsIFrame::IndentBy(stdout, mSpanDepth); + printf("PushFrame %p, before:\n", psd); + DumpPerSpanData(psd, 1); +#endif + + // Take the last frame off of the span's frame list + PerFrameData* pfd = psd->mLastFrame; + if (pfd == psd->mFirstFrame) { + // We are pushing away the only frame...empty the list + psd->mFirstFrame = nullptr; + psd->mLastFrame = nullptr; + } else { + PerFrameData* prevFrame = pfd->mPrev; + prevFrame->mNext = nullptr; + psd->mLastFrame = prevFrame; + } + + // Now unlink the frame + MOZ_ASSERT(!pfd->mNext); + UnlinkFrame(pfd); +#ifdef NOISY_PUSHING + nsIFrame::IndentBy(stdout, mSpanDepth); + printf("PushFrame: %p after:\n", psd); + DumpPerSpanData(psd, 1); +#endif +} + +void nsLineLayout::UnlinkFrame(PerFrameData* pfd) { + while (nullptr != pfd) { + PerFrameData* next = pfd->mNext; + if (pfd->mIsLinkedToBase) { + // This frame is linked to a ruby base, and should not be freed + // now. Just unlink it from the span. It will be freed when its + // base frame gets unlinked. + pfd->mNext = pfd->mPrev = nullptr; + pfd = next; + continue; + } + + // It is a ruby base frame. If there are any annotations + // linked to this frame, free them first. + PerFrameData* annotationPFD = pfd->mNextAnnotation; + while (annotationPFD) { + PerFrameData* nextAnnotation = annotationPFD->mNextAnnotation; + MOZ_ASSERT( + annotationPFD->mNext == nullptr && annotationPFD->mPrev == nullptr, + "PFD in annotations should have been unlinked."); + FreeFrame(annotationPFD); + annotationPFD = nextAnnotation; + } + + FreeFrame(pfd); + pfd = next; + } +} + +void nsLineLayout::FreeFrame(PerFrameData* pfd) { + if (nullptr != pfd->mSpan) { + FreeSpan(pfd->mSpan); + } + nsLineLayout* outerLineLayout = GetOutermostLineLayout(); + pfd->mNext = outerLineLayout->mFrameFreeList; + outerLineLayout->mFrameFreeList = pfd; +#ifdef DEBUG + outerLineLayout->mFramesFreed++; +#endif +} + +void nsLineLayout::FreeSpan(PerSpanData* psd) { + // Unlink its frames + UnlinkFrame(psd->mFirstFrame); + + nsLineLayout* outerLineLayout = GetOutermostLineLayout(); + // Now put the span on the free list since it's free too + psd->mNextFreeSpan = outerLineLayout->mSpanFreeList; + outerLineLayout->mSpanFreeList = psd; +#ifdef DEBUG + outerLineLayout->mSpansFreed++; +#endif +} + +bool nsLineLayout::IsZeroBSize() { + PerSpanData* psd = mCurrentSpan; + PerFrameData* pfd = psd->mFirstFrame; + while (nullptr != pfd) { + if (0 != pfd->mBounds.BSize(psd->mWritingMode)) { + return false; + } + pfd = pfd->mNext; + } + return true; +} + +nsLineLayout::PerFrameData* nsLineLayout::NewPerFrameData(nsIFrame* aFrame) { + nsLineLayout* outerLineLayout = GetOutermostLineLayout(); + PerFrameData* pfd = outerLineLayout->mFrameFreeList; + if (!pfd) { + void* mem = outerLineLayout->mArena.Allocate(sizeof(PerFrameData)); + pfd = reinterpret_cast<PerFrameData*>(mem); + } else { + outerLineLayout->mFrameFreeList = pfd->mNext; + } + pfd->mSpan = nullptr; + pfd->mNext = nullptr; + pfd->mPrev = nullptr; + pfd->mNextAnnotation = nullptr; + pfd->mFrame = aFrame; + + // all flags default to false + pfd->mIsRelativelyOrStickyPos = false; + pfd->mIsTextFrame = false; + pfd->mIsNonEmptyTextFrame = false; + pfd->mIsNonWhitespaceTextFrame = false; + pfd->mIsLetterFrame = false; + pfd->mRecomputeOverflow = false; + pfd->mIsMarker = false; + pfd->mSkipWhenTrimmingWhitespace = false; + pfd->mIsEmpty = false; + pfd->mIsPlaceholder = false; + pfd->mIsLinkedToBase = false; + + pfd->mWritingMode = aFrame->GetWritingMode(); + WritingMode lineWM = mRootSpan->mWritingMode; + pfd->mBounds = LogicalRect(lineWM); + pfd->mOverflowAreas.Clear(); + pfd->mMargin = LogicalMargin(lineWM); + pfd->mBorderPadding = LogicalMargin(lineWM); + pfd->mOffsets = LogicalMargin(pfd->mWritingMode); + + pfd->mJustificationInfo = JustificationInfo(); + pfd->mJustificationAssignment = JustificationAssignment(); + +#ifdef DEBUG + pfd->mBlockDirAlign = 0xFF; + outerLineLayout->mFramesAllocated++; +#endif + return pfd; +} + +bool nsLineLayout::LineIsBreakable() const { + // XXX mTotalPlacedFrames should go away and we should just use + // mLineIsEmpty here instead + if ((0 != mTotalPlacedFrames) || mImpactedByFloats) { + return true; + } + return false; +} + +// Checks all four sides for percentage units. This means it should +// only be used for things (margin, padding) where percentages on top +// and bottom depend on the *width* just like percentages on left and +// right. +template <typename T> +static bool HasPercentageUnitSide(const StyleRect<T>& aSides) { + return aSides.Any([](const auto& aLength) { return aLength.HasPercent(); }); +} + +static bool IsPercentageAware(const nsIFrame* aFrame, WritingMode aWM) { + NS_ASSERTION(aFrame, "null frame is not allowed"); + + LayoutFrameType fType = aFrame->Type(); + if (fType == LayoutFrameType::Text) { + // None of these things can ever be true for text frames. + return false; + } + + // Some of these things don't apply to non-replaced inline frames + // (that is, fType == LayoutFrameType::Inline), but we won't bother making + // things unnecessarily complicated, since they'll probably be set + // quite rarely. + + const nsStyleMargin* margin = aFrame->StyleMargin(); + if (HasPercentageUnitSide(margin->mMargin)) { + return true; + } + + const nsStylePadding* padding = aFrame->StylePadding(); + if (HasPercentageUnitSide(padding->mPadding)) { + return true; + } + + // Note that borders can't be aware of percentages + + const nsStylePosition* pos = aFrame->StylePosition(); + + if ((pos->ISizeDependsOnContainer(aWM) && !pos->ISize(aWM).IsAuto()) || + pos->MaxISizeDependsOnContainer(aWM) || + pos->MinISizeDependsOnContainer(aWM) || + pos->mOffset.GetIStart(aWM).HasPercent() || + pos->mOffset.GetIEnd(aWM).HasPercent()) { + return true; + } + + if (pos->ISize(aWM).IsAuto()) { + // We need to check for frames that shrink-wrap when they're auto + // width. + const nsStyleDisplay* disp = aFrame->StyleDisplay(); + if ((disp->DisplayOutside() == StyleDisplayOutside::Inline && + (disp->DisplayInside() == StyleDisplayInside::FlowRoot || + disp->DisplayInside() == StyleDisplayInside::Table)) || + fType == LayoutFrameType::HTMLButtonControl || + fType == LayoutFrameType::GfxButtonControl || + fType == LayoutFrameType::FieldSet || + fType == LayoutFrameType::ComboboxDisplay) { + return true; + } + + // Per CSS 2.1, section 10.3.2: + // If 'height' and 'width' both have computed values of 'auto' and + // the element has an intrinsic ratio but no intrinsic height or + // width and the containing block's width does not itself depend + // on the replaced element's width, then the used value of 'width' + // is calculated from the constraint equation used for + // block-level, non-replaced elements in normal flow. + nsIFrame* f = const_cast<nsIFrame*>(aFrame); + if (f->GetAspectRatio() && + // Some percents are treated like 'auto', so check != coord + !pos->BSize(aWM).ConvertsToLength()) { + const IntrinsicSize& intrinsicSize = f->GetIntrinsicSize(); + if (!intrinsicSize.width && !intrinsicSize.height) { + return true; + } + } + } + + return false; +} + +void nsLineLayout::ReflowFrame(nsIFrame* aFrame, nsReflowStatus& aReflowStatus, + ReflowOutput* aMetrics, bool& aPushedFrame) { + // Initialize OUT parameter + aPushedFrame = false; + + PerFrameData* pfd = NewPerFrameData(aFrame); + PerSpanData* psd = mCurrentSpan; + psd->AppendFrame(pfd); + +#ifdef REALLY_NOISY_REFLOW + nsIFrame::IndentBy(stdout, mSpanDepth); + printf("%p: Begin ReflowFrame pfd=%p ", psd, pfd); + aFrame->ListTag(stdout); + printf("\n"); +#endif + + if (mCurrentSpan == mRootSpan) { + pfd->mFrame->RemoveProperty(nsIFrame::LineBaselineOffset()); + } else { +#ifdef DEBUG + bool hasLineOffset; + pfd->mFrame->GetProperty(nsIFrame::LineBaselineOffset(), &hasLineOffset); + NS_ASSERTION(!hasLineOffset, + "LineBaselineOffset was set but was not expected"); +#endif + } + + mJustificationInfo = JustificationInfo(); + + // Stash copies of some of the computed state away for later + // (block-direction alignment, for example) + WritingMode frameWM = pfd->mWritingMode; + WritingMode lineWM = mRootSpan->mWritingMode; + + // NOTE: While the inline direction coordinate remains relative to the + // parent span, the block direction coordinate is fixed at the top + // edge for the line. During VerticalAlignFrames we will repair this + // so that the block direction coordinate is properly set and relative + // to the appropriate span. + pfd->mBounds.IStart(lineWM) = psd->mICoord; + pfd->mBounds.BStart(lineWM) = mBStartEdge; + + // We want to guarantee that we always make progress when + // formatting. Therefore, if the object being placed on the line is + // too big for the line, but it is the only thing on the line and is not + // impacted by a float, then we go ahead and place it anyway. (If the line + // is impacted by one or more floats, then it is safe to break because + // we can move the line down below float(s).) + // + // Capture this state *before* we reflow the frame in case it clears + // the state out. We need to know how to treat the current frame + // when breaking. + bool notSafeToBreak = LineIsEmpty() && !mImpactedByFloats; + + // Figure out whether we're talking about a textframe here + LayoutFrameType frameType = aFrame->Type(); + const bool isText = frameType == LayoutFrameType::Text; + + // Inline-ish and text-ish things don't compute their width; + // everything else does. We need to give them an available width that + // reflects the space left on the line. + LAYOUT_WARN_IF_FALSE(psd->mIEnd != NS_UNCONSTRAINEDSIZE, + "have unconstrained width; this should only result from " + "very large sizes, not attempts at intrinsic width " + "calculation"); + nscoord availableSpaceOnLine = psd->mIEnd - psd->mICoord; + + // Setup reflow input for reflowing the frame + Maybe<ReflowInput> reflowInputHolder; + if (!isText) { + // Compute the available size for the frame. This available width + // includes room for the side margins. + // For now, set the available block-size to unconstrained always. + LogicalSize availSize = mLineContainerRI.ComputedSize(frameWM); + availSize.BSize(frameWM) = NS_UNCONSTRAINEDSIZE; + reflowInputHolder.emplace(mPresContext, *psd->mReflowInput, aFrame, + availSize); + ReflowInput& reflowInput = *reflowInputHolder; + reflowInput.mLineLayout = this; + reflowInput.mFlags.mIsTopOfPage = mIsTopOfPage; + if (reflowInput.ComputedISize() == NS_UNCONSTRAINEDSIZE) { + reflowInput.SetAvailableISize(availableSpaceOnLine); + } + pfd->mMargin = reflowInput.ComputedLogicalMargin(lineWM); + pfd->mBorderPadding = reflowInput.ComputedLogicalBorderPadding(lineWM); + pfd->mIsRelativelyOrStickyPos = + reflowInput.mStyleDisplay->IsRelativelyOrStickyPositionedStyle(); + if (pfd->mIsRelativelyOrStickyPos) { + pfd->mOffsets = reflowInput.ComputedLogicalOffsets(frameWM); + } + + // Calculate whether the the frame should have a start margin and + // subtract the margin from the available width if necessary. + // The margin will be applied to the starting inline coordinates of + // the frame in CanPlaceFrame() after reflowing the frame. + AllowForStartMargin(pfd, reflowInput); + } + // if isText(), no need to propagate NS_FRAME_IS_DIRTY from the parent, + // because reflow doesn't look at the dirty bits on the frame being reflowed. + + // See if this frame depends on the inline-size of its containing block. + // If so, disable resize reflow optimizations for the line. (Note that, + // to be conservative, we do this if we *try* to fit a frame on a + // line, even if we don't succeed.) (Note also that we can only make + // this IsPercentageAware check *after* we've constructed our + // ReflowInput, because that construction may be what forces aFrame + // to lazily initialize its (possibly-percent-valued) intrinsic size.) + if (mGotLineBox && IsPercentageAware(aFrame, lineWM)) { + mLineBox->DisableResizeReflowOptimization(); + } + + // Note that we don't bother positioning the frame yet, because we're probably + // going to end up moving it when we do the block-direction alignment. + + // Adjust float manager coordinate system for the frame. + ReflowOutput reflowOutput(lineWM); +#ifdef DEBUG + reflowOutput.ISize(lineWM) = nscoord(0xdeadbeef); + reflowOutput.BSize(lineWM) = nscoord(0xdeadbeef); +#endif + nscoord tI = pfd->mBounds.LineLeft(lineWM, ContainerSize()); + nscoord tB = pfd->mBounds.BStart(lineWM); + mFloatManager->Translate(tI, tB); + + int32_t savedOptionalBreakOffset; + gfxBreakPriority savedOptionalBreakPriority; + nsIFrame* savedOptionalBreakFrame = GetLastOptionalBreakPosition( + &savedOptionalBreakOffset, &savedOptionalBreakPriority); + + if (!isText) { + aFrame->Reflow(mPresContext, reflowOutput, *reflowInputHolder, + aReflowStatus); + } else { + static_cast<nsTextFrame*>(aFrame)->ReflowText( + *this, availableSpaceOnLine, + psd->mReflowInput->mRenderingContext->GetDrawTarget(), reflowOutput, + aReflowStatus); + } + + pfd->mJustificationInfo = mJustificationInfo; + mJustificationInfo = JustificationInfo(); + + // See if the frame is a placeholderFrame and if it is process + // the float. At the same time, check if the frame has any non-collapsed-away + // content. + bool placedFloat = false; + bool isEmpty; + if (frameType == LayoutFrameType::None) { + isEmpty = pfd->mFrame->IsEmpty(); + } else if (LayoutFrameType::Placeholder == frameType) { + isEmpty = true; + pfd->mIsPlaceholder = true; + pfd->mSkipWhenTrimmingWhitespace = true; + nsIFrame* outOfFlowFrame = nsLayoutUtils::GetFloatFromPlaceholder(aFrame); + if (outOfFlowFrame) { + if (psd->mNoWrap && + // We can always place floats in an empty line. + !LineIsEmpty() && + // We always place floating letter frames. This kinda sucks. They'd + // usually fall into the LineIsEmpty() check anyway, except when + // there's something like a ::marker before or what not. We actually + // need to place them now, because they're pretty nasty and they + // create continuations that are in flow and not a kid of the + // previous continuation's parent. We don't want the deferred reflow + // of the letter frame to kill a continuation after we've stored it + // in the line layout data structures. See bug 1490281 to fix the + // underlying issue. When that's fixed this check should be removed. + !outOfFlowFrame->IsLetterFrame() && + !GetOutermostLineLayout()->mBlockRS->mFlags.mCanHaveOverflowMarkers) { + // We'll do this at the next break opportunity. + RecordNoWrapFloat(outOfFlowFrame); + } else { + placedFloat = TryToPlaceFloat(outOfFlowFrame); + } + } + } else if (isText) { + // Note non-empty text-frames for inline frame compatibility hackery + pfd->mIsTextFrame = true; + auto* textFrame = static_cast<nsTextFrame*>(pfd->mFrame); + isEmpty = !textFrame->HasNoncollapsedCharacters(); + if (!isEmpty) { + pfd->mIsNonEmptyTextFrame = true; + pfd->mIsNonWhitespaceTextFrame = + !textFrame->GetContent()->TextIsOnlyWhitespace(); + } + } else if (LayoutFrameType::Br == frameType) { + pfd->mSkipWhenTrimmingWhitespace = true; + isEmpty = false; + } else { + if (LayoutFrameType::Letter == frameType) { + pfd->mIsLetterFrame = true; + } + if (pfd->mSpan) { + isEmpty = !pfd->mSpan->mHasNonemptyContent && pfd->mFrame->IsSelfEmpty(); + } else { + isEmpty = pfd->mFrame->IsEmpty(); + } + } + pfd->mIsEmpty = isEmpty; + + mFloatManager->Translate(-tI, -tB); + + NS_ASSERTION(reflowOutput.ISize(lineWM) >= 0, "bad inline size"); + NS_ASSERTION(reflowOutput.BSize(lineWM) >= 0, "bad block size"); + if (reflowOutput.ISize(lineWM) < 0) { + reflowOutput.ISize(lineWM) = 0; + } + if (reflowOutput.BSize(lineWM) < 0) { + reflowOutput.BSize(lineWM) = 0; + } + +#ifdef DEBUG + // Note: break-before means ignore the reflow metrics since the + // frame will be reflowed another time. + if (!aReflowStatus.IsInlineBreakBefore()) { + if ((ABSURD_SIZE(reflowOutput.ISize(lineWM)) || + ABSURD_SIZE(reflowOutput.BSize(lineWM))) && + !LineContainerFrame()->GetParent()->IsAbsurdSizeAssertSuppressed()) { + printf("nsLineLayout: "); + aFrame->ListTag(stdout); + printf(" metrics=%d,%d!\n", reflowOutput.Width(), reflowOutput.Height()); + } + if ((reflowOutput.Width() == nscoord(0xdeadbeef)) || + (reflowOutput.Height() == nscoord(0xdeadbeef))) { + printf("nsLineLayout: "); + aFrame->ListTag(stdout); + printf(" didn't set w/h %d,%d!\n", reflowOutput.Width(), + reflowOutput.Height()); + } + } +#endif + + // Unlike with non-inline reflow, the overflow area here does *not* + // include the accumulation of the frame's bounds and its inline + // descendants' bounds. Nor does it include the outline area; it's + // just the union of the bounds of any absolute children. That is + // added in later by nsLineLayout::ReflowInlineFrames. + pfd->mOverflowAreas = reflowOutput.mOverflowAreas; + + pfd->mBounds.ISize(lineWM) = reflowOutput.ISize(lineWM); + pfd->mBounds.BSize(lineWM) = reflowOutput.BSize(lineWM); + + // Size the frame, but |RelativePositionFrames| will size the view. + aFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd)); + + // Tell the frame that we're done reflowing it + aFrame->DidReflow(mPresContext, isText ? nullptr : reflowInputHolder.ptr()); + + if (aMetrics) { + *aMetrics = reflowOutput; + } + + if (!aReflowStatus.IsInlineBreakBefore()) { + // If frame is complete and has a next-in-flow, we need to delete + // them now. Do not do this when a break-before is signaled because + // the frame is going to get reflowed again (and may end up wanting + // a next-in-flow where it ends up). + if (aReflowStatus.IsComplete()) { + if (nsIFrame* kidNextInFlow = aFrame->GetNextInFlow()) { + // Remove all of the childs next-in-flows. Make sure that we ask + // the right parent to do the removal (it's possible that the + // parent is not this because we are executing pullup code) + FrameDestroyContext context(aFrame->PresShell()); + kidNextInFlow->GetParent()->DeleteNextInFlowChild(context, + kidNextInFlow, true); + } + } + + // Check whether this frame breaks up text runs. All frames break up text + // runs (hence return false here) except for text frames and inline + // containers. + bool continuingTextRun = aFrame->CanContinueTextRun(); + + // Clear any residual mTrimmableISize if this isn't a text frame + if (!continuingTextRun && !pfd->mSkipWhenTrimmingWhitespace) { + mTrimmableISize = 0; + } + + // See if we can place the frame. If we can't fit it, then we + // return now. + bool optionalBreakAfterFits; + NS_ASSERTION(isText || !reflowInputHolder->mStyleDisplay->IsFloating( + reflowInputHolder->mFrame), + "How'd we get a floated inline frame? " + "The frame ctor should've dealt with this."); + if (CanPlaceFrame(pfd, notSafeToBreak, continuingTextRun, + savedOptionalBreakFrame != nullptr, reflowOutput, + aReflowStatus, &optionalBreakAfterFits)) { + if (!isEmpty) { + psd->mHasNonemptyContent = true; + mLineIsEmpty = false; + if (!pfd->mSpan) { + // nonempty leaf content has been placed + mLineAtStart = false; + } + if (LayoutFrameType::Ruby == frameType) { + mHasRuby = true; + SyncAnnotationBounds(pfd); + } + } + + // Place the frame, updating aBounds with the final size and + // location. Then apply the bottom+right margins (as + // appropriate) to the frame. + PlaceFrame(pfd, reflowOutput); + PerSpanData* span = pfd->mSpan; + if (span) { + // The frame we just finished reflowing is an inline + // container. It needs its child frames aligned in the block direction, + // so do most of it now. + VerticalAlignFrames(span); + } + + if (!continuingTextRun && !psd->mNoWrap) { + if (!LineIsEmpty() || placedFloat) { + // record soft break opportunity after this content that can't be + // part of a text run. This is not a text frame so we know + // that offset INT32_MAX means "after the content". + if ((!aFrame->IsPlaceholderFrame() || LineIsEmpty()) && + NotifyOptionalBreakPosition(aFrame, INT32_MAX, + optionalBreakAfterFits, + gfxBreakPriority::eNormalBreak)) { + // If this returns true then we are being told to actually break + // here. + aReflowStatus.SetInlineLineBreakAfter(); + } + } + } + } else { + PushFrame(aFrame); + aPushedFrame = true; + // Undo any saved break positions that the frame might have told us about, + // since we didn't end up placing it + RestoreSavedBreakPosition(savedOptionalBreakFrame, + savedOptionalBreakOffset, + savedOptionalBreakPriority); + } + } else { + PushFrame(aFrame); + aPushedFrame = true; + } + +#ifdef REALLY_NOISY_REFLOW + nsIFrame::IndentBy(stdout, mSpanDepth); + printf("End ReflowFrame "); + aFrame->ListTag(stdout); + printf(" status=%x\n", aReflowStatus); +#endif +} + +void nsLineLayout::AllowForStartMargin(PerFrameData* pfd, + ReflowInput& aReflowInput) { + NS_ASSERTION(!aReflowInput.mStyleDisplay->IsFloating(aReflowInput.mFrame), + "How'd we get a floated inline frame? " + "The frame ctor should've dealt with this."); + + WritingMode lineWM = mRootSpan->mWritingMode; + + // Only apply start-margin on the first-in flow for inline frames, + // and make sure to not apply it to any inline other than the first + // in an ib split. Note that the ib sibling (block-in-inline + // sibling) annotations only live on the first continuation, but we + // don't want to apply the start margin for later continuations + // anyway. For box-decoration-break:clone we apply the start-margin + // on all continuations. + if ((pfd->mFrame->GetPrevContinuation() || + pfd->mFrame->FrameIsNonFirstInIBSplit()) && + aReflowInput.mStyleBorder->mBoxDecorationBreak == + StyleBoxDecorationBreak::Slice) { + // Zero this out so that when we compute the max-element-width of + // the frame we will properly avoid adding in the starting margin. + pfd->mMargin.IStart(lineWM) = 0; + } else if (NS_UNCONSTRAINEDSIZE == aReflowInput.ComputedISize()) { + NS_WARNING_ASSERTION( + NS_UNCONSTRAINEDSIZE != aReflowInput.AvailableISize(), + "have unconstrained inline-size; this should only result from very " + "large sizes, not attempts at intrinsic inline-size calculation"); + // For inline-ish and text-ish things (which don't compute widths + // in the reflow input), adjust available inline-size to account + // for the start margin. The end margin will be accounted for when + // we finish flowing the frame. + WritingMode wm = aReflowInput.GetWritingMode(); + aReflowInput.SetAvailableISize( + aReflowInput.AvailableISize() - + pfd->mMargin.ConvertTo(wm, lineWM).IStart(wm)); + } +} + +nscoord nsLineLayout::GetCurrentFrameInlineDistanceFromBlock() { + PerSpanData* psd; + nscoord x = 0; + for (psd = mCurrentSpan; psd; psd = psd->mParent) { + x += psd->mICoord; + } + return x; +} + +/** + * This method syncs bounds of ruby annotations and ruby annotation + * containers from their rect. It is necessary because: + * Containers are not part of the line in their levels, which means + * their bounds are not set properly before. + * Ruby annotations' position may have been changed when reflowing + * their containers. + */ +void nsLineLayout::SyncAnnotationBounds(PerFrameData* aRubyFrame) { + MOZ_ASSERT(aRubyFrame->mFrame->IsRubyFrame()); + MOZ_ASSERT(aRubyFrame->mSpan); + + PerSpanData* span = aRubyFrame->mSpan; + WritingMode lineWM = mRootSpan->mWritingMode; + for (PerFrameData* pfd = span->mFirstFrame; pfd; pfd = pfd->mNext) { + for (PerFrameData* rtc = pfd->mNextAnnotation; rtc; + rtc = rtc->mNextAnnotation) { + if (lineWM.IsOrthogonalTo(rtc->mFrame->GetWritingMode())) { + // Inter-character case: don't attempt to sync annotation bounds. + continue; + } + // When the annotation container is reflowed, the width of the + // ruby container is unknown so we use a dummy container size; + // in the case of RTL block direction, the final position will be + // fixed up later. + const nsSize dummyContainerSize; + LogicalRect rtcBounds(lineWM, rtc->mFrame->GetRect(), dummyContainerSize); + rtc->mBounds = rtcBounds; + nsSize rtcSize = rtcBounds.Size(lineWM).GetPhysicalSize(lineWM); + for (PerFrameData* rt = rtc->mSpan->mFirstFrame; rt; rt = rt->mNext) { + LogicalRect rtBounds = rt->mFrame->GetLogicalRect(lineWM, rtcSize); + MOZ_ASSERT(rt->mBounds.Size(lineWM) == rtBounds.Size(lineWM), + "Size of the annotation should not have been changed"); + rt->mBounds.SetOrigin(lineWM, rtBounds.Origin(lineWM)); + } + } + } +} + +/** + * See if the frame can be placed now that we know it's desired size. + * We can always place the frame if the line is empty. Note that we + * know that the reflow-status is not a break-before because if it was + * ReflowFrame above would have returned false, preventing this method + * from being called. The logic in this method assumes that. + * + * Note that there is no check against the Y coordinate because we + * assume that the caller will take care of that. + */ +bool nsLineLayout::CanPlaceFrame(PerFrameData* pfd, bool aNotSafeToBreak, + bool aFrameCanContinueTextRun, + bool aCanRollBackBeforeFrame, + ReflowOutput& aMetrics, + nsReflowStatus& aStatus, + bool* aOptionalBreakAfterFits) { + MOZ_ASSERT(pfd && pfd->mFrame, "bad args, null pointers for frame data"); + + *aOptionalBreakAfterFits = true; + + WritingMode lineWM = mRootSpan->mWritingMode; + /* + * We want to only apply the end margin if we're the last continuation and + * either not in an {ib} split or the last inline in it. In all other + * cases we want to zero it out. That means zeroing it out if any of these + * conditions hold: + * 1) The frame is not complete (in this case it will get a next-in-flow) + * 2) The frame is complete but has a non-fluid continuation on its + * continuation chain. Note that if it has a fluid continuation, that + * continuation will get destroyed later, so we don't want to drop the + * end-margin in that case. + * 3) The frame is in an {ib} split and is not the last part. + * + * However, none of that applies if this is a letter frame (XXXbz why?) + * + * For box-decoration-break:clone we apply the end margin on all + * continuations (that are not letter frames). + */ + if ((aStatus.IsIncomplete() || + pfd->mFrame->LastInFlow()->GetNextContinuation() || + pfd->mFrame->FrameIsNonLastInIBSplit()) && + !pfd->mIsLetterFrame && + pfd->mFrame->StyleBorder()->mBoxDecorationBreak == + StyleBoxDecorationBreak::Slice) { + pfd->mMargin.IEnd(lineWM) = 0; + } + + // Apply the start margin to the frame bounds. + nscoord startMargin = pfd->mMargin.IStart(lineWM); + nscoord endMargin = pfd->mMargin.IEnd(lineWM); + + pfd->mBounds.IStart(lineWM) += startMargin; + + PerSpanData* psd = mCurrentSpan; + if (psd->mNoWrap) { + // When wrapping is off, everything fits. + return true; + } + +#ifdef NOISY_CAN_PLACE_FRAME + if (psd->mFrame) { + psd->mFrame->mFrame->ListTag(stdout); + } + printf(": aNotSafeToBreak=%s frame=", aNotSafeToBreak ? "true" : "false"); + pfd->mFrame->ListTag(stdout); + printf(" frameWidth=%d, margins=%d,%d\n", + pfd->mBounds.IEnd(lineWM) + endMargin - psd->mICoord, startMargin, + endMargin); +#endif + + // Set outside to true if the result of the reflow leads to the + // frame sticking outside of our available area. + bool outside = + pfd->mBounds.IEnd(lineWM) - mTrimmableISize + endMargin > psd->mIEnd; + if (!outside) { + // If it fits, it fits +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> inside\n"); +#endif + return true; + } + *aOptionalBreakAfterFits = false; + + // When it doesn't fit, check for a few special conditions where we + // allow it to fit anyway. + if (0 == startMargin + pfd->mBounds.ISize(lineWM) + endMargin) { + // Empty frames always fit right where they are +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> empty frame fits\n"); +#endif + return true; + } + + // another special case: always place a BR + if (pfd->mFrame->IsBrFrame()) { +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> BR frame fits\n"); +#endif + return true; + } + + if (aNotSafeToBreak) { + // There are no frames on the line that take up width and the line is + // not impacted by floats, so we must allow the current frame to be + // placed on the line +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> not-safe and not-impacted fits: "); + while (nullptr != psd) { + printf("<psd=%p x=%d left=%d> ", psd, psd->mICoord, psd->mIStart); + psd = psd->mParent; + } + printf("\n"); +#endif + return true; + } + + // Special check for span frames + if (pfd->mSpan && pfd->mSpan->mContainsFloat) { + // If the span either directly or indirectly contains a float then + // it fits. Why? It's kind of complicated, but here goes: + // + // 1. CanPlaceFrame is used for all frame placements on a line, + // and in a span. This includes recursively placement of frames + // inside of spans, and the span itself. Because the logic always + // checks for room before proceeding (the code above here), the + // only things on a line will be those things that "fit". + // + // 2. Before a float is placed on a line, the line has to be empty + // (otherwise it's a "below current line" float and will be placed + // after the line). + // + // Therefore, if the span directly or indirectly has a float + // then it means that at the time of the placement of the float + // the line was empty. Because of #1, only the frames that fit can + // be added after that point, therefore we can assume that the + // current span being placed has fit. + // + // So how do we get here and have a span that should already fit + // and yet doesn't: Simple: span's that have the no-wrap attribute + // set on them and contain a float and are placed where they + // don't naturally fit. + return true; + } + + if (aFrameCanContinueTextRun) { + // Let it fit, but we reserve the right to roll back. + // Note that we usually won't get here because a text frame will break + // itself to avoid exceeding the available width. + // We'll only get here for text frames that couldn't break early enough. +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> placing overflowing textrun, requesting backup\n"); +#endif + + // We will want to try backup. + mNeedBackup = true; + return true; + } + +#ifdef NOISY_CAN_PLACE_FRAME + printf(" ==> didn't fit\n"); +#endif + aStatus.SetInlineLineBreakBeforeAndReset(); + return false; +} + +/** + * Place the frame. Update running counters. + */ +void nsLineLayout::PlaceFrame(PerFrameData* pfd, ReflowOutput& aMetrics) { + WritingMode lineWM = mRootSpan->mWritingMode; + + // If the frame's block direction does not match the line's, we can't use + // its ascent; instead, treat it as a block with baseline at the block-end + // edge (or block-begin in the case of an "inverted" line). + if (pfd->mWritingMode.GetBlockDir() != lineWM.GetBlockDir()) { + pfd->mAscent = lineWM.IsAlphabeticalBaseline() + ? lineWM.IsLineInverted() ? 0 : aMetrics.BSize(lineWM) + : aMetrics.BSize(lineWM) / 2; + } else { + // For inline reflow participants, baseline may get assigned as the frame is + // vertically aligned, which happens after this. + const auto baselineSource = pfd->mFrame->StyleDisplay()->mBaselineSource; + if (baselineSource == StyleBaselineSource::Auto || + pfd->mFrame->IsFrameOfType(nsIFrame::eLineParticipant)) { + if (aMetrics.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) { + pfd->mAscent = pfd->mFrame->GetLogicalBaseline(lineWM); + } else { + pfd->mAscent = aMetrics.BlockStartAscent(); + } + } else { + const auto sourceGroup = [baselineSource]() { + switch (baselineSource) { + case StyleBaselineSource::First: + return BaselineSharingGroup::First; + case StyleBaselineSource::Last: + return BaselineSharingGroup::Last; + case StyleBaselineSource::Auto: + break; + } + MOZ_ASSERT_UNREACHABLE("Auto should be already handled?"); + return BaselineSharingGroup::First; + }(); + // We ignore line-layout specific layout quirks by setting + // `BaselineExportContext::Other`. + // Note(dshin): For a lot of frames, the export context does not make a + // difference, and we may be wasting the value cached in + // `BlockStartAscent`. + pfd->mAscent = pfd->mFrame->GetLogicalBaseline( + lineWM, sourceGroup, BaselineExportContext::Other); + } + } + + // Advance to next inline coordinate + mCurrentSpan->mICoord = pfd->mBounds.IEnd(lineWM) + pfd->mMargin.IEnd(lineWM); + + // Count the number of non-placeholder frames on the line... + if (pfd->mFrame->IsPlaceholderFrame()) { + NS_ASSERTION( + pfd->mBounds.ISize(lineWM) == 0 && pfd->mBounds.BSize(lineWM) == 0, + "placeholders should have 0 width/height (checking " + "placeholders were never counted by the old code in " + "this function)"); + } else { + mTotalPlacedFrames++; + } +} + +void nsLineLayout::AddMarkerFrame(nsIFrame* aFrame, + const ReflowOutput& aMetrics) { + NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user"); + NS_ASSERTION(mGotLineBox, "must have line box"); + + nsBlockFrame* blockFrame = do_QueryFrame(LineContainerFrame()); + MOZ_ASSERT(blockFrame, "must be for block"); + if (!blockFrame->MarkerIsEmpty()) { + mHasMarker = true; + mLineBox->SetHasMarker(); + } + + WritingMode lineWM = mRootSpan->mWritingMode; + PerFrameData* pfd = NewPerFrameData(aFrame); + PerSpanData* psd = mRootSpan; + + MOZ_ASSERT(psd->mFirstFrame, "adding marker to an empty line?"); + // Prepend the marker frame to the line. + psd->mFirstFrame->mPrev = pfd; + pfd->mNext = psd->mFirstFrame; + psd->mFirstFrame = pfd; + + pfd->mIsMarker = true; + if (aMetrics.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) { + pfd->mAscent = aFrame->GetLogicalBaseline(lineWM); + } else { + pfd->mAscent = aMetrics.BlockStartAscent(); + } + + // Note: block-coord value will be updated during block-direction alignment + pfd->mBounds = LogicalRect(lineWM, aFrame->GetRect(), ContainerSize()); + pfd->mOverflowAreas = aMetrics.mOverflowAreas; +} + +void nsLineLayout::RemoveMarkerFrame(nsIFrame* aFrame) { + PerSpanData* psd = mCurrentSpan; + MOZ_ASSERT(psd == mRootSpan, "::marker on non-root span?"); + MOZ_ASSERT(psd->mFirstFrame->mFrame == aFrame, + "::marker is not the first frame?"); + PerFrameData* pfd = psd->mFirstFrame; + MOZ_ASSERT(pfd != psd->mLastFrame, "::marker is the only frame?"); + pfd->mNext->mPrev = nullptr; + psd->mFirstFrame = pfd->mNext; + FreeFrame(pfd); +} +#ifdef DEBUG +void nsLineLayout::DumpPerSpanData(PerSpanData* psd, int32_t aIndent) { + nsIFrame::IndentBy(stdout, aIndent); + printf("%p: left=%d x=%d right=%d\n", static_cast<void*>(psd), psd->mIStart, + psd->mICoord, psd->mIEnd); + PerFrameData* pfd = psd->mFirstFrame; + while (nullptr != pfd) { + nsIFrame::IndentBy(stdout, aIndent + 1); + pfd->mFrame->ListTag(stdout); + nsRect rect = + pfd->mBounds.GetPhysicalRect(psd->mWritingMode, ContainerSize()); + printf(" %d,%d,%d,%d\n", rect.x, rect.y, rect.width, rect.height); + if (pfd->mSpan) { + DumpPerSpanData(pfd->mSpan, aIndent + 1); + } + pfd = pfd->mNext; + } +} +#endif + +void nsLineLayout::RecordNoWrapFloat(nsIFrame* aFloat) { + GetOutermostLineLayout()->mBlockRS->mNoWrapFloats.AppendElement(aFloat); +} + +void nsLineLayout::FlushNoWrapFloats() { + auto& noWrapFloats = GetOutermostLineLayout()->mBlockRS->mNoWrapFloats; + for (nsIFrame* floatedFrame : noWrapFloats) { + TryToPlaceFloat(floatedFrame); + } + noWrapFloats.Clear(); +} + +bool nsLineLayout::TryToPlaceFloat(nsIFrame* aFloat) { + // Add mTrimmableISize to the available width since if the line ends here, the + // width of the inline content will be reduced by mTrimmableISize. + nscoord availableISize = + mCurrentSpan->mIEnd - (mCurrentSpan->mICoord - mTrimmableISize); + NS_ASSERTION(!(aFloat->IsLetterFrame() && GetFirstLetterStyleOK()), + "FirstLetterStyle set on line with floating first letter"); + return GetOutermostLineLayout()->AddFloat(aFloat, availableISize); +} + +bool nsLineLayout::NotifyOptionalBreakPosition(nsIFrame* aFrame, + int32_t aOffset, bool aFits, + gfxBreakPriority aPriority) { + NS_ASSERTION(!aFits || !mNeedBackup, + "Shouldn't be updating the break position with a break that fits" + " after we've already flagged an overrun"); + MOZ_ASSERT(mCurrentSpan, "Should be doing line layout"); + if (mCurrentSpan->mNoWrap) { + FlushNoWrapFloats(); + } + + // Remember the last break position that fits; if there was no break that fit, + // just remember the first break + if ((aFits && aPriority >= mLastOptionalBreakPriority) || + !mLastOptionalBreakFrame) { + mLastOptionalBreakFrame = aFrame; + mLastOptionalBreakFrameOffset = aOffset; + mLastOptionalBreakPriority = aPriority; + } + return aFrame && mForceBreakFrame == aFrame && + mForceBreakFrameOffset == aOffset; +} + +#define VALIGN_OTHER 0 +#define VALIGN_TOP 1 +#define VALIGN_BOTTOM 2 + +void nsLineLayout::VerticalAlignLine() { + // Partially place the children of the block frame. The baseline for + // this operation is set to zero so that the y coordinates for all + // of the placed children will be relative to there. + PerSpanData* psd = mRootSpan; + VerticalAlignFrames(psd); + + // *** Note that comments here still use the anachronistic term + // "line-height" when we really mean "size of the line in the block + // direction", "vertical-align" when we really mean "alignment in + // the block direction", and "top" and "bottom" when we really mean + // "block start" and "block end". This is partly for brevity and + // partly to retain the association with the CSS line-height and + // vertical-align properties. + // + // Compute the line-height. The line-height will be the larger of: + // + // [1] maxBCoord - minBCoord (the distance between the first child's + // block-start edge and the last child's block-end edge) + // + // [2] the maximum logical box block size (since not every frame may have + // participated in #1; for example: "top" and "botttom" aligned frames) + // + // [3] the minimum line height ("line-height" property set on the + // block frame) + nscoord lineBSize = psd->mMaxBCoord - psd->mMinBCoord; + + // Now that the line-height is computed, we need to know where the + // baseline is in the line. Position baseline so that mMinBCoord is just + // inside the start of the line box. + nscoord baselineBCoord; + if (psd->mMinBCoord < 0) { + baselineBCoord = mBStartEdge - psd->mMinBCoord; + } else { + baselineBCoord = mBStartEdge; + } + + // It's also possible that the line block-size isn't tall enough because + // of "top" and "bottom" aligned elements that were not accounted for in + // min/max BCoord. + // + // The CSS2 spec doesn't really say what happens when to the + // baseline in this situations. What we do is if the largest start + // aligned box block size is greater than the line block-size then we leave + // the baseline alone. If the largest end aligned box is greater + // than the line block-size then we slide the baseline forward by the extra + // amount. + // + // Navigator 4 gives precedence to the first top/bottom aligned + // object. We just let block end aligned objects win. + if (lineBSize < mMaxEndBoxBSize) { + // When the line is shorter than the maximum block start aligned box + nscoord extra = mMaxEndBoxBSize - lineBSize; + baselineBCoord += extra; + lineBSize = mMaxEndBoxBSize; + } + if (lineBSize < mMaxStartBoxBSize) { + lineBSize = mMaxStartBoxBSize; + } +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" [line]==> lineBSize=%d baselineBCoord=%d\n", lineBSize, + baselineBCoord); +#endif + + // Now position all of the frames in the root span. We will also + // recurse over the child spans and place any frames we find with + // vertical-align: top or bottom. + // XXX PERFORMANCE: set a bit per-span to avoid the extra work + // (propagate it upward too) + WritingMode lineWM = psd->mWritingMode; + for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) { + if (pfd->mBlockDirAlign == VALIGN_OTHER) { + pfd->mBounds.BStart(lineWM) += baselineBCoord; + pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSize()); + } + } + PlaceTopBottomFrames(psd, -mBStartEdge, lineBSize); + + mFinalLineBSize = lineBSize; + if (mGotLineBox) { + // Fill in returned line-box and max-element-width data + mLineBox->SetBounds(lineWM, psd->mIStart, mBStartEdge, + psd->mICoord - psd->mIStart, lineBSize, + ContainerSize()); + + mLineBox->SetLogicalAscent(baselineBCoord - mBStartEdge); +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" [line]==> bounds{x,y,w,h}={%d,%d,%d,%d} lh=%d a=%d\n", + mLineBox->GetBounds().IStart(lineWM), + mLineBox->GetBounds().BStart(lineWM), + mLineBox->GetBounds().ISize(lineWM), + mLineBox->GetBounds().BSize(lineWM), mFinalLineBSize, + mLineBox->GetLogicalAscent()); +#endif + } +} + +// Place frames with CSS property vertical-align: top or bottom. +void nsLineLayout::PlaceTopBottomFrames(PerSpanData* psd, + nscoord aDistanceFromStart, + nscoord aLineBSize) { + for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) { + PerSpanData* span = pfd->mSpan; +#ifdef DEBUG + NS_ASSERTION(0xFF != pfd->mBlockDirAlign, "umr"); +#endif + WritingMode lineWM = mRootSpan->mWritingMode; + nsSize containerSize = ContainerSizeForSpan(psd); + switch (pfd->mBlockDirAlign) { + case VALIGN_TOP: + if (span) { + pfd->mBounds.BStart(lineWM) = -aDistanceFromStart - span->mMinBCoord; + } else { + pfd->mBounds.BStart(lineWM) = + -aDistanceFromStart + pfd->mMargin.BStart(lineWM); + } + pfd->mFrame->SetRect(lineWM, pfd->mBounds, containerSize); +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" "); + pfd->mFrame->ListTag(stdout); + printf(": y=%d dTop=%d [bp.top=%d topLeading=%d]\n", + pfd->mBounds.BStart(lineWM), aDistanceFromStart, + span ? pfd->mBorderPadding.BStart(lineWM) : 0, + span ? span->mBStartLeading : 0); +#endif + break; + case VALIGN_BOTTOM: + if (span) { + // Compute bottom leading + pfd->mBounds.BStart(lineWM) = + -aDistanceFromStart + aLineBSize - span->mMaxBCoord; + } else { + pfd->mBounds.BStart(lineWM) = -aDistanceFromStart + aLineBSize - + pfd->mMargin.BEnd(lineWM) - + pfd->mBounds.BSize(lineWM); + } + pfd->mFrame->SetRect(lineWM, pfd->mBounds, containerSize); +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" "); + pfd->mFrame->ListTag(stdout); + printf(": y=%d\n", pfd->mBounds.BStart(lineWM)); +#endif + break; + } + if (span) { + nscoord fromStart = aDistanceFromStart + pfd->mBounds.BStart(lineWM); + PlaceTopBottomFrames(span, fromStart, aLineBSize); + } + } +} + +static nscoord GetBSizeOfEmphasisMarks(nsIFrame* aSpanFrame, float aInflation) { + RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsOfEmphasisMarks( + aSpanFrame->Style(), aSpanFrame->PresContext(), aInflation); + return fm->MaxHeight(); +} + +void nsLineLayout::AdjustLeadings(nsIFrame* spanFrame, PerSpanData* psd, + const nsStyleText* aStyleText, + float aInflation, + bool* aZeroEffectiveSpanBox) { + MOZ_ASSERT(spanFrame == psd->mFrame->mFrame); + nscoord requiredStartLeading = 0; + nscoord requiredEndLeading = 0; + if (spanFrame->IsRubyFrame()) { + // We may need to extend leadings here for ruby annotations as + // required by section Line Spacing in the CSS Ruby spec. + // See http://dev.w3.org/csswg/css-ruby/#line-height + auto rubyFrame = static_cast<nsRubyFrame*>(spanFrame); + RubyBlockLeadings leadings = rubyFrame->GetBlockLeadings(); + requiredStartLeading += leadings.mStart; + requiredEndLeading += leadings.mEnd; + } + if (aStyleText->HasEffectiveTextEmphasis()) { + nscoord bsize = GetBSizeOfEmphasisMarks(spanFrame, aInflation); + LogicalSide side = aStyleText->TextEmphasisSide(mRootSpan->mWritingMode); + if (side == eLogicalSideBStart) { + requiredStartLeading += bsize; + } else { + MOZ_ASSERT(side == eLogicalSideBEnd, + "emphasis marks must be in block axis"); + requiredEndLeading += bsize; + } + } + + nscoord requiredLeading = requiredStartLeading + requiredEndLeading; + // If we do not require any additional leadings, don't touch anything + // here even if it is greater than the original leading, because the + // latter could be negative. + if (requiredLeading != 0) { + nscoord leading = psd->mBStartLeading + psd->mBEndLeading; + nscoord deltaLeading = requiredLeading - leading; + if (deltaLeading > 0) { + // If the total leading is not wide enough for ruby annotations + // and/or emphasis marks, extend the side which is not enough. If + // both sides are not wide enough, replace the leadings with the + // requested values. + if (requiredStartLeading < psd->mBStartLeading) { + psd->mBEndLeading += deltaLeading; + } else if (requiredEndLeading < psd->mBEndLeading) { + psd->mBStartLeading += deltaLeading; + } else { + psd->mBStartLeading = requiredStartLeading; + psd->mBEndLeading = requiredEndLeading; + } + psd->mLogicalBSize += deltaLeading; + // We have adjusted the leadings, it is no longer a zero + // effective span box. + *aZeroEffectiveSpanBox = false; + } + } +} + +static float GetInflationForBlockDirAlignment(nsIFrame* aFrame, + nscoord aInflationMinFontSize) { + if (aFrame->IsInSVGTextSubtree()) { + const nsIFrame* container = + nsLayoutUtils::GetClosestFrameOfType(aFrame, LayoutFrameType::SVGText); + NS_ASSERTION(container, "expected to find an ancestor SVGTextFrame"); + return static_cast<const SVGTextFrame*>(container) + ->GetFontSizeScaleFactor(); + } + return nsLayoutUtils::FontSizeInflationInner(aFrame, aInflationMinFontSize); +} + +#define BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM nscoord_MAX +#define BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM nscoord_MIN + +// Place frames in the block direction within a given span (CSS property +// vertical-align) Note: this doesn't place frames with vertical-align: +// top or bottom as those have to wait until the entire line box block +// size is known. This is called after the span frame has finished being +// reflowed so that we know its block size. +void nsLineLayout::VerticalAlignFrames(PerSpanData* psd) { + // Get parent frame info + PerFrameData* spanFramePFD = psd->mFrame; + nsIFrame* spanFrame = spanFramePFD->mFrame; + + // Get the parent frame's font for all of the frames in this span + float inflation = + GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize); + RefPtr<nsFontMetrics> fm = + nsLayoutUtils::GetFontMetricsForFrame(spanFrame, inflation); + + bool preMode = mStyleText->WhiteSpaceIsSignificant(); + + // See if the span is an empty continuation. It's an empty continuation iff: + // - it has a prev-in-flow + // - it has no next in flow + // - it's zero sized + WritingMode lineWM = mRootSpan->mWritingMode; + bool emptyContinuation = psd != mRootSpan && spanFrame->GetPrevInFlow() && + !spanFrame->GetNextInFlow() && + spanFramePFD->mBounds.IsZeroSize(); + +#ifdef NOISY_BLOCKDIR_ALIGN + printf("[%sSpan]", (psd == mRootSpan) ? "Root" : ""); + spanFrame->ListTag(stdout); + printf(": preMode=%s strictMode=%s w/h=%d,%d emptyContinuation=%s", + preMode ? "yes" : "no", + mPresContext->CompatibilityMode() != eCompatibility_NavQuirks ? "yes" + : "no", + spanFramePFD->mBounds.ISize(lineWM), + spanFramePFD->mBounds.BSize(lineWM), emptyContinuation ? "yes" : "no"); + if (psd != mRootSpan) { + printf(" bp=%d,%d,%d,%d margin=%d,%d,%d,%d", + spanFramePFD->mBorderPadding.Top(lineWM), + spanFramePFD->mBorderPadding.Right(lineWM), + spanFramePFD->mBorderPadding.Bottom(lineWM), + spanFramePFD->mBorderPadding.Left(lineWM), + spanFramePFD->mMargin.Top(lineWM), + spanFramePFD->mMargin.Right(lineWM), + spanFramePFD->mMargin.Bottom(lineWM), + spanFramePFD->mMargin.Left(lineWM)); + } + printf("\n"); +#endif + + // Compute the span's zeroEffectiveSpanBox flag. What we are trying + // to determine is how we should treat the span: should it act + // "normally" according to css2 or should it effectively + // "disappear". + // + // In general, if the document being processed is in full standards + // mode then it should act normally (with one exception). The + // exception case is when a span is continued and yet the span is + // empty (e.g. compressed whitespace). For this kind of span we treat + // it as if it were not there so that it doesn't impact the + // line block-size. + // + // In almost standards mode or quirks mode, we should sometimes make + // it disappear. The cases that matter are those where the span + // contains no real text elements that would provide an ascent and + // descent and height. However, if css style elements have been + // applied to the span (border/padding/margin) so that it's clear the + // document author is intending css2 behavior then we act as if strict + // mode is set. + // + // This code works correctly for preMode, because a blank line + // in PRE mode is encoded as a text node with a LF in it, since + // text nodes with only whitespace are considered in preMode. + // + // Much of this logic is shared with the various implementations of + // nsIFrame::IsEmpty since they need to duplicate the way it makes + // some lines empty. However, nsIFrame::IsEmpty can't be reused here + // since this code sets zeroEffectiveSpanBox even when there are + // non-empty children. + bool zeroEffectiveSpanBox = false; + // XXXldb If we really have empty continuations, then all these other + // checks don't make sense for them. + // XXXldb This should probably just use nsIFrame::IsSelfEmpty, assuming that + // it agrees with this code. (If it doesn't agree, it probably should.) + if ((emptyContinuation || + mPresContext->CompatibilityMode() != eCompatibility_FullStandards) && + ((psd == mRootSpan) || (spanFramePFD->mBorderPadding.IsAllZero() && + spanFramePFD->mMargin.IsAllZero()))) { + // This code handles an issue with compatibility with non-css + // conformant browsers. In particular, there are some cases + // where the font-size and line-height for a span must be + // ignored and instead the span must *act* as if it were zero + // sized. In general, if the span contains any non-compressed + // text then we don't use this logic. + // However, this is not propagated outwards, since (in compatibility + // mode) we don't want big line heights for things like + // <p><font size="-1">Text</font></p> + + // We shouldn't include any whitespace that collapses, unless we're + // preformatted (in which case it shouldn't, but the width=0 test is + // perhaps incorrect). This includes whitespace at the beginning of + // a line and whitespace preceded (?) by other whitespace. + // See bug 134580 and bug 155333. + zeroEffectiveSpanBox = true; + for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) { + if (pfd->mIsTextFrame && + (pfd->mIsNonWhitespaceTextFrame || preMode || + pfd->mBounds.ISize(mRootSpan->mWritingMode) != 0)) { + zeroEffectiveSpanBox = false; + break; + } + } + } + + // Setup baselineBCoord, minBCoord, and maxBCoord + nscoord baselineBCoord, minBCoord, maxBCoord; + if (psd == mRootSpan) { + // Use a zero baselineBCoord since we don't yet know where the baseline + // will be (until we know how tall the line is; then we will + // know). In addition, use extreme values for the minBCoord and maxBCoord + // values so that only the child frames will impact their values + // (since these are children of the block, there is no span box to + // provide initial values). + baselineBCoord = 0; + minBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM; + maxBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM; +#ifdef NOISY_BLOCKDIR_ALIGN + printf("[RootSpan]"); + spanFrame->ListTag(stdout); + printf( + ": pass1 valign frames: topEdge=%d minLineBSize=%d " + "zeroEffectiveSpanBox=%s\n", + mBStartEdge, mMinLineBSize, zeroEffectiveSpanBox ? "yes" : "no"); +#endif + } else { + // Compute the logical block size for this span. The logical block size + // is based on the "line-height" value, not the font-size. Also + // compute the top leading. + float inflation = + GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize); + nscoord logicalBSize = ReflowInput::CalcLineHeight( + *spanFrame->Style(), spanFrame->PresContext(), spanFrame->GetContent(), + mLineContainerRI.ComputedHeight(), inflation); + nscoord contentBSize = spanFramePFD->mBounds.BSize(lineWM) - + spanFramePFD->mBorderPadding.BStartEnd(lineWM); + + // Special-case for a ::first-letter frame, set the line height to + // the frame block size if the user has left line-height == normal + const nsStyleText* styleText = spanFrame->StyleText(); + if (spanFramePFD->mIsLetterFrame && !spanFrame->GetPrevInFlow() && + styleText->mLineHeight.IsNormal()) { + logicalBSize = spanFramePFD->mBounds.BSize(lineWM); + } + + nscoord leading = logicalBSize - contentBSize; + psd->mBStartLeading = leading / 2; + psd->mBEndLeading = leading - psd->mBStartLeading; + psd->mLogicalBSize = logicalBSize; + AdjustLeadings(spanFrame, psd, styleText, inflation, &zeroEffectiveSpanBox); + + if (zeroEffectiveSpanBox) { + // When the span-box is to be ignored, zero out the initial + // values so that the span doesn't impact the final line + // height. The contents of the span can impact the final line + // height. + + // Note that things are readjusted for this span after its children + // are reflowed + minBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM; + maxBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM; + } else { + // The initial values for the min and max block coord values are in the + // span's coordinate space, and cover the logical block size of the span. + // If there are child frames in this span that stick out of this area + // then the minBCoord and maxBCoord are updated by the amount of logical + // blockSize that is outside this range. + minBCoord = + spanFramePFD->mBorderPadding.BStart(lineWM) - psd->mBStartLeading; + maxBCoord = minBCoord + psd->mLogicalBSize; + } + + // This is the distance from the top edge of the parents visual + // box to the baseline. The span already computed this for us, + // so just use it. + *psd->mBaseline = baselineBCoord = spanFramePFD->mAscent; + +#ifdef NOISY_BLOCKDIR_ALIGN + printf("[%sSpan]", (psd == mRootSpan) ? "Root" : ""); + spanFrame->ListTag(stdout); + printf( + ": baseLine=%d logicalBSize=%d topLeading=%d h=%d bp=%d,%d " + "zeroEffectiveSpanBox=%s\n", + baselineBCoord, psd->mLogicalBSize, psd->mBStartLeading, + spanFramePFD->mBounds.BSize(lineWM), + spanFramePFD->mBorderPadding.Top(lineWM), + spanFramePFD->mBorderPadding.Bottom(lineWM), + zeroEffectiveSpanBox ? "yes" : "no"); +#endif + } + + nscoord maxStartBoxBSize = 0; + nscoord maxEndBoxBSize = 0; + PerFrameData* pfd = psd->mFirstFrame; + while (nullptr != pfd) { + nsIFrame* frame = pfd->mFrame; + + // sanity check (see bug 105168, non-reproducible crashes from null frame) + NS_ASSERTION(frame, + "null frame in PerFrameData - something is very very bad"); + if (!frame) { + return; + } + + // Compute the logical block size of the frame + nscoord logicalBSize; + PerSpanData* frameSpan = pfd->mSpan; + if (frameSpan) { + // For span frames the logical-block-size and start-leading were + // pre-computed when the span was reflowed. + logicalBSize = frameSpan->mLogicalBSize; + } else { + // For other elements the logical block size is the same as the + // frame's block size plus its margins. + logicalBSize = + pfd->mBounds.BSize(lineWM) + pfd->mMargin.BStartEnd(lineWM); + if (logicalBSize < 0 && + mPresContext->CompatibilityMode() != eCompatibility_FullStandards) { + pfd->mAscent -= logicalBSize; + logicalBSize = 0; + } + } + + // Get vertical-align property ("vertical-align" is the CSS name for + // block-direction align) + const auto& verticalAlign = frame->StyleDisplay()->mVerticalAlign; + Maybe<StyleVerticalAlignKeyword> verticalAlignEnum = + frame->VerticalAlignEnum(); +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" [frame]"); + frame->ListTag(stdout); + printf(": verticalAlignIsKw=%d (enum == %d", verticalAlign.IsKeyword(), + verticalAlign.IsKeyword() + ? static_cast<int>(verticalAlign.AsKeyword()) + : -1); + if (verticalAlignEnum) { + printf(", after SVG dominant-baseline conversion == %d", + static_cast<int>(*verticalAlignEnum)); + } + printf(")\n"); +#endif + + if (verticalAlignEnum) { + StyleVerticalAlignKeyword keyword = *verticalAlignEnum; + if (lineWM.IsVertical()) { + if (keyword == StyleVerticalAlignKeyword::Middle) { + // For vertical writing mode where the dominant baseline is centered + // (i.e. text-orientation is not sideways-*), we remap 'middle' to + // 'middle-with-baseline' so that images align sensibly with the + // center-baseline-aligned text. + if (!lineWM.IsSideways()) { + keyword = StyleVerticalAlignKeyword::MozMiddleWithBaseline; + } + } else if (lineWM.IsLineInverted()) { + // Swap the meanings of top and bottom when line is inverted + // relative to block direction. + switch (keyword) { + case StyleVerticalAlignKeyword::Top: + keyword = StyleVerticalAlignKeyword::Bottom; + break; + case StyleVerticalAlignKeyword::Bottom: + keyword = StyleVerticalAlignKeyword::Top; + break; + case StyleVerticalAlignKeyword::TextTop: + keyword = StyleVerticalAlignKeyword::TextBottom; + break; + case StyleVerticalAlignKeyword::TextBottom: + keyword = StyleVerticalAlignKeyword::TextTop; + break; + default: + break; + } + } + } + + // baseline coord that may be adjusted for script offset + nscoord revisedBaselineBCoord = baselineBCoord; + + // For superscript and subscript, raise or lower the baseline of the box + // to the proper offset of the parent's box, then proceed as for BASELINE + if (keyword == StyleVerticalAlignKeyword::Sub || + keyword == StyleVerticalAlignKeyword::Super) { + revisedBaselineBCoord += lineWM.FlowRelativeToLineRelativeFactor() * + (keyword == StyleVerticalAlignKeyword::Sub + ? fm->SubscriptOffset() + : -fm->SuperscriptOffset()); + keyword = StyleVerticalAlignKeyword::Baseline; + } + + switch (keyword) { + default: + case StyleVerticalAlignKeyword::Baseline: + pfd->mBounds.BStart(lineWM) = revisedBaselineBCoord - pfd->mAscent; + pfd->mBlockDirAlign = VALIGN_OTHER; + break; + + case StyleVerticalAlignKeyword::Top: { + pfd->mBlockDirAlign = VALIGN_TOP; + nscoord subtreeBSize = logicalBSize; + if (frameSpan) { + subtreeBSize = frameSpan->mMaxBCoord - frameSpan->mMinBCoord; + NS_ASSERTION(subtreeBSize >= logicalBSize, + "unexpected subtree block size"); + } + if (subtreeBSize > maxStartBoxBSize) { + maxStartBoxBSize = subtreeBSize; + } + break; + } + + case StyleVerticalAlignKeyword::Bottom: { + pfd->mBlockDirAlign = VALIGN_BOTTOM; + nscoord subtreeBSize = logicalBSize; + if (frameSpan) { + subtreeBSize = frameSpan->mMaxBCoord - frameSpan->mMinBCoord; + NS_ASSERTION(subtreeBSize >= logicalBSize, + "unexpected subtree block size"); + } + if (subtreeBSize > maxEndBoxBSize) { + maxEndBoxBSize = subtreeBSize; + } + break; + } + + case StyleVerticalAlignKeyword::Middle: { + // Align the midpoint of the frame with 1/2 the parents + // x-height above the baseline. + nscoord parentXHeight = + lineWM.FlowRelativeToLineRelativeFactor() * fm->XHeight(); + if (frameSpan) { + pfd->mBounds.BStart(lineWM) = + baselineBCoord - + (parentXHeight + pfd->mBounds.BSize(lineWM)) / 2; + } else { + pfd->mBounds.BStart(lineWM) = baselineBCoord - + (parentXHeight + logicalBSize) / 2 + + pfd->mMargin.BStart(lineWM); + } + pfd->mBlockDirAlign = VALIGN_OTHER; + break; + } + + case StyleVerticalAlignKeyword::TextTop: { + // The top of the logical box is aligned with the top of + // the parent element's text. + // XXX For vertical text we will need a new API to get the logical + // max-ascent here + nscoord parentAscent = + lineWM.IsLineInverted() ? fm->MaxDescent() : fm->MaxAscent(); + if (frameSpan) { + pfd->mBounds.BStart(lineWM) = baselineBCoord - parentAscent - + pfd->mBorderPadding.BStart(lineWM) + + frameSpan->mBStartLeading; + } else { + pfd->mBounds.BStart(lineWM) = + baselineBCoord - parentAscent + pfd->mMargin.BStart(lineWM); + } + pfd->mBlockDirAlign = VALIGN_OTHER; + break; + } + + case StyleVerticalAlignKeyword::TextBottom: { + // The bottom of the logical box is aligned with the + // bottom of the parent elements text. + nscoord parentDescent = + lineWM.IsLineInverted() ? fm->MaxAscent() : fm->MaxDescent(); + if (frameSpan) { + pfd->mBounds.BStart(lineWM) = + baselineBCoord + parentDescent - pfd->mBounds.BSize(lineWM) + + pfd->mBorderPadding.BEnd(lineWM) - frameSpan->mBEndLeading; + } else { + pfd->mBounds.BStart(lineWM) = baselineBCoord + parentDescent - + pfd->mBounds.BSize(lineWM) - + pfd->mMargin.BEnd(lineWM); + } + pfd->mBlockDirAlign = VALIGN_OTHER; + break; + } + + case StyleVerticalAlignKeyword::MozMiddleWithBaseline: { + // Align the midpoint of the frame with the baseline of the parent. + if (frameSpan) { + pfd->mBounds.BStart(lineWM) = + baselineBCoord - pfd->mBounds.BSize(lineWM) / 2; + } else { + pfd->mBounds.BStart(lineWM) = + baselineBCoord - logicalBSize / 2 + pfd->mMargin.BStart(lineWM); + } + pfd->mBlockDirAlign = VALIGN_OTHER; + break; + } + } + } else { + // We have either a coord, a percent, or a calc(). + nscoord offset = verticalAlign.AsLength().Resolve([&] { + // Percentages are like lengths, except treated as a percentage + // of the elements line block size value. + float inflation = + GetInflationForBlockDirAlignment(frame, mInflationMinFontSize); + return ReflowInput::CalcLineHeight( + *frame->Style(), frame->PresContext(), frame->GetContent(), + mLineContainerRI.ComputedBSize(), inflation); + }); + + // According to the CSS2 spec (10.8.1), a positive value + // "raises" the box by the given distance while a negative value + // "lowers" the box by the given distance (with zero being the + // baseline). Since Y coordinates increase towards the bottom of + // the screen we reverse the sign, unless the line orientation is + // inverted relative to block direction. + nscoord revisedBaselineBCoord = + baselineBCoord - offset * lineWM.FlowRelativeToLineRelativeFactor(); + if (lineWM.IsCentralBaseline()) { + // If we're using a dominant center baseline, we align with the center + // of the frame being placed (bug 1133945). + pfd->mBounds.BStart(lineWM) = + revisedBaselineBCoord - pfd->mBounds.BSize(lineWM) / 2; + } else { + pfd->mBounds.BStart(lineWM) = revisedBaselineBCoord - pfd->mAscent; + } + pfd->mBlockDirAlign = VALIGN_OTHER; + } + + // Update minBCoord/maxBCoord for frames that we just placed. Do not factor + // text into the equation. + if (pfd->mBlockDirAlign == VALIGN_OTHER) { + // Text frames do not contribute to the min/max Y values for the + // line (instead their parent frame's font-size contributes). + // XXXrbs -- relax this restriction because it causes text frames + // to jam together when 'font-size-adjust' is enabled + // and layout is using dynamic font heights (bug 20394) + // -- Note #1: With this code enabled and with the fact that we are + // not using Em[Ascent|Descent] as nsDimensions for text + // metrics in GFX mean that the discussion in bug 13072 cannot + // hold. + // -- Note #2: We still don't want empty-text frames to interfere. + // For example in quirks mode, avoiding empty text frames + // prevents "tall" lines around elements like <hr> since the + // rules of <hr> in quirks.css have pseudo text contents with LF + // in them. + bool canUpdate; + if (pfd->mIsTextFrame) { + // Only consider text frames if they're not empty and + // line-height=normal. + canUpdate = pfd->mIsNonWhitespaceTextFrame && + frame->StyleText()->mLineHeight.IsNormal(); + } else { + canUpdate = !pfd->mIsPlaceholder; + } + + if (canUpdate) { + nscoord blockStart, blockEnd; + if (frameSpan) { + // For spans that were are now placing, use their position + // plus their already computed min-Y and max-Y values for + // computing blockStart and blockEnd. + blockStart = pfd->mBounds.BStart(lineWM) + frameSpan->mMinBCoord; + blockEnd = pfd->mBounds.BStart(lineWM) + frameSpan->mMaxBCoord; + } else { + blockStart = + pfd->mBounds.BStart(lineWM) - pfd->mMargin.BStart(lineWM); + blockEnd = blockStart + logicalBSize; + } + if (!preMode && + mPresContext->CompatibilityMode() != eCompatibility_FullStandards && + !logicalBSize) { + // Check if it's a BR frame that is not alone on its line (it + // is given a block size of zero to indicate this), and if so reset + // blockStart and blockEnd so that BR frames don't influence the line. + if (frame->IsBrFrame()) { + blockStart = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM; + blockEnd = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM; + } + } + if (blockStart < minBCoord) minBCoord = blockStart; + if (blockEnd > maxBCoord) maxBCoord = blockEnd; +#ifdef NOISY_BLOCKDIR_ALIGN + printf( + " [frame]raw: a=%d h=%d bp=%d,%d logical: h=%d leading=%d y=%d " + "minBCoord=%d maxBCoord=%d\n", + pfd->mAscent, pfd->mBounds.BSize(lineWM), + pfd->mBorderPadding.Top(lineWM), pfd->mBorderPadding.Bottom(lineWM), + logicalBSize, frameSpan ? frameSpan->mBStartLeading : 0, + pfd->mBounds.BStart(lineWM), minBCoord, maxBCoord); +#endif + } + if (psd != mRootSpan) { + frame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd)); + } + } + pfd = pfd->mNext; + } + + // Factor in the minimum line block-size when handling the root-span for + // the block. + if (psd == mRootSpan) { + // We should factor in the block element's minimum line-height (as + // defined in section 10.8.1 of the css2 spec) assuming that + // zeroEffectiveSpanBox is not set on the root span. This only happens + // in some cases in quirks mode: + // (1) if the root span contains non-whitespace text directly (this + // is handled by zeroEffectiveSpanBox + // (2) if this line has a ::marker + // (3) if this is the last line of an LI, DT, or DD element + // (The last line before a block also counts, but not before a + // BR) (NN4/IE5 quirk) + + // (1) and (2) above + bool applyMinLH = !zeroEffectiveSpanBox || mHasMarker; + bool isLastLine = + !mGotLineBox || (!mLineBox->IsLineWrapped() && !mLineEndsInBR); + if (!applyMinLH && isLastLine) { + nsIContent* blockContent = mRootSpan->mFrame->mFrame->GetContent(); + if (blockContent) { + // (3) above, if the last line of LI, DT, or DD + if (blockContent->IsAnyOfHTMLElements(nsGkAtoms::li, nsGkAtoms::dt, + nsGkAtoms::dd)) { + applyMinLH = true; + } + } + } + if (applyMinLH) { + if (psd->mHasNonemptyContent || preMode || mHasMarker) { +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" [span]==> adjusting min/maxBCoord: currentValues: %d,%d", + minBCoord, maxBCoord); +#endif + nscoord minimumLineBSize = mMinLineBSize; + nscoord blockStart = -nsLayoutUtils::GetCenteredFontBaseline( + fm, minimumLineBSize, lineWM.IsLineInverted()); + nscoord blockEnd = blockStart + minimumLineBSize; + + if (mStyleText->HasEffectiveTextEmphasis()) { + nscoord fontMaxHeight = fm->MaxHeight(); + nscoord emphasisHeight = + GetBSizeOfEmphasisMarks(spanFrame, inflation); + nscoord delta = fontMaxHeight + emphasisHeight - minimumLineBSize; + if (delta > 0) { + if (minimumLineBSize < fontMaxHeight) { + // If the leadings are negative, fill them first. + nscoord ascent = fm->MaxAscent(); + nscoord descent = fm->MaxDescent(); + if (lineWM.IsLineInverted()) { + std::swap(ascent, descent); + } + blockStart = -ascent; + blockEnd = descent; + delta = emphasisHeight; + } + LogicalSide side = mStyleText->TextEmphasisSide(lineWM); + if (side == eLogicalSideBStart) { + blockStart -= delta; + } else { + blockEnd += delta; + } + } + } + + if (blockStart < minBCoord) minBCoord = blockStart; + if (blockEnd > maxBCoord) maxBCoord = blockEnd; + +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" new values: %d,%d\n", minBCoord, maxBCoord); +#endif +#ifdef NOISY_BLOCKDIR_ALIGN + printf( + " Used mMinLineBSize: %d, blockStart: %d, blockEnd: " + "%d\n", + mMinLineBSize, blockStart, blockEnd); +#endif + } else { + // XXX issues: + // [1] BR's on empty lines stop working + // [2] May not honor css2's notion of handling empty elements + // [3] blank lines in a pre-section ("\n") (handled with preMode) + + // XXX Are there other problems with this? +#ifdef NOISY_BLOCKDIR_ALIGN + printf( + " [span]==> zapping min/maxBCoord: currentValues: %d,%d " + "newValues: 0,0\n", + minBCoord, maxBCoord); +#endif + minBCoord = maxBCoord = 0; + } + } + } + + if ((minBCoord == BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM) || + (maxBCoord == BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM)) { + minBCoord = maxBCoord = baselineBCoord; + } + + if (psd != mRootSpan && zeroEffectiveSpanBox) { +#ifdef NOISY_BLOCKDIR_ALIGN + printf(" [span]adjusting for zeroEffectiveSpanBox\n"); + printf( + " Original: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, " + "logicalBSize=%d, topLeading=%d, bottomLeading=%d\n", + minBCoord, maxBCoord, spanFramePFD->mBounds.BSize(lineWM), + spanFramePFD->mAscent, psd->mLogicalBSize, psd->mBStartLeading, + psd->mBEndLeading); +#endif + nscoord goodMinBCoord = + spanFramePFD->mBorderPadding.BStart(lineWM) - psd->mBStartLeading; + nscoord goodMaxBCoord = goodMinBCoord + psd->mLogicalBSize; + + // For cases like the one in bug 714519 (text-decoration placement + // or making nsLineLayout::IsZeroBSize() handle + // vertical-align:top/bottom on a descendant of the line that's not + // a child of it), we want to treat elements that are + // vertical-align: top or bottom somewhat like children for the + // purposes of this quirk. To some extent, this is guessing, since + // they might end up being aligned anywhere. However, we'll guess + // that they'll be placed aligned with the top or bottom of this + // frame (as though this frame is the only thing in the line). + // (Guessing isn't unreasonable, since all we're doing is reducing the + // scope of a quirk and making the behavior more standards-like.) + if (maxStartBoxBSize > maxBCoord - minBCoord) { + // Distribute maxStartBoxBSize to ascent (baselineBCoord - minBCoord), and + // then to descent (maxBCoord - baselineBCoord) by adjusting minBCoord or + // maxBCoord, but not to exceed goodMinBCoord and goodMaxBCoord. + nscoord distribute = maxStartBoxBSize - (maxBCoord - minBCoord); + nscoord ascentSpace = std::max(minBCoord - goodMinBCoord, 0); + if (distribute > ascentSpace) { + distribute -= ascentSpace; + minBCoord -= ascentSpace; + nscoord descentSpace = std::max(goodMaxBCoord - maxBCoord, 0); + if (distribute > descentSpace) { + maxBCoord += descentSpace; + } else { + maxBCoord += distribute; + } + } else { + minBCoord -= distribute; + } + } + if (maxEndBoxBSize > maxBCoord - minBCoord) { + // Likewise, but preferring descent to ascent. + nscoord distribute = maxEndBoxBSize - (maxBCoord - minBCoord); + nscoord descentSpace = std::max(goodMaxBCoord - maxBCoord, 0); + if (distribute > descentSpace) { + distribute -= descentSpace; + maxBCoord += descentSpace; + nscoord ascentSpace = std::max(minBCoord - goodMinBCoord, 0); + if (distribute > ascentSpace) { + minBCoord -= ascentSpace; + } else { + minBCoord -= distribute; + } + } else { + maxBCoord += distribute; + } + } + + if (minBCoord > goodMinBCoord) { + nscoord adjust = minBCoord - goodMinBCoord; // positive + + // shrink the logical extents + psd->mLogicalBSize -= adjust; + psd->mBStartLeading -= adjust; + } + if (maxBCoord < goodMaxBCoord) { + nscoord adjust = goodMaxBCoord - maxBCoord; + psd->mLogicalBSize -= adjust; + psd->mBEndLeading -= adjust; + } + if (minBCoord > 0) { + // shrink the content by moving its block start down. This is tricky, + // since the block start is the 0 for many coordinates, so what we do is + // move everything else up. + spanFramePFD->mAscent -= minBCoord; // move the baseline up + spanFramePFD->mBounds.BSize(lineWM) -= + minBCoord; // move the block end up + psd->mBStartLeading += minBCoord; + *psd->mBaseline -= minBCoord; + + pfd = psd->mFirstFrame; + while (nullptr != pfd) { + pfd->mBounds.BStart(lineWM) -= minBCoord; // move all the children + // back up + pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd)); + pfd = pfd->mNext; + } + maxBCoord -= minBCoord; // since minBCoord is in the frame's own + // coordinate system + minBCoord = 0; + } + if (maxBCoord < spanFramePFD->mBounds.BSize(lineWM)) { + nscoord adjust = spanFramePFD->mBounds.BSize(lineWM) - maxBCoord; + spanFramePFD->mBounds.BSize(lineWM) -= adjust; // move the bottom up + psd->mBEndLeading += adjust; + } +#ifdef NOISY_BLOCKDIR_ALIGN + printf( + " New: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, " + "logicalBSize=%d, topLeading=%d, bottomLeading=%d\n", + minBCoord, maxBCoord, spanFramePFD->mBounds.BSize(lineWM), + spanFramePFD->mAscent, psd->mLogicalBSize, psd->mBStartLeading, + psd->mBEndLeading); +#endif + } + + psd->mMinBCoord = minBCoord; + psd->mMaxBCoord = maxBCoord; +#ifdef NOISY_BLOCKDIR_ALIGN + printf( + " [span]==> minBCoord=%d maxBCoord=%d delta=%d maxStartBoxBSize=%d " + "maxEndBoxBSize=%d\n", + minBCoord, maxBCoord, maxBCoord - minBCoord, maxStartBoxBSize, + maxEndBoxBSize); +#endif + if (maxStartBoxBSize > mMaxStartBoxBSize) { + mMaxStartBoxBSize = maxStartBoxBSize; + } + if (maxEndBoxBSize > mMaxEndBoxBSize) { + mMaxEndBoxBSize = maxEndBoxBSize; + } +} + +static void SlideSpanFrameRect(nsIFrame* aFrame, nscoord aDeltaWidth) { + // This should not use nsIFrame::MovePositionBy because it happens + // prior to relative positioning. In particular, because + // nsBlockFrame::PlaceLine calls aLineLayout.TrimTrailingWhiteSpace() + // prior to calling aLineLayout.RelativePositionFrames(). + nsPoint p = aFrame->GetPosition(); + p.x -= aDeltaWidth; + aFrame->SetPosition(p); +} + +bool nsLineLayout::TrimTrailingWhiteSpaceIn(PerSpanData* psd, + nscoord* aDeltaISize) { + PerFrameData* pfd = psd->mFirstFrame; + if (!pfd) { + *aDeltaISize = 0; + return false; + } + pfd = pfd->Last(); + while (nullptr != pfd) { +#ifdef REALLY_NOISY_TRIM + psd->mFrame->mFrame->ListTag(stdout); + printf(": attempting trim of "); + pfd->mFrame->ListTag(stdout); + printf("\n"); +#endif + PerSpanData* childSpan = pfd->mSpan; + WritingMode lineWM = mRootSpan->mWritingMode; + if (childSpan) { + // Maybe the child span has the trailing white-space in it? + if (TrimTrailingWhiteSpaceIn(childSpan, aDeltaISize)) { + nscoord deltaISize = *aDeltaISize; + if (deltaISize) { + // Adjust the child spans frame size + pfd->mBounds.ISize(lineWM) -= deltaISize; + if (psd != mRootSpan) { + // When the child span is not a direct child of the block + // we need to update the child spans frame rectangle + // because it most likely will not be done again. Spans + // that are direct children of the block will be updated + // later, however, because the VerticalAlignFrames method + // will be run after this method. + nsSize containerSize = ContainerSizeForSpan(childSpan); + nsIFrame* f = pfd->mFrame; + LogicalRect r(lineWM, f->GetRect(), containerSize); + r.ISize(lineWM) -= deltaISize; + f->SetRect(lineWM, r, containerSize); + } + + // Adjust the inline end edge of the span that contains the child span + psd->mICoord -= deltaISize; + + // Slide any frames that follow the child span over by the + // correct amount. The only thing that can follow the child + // span is empty stuff, so we are just making things + // sensible (keeping the combined area honest). + while (pfd->mNext) { + pfd = pfd->mNext; + pfd->mBounds.IStart(lineWM) -= deltaISize; + if (psd != mRootSpan) { + // When the child span is not a direct child of the block + // we need to update the child span's frame rectangle + // because it most likely will not be done again. Spans + // that are direct children of the block will be updated + // later, however, because the VerticalAlignFrames method + // will be run after this method. + SlideSpanFrameRect(pfd->mFrame, deltaISize); + } + } + } + return true; + } + } else if (!pfd->mIsTextFrame && !pfd->mSkipWhenTrimmingWhitespace) { + // If we hit a frame on the end that's not text and not a placeholder, + // then there is no trailing whitespace to trim. Stop the search. + *aDeltaISize = 0; + return true; + } else if (pfd->mIsTextFrame) { + // Call TrimTrailingWhiteSpace even on empty textframes because they + // might have a soft hyphen which should now appear, changing the frame's + // width + nsTextFrame::TrimOutput trimOutput = + static_cast<nsTextFrame*>(pfd->mFrame) + ->TrimTrailingWhiteSpace( + mLineContainerRI.mRenderingContext->GetDrawTarget()); +#ifdef NOISY_TRIM + psd->mFrame->mFrame->ListTag(stdout); + printf(": trim of "); + pfd->mFrame->ListTag(stdout); + printf(" returned %d\n", trimOutput.mDeltaWidth); +#endif + + if (trimOutput.mChanged) { + pfd->mRecomputeOverflow = true; + } + + // Delta width not being zero means that + // there is trimmed space in the frame. + if (trimOutput.mDeltaWidth) { + pfd->mBounds.ISize(lineWM) -= trimOutput.mDeltaWidth; + + // If any trailing space is trimmed, the justification opportunity + // generated by the space should be removed as well. + pfd->mJustificationInfo.CancelOpportunityForTrimmedSpace(); + + // See if the text frame has already been placed in its parent + if (psd != mRootSpan) { + // The frame was already placed during psd's + // reflow. Update the frames rectangle now. + pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd)); + } + + // Adjust containing span's right edge + psd->mICoord -= trimOutput.mDeltaWidth; + + // Slide any frames that follow the text frame over by the + // right amount. The only thing that can follow the text + // frame is empty stuff, so we are just making things + // sensible (keeping the combined area honest). + while (pfd->mNext) { + pfd = pfd->mNext; + pfd->mBounds.IStart(lineWM) -= trimOutput.mDeltaWidth; + if (psd != mRootSpan) { + // When the child span is not a direct child of the block + // we need to update the child spans frame rectangle + // because it most likely will not be done again. Spans + // that are direct children of the block will be updated + // later, however, because the VerticalAlignFrames method + // will be run after this method. + SlideSpanFrameRect(pfd->mFrame, trimOutput.mDeltaWidth); + } + } + } + + if (pfd->mIsNonEmptyTextFrame || trimOutput.mChanged) { + // Pass up to caller so they can shrink their span + *aDeltaISize = trimOutput.mDeltaWidth; + return true; + } + } + pfd = pfd->mPrev; + } + + *aDeltaISize = 0; + return false; +} + +bool nsLineLayout::TrimTrailingWhiteSpace() { + PerSpanData* psd = mRootSpan; + nscoord deltaISize; + TrimTrailingWhiteSpaceIn(psd, &deltaISize); + return 0 != deltaISize; +} + +bool nsLineLayout::PerFrameData::ParticipatesInJustification() const { + if (mIsMarker || mIsEmpty || mSkipWhenTrimmingWhitespace) { + // Skip ::markers, empty frames, and placeholders + return false; + } + if (mIsTextFrame && !mIsNonWhitespaceTextFrame && + static_cast<nsTextFrame*>(mFrame)->IsAtEndOfLine()) { + // Skip trimmed whitespaces + return false; + } + return true; +} + +struct nsLineLayout::JustificationComputationState { + PerFrameData* mFirstParticipant; + PerFrameData* mLastParticipant; + // When we are going across a boundary of ruby base, i.e. entering + // one, leaving one, or both, the following fields will be set to + // the corresponding ruby base frame for handling ruby-align. + PerFrameData* mLastExitedRubyBase; + PerFrameData* mLastEnteredRubyBase; + + JustificationComputationState() + : mFirstParticipant(nullptr), + mLastParticipant(nullptr), + mLastExitedRubyBase(nullptr), + mLastEnteredRubyBase(nullptr) {} +}; + +static bool IsRubyAlignSpaceAround(nsIFrame* aRubyBase) { + return aRubyBase->StyleText()->mRubyAlign == StyleRubyAlign::SpaceAround; +} + +/** + * Assign justification gaps for justification + * opportunities across two frames. + */ +/* static */ +int nsLineLayout::AssignInterframeJustificationGaps( + PerFrameData* aFrame, JustificationComputationState& aState) { + PerFrameData* prev = aState.mLastParticipant; + MOZ_ASSERT(prev); + + auto& assign = aFrame->mJustificationAssignment; + auto& prevAssign = prev->mJustificationAssignment; + + if (aState.mLastExitedRubyBase || aState.mLastEnteredRubyBase) { + PerFrameData* exitedRubyBase = aState.mLastExitedRubyBase; + if (!exitedRubyBase || IsRubyAlignSpaceAround(exitedRubyBase->mFrame)) { + prevAssign.mGapsAtEnd = 1; + } else { + exitedRubyBase->mJustificationAssignment.mGapsAtEnd = 1; + } + + PerFrameData* enteredRubyBase = aState.mLastEnteredRubyBase; + if (!enteredRubyBase || IsRubyAlignSpaceAround(enteredRubyBase->mFrame)) { + assign.mGapsAtStart = 1; + } else { + enteredRubyBase->mJustificationAssignment.mGapsAtStart = 1; + } + + // We are no longer going across a ruby base boundary. + aState.mLastExitedRubyBase = nullptr; + aState.mLastEnteredRubyBase = nullptr; + return 1; + } + + const auto& info = aFrame->mJustificationInfo; + const auto& prevInfo = prev->mJustificationInfo; + if (!info.mIsStartJustifiable && !prevInfo.mIsEndJustifiable) { + return 0; + } + + if (!info.mIsStartJustifiable) { + prevAssign.mGapsAtEnd = 2; + assign.mGapsAtStart = 0; + } else if (!prevInfo.mIsEndJustifiable) { + prevAssign.mGapsAtEnd = 0; + assign.mGapsAtStart = 2; + } else { + prevAssign.mGapsAtEnd = 1; + assign.mGapsAtStart = 1; + } + return 1; +} + +/** + * Compute the justification info of the given span, and store the + * number of inner opportunities into the frame's justification info. + * It returns the number of non-inner opportunities it detects. + */ +int32_t nsLineLayout::ComputeFrameJustification( + PerSpanData* aPSD, JustificationComputationState& aState) { + NS_ASSERTION(aPSD, "null arg"); + NS_ASSERTION(!aState.mLastParticipant || !aState.mLastParticipant->mSpan, + "Last participant shall always be a leaf frame"); + bool firstChild = true; + int32_t& innerOpportunities = + aPSD->mFrame->mJustificationInfo.mInnerOpportunities; + MOZ_ASSERT(innerOpportunities == 0, + "Justification info should not have been set yet."); + int32_t outerOpportunities = 0; + + for (PerFrameData* pfd = aPSD->mFirstFrame; pfd; pfd = pfd->mNext) { + if (!pfd->ParticipatesInJustification()) { + continue; + } + + bool isRubyBase = pfd->mFrame->IsRubyBaseFrame(); + PerFrameData* outerRubyBase = aState.mLastEnteredRubyBase; + if (isRubyBase) { + aState.mLastEnteredRubyBase = pfd; + } + + int extraOpportunities = 0; + if (pfd->mSpan) { + PerSpanData* span = pfd->mSpan; + extraOpportunities = ComputeFrameJustification(span, aState); + innerOpportunities += pfd->mJustificationInfo.mInnerOpportunities; + } else { + if (pfd->mIsTextFrame) { + innerOpportunities += pfd->mJustificationInfo.mInnerOpportunities; + } + + if (!aState.mLastParticipant) { + aState.mFirstParticipant = pfd; + // It is not an empty ruby base, but we are not assigning gaps + // to the content for now. Clear the last entered ruby base so + // that we can correctly set the last exited ruby base. + aState.mLastEnteredRubyBase = nullptr; + } else { + extraOpportunities = AssignInterframeJustificationGaps(pfd, aState); + } + + aState.mLastParticipant = pfd; + } + + if (isRubyBase) { + if (aState.mLastEnteredRubyBase == pfd) { + // There is no justification participant inside this ruby base. + // Ignore this ruby base completely and restore the outer ruby + // base here. + aState.mLastEnteredRubyBase = outerRubyBase; + } else { + aState.mLastExitedRubyBase = pfd; + } + } + + if (firstChild) { + outerOpportunities = extraOpportunities; + firstChild = false; + } else { + innerOpportunities += extraOpportunities; + } + } + + return outerOpportunities; +} + +void nsLineLayout::AdvanceAnnotationInlineBounds(PerFrameData* aPFD, + const nsSize& aContainerSize, + nscoord aDeltaICoord, + nscoord aDeltaISize) { + nsIFrame* frame = aPFD->mFrame; + LayoutFrameType frameType = frame->Type(); + MOZ_ASSERT(frameType == LayoutFrameType::RubyText || + frameType == LayoutFrameType::RubyTextContainer); + MOZ_ASSERT(aPFD->mSpan, "rt and rtc should have span."); + + PerSpanData* psd = aPFD->mSpan; + WritingMode lineWM = mRootSpan->mWritingMode; + aPFD->mBounds.IStart(lineWM) += aDeltaICoord; + + // Check whether this expansion should be counted into the reserved + // isize or not. When it is a ruby text container, and it has some + // children linked to the base, it must not have reserved isize, + // or its children won't align with their bases. Otherwise, this + // expansion should be reserved. There are two cases a ruby text + // container does not have children linked to the base: + // 1. it is a container for span; 2. its children are collapsed. + // See bug 1055674 for the second case. + if (frameType == LayoutFrameType::RubyText || + // This ruby text container is a span. + (psd->mFirstFrame == psd->mLastFrame && psd->mFirstFrame && + !psd->mFirstFrame->mIsLinkedToBase)) { + // For ruby text frames, only increase frames + // which are not auto-hidden. + if (frameType != LayoutFrameType::RubyText || + !static_cast<nsRubyTextFrame*>(frame)->IsCollapsed()) { + nscoord reservedISize = RubyUtils::GetReservedISize(frame); + RubyUtils::SetReservedISize(frame, reservedISize + aDeltaISize); + } + } else { + // It is a normal ruby text container. Its children will expand + // themselves properly. We only need to expand its own size here. + aPFD->mBounds.ISize(lineWM) += aDeltaISize; + } + aPFD->mFrame->SetRect(lineWM, aPFD->mBounds, aContainerSize); +} + +/** + * This function applies the changes of icoord and isize caused by + * justification to annotations of the given frame. + */ +void nsLineLayout::ApplyLineJustificationToAnnotations(PerFrameData* aPFD, + nscoord aDeltaICoord, + nscoord aDeltaISize) { + PerFrameData* pfd = aPFD->mNextAnnotation; + while (pfd) { + nsSize containerSize = pfd->mFrame->GetParent()->GetSize(); + AdvanceAnnotationInlineBounds(pfd, containerSize, aDeltaICoord, + aDeltaISize); + + // There are two cases where an annotation frame has siblings which + // do not attached to a ruby base-level frame: + // 1. there's an intra-annotation whitespace which has no intra-base + // white-space to pair with; + // 2. there are not enough ruby bases to be paired with annotations. + // In these cases, their size should not be affected, but we still + // need to move them so that they won't overlap other frames. + PerFrameData* sibling = pfd->mNext; + while (sibling && !sibling->mIsLinkedToBase) { + AdvanceAnnotationInlineBounds(sibling, containerSize, + aDeltaICoord + aDeltaISize, 0); + sibling = sibling->mNext; + } + + pfd = pfd->mNextAnnotation; + } +} + +nscoord nsLineLayout::ApplyFrameJustification( + PerSpanData* aPSD, JustificationApplicationState& aState) { + NS_ASSERTION(aPSD, "null arg"); + + nscoord deltaICoord = 0; + for (PerFrameData* pfd = aPSD->mFirstFrame; pfd != nullptr; + pfd = pfd->mNext) { + nscoord dw = 0; + WritingMode lineWM = mRootSpan->mWritingMode; + const auto& assign = pfd->mJustificationAssignment; + bool isInlineText = + pfd->mIsTextFrame && !pfd->mWritingMode.IsOrthogonalTo(lineWM); + + // Don't apply justification if the frame doesn't participate. Same + // as the condition used in ComputeFrameJustification. Note that, + // we still need to move the frame based on deltaICoord even if the + // frame itself doesn't expand. + if (pfd->ParticipatesInJustification()) { + if (isInlineText) { + if (aState.IsJustifiable()) { + // Set corresponding justification gaps here, so that the + // text frame knows how it should add gaps at its sides. + const auto& info = pfd->mJustificationInfo; + auto textFrame = static_cast<nsTextFrame*>(pfd->mFrame); + textFrame->AssignJustificationGaps(assign); + dw = aState.Consume(JustificationUtils::CountGaps(info, assign)); + } + + if (dw) { + pfd->mRecomputeOverflow = true; + } + } else { + if (nullptr != pfd->mSpan) { + dw = ApplyFrameJustification(pfd->mSpan, aState); + } + } + } else { + MOZ_ASSERT(!assign.TotalGaps(), + "Non-participants shouldn't have assigned gaps"); + } + + pfd->mBounds.ISize(lineWM) += dw; + nscoord gapsAtEnd = 0; + if (!isInlineText && assign.TotalGaps()) { + // It is possible that we assign gaps to non-text frame or an + // orthogonal text frame. Apply the gaps as margin for them. + deltaICoord += aState.Consume(assign.mGapsAtStart); + gapsAtEnd = aState.Consume(assign.mGapsAtEnd); + dw += gapsAtEnd; + } + pfd->mBounds.IStart(lineWM) += deltaICoord; + + // The gaps added to the end of the frame should also be + // excluded from the isize added to the annotation. + ApplyLineJustificationToAnnotations(pfd, deltaICoord, dw - gapsAtEnd); + deltaICoord += dw; + pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(aPSD)); + } + return deltaICoord; +} + +static nsIFrame* FindNearestRubyBaseAncestor(nsIFrame* aFrame) { + MOZ_ASSERT(aFrame->Style()->ShouldSuppressLineBreak()); + while (aFrame && !aFrame->IsRubyBaseFrame()) { + aFrame = aFrame->GetParent(); + } + // XXX It is possible that no ruby base ancestor is found because of + // some edge cases like form control or canvas inside ruby text. + // See bug 1138092 comment 4. + NS_WARNING_ASSERTION(aFrame, "no ruby base ancestor?"); + return aFrame; +} + +/** + * This method expands the given frame by the given reserved isize. + */ +void nsLineLayout::ExpandRubyBox(PerFrameData* aFrame, nscoord aReservedISize, + const nsSize& aContainerSize) { + WritingMode lineWM = mRootSpan->mWritingMode; + auto rubyAlign = aFrame->mFrame->StyleText()->mRubyAlign; + switch (rubyAlign) { + case StyleRubyAlign::Start: + // do nothing for start + break; + case StyleRubyAlign::SpaceBetween: + case StyleRubyAlign::SpaceAround: { + int32_t opportunities = aFrame->mJustificationInfo.mInnerOpportunities; + int32_t gaps = opportunities * 2; + if (rubyAlign == StyleRubyAlign::SpaceAround) { + // Each expandable ruby box with ruby-align space-around has a + // gap at each of its sides. For rb/rbc, see comment in + // AssignInterframeJustificationGaps; for rt/rtc, see comment + // in ExpandRubyBoxWithAnnotations. + gaps += 2; + } + if (gaps > 0) { + JustificationApplicationState state(gaps, aReservedISize); + ApplyFrameJustification(aFrame->mSpan, state); + break; + } + // If there are no justification opportunities for space-between, + // fall-through to center per spec. + [[fallthrough]]; + } + case StyleRubyAlign::Center: + // Indent all children by half of the reserved inline size. + for (PerFrameData* child = aFrame->mSpan->mFirstFrame; child; + child = child->mNext) { + child->mBounds.IStart(lineWM) += aReservedISize / 2; + child->mFrame->SetRect(lineWM, child->mBounds, aContainerSize); + } + break; + default: + MOZ_ASSERT_UNREACHABLE("Unknown ruby-align value"); + } + + aFrame->mBounds.ISize(lineWM) += aReservedISize; + aFrame->mFrame->SetRect(lineWM, aFrame->mBounds, aContainerSize); +} + +/** + * This method expands the given frame by the reserved inline size. + * It also expands its annotations if they are expandable and have + * reserved isize larger than zero. + */ +void nsLineLayout::ExpandRubyBoxWithAnnotations(PerFrameData* aFrame, + const nsSize& aContainerSize) { + nscoord reservedISize = RubyUtils::GetReservedISize(aFrame->mFrame); + if (reservedISize) { + ExpandRubyBox(aFrame, reservedISize, aContainerSize); + } + + WritingMode lineWM = mRootSpan->mWritingMode; + bool isLevelContainer = aFrame->mFrame->IsRubyBaseContainerFrame(); + for (PerFrameData* annotation = aFrame->mNextAnnotation; annotation; + annotation = annotation->mNextAnnotation) { + if (lineWM.IsOrthogonalTo(annotation->mFrame->GetWritingMode())) { + // Inter-character case: don't attempt to expand ruby annotations. + continue; + } + if (isLevelContainer) { + nsIFrame* rtcFrame = annotation->mFrame; + MOZ_ASSERT(rtcFrame->IsRubyTextContainerFrame()); + // It is necessary to set the rect again because the container + // width was unknown, and zero was used instead when we reflow + // them. The corresponding base containers were repositioned in + // VerticalAlignFrames and PlaceTopBottomFrames. + MOZ_ASSERT(rtcFrame->GetLogicalSize(lineWM) == + annotation->mBounds.Size(lineWM)); + rtcFrame->SetPosition(lineWM, annotation->mBounds.Origin(lineWM), + aContainerSize); + } + + nscoord reservedISize = RubyUtils::GetReservedISize(annotation->mFrame); + if (!reservedISize) { + continue; + } + + MOZ_ASSERT(annotation->mSpan); + JustificationComputationState computeState; + ComputeFrameJustification(annotation->mSpan, computeState); + if (!computeState.mFirstParticipant) { + continue; + } + if (IsRubyAlignSpaceAround(annotation->mFrame)) { + // Add one gap at each side of this annotation. + computeState.mFirstParticipant->mJustificationAssignment.mGapsAtStart = 1; + computeState.mLastParticipant->mJustificationAssignment.mGapsAtEnd = 1; + } + nsIFrame* parentFrame = annotation->mFrame->GetParent(); + nsSize containerSize = parentFrame->GetSize(); + MOZ_ASSERT(containerSize == aContainerSize || + parentFrame->IsRubyTextContainerFrame(), + "Container width should only be different when the current " + "annotation is a ruby text frame, whose parent is not same " + "as its base frame."); + ExpandRubyBox(annotation, reservedISize, containerSize); + ExpandInlineRubyBoxes(annotation->mSpan); + } +} + +/** + * This method looks for all expandable ruby box in the given span, and + * calls ExpandRubyBox to expand them in depth-first preorder. + */ +void nsLineLayout::ExpandInlineRubyBoxes(PerSpanData* aSpan) { + nsSize containerSize = ContainerSizeForSpan(aSpan); + for (PerFrameData* pfd = aSpan->mFirstFrame; pfd; pfd = pfd->mNext) { + if (RubyUtils::IsExpandableRubyBox(pfd->mFrame)) { + ExpandRubyBoxWithAnnotations(pfd, containerSize); + } + if (pfd->mSpan) { + ExpandInlineRubyBoxes(pfd->mSpan); + } + } +} + +nscoord nsLineLayout::GetHangFrom(const PerSpanData* aSpan, + bool aLineIsRTL) const { + const PerFrameData* pfd = aSpan->mLastFrame; + nscoord result = 0; + while (pfd) { + if (const PerSpanData* childSpan = pfd->mSpan) { + return GetHangFrom(childSpan, aLineIsRTL); + } + if (pfd->mIsTextFrame) { + auto* lastText = static_cast<nsTextFrame*>(pfd->mFrame); + result = lastText->GetHangableISize(); + if (result) { + // If the hangable space will be at the start edge of the line, due to + // its bidi direction being against the line direction, we flag this by + // negating the advance. + lastText->EnsureTextRun(nsTextFrame::eInflated); + auto* textRun = lastText->GetTextRun(nsTextFrame::eInflated); + if (textRun && textRun->IsRightToLeft() != aLineIsRTL) { + result = -result; + } + } + return result; + } + if (!pfd->mSkipWhenTrimmingWhitespace) { + // If we hit a frame on the end that's not text and not a placeholder or + // <br>, then there is no trailing whitespace to hang. Stop the search. + return result; + } + // Scan back for a preceding frame whose whitespace we can hang. + pfd = pfd->mPrev; + } + return result; +} + +gfxTextRun::TrimmableWS nsLineLayout::GetTrimFrom(const PerSpanData* aSpan, + bool aLineIsRTL) const { + const PerFrameData* pfd = aSpan->mLastFrame; + while (pfd) { + if (const PerSpanData* childSpan = pfd->mSpan) { + return GetTrimFrom(childSpan, aLineIsRTL); + } + if (pfd->mIsTextFrame) { + auto* lastText = static_cast<nsTextFrame*>(pfd->mFrame); + auto result = lastText->GetTrimmableWS(); + if (result.mAdvance) { + lastText->EnsureTextRun(nsTextFrame::eInflated); + auto* textRun = lastText->GetTextRun(nsTextFrame::eInflated); + if (textRun && textRun->IsRightToLeft() != aLineIsRTL) { + result.mAdvance = -result.mAdvance; + } + } + return result; + } + if (!pfd->mSkipWhenTrimmingWhitespace) { + // If we hit a frame on the end that's not text and not a placeholder or + // <br>, then there is no trailing whitespace to trim. Stop the search. + return gfxTextRun::TrimmableWS{}; + } + // Scan back for a preceding frame whose whitespace we can trim. + pfd = pfd->mPrev; + } + return gfxTextRun::TrimmableWS{}; +} + +// Align inline frames within the line according to the CSS text-align +// property. +void nsLineLayout::TextAlignLine(nsLineBox* aLine, bool aIsLastLine) { + /** + * NOTE: aIsLastLine ain't necessarily so: it is correctly set by caller + * only in cases where the last line needs special handling. + */ + PerSpanData* psd = mRootSpan; + WritingMode lineWM = psd->mWritingMode; + LAYOUT_WARN_IF_FALSE(psd->mIEnd != NS_UNCONSTRAINEDSIZE, + "have unconstrained width; this should only result from " + "very large sizes, not attempts at intrinsic width " + "calculation"); + nscoord availISize = psd->mIEnd - psd->mIStart; + nscoord remainingISize = availISize - aLine->ISize(); +#ifdef NOISY_INLINEDIR_ALIGN + LineContainerFrame()->ListTag(stdout); + printf(": availISize=%d lineBounds.IStart=%d lineISize=%d delta=%d\n", + availISize, aLine->IStart(), aLine->ISize(), remainingISize); +#endif + + nscoord dx = 0; + StyleTextAlign textAlign = + aIsLastLine ? mStyleText->TextAlignForLastLine() : mStyleText->mTextAlign; + + // Check if there's trailing whitespace we need to "hang" at line-wrap. + nscoord hang = 0; + uint32_t trimCount = 0; + if (aLine->IsLineWrapped()) { + if (textAlign == StyleTextAlign::Justify) { + auto trim = GetTrimFrom(mRootSpan, lineWM.IsBidiRTL()); + hang = NSToCoordRound(trim.mAdvance); + trimCount = trim.mCount; + } else { + hang = GetHangFrom(mRootSpan, lineWM.IsBidiRTL()); + } + } + + bool isSVG = LineContainerFrame()->IsInSVGTextSubtree(); + bool doTextAlign = remainingISize > 0 || hang != 0; + + int32_t additionalGaps = 0; + if (!isSVG && + (mHasRuby || (doTextAlign && textAlign == StyleTextAlign::Justify))) { + JustificationComputationState computeState; + ComputeFrameJustification(psd, computeState); + if (mHasRuby && computeState.mFirstParticipant) { + PerFrameData* firstFrame = computeState.mFirstParticipant; + if (firstFrame->mFrame->Style()->ShouldSuppressLineBreak()) { + MOZ_ASSERT(!firstFrame->mJustificationAssignment.mGapsAtStart); + nsIFrame* rubyBase = FindNearestRubyBaseAncestor(firstFrame->mFrame); + if (rubyBase && IsRubyAlignSpaceAround(rubyBase)) { + firstFrame->mJustificationAssignment.mGapsAtStart = 1; + additionalGaps++; + } + } + PerFrameData* lastFrame = computeState.mLastParticipant; + if (lastFrame->mFrame->Style()->ShouldSuppressLineBreak()) { + MOZ_ASSERT(!lastFrame->mJustificationAssignment.mGapsAtEnd); + nsIFrame* rubyBase = FindNearestRubyBaseAncestor(lastFrame->mFrame); + if (rubyBase && IsRubyAlignSpaceAround(rubyBase)) { + lastFrame->mJustificationAssignment.mGapsAtEnd = 1; + additionalGaps++; + } + } + } + } + + if (!isSVG && doTextAlign) { + switch (textAlign) { + case StyleTextAlign::Justify: { + int32_t opportunities = + psd->mFrame->mJustificationInfo.mInnerOpportunities - + (hang ? trimCount : 0); + if (opportunities > 0) { + int32_t gaps = opportunities * 2 + additionalGaps; + remainingISize += std::abs(hang); + JustificationApplicationState applyState(gaps, remainingISize); + + // Apply the justification, and make sure to update our linebox + // width to account for it. + aLine->ExpandBy(ApplyFrameJustification(psd, applyState), + ContainerSizeForSpan(psd)); + + // If the trimmable trailing whitespace that we want to hang had + // reverse-inline directionality, adjust line position to account for + // it being at the inline-start side. + // On top of the original "hang" amount, justification will have + // modified its width, so we include that adjustment here. + if (hang < 0) { + dx = hang - trimCount * remainingISize / opportunities; + } + + // Gaps that belong to trimmed whitespace were not included in the + // applyState count, so we need to add them here for the assert. + DebugOnly<int32_t> trimmedGaps = hang ? trimCount * 2 : 0; + MOZ_ASSERT(applyState.mGaps.mHandled == + applyState.mGaps.mCount + trimmedGaps, + "Unprocessed justification gaps"); + // Similarly, account for the adjustment applied to the trimmed + // whitespace, which is in addition to the adjustment that applies + // within the actual width of the line. + DebugOnly<int32_t> trimmedAdjustment = + trimCount * remainingISize / opportunities; + NS_ASSERTION(applyState.mWidth.mConsumed == + applyState.mWidth.mAvailable + trimmedAdjustment, + "Unprocessed justification width"); + break; + } + // Fall through to the default case if we could not justify to fill + // the space. + [[fallthrough]]; + } + + case StyleTextAlign::Start: + case StyleTextAlign::Char: + // Default alignment is to start edge so do nothing, except to apply + // any "reverse-hang" amount resulting from reversed-direction trailing + // space. + // Char is for tables so treat as start if we find it in block layout. + if (hang < 0) { + dx = hang; + } + break; + + case StyleTextAlign::Left: + case StyleTextAlign::MozLeft: + if (lineWM.IsBidiRTL()) { + dx = remainingISize + (hang > 0 ? hang : 0); + } else if (hang < 0) { + dx = hang; + } + break; + + case StyleTextAlign::Right: + case StyleTextAlign::MozRight: + if (lineWM.IsBidiLTR()) { + dx = remainingISize + (hang > 0 ? hang : 0); + } else if (hang < 0) { + dx = hang; + } + break; + + case StyleTextAlign::End: + dx = remainingISize + (hang > 0 ? hang : 0); + break; + + case StyleTextAlign::Center: + case StyleTextAlign::MozCenter: + dx = (remainingISize + hang) / 2; + break; + } + } + + if (mHasRuby) { + ExpandInlineRubyBoxes(mRootSpan); + } + + PerFrameData* startFrame = psd->mFirstFrame; + MOZ_ASSERT(startFrame, "empty line?"); + if (startFrame->mIsMarker) { + // ::marker shouldn't participate in bidi reordering nor text alignment. + startFrame = startFrame->mNext; + MOZ_ASSERT(startFrame, "no frame after ::marker?"); + MOZ_ASSERT(!startFrame->mIsMarker, "multiple ::markers?"); + } + + const bool bidi = mPresContext->BidiEnabled() && + (!mPresContext->IsVisualMode() || lineWM.IsBidiRTL()); + if (bidi) { + nsBidiPresUtils::ReorderFrames(startFrame->mFrame, aLine->GetChildCount(), + lineWM, mContainerSize, + psd->mIStart + mTextIndent + dx); + } + + if (dx) { + // For the bidi case, if startFrame is a ::first-line frame, the mIStart and + // mTextIndent offsets will already have been applied to its position, but + // we still need to apply the text-align adjustment |dx| to its position. + const bool needToAdjustFrames = !bidi || startFrame->mFrame->IsLineFrame(); + MOZ_ASSERT_IF(startFrame->mFrame->IsLineFrame(), !startFrame->mNext); + if (needToAdjustFrames) { + for (PerFrameData* pfd = startFrame; pfd; pfd = pfd->mNext) { + pfd->mBounds.IStart(lineWM) += dx; + pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd)); + } + } + aLine->IndentBy(dx, ContainerSize()); + } +} + +// This method applies any relative positioning to the given frame. +void nsLineLayout::ApplyRelativePositioning(PerFrameData* aPFD) { + if (!aPFD->mIsRelativelyOrStickyPos) { + return; + } + + nsIFrame* frame = aPFD->mFrame; + WritingMode frameWM = aPFD->mWritingMode; + LogicalPoint origin = frame->GetLogicalPosition(ContainerSize()); + // right and bottom are handled by + // ReflowInput::ComputeRelativeOffsets + ReflowInput::ApplyRelativePositioning(frame, frameWM, aPFD->mOffsets, &origin, + ContainerSize()); + frame->SetPosition(frameWM, origin, ContainerSize()); +} + +// This method do relative positioning for ruby annotations. +void nsLineLayout::RelativePositionAnnotations(PerSpanData* aRubyPSD, + OverflowAreas& aOverflowAreas) { + MOZ_ASSERT(aRubyPSD->mFrame->mFrame->IsRubyFrame()); + for (PerFrameData* pfd = aRubyPSD->mFirstFrame; pfd; pfd = pfd->mNext) { + MOZ_ASSERT(pfd->mFrame->IsRubyBaseContainerFrame()); + for (PerFrameData* rtc = pfd->mNextAnnotation; rtc; + rtc = rtc->mNextAnnotation) { + nsIFrame* rtcFrame = rtc->mFrame; + MOZ_ASSERT(rtcFrame->IsRubyTextContainerFrame()); + ApplyRelativePositioning(rtc); + OverflowAreas rtcOverflowAreas; + RelativePositionFrames(rtc->mSpan, rtcOverflowAreas); + aOverflowAreas.UnionWith(rtcOverflowAreas + rtcFrame->GetPosition()); + } + } +} + +void nsLineLayout::RelativePositionFrames(PerSpanData* psd, + OverflowAreas& aOverflowAreas) { + OverflowAreas overflowAreas; + WritingMode wm = psd->mWritingMode; + if (psd != mRootSpan) { + // The span's overflow areas come in three parts: + // -- this frame's width and height + // -- pfd->mOverflowAreas, which is the area of a ::marker or the union + // of a relatively positioned frame's absolute children + // -- the bounds of all inline descendants + // The former two parts are computed right here, we gather the descendants + // below. + // At this point psd->mFrame->mBounds might be out of date since + // bidi reordering can move and resize the frames. So use the frame's + // rect instead of mBounds. + nsRect adjustedBounds(nsPoint(0, 0), psd->mFrame->mFrame->GetSize()); + + overflowAreas.ScrollableOverflow().UnionRect( + psd->mFrame->mOverflowAreas.ScrollableOverflow(), adjustedBounds); + overflowAreas.InkOverflow().UnionRect( + psd->mFrame->mOverflowAreas.InkOverflow(), adjustedBounds); + } else { + LogicalRect rect(wm, psd->mIStart, mBStartEdge, psd->mICoord - psd->mIStart, + mFinalLineBSize); + // The minimum combined area for the frames that are direct + // children of the block starts at the upper left corner of the + // line and is sized to match the size of the line's bounding box + // (the same size as the values returned from VerticalAlignFrames) + overflowAreas.InkOverflow() = rect.GetPhysicalRect(wm, ContainerSize()); + overflowAreas.ScrollableOverflow() = overflowAreas.InkOverflow(); + } + + for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) { + nsIFrame* frame = pfd->mFrame; + + // Adjust the origin of the frame + ApplyRelativePositioning(pfd); + + // We must position the view correctly before positioning its + // descendants so that widgets are positioned properly (since only + // some views have widgets). + if (frame->HasView()) + nsContainerFrame::SyncFrameViewAfterReflow( + mPresContext, frame, frame->GetView(), + pfd->mOverflowAreas.InkOverflow(), + nsIFrame::ReflowChildFlags::NoSizeView); + + // Note: the combined area of a child is in its coordinate + // system. We adjust the childs combined area into our coordinate + // system before computing the aggregated value by adding in + // <b>x</b> and <b>y</b> which were computed above. + OverflowAreas r; + if (pfd->mSpan) { + // Compute a new combined area for the child span before + // aggregating it into our combined area. + RelativePositionFrames(pfd->mSpan, r); + } else { + r = pfd->mOverflowAreas; + if (pfd->mIsTextFrame) { + // We need to recompute overflow areas in four cases: + // (1) When PFD_RECOMPUTEOVERFLOW is set due to trimming + // (2) When there are text decorations, since we can't recompute the + // overflow area until Reflow and VerticalAlignLine have finished + // (3) When there are text emphasis marks, since the marks may be + // put further away if the text is inside ruby. + // (4) When there are text strokes + if (pfd->mRecomputeOverflow || + frame->Style()->HasTextDecorationLines() || + frame->StyleText()->HasEffectiveTextEmphasis() || + frame->StyleText()->HasWebkitTextStroke()) { + nsTextFrame* f = static_cast<nsTextFrame*>(frame); + r = f->RecomputeOverflow(LineContainerFrame()); + } + frame->FinishAndStoreOverflow(r, frame->GetSize()); + } + + // If we have something that's not an inline but with a complex frame + // hierarchy inside that contains views, they need to be + // positioned. + // All descendant views must be repositioned even if this frame + // does have a view in case this frame's view does not have a + // widget and some of the descendant views do have widgets -- + // otherwise the widgets won't be repositioned. + nsContainerFrame::PositionChildViews(frame); + } + + // Do this here (rather than along with setting the overflow rect + // below) so we get leaf frames as well. No need to worry + // about the root span, since it doesn't have a frame. + if (frame->HasView()) + nsContainerFrame::SyncFrameViewAfterReflow( + mPresContext, frame, frame->GetView(), r.InkOverflow(), + nsIFrame::ReflowChildFlags::NoMoveView); + + overflowAreas.UnionWith(r + frame->GetPosition()); + } + + // Also compute relative position in the annotations. + if (psd->mFrame->mFrame->IsRubyFrame()) { + RelativePositionAnnotations(psd, overflowAreas); + } + + // If we just computed a spans combined area, we need to update its + // overflow rect... + if (psd != mRootSpan) { + PerFrameData* spanPFD = psd->mFrame; + nsIFrame* frame = spanPFD->mFrame; + frame->FinishAndStoreOverflow(overflowAreas, frame->GetSize()); + } + aOverflowAreas = overflowAreas; +} |