diff options
Diffstat (limited to 'layout/generic/nsLineLayout.h')
| -rw-r--r-- | layout/generic/nsLineLayout.h | 693 |
1 files changed, 693 insertions, 0 deletions
diff --git a/layout/generic/nsLineLayout.h b/layout/generic/nsLineLayout.h new file mode 100644 index 0000000000..1c265c9e91 --- /dev/null +++ b/layout/generic/nsLineLayout.h @@ -0,0 +1,693 @@ +/* -*- 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 */ + +#ifndef nsLineLayout_h___ +#define nsLineLayout_h___ + +#include "gfxTypes.h" +#include "gfxTextRun.h" +#include "JustificationUtils.h" +#include "mozilla/ArenaAllocator.h" +#include "mozilla/WritingModes.h" +#include "BlockReflowState.h" +#include "nsLineBox.h" + +class nsFloatManager; +struct nsStyleText; + +class nsLineLayout { + using BlockReflowState = mozilla::BlockReflowState; + 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& aLineContainerRI, + const nsLineList::iterator* aLine, + nsLineLayout* aBaseLineLayout); + ~nsLineLayout(); + + void Init(BlockReflowState* aState, nscoord aMinLineBSize, + int32_t aLineNumber) { + mBlockRS = 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 AddMarkerFrame(nsIFrame* aFrame, const ReflowOutput& aMetrics); + + void RemoveMarkerFrame(nsIFrame* 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(mozilla::OverflowAreas& 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(mBlockRS, + "Should not call this method if there is no block reflow state " + "available"); + return mBlockRS->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); + + // Tries to place a float, and records whether the float actually was placed. + bool TryToPlaceFloat(nsIFrame* aFloat); + + // Records a floating frame in a nowrap context for it to be placed on the + // next break opportunity. + void RecordNoWrapFloat(nsIFrame* aFloat); + + // Tries to place the floats from the nowrap context. + void FlushNoWrapFloats(); + + /** + * 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 mLineContainerRI.mFrame; } + const ReflowInput& LineContainerRI() const { return mLineContainerRI; } + 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 + + // A non-owning pointer, which points to the object owned by + // nsAutoFloatManager::mNew. + nsFloatManager* mFloatManager; + + const nsStyleText* mStyleText; // for the block + const ReflowInput& mLineContainerRI; + + // 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 + BlockReflowState* mBlockRS = nullptr; /* 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; + mozilla::OverflowAreas 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 mIsRelativelyOrStickyPos : 1; + bool mIsTextFrame : 1; + bool mIsNonEmptyTextFrame : 1; + bool mIsNonWhitespaceTextFrame : 1; + bool mIsLetterFrame : 1; + bool mRecomputeOverflow : 1; + bool mIsMarker : 1; + bool mSkipWhenTrimmingWhitespace : 1; + bool mIsEmpty : 1; + bool mIsPlaceholder : 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 (!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); + } + + // Get the advance of any trailing hangable whitespace. If the whitespace + // has directionality opposite to the line, the result is negated. + nscoord GetHangFrom(const PerSpanData* aSpan, bool aLineIsRTL) const; + gfxTextRun::TrimmableWS GetTrimFrom(const PerSpanData* aSpan, + bool aLineIsRTL) const; + + 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 mHasMarker : 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 + + /** + * Per span and per frame data. + */ + mozilla::ArenaAllocator<1024, sizeof(void*)> mArena; + + /** + * 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, + mozilla::OverflowAreas& aOverflowAreas); + + void RelativePositionFrames(PerSpanData* psd, + mozilla::OverflowAreas& 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___ */ |