The Tor Browser: layout/generic/nsLineLayout.h@6474c204b198 (annotated)

layout/generic/nsLineLayout.h@6474c204b198 (annotated)

layout/generic/nsLineLayout.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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___ */

The Tor Browser / annotate

layout/generic/nsLineLayout.h@6474c204b198 (annotated)

layout/generic/nsLineLayout.h