/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * vim:cindent:ts=2:et:sw=2: * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * This Original Code has been modified by IBM Corporation. Modifications made by IBM * described herein are Copyright (c) International Business Machines Corporation, 2000. * Modifications to Mozilla code or documentation identified per MPL Section 3.3 * * Date Modified by Description of modification * 04/20/2000 IBM Corp. OS/2 VisualAge build. */ /* state and methods used while laying out a single line of a block frame */ #ifndef nsLineLayout_h___ #define nsLineLayout_h___ #include "gfxTypes.h" #include "JustificationUtils.h" #include "mozilla/WritingModes.h" #include "BlockReflowInput.h" #include "nsLineBox.h" #include "plarena.h" class nsFloatManager; struct nsStyleText; class nsLineLayout { using BlockReflowInput = mozilla::BlockReflowInput; using ReflowInput = mozilla::ReflowInput; using ReflowOutput = mozilla::ReflowOutput; public: /** * @param aBaseLineLayout the nsLineLayout for ruby base, * nullptr if no separate base nsLineLayout is needed. */ nsLineLayout(nsPresContext* aPresContext, nsFloatManager* aFloatManager, const ReflowInput* aOuterReflowInput, const nsLineList::iterator* aLine, nsLineLayout* aBaseLineLayout); ~nsLineLayout(); void Init(BlockReflowInput* aState, nscoord aMinLineBSize, int32_t aLineNumber) { mBlockRI = aState; mMinLineBSize = aMinLineBSize; mLineNumber = aLineNumber; } int32_t GetLineNumber() const { return mLineNumber; } void BeginLineReflow(nscoord aICoord, nscoord aBCoord, nscoord aISize, nscoord aBSize, bool aImpactedByFloats, bool aIsTopOfPage, mozilla::WritingMode aWritingMode, const nsSize& aContainerSize); void EndLineReflow(); /** * Called when a float has been placed. This method updates the * inline frame and span data to account for any change in positions * due to available space for the line boxes changing. * @param aX/aY/aWidth/aHeight are the new available * space rectangle, relative to the containing block. * @param aFloatFrame the float frame that was placed. */ void UpdateBand(mozilla::WritingMode aWM, const mozilla::LogicalRect& aNewAvailableSpace, nsIFrame* aFloatFrame); void BeginSpan(nsIFrame* aFrame, const ReflowInput* aSpanReflowInput, nscoord aLeftEdge, nscoord aRightEdge, nscoord* aBaseline); // Returns the width of the span nscoord EndSpan(nsIFrame* aFrame); // This method attaches the last frame reflowed in this line layout // to that in the base line layout. void AttachLastFrameToBaseLineLayout() { AttachFrameToBaseLineLayout(LastFrame()); } // This method attaches the root frame of this line layout to the // last reflowed frame in the base line layout. void AttachRootFrameToBaseLineLayout() { AttachFrameToBaseLineLayout(mRootSpan->mFrame); } int32_t GetCurrentSpanCount() const; void SplitLineTo(int32_t aNewCount); bool IsZeroBSize(); // Reflows the frame and returns the reflow status. aPushedFrame is true // if the frame is pushed to the next line because it doesn't fit. void ReflowFrame(nsIFrame* aFrame, nsReflowStatus& aReflowStatus, ReflowOutput* aMetrics, bool& aPushedFrame); void AddBulletFrame(nsIFrame* aFrame, const ReflowOutput& aMetrics); void RemoveBulletFrame(nsIFrame* aFrame) { PushFrame(aFrame); } /** * Place frames in the block direction (CSS property vertical-align) */ void VerticalAlignLine(); bool TrimTrailingWhiteSpace(); /** * Place frames in the inline direction (CSS property text-align). */ void TextAlignLine(nsLineBox* aLine, bool aIsLastLine); /** * Handle all the relative positioning in the line, compute the * combined area (== overflow area) for the line, and handle view * sizing/positioning and the setting of the overflow rect. */ void RelativePositionFrames(nsOverflowAreas& aOverflowAreas) { RelativePositionFrames(mRootSpan, aOverflowAreas); } // Support methods for word-wrapping during line reflow void SetJustificationInfo(const mozilla::JustificationInfo& aInfo) { mJustificationInfo = aInfo; } /** * @return true if so far during reflow no non-empty content has been * placed in the line (according to nsIFrame::IsEmpty()) */ bool LineIsEmpty() const { return mLineIsEmpty; } /** * @return true if so far during reflow no non-empty leaf content * (non-collapsed whitespace, replaced element, inline-block, etc) has been * placed in the line */ bool LineAtStart() const { return mLineAtStart; } bool LineIsBreakable() const; bool GetLineEndsInBR() const { return mLineEndsInBR; } void SetLineEndsInBR(bool aOn) { mLineEndsInBR = aOn; } //---------------------------------------- // Inform the line-layout about the presence of a floating frame // XXX get rid of this: use get-frame-type? bool AddFloat(nsIFrame* aFloat, nscoord aAvailableISize) { // When reflowing ruby text frames, no block reflow state is // provided to the line layout. However, floats should never be // associated with ruby text containers, hence this method should // not be called in that case. MOZ_ASSERT(mBlockRI, "Should not call this method if there is no block reflow state " "available"); return mBlockRI->AddFloat(this, aFloat, aAvailableISize); } void SetTrimmableISize(nscoord aTrimmableISize) { mTrimmableISize = aTrimmableISize; } //---------------------------------------- bool GetFirstLetterStyleOK() const { return mFirstLetterStyleOK; } void SetFirstLetterStyleOK(bool aSetting) { mFirstLetterStyleOK = aSetting; } bool GetInFirstLetter() const { return mInFirstLetter; } void SetInFirstLetter(bool aSetting) { mInFirstLetter = aSetting; } bool GetInFirstLine() const { return mInFirstLine; } void SetInFirstLine(bool aSetting) { mInFirstLine = aSetting; } // Calling this during block reflow ensures that the next line of inlines // will be marked dirty, if there is one. void SetDirtyNextLine() { mDirtyNextLine = true; } bool GetDirtyNextLine() { return mDirtyNextLine; } //---------------------------------------- nsPresContext* mPresContext; /** * Record where an optional break could have been placed. During line reflow, * frames containing optional break points (e.g., whitespace in text frames) * can call SetLastOptionalBreakPosition to record where a break could * have been made, but wasn't because we decided to place more content on * the line. For non-text frames, offset 0 means before the frame, offset * INT32_MAX means after the frame. * * Currently this is used to handle cases where a single word comprises * multiple frames, and the first frame fits on the line but the whole word * doesn't. We look back to the last optional break position and * reflow the whole line again, forcing a break at that position. The last * optional break position could be in a text frame or else after a frame * that cannot be part of a text run, so those are the positions we record. * * @param aFrame the frame which contains the optional break position. * * @param aFits set to true if the break position is within the available width. * * @param aPriority the priority of the break opportunity. If we are * prioritizing break opportunities, we will not set a break if we have * already set a break with a higher priority. @see gfxBreakPriority. * * @return true if we are actually reflowing with forced break position and we * should break here */ bool 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"); // 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; } /** * Like NotifyOptionalBreakPosition, but here it's OK for mNeedBackup * to be set, because the caller is merely pruning some saved break position(s) * that are actually not feasible. */ void RestoreSavedBreakPosition(nsIFrame* aFrame, int32_t aOffset, gfxBreakPriority aPriority) { mLastOptionalBreakFrame = aFrame; mLastOptionalBreakFrameOffset = aOffset; mLastOptionalBreakPriority = aPriority; } /** * Signal that no backing up will be required after all. */ void ClearOptionalBreakPosition() { mNeedBackup = false; mLastOptionalBreakFrame = nullptr; mLastOptionalBreakFrameOffset = -1; mLastOptionalBreakPriority = gfxBreakPriority::eNoBreak; } // Retrieve last set optional break position. When this returns null, no // optional break has been recorded (which means that the line can't break yet). nsIFrame* GetLastOptionalBreakPosition(int32_t* aOffset, gfxBreakPriority* aPriority) { *aOffset = mLastOptionalBreakFrameOffset; *aPriority = mLastOptionalBreakPriority; return mLastOptionalBreakFrame; } // Whether any optional break position has been recorded. bool HasOptionalBreakPosition() const { return mLastOptionalBreakFrame != nullptr; } // Get the priority of the last optional break position recorded. gfxBreakPriority LastOptionalBreakPriority() const { return mLastOptionalBreakPriority; } /** * Check whether frames overflowed the available width and CanPlaceFrame * requested backing up to a saved break position. */ bool NeedsBackup() { return mNeedBackup; } // Line layout may place too much content on a line, overflowing its available // width. When that happens, if SetLastOptionalBreakPosition has been // used to record an optional break that wasn't taken, we can reflow the line // again and force the break to happen at that point (i.e., backtracking // to the last choice point). // Record that we want to break at the given content+offset (which // should have been previously returned by GetLastOptionalBreakPosition // from another nsLineLayout). void ForceBreakAtPosition(nsIFrame* aFrame, int32_t aOffset) { mForceBreakFrame = aFrame; mForceBreakFrameOffset = aOffset; } bool HaveForcedBreakPosition() { return mForceBreakFrame != nullptr; } int32_t GetForcedBreakPosition(nsIFrame* aFrame) { return mForceBreakFrame == aFrame ? mForceBreakFrameOffset : -1; } /** * This can't be null. It usually returns a block frame but may return * some other kind of frame when inline frames are reflowed in a non-block * context (e.g. MathML or floating first-letter). */ nsIFrame* LineContainerFrame() const { return mBlockReflowInput->mFrame; } const ReflowInput* LineContainerRI() const { return mBlockReflowInput; } const nsLineList::iterator* GetLine() const { return mGotLineBox ? &mLineBox : nullptr; } nsLineList::iterator* GetLine() { return mGotLineBox ? &mLineBox : nullptr; } /** * Returns the accumulated advance width of frames before the current frame * on the line, plus the line container's left border+padding. * This is always positive, the advance width is measured from * the right edge for RTL blocks and from the left edge for LTR blocks. * In other words, the current frame's distance from the line container's * start content edge is: * <code>GetCurrentFrameInlineDistanceFromBlock() - lineContainer->GetUsedBorderAndPadding().left</code> * Note the use of <code>.left</code> for both LTR and RTL line containers. */ nscoord GetCurrentFrameInlineDistanceFromBlock(); /** * Move the inline position where the next frame will be reflowed forward by * aAmount. */ void AdvanceICoord(nscoord aAmount) { mCurrentSpan->mICoord += aAmount; } /** * Returns the writing mode for the root span. */ mozilla::WritingMode GetWritingMode() { return mRootSpan->mWritingMode; } /** * Returns the inline position where the next frame will be reflowed. */ nscoord GetCurrentICoord() { return mCurrentSpan->mICoord; } void SetSuppressLineWrap(bool aEnabled) { mSuppressLineWrap = aEnabled; } protected: // This state is constant for a given block frame doing line layout nsFloatManager* mFloatManager; const nsStyleText* mStyleText; // for the block const ReflowInput* mBlockReflowInput; // The line layout for the base text. It is usually nullptr. // It becomes not null when the current line layout is for ruby // annotations. When there is nested ruby inside annotation, it // forms a linked list from the inner annotation to the outermost // line layout. The outermost line layout, which has this member // being nullptr, is responsible for managing the life cycle of // per-frame data and per-span data, and handling floats. nsLineLayout* const mBaseLineLayout; nsLineLayout* GetOutermostLineLayout() { nsLineLayout* lineLayout = this; while (lineLayout->mBaseLineLayout) { lineLayout = lineLayout->mBaseLineLayout; } return lineLayout; } nsIFrame* mLastOptionalBreakFrame; nsIFrame* mForceBreakFrame; // XXX remove this when landing bug 154892 (splitting absolute positioned frames) friend class nsInlineFrame; // XXX Take care that nsRubyBaseContainer would give nullptr to this // member. It should not be a problem currently, since the only // code use it is handling float, which does not affect ruby. // See comment in nsLineLayout::AddFloat BlockReflowInput* mBlockRI;/* XXX hack! */ nsLineList::iterator mLineBox; // Per-frame data recorded by the line-layout reflow logic. This // state is the state needed to post-process the line after reflow // has completed (block-direction alignment, inline-direction alignment, // justification and relative positioning). struct PerSpanData; struct PerFrameData; friend struct PerSpanData; friend struct PerFrameData; struct PerFrameData { // link to next/prev frame in same span PerFrameData* mNext; PerFrameData* mPrev; // Link to the frame of next ruby annotation. It is a linked list // through this pointer from ruby base to all its annotations. It // could be nullptr if there is no more annotation. // If PFD_ISLINKEDTOBASE is set, the current PFD is one of the ruby // annotations in the base's list, otherwise it is the ruby base, // and its mNextAnnotation is the start of the linked list. PerFrameData* mNextAnnotation; // pointer to child span data if this is an inline container frame PerSpanData* mSpan; // The frame nsIFrame* mFrame; // From metrics nscoord mAscent; // note that mBounds is a logical rect in the *line*'s writing mode. // When setting frame coordinates, we have to convert to the frame's // writing mode mozilla::LogicalRect mBounds; nsOverflowAreas mOverflowAreas; // From reflow-state mozilla::LogicalMargin mMargin; // in *line* writing mode mozilla::LogicalMargin mBorderPadding; // in *line* writing mode mozilla::LogicalMargin mOffsets; // in *frame* writing mode // state for text justification // Note that, although all frames would have correct inner // opportunities computed after ComputeFrameJustification, start // and end justifiable info are not reliable for non-text frames. mozilla::JustificationInfo mJustificationInfo; mozilla::JustificationAssignment mJustificationAssignment; // PerFrameData flags bool mRelativePos : 1; bool mIsTextFrame : 1; bool mIsNonEmptyTextFrame : 1; bool mIsNonWhitespaceTextFrame : 1; bool mIsLetterFrame : 1; bool mRecomputeOverflow : 1; bool mIsBullet : 1; bool mSkipWhenTrimmingWhitespace : 1; bool mIsEmpty : 1; bool mIsLinkedToBase : 1; // Other state we use uint8_t mBlockDirAlign; mozilla::WritingMode mWritingMode; PerFrameData* Last() { PerFrameData* pfd = this; while (pfd->mNext) { pfd = pfd->mNext; } return pfd; } bool IsStartJustifiable() const { return mJustificationInfo.mIsStartJustifiable; } bool IsEndJustifiable() const { return mJustificationInfo.mIsEndJustifiable; } bool ParticipatesInJustification() const; }; PerFrameData* mFrameFreeList; // In nsLineLayout, a "span" is a container inline frame, and a "frame" is one // of its children. // // nsLineLayout::BeginLineReflow() creates the initial PerSpanData which is // called the "root span". nsInlineFrame::ReflowFrames() creates a new // PerSpanData when it calls nsLineLayout::BeginSpan(); at this time, the // nsLineLayout object's mCurrentSpan is switched to the new span. The new // span records the old mCurrentSpan as its parent. After reflowing the child // inline frames, nsInlineFrame::ReflowFrames() calls nsLineLayout::EndSpan(), // which pops the PerSpanData and re-sets mCurrentSpan. struct PerSpanData { union { PerSpanData* mParent; PerSpanData* mNextFreeSpan; }; // The PerFrameData of the inline frame that "owns" the span, or null if // this is the root span. mFrame is initialized to the containing inline // frame's PerFrameData when a new PerSpanData is pushed in // nsLineLayout::BeginSpan(). PerFrameData* mFrame; // The first PerFrameData structure in the span. PerFrameData* mFirstFrame; // The last PerFrameData structure in the span. PerFrameData structures are // added to the span as they are reflowed. mLastFrame may also be directly // manipulated if a line is split, or if frames are pushed from one line to // the next. PerFrameData* mLastFrame; const ReflowInput* mReflowInput; bool mNoWrap; mozilla::WritingMode mWritingMode; bool mContainsFloat; bool mHasNonemptyContent; nscoord mIStart; nscoord mICoord; nscoord mIEnd; nscoord mBStartLeading, mBEndLeading; nscoord mLogicalBSize; nscoord mMinBCoord, mMaxBCoord; nscoord* mBaseline; void AppendFrame(PerFrameData* pfd) { if (nullptr == mLastFrame) { mFirstFrame = pfd; } else { mLastFrame->mNext = pfd; pfd->mPrev = mLastFrame; } mLastFrame = pfd; } }; PerSpanData* mSpanFreeList; PerSpanData* mRootSpan; PerSpanData* mCurrentSpan; // The container size to use when converting between logical and // physical coordinates for frames in this span. For the root span // this is the size of the block cached in mContainerSize; for // child spans it's the size of the root span. nsSize ContainerSizeForSpan(PerSpanData* aPSD) { return (aPSD == mRootSpan) ? mContainerSize : aPSD->mFrame->mBounds.Size(mRootSpan->mWritingMode). GetPhysicalSize(mRootSpan->mWritingMode); } gfxBreakPriority mLastOptionalBreakPriority; int32_t mLastOptionalBreakFrameOffset; int32_t mForceBreakFrameOffset; nscoord mMinLineBSize; // The amount of text indent that we applied to this line, needed for // max-element-size calculation. nscoord mTextIndent; // This state varies during the reflow of a line but is line // "global" state not span "local" state. int32_t mLineNumber; mozilla::JustificationInfo mJustificationInfo; int32_t mTotalPlacedFrames; nscoord mBStartEdge; nscoord mMaxStartBoxBSize; nscoord mMaxEndBoxBSize; nscoord mInflationMinFontSize; // Final computed line-bSize value after VerticalAlignFrames for // the block has been called. nscoord mFinalLineBSize; // Amount of trimmable whitespace inline size for the trailing text // frame, if any nscoord mTrimmableISize; // Physical size. Use only for physical <-> logical coordinate conversion. nsSize mContainerSize; const nsSize& ContainerSize() const { return mContainerSize; } bool mFirstLetterStyleOK : 1; bool mIsTopOfPage : 1; bool mImpactedByFloats : 1; bool mLastFloatWasLetterFrame : 1; bool mLineIsEmpty : 1; bool mLineEndsInBR : 1; bool mNeedBackup : 1; bool mInFirstLine : 1; bool mGotLineBox : 1; bool mInFirstLetter : 1; bool mHasBullet : 1; bool mDirtyNextLine : 1; bool mLineAtStart : 1; bool mHasRuby : 1; bool mSuppressLineWrap : 1; int32_t mSpanDepth; #ifdef DEBUG int32_t mSpansAllocated, mSpansFreed; int32_t mFramesAllocated, mFramesFreed; #endif PLArenaPool mArena; // Per span and per frame data, 4 byte aligned /** * Allocate a PerFrameData from the mArena pool. The allocation is infallible. */ PerFrameData* NewPerFrameData(nsIFrame* aFrame); /** * Allocate a PerSpanData from the mArena pool. The allocation is infallible. */ PerSpanData* NewPerSpanData(); PerFrameData* LastFrame() const { return mCurrentSpan->mLastFrame; } /** * Unlink the given PerFrameData and all the siblings after it from * the span. The unlinked PFDs are usually freed immediately. * However, if PFD_ISLINKEDTOBASE is set, it won't be freed until * the frame of its base is unlinked. */ void UnlinkFrame(PerFrameData* pfd); /** * Free the given PerFrameData. */ void FreeFrame(PerFrameData* pfd); void FreeSpan(PerSpanData* psd); bool InBlockContext() const { return mSpanDepth == 0; } void PushFrame(nsIFrame* aFrame); void AllowForStartMargin(PerFrameData* pfd, ReflowInput& aReflowInput); void SyncAnnotationBounds(PerFrameData* aRubyFrame); bool CanPlaceFrame(PerFrameData* pfd, bool aNotSafeToBreak, bool aFrameCanContinueTextRun, bool aCanRollBackBeforeFrame, ReflowOutput& aMetrics, nsReflowStatus& aStatus, bool* aOptionalBreakAfterFits); void PlaceFrame(PerFrameData* pfd, ReflowOutput& aMetrics); void AdjustLeadings(nsIFrame* spanFrame, PerSpanData* psd, const nsStyleText* aStyleText, float aInflation, bool* aZeroEffectiveSpanBox); void VerticalAlignFrames(PerSpanData* psd); void PlaceTopBottomFrames(PerSpanData* psd, nscoord aDistanceFromStart, nscoord aLineBSize); void ApplyRelativePositioning(PerFrameData* aPFD); void RelativePositionAnnotations(PerSpanData* aRubyPSD, nsOverflowAreas& aOverflowAreas); void RelativePositionFrames(PerSpanData* psd, nsOverflowAreas& aOverflowAreas); bool TrimTrailingWhiteSpaceIn(PerSpanData* psd, nscoord* aDeltaISize); struct JustificationComputationState; static int AssignInterframeJustificationGaps( PerFrameData* aFrame, JustificationComputationState& aState); int32_t ComputeFrameJustification(PerSpanData* psd, JustificationComputationState& aState); void AdvanceAnnotationInlineBounds(PerFrameData* aPFD, const nsSize& aContainerSize, nscoord aDeltaICoord, nscoord aDeltaISize); void ApplyLineJustificationToAnnotations(PerFrameData* aPFD, nscoord aDeltaICoord, nscoord aDeltaISize); // Apply justification. The return value is the amount by which the width of // the span corresponding to aPSD got increased due to justification. nscoord ApplyFrameJustification( PerSpanData* aPSD, mozilla::JustificationApplicationState& aState); void ExpandRubyBox(PerFrameData* aFrame, nscoord aReservedISize, const nsSize& aContainerSize); void ExpandRubyBoxWithAnnotations(PerFrameData* aFrame, const nsSize& aContainerSize); void ExpandInlineRubyBoxes(PerSpanData* aSpan); void AttachFrameToBaseLineLayout(PerFrameData* aFrame); #ifdef DEBUG void DumpPerSpanData(PerSpanData* psd, int32_t aIndent); #endif }; #endif /* nsLineLayout_h___ */