The Tor Browser / file revision

 /* -*- 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 "nsLineBox.h"

 #include "nsBlockReflowState.h"

 #include "plarena.h"

 #include "gfxTypes.h"

 #include "WritingModes.h"

 class nsFloatManager;

 struct nsStyleText;

 class nsLineLayout {

 public:

   nsLineLayout(nsPresContext* aPresContext,

                nsFloatManager* aFloatManager,

                const nsHTMLReflowState* aOuterReflowState,

                const nsLineList::iterator* aLine);

   ~nsLineLayout();

   void Init(nsBlockReflowState* 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,

                        nscoord aContainerWidth);

   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(const nsRect& aNewAvailableSpace,

                   nsIFrame* aFloatFrame);

   void BeginSpan(nsIFrame* aFrame, const nsHTMLReflowState* aSpanReflowState,

                  nscoord aLeftEdge, nscoord aRightEdge, nscoord* aBaseline);

   // Returns the width of the span

   nscoord EndSpan(nsIFrame* aFrame);

   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

   nsresult ReflowFrame(nsIFrame* aFrame,

                        nsReflowStatus& aReflowStatus,

                        nsHTMLReflowMetrics* aMetrics,

                        bool& aPushedFrame);

   void AddBulletFrame(nsIFrame* aFrame, const nsHTMLReflowMetrics& aMetrics);

   void RemoveBulletFrame(nsIFrame* aFrame) {

     PushFrame(aFrame);

   }

   void BlockDirAlignLine();

   bool TrimTrailingWhiteSpace();

   void InlineDirAlignFrames(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);

   // Support methods for word-wrapping during line reflow

   void SetTextJustificationWeights(int32_t aNumSpaces, int32_t aNumLetters) {

     mTextJustificationNumSpaces = aNumSpaces;

     mTextJustificationNumLetters = aNumLetters;

   }

   /**

    * @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 aAvailableWidth)

   {

     return mBlockRS->AddFloat(this, aFloat, aAvailableWidth);

   }

   void SetTrimmableWidth(nscoord aTrimmableWidth) {

     mTrimmableWidth = aTrimmableWidth;

   }

   //----------------------------------------

   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 content, offset INT32_MAX means after the content.

    * 

    * 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 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(nsIContent* aContent, 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) ||

         !mLastOptionalBreakContent) {

       mLastOptionalBreakContent = aContent;

       mLastOptionalBreakContentOffset = aOffset;

       mLastOptionalBreakPriority = aPriority;

     }

     return aContent && mForceBreakContent == aContent &&

       mForceBreakContentOffset == 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(nsIContent* aContent, int32_t aOffset,

                                  gfxBreakPriority aPriority) {

     mLastOptionalBreakContent = aContent;

     mLastOptionalBreakContentOffset = aOffset;

     mLastOptionalBreakPriority = aPriority;

   }

   /**

    * Signal that no backing up will be required after all.

    */

   void ClearOptionalBreakPosition() {

     mNeedBackup = false;

     mLastOptionalBreakContent = nullptr;

     mLastOptionalBreakContentOffset = -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).

   nsIContent* GetLastOptionalBreakPosition(int32_t* aOffset,

                                            gfxBreakPriority* aPriority) {

     *aOffset = mLastOptionalBreakContentOffset;

     *aPriority = mLastOptionalBreakPriority;

     return mLastOptionalBreakContent;

   }

   /**

    * 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(nsIContent* aContent, int32_t aOffset) {

     mForceBreakContent = aContent;

     mForceBreakContentOffset = aOffset;

   }

   bool HaveForcedBreakPosition() { return mForceBreakContent != nullptr; }

   int32_t GetForcedBreakPosition(nsIContent* aContent) {

     return mForceBreakContent == aContent ? mForceBreakContentOffset : -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 mBlockReflowState->frame; }

   const nsHTMLReflowState* LineContainerRS() const { return mBlockReflowState; }

   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();

 protected:

   // This state is constant for a given block frame doing line layout

   nsFloatManager* mFloatManager;

   const nsStyleText* mStyleText; // for the block

   const nsHTMLReflowState* mBlockReflowState;

   nsIContent* mLastOptionalBreakContent;

   nsIContent* mForceBreakContent;

   // XXX remove this when landing bug 154892 (splitting absolute positioned frames)

   friend class nsInlineFrame;

   nsBlockReflowState* mBlockRS;/* 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

   {

     PerFrameData(mozilla::WritingMode aWritingMode)

       : mBounds(aWritingMode)

       , mMargin(aWritingMode)

       , mBorderPadding(aWritingMode)

       , mOffsets(aWritingMode)

     {}

     // link to next/prev frame in same span

     PerFrameData* mNext;

     PerFrameData* mPrev;

     // 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;

     mozilla::LogicalMargin mBorderPadding;

     mozilla::LogicalMargin mOffsets;

     // state for text justification

     int32_t mJustificationNumSpaces;

     int32_t mJustificationNumLetters;

     // Other state we use

     uint8_t mBlockDirAlign;

 // PerFrameData flags

 #define PFD_RELATIVEPOS                 0x00000001

 #define PFD_ISTEXTFRAME                 0x00000002

 #define PFD_ISNONEMPTYTEXTFRAME         0x00000004

 #define PFD_ISNONWHITESPACETEXTFRAME    0x00000008

 #define PFD_ISLETTERFRAME               0x00000010

 #define PFD_RECOMPUTEOVERFLOW           0x00000020

 #define PFD_ISBULLET                    0x00000040

 #define PFD_SKIPWHENTRIMMINGWHITESPACE  0x00000080

 #define PFD_LASTFLAG                    PFD_SKIPWHENTRIMMINGWHITESPACE

     uint8_t mFlags;

     void SetFlag(uint32_t aFlag, bool aValue)

     {

       NS_ASSERTION(aFlag<=PFD_LASTFLAG, "bad flag");

       NS_ASSERTION(aFlag<=UINT8_MAX, "bad flag");

       if (aValue) { // set flag

         mFlags |= aFlag;

       }

       else {        // unset flag

         mFlags &= ~aFlag;

       }

     }

     bool GetFlag(uint32_t aFlag) const

     {

       NS_ASSERTION(aFlag<=PFD_LASTFLAG, "bad flag");

       return !!(mFlags & aFlag);

     }

     PerFrameData* Last() {

       PerFrameData* pfd = this;

       while (pfd->mNext) {

         pfd = pfd->mNext;

       }

       return pfd;

     }

   };

   PerFrameData* mFrameFreeList;

   struct PerSpanData {

     union {

       PerSpanData* mParent;

       PerSpanData* mNextFreeSpan;

     };

     PerFrameData* mFrame;

     PerFrameData* mFirstFrame;

     PerFrameData* mLastFrame;

     const nsHTMLReflowState* mReflowState;

     bool mNoWrap;

     mozilla::WritingMode mWritingMode;

     bool mZeroEffectiveSpanBox;

     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;

   gfxBreakPriority mLastOptionalBreakPriority;

   int32_t     mLastOptionalBreakContentOffset;

   int32_t     mForceBreakContentOffset;

   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;

   int32_t mTextJustificationNumSpaces;

   int32_t mTextJustificationNumLetters;

   int32_t mTotalPlacedFrames;

   nscoord mBStartEdge;

   nscoord mMaxStartBoxBSize;

   nscoord mMaxEndBoxBSize;

   nscoord mInflationMinFontSize;

   // Final computed line-bSize value after BlockDirAlignFrames for

   // the block has been called.

   nscoord mFinalLineBSize;

   // Amount of trimmable whitespace width for the trailing text frame, if any

   nscoord mTrimmableWidth;

   nscoord mContainerWidth;

   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;

   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();

   void FreeSpan(PerSpanData* psd);

   bool InBlockContext() const {

     return mSpanDepth == 0;

   }

   void PushFrame(nsIFrame* aFrame);

   void AllowForStartMargin(PerFrameData* pfd,

                            nsHTMLReflowState& aReflowState);

   bool CanPlaceFrame(PerFrameData* pfd,

                        bool aNotSafeToBreak,

                        bool aFrameCanContinueTextRun,

                        bool aCanRollBackBeforeFrame,

                        nsHTMLReflowMetrics& aMetrics,

                        nsReflowStatus& aStatus,

                        bool* aOptionalBreakAfterFits);

   void PlaceFrame(PerFrameData* pfd,

                   nsHTMLReflowMetrics& aMetrics);

   void BlockDirAlignFrames(PerSpanData* psd);

   void PlaceStartEndFrames(PerSpanData* psd,

                            nscoord aDistanceFromStart,

                            nscoord aLineBSize);

   void RelativePositionFrames(PerSpanData* psd, nsOverflowAreas& aOverflowAreas);

   bool TrimTrailingWhiteSpaceIn(PerSpanData* psd, nscoord* aDeltaISize);

   void ComputeJustificationWeights(PerSpanData* psd, int32_t* numSpaces, int32_t* numLetters);

   struct FrameJustificationState {

     int32_t mTotalNumSpaces;

     int32_t mTotalNumLetters;

     nscoord mTotalWidthForSpaces;

     nscoord mTotalWidthForLetters;

     int32_t mNumSpacesProcessed;

     int32_t mNumLettersProcessed;

     nscoord mWidthForSpacesProcessed;

     nscoord mWidthForLettersProcessed;

   };

   // 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,

                                   FrameJustificationState* aState);

 #ifdef DEBUG

   void DumpPerSpanData(PerSpanData* psd, int32_t aIndent);

 #endif

 };

 #endif /* nsLineLayout_h___ */