diff options
Diffstat (limited to 'layout/generic/nsTextFrame.h')
| -rw-r--r-- | layout/generic/nsTextFrame.h | 1004 |
1 files changed, 1004 insertions, 0 deletions
diff --git a/layout/generic/nsTextFrame.h b/layout/generic/nsTextFrame.h new file mode 100644 index 0000000000..66ed7eb175 --- /dev/null +++ b/layout/generic/nsTextFrame.h @@ -0,0 +1,1004 @@ +/* -*- 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/. */ + +#ifndef nsTextFrame_h__ +#define nsTextFrame_h__ + +#include "mozilla/Attributes.h" +#include "mozilla/EventForwards.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/Text.h" +#include "nsIFrame.h" +#include "nsFrameSelection.h" +#include "nsSplittableFrame.h" +#include "nsLineBox.h" +#include "gfxSkipChars.h" +#include "gfxTextRun.h" +#include "nsDisplayList.h" +#include "nsFontMetrics.h" +#include "JustificationUtils.h" +#include "RubyUtils.h" + +// Undo the windows.h damage +#if defined(XP_WIN) && defined(DrawText) +# undef DrawText +#endif + +class nsTextPaintStyle; +struct SelectionDetails; +class nsTextFragment; + +namespace mozilla { +class SVGContextPaint; +class SVGTextFrame; +} // namespace mozilla + +class nsTextFrame : public nsIFrame { + typedef mozilla::LayoutDeviceRect LayoutDeviceRect; + typedef mozilla::SelectionTypeMask SelectionTypeMask; + typedef mozilla::SelectionType SelectionType; + typedef mozilla::TextRangeStyle TextRangeStyle; + typedef mozilla::gfx::DrawTarget DrawTarget; + typedef mozilla::gfx::Point Point; + typedef mozilla::gfx::Rect Rect; + typedef mozilla::gfx::Size Size; + typedef gfxTextRun::Range Range; + + public: + enum TextRunType : uint8_t; + struct TabWidthStore; + + /** + * An implementation of gfxTextRun::PropertyProvider that computes spacing and + * hyphenation based on CSS properties for a text frame. + */ + class MOZ_STACK_CLASS PropertyProvider final + : public gfxTextRun::PropertyProvider { + typedef gfxTextRun::Range Range; + typedef gfxTextRun::HyphenType HyphenType; + typedef mozilla::gfx::DrawTarget DrawTarget; + + public: + /** + * Use this constructor for reflow, when we don't know what text is + * really mapped by the frame and we have a lot of other data around. + * + * @param aLength can be INT32_MAX to indicate we cover all the text + * associated with aFrame up to where its flow chain ends in the given + * textrun. If INT32_MAX is passed, justification and hyphen-related methods + * cannot be called, nor can GetOriginalLength(). + */ + PropertyProvider(gfxTextRun* aTextRun, const nsStyleText* aTextStyle, + const nsTextFragment* aFrag, nsTextFrame* aFrame, + const gfxSkipCharsIterator& aStart, int32_t aLength, + nsIFrame* aLineContainer, + nscoord aOffsetFromBlockOriginForTabs, + nsTextFrame::TextRunType aWhichTextRun); + + /** + * Use this constructor after the frame has been reflowed and we don't + * have other data around. Gets everything from the frame. EnsureTextRun + * *must* be called before this!!! + */ + PropertyProvider(nsTextFrame* aFrame, const gfxSkipCharsIterator& aStart, + nsTextFrame::TextRunType aWhichTextRun, + nsFontMetrics* aFontMetrics); + + /** + * As above, but assuming we want the inflated text run and associated + * metrics. + */ + PropertyProvider(nsTextFrame* aFrame, const gfxSkipCharsIterator& aStart) + : PropertyProvider(aFrame, aStart, nsTextFrame::eInflated, + aFrame->InflatedFontMetrics()) {} + + // Call this after construction if you're not going to reflow the text + void InitializeForDisplay(bool aTrimAfter); + + void InitializeForMeasure(); + + void GetSpacing(Range aRange, Spacing* aSpacing) const final; + gfxFloat GetHyphenWidth() const final; + void GetHyphenationBreaks(Range aRange, + HyphenType* aBreakBefore) const final; + mozilla::StyleHyphens GetHyphensOption() const final { + return mTextStyle->mHyphens; + } + + already_AddRefed<DrawTarget> GetDrawTarget() const final; + + uint32_t GetAppUnitsPerDevUnit() const final { + return mTextRun->GetAppUnitsPerDevUnit(); + } + + void GetSpacingInternal(Range aRange, Spacing* aSpacing, + bool aIgnoreTabs) const; + + /** + * Compute the justification information in given DOM range, return + * justification info and assignments if requested. + */ + mozilla::JustificationInfo ComputeJustification( + Range aRange, + nsTArray<mozilla::JustificationAssignment>* aAssignments = nullptr); + + const nsTextFrame* GetFrame() const { return mFrame; } + // This may not be equal to the frame offset/length in because we may have + // adjusted for whitespace trimming according to the state bits set in the + // frame (for the static provider) + const gfxSkipCharsIterator& GetStart() const { return mStart; } + // May return INT32_MAX if that was given to the constructor + uint32_t GetOriginalLength() const { + NS_ASSERTION(mLength != INT32_MAX, "Length not known"); + return mLength; + } + const nsTextFragment* GetFragment() const { return mFrag; } + + gfxFontGroup* GetFontGroup() const { + if (!mFontGroup) { + mFontGroup = GetFontMetrics()->GetThebesFontGroup(); + } + return mFontGroup; + } + + nsFontMetrics* GetFontMetrics() const { + if (!mFontMetrics) { + InitFontGroupAndFontMetrics(); + } + return mFontMetrics; + } + + void CalcTabWidths(Range aTransformedRange, gfxFloat aTabWidth) const; + + gfxFloat MinTabAdvance() const; + + const gfxSkipCharsIterator& GetEndHint() const { return mTempIterator; } + + protected: + void SetupJustificationSpacing(bool aPostReflow); + + void InitFontGroupAndFontMetrics() const; + + const RefPtr<gfxTextRun> mTextRun; + mutable gfxFontGroup* mFontGroup; + mutable RefPtr<nsFontMetrics> mFontMetrics; + const nsStyleText* mTextStyle; + const nsTextFragment* mFrag; + const nsIFrame* mLineContainer; + nsTextFrame* mFrame; + gfxSkipCharsIterator mStart; // Offset in original and transformed string + const gfxSkipCharsIterator mTempIterator; + + // Either null, or pointing to the frame's TabWidthProperty. + mutable nsTextFrame::TabWidthStore* mTabWidths; + // How far we've done tab-width calculation; this is ONLY valid when + // mTabWidths is nullptr (otherwise rely on mTabWidths->mLimit instead). + // It's a DOM offset relative to the current frame's offset. + mutable uint32_t mTabWidthsAnalyzedLimit; + + int32_t mLength; // DOM string length, may be INT32_MAX + const gfxFloat mWordSpacing; // space for each whitespace char + const gfxFloat mLetterSpacing; // space for each letter + mutable gfxFloat mMinTabAdvance; // min advance for <tab> char + mutable gfxFloat mHyphenWidth; + mutable gfxFloat mOffsetFromBlockOriginForTabs; + + // The values in mJustificationSpacings corresponds to unskipped + // characters start from mJustificationArrayStart. + uint32_t mJustificationArrayStart; + nsTArray<Spacing> mJustificationSpacings; + + const bool mReflowing; + const nsTextFrame::TextRunType mWhichTextRun; + }; + + explicit nsTextFrame(ComputedStyle* aStyle, nsPresContext* aPresContext, + ClassID aID = kClassID) + : nsIFrame(aStyle, aPresContext, aID), + mNextContinuation(nullptr), + mContentOffset(0), + mContentLengthHint(0), + mAscent(0) {} + + NS_DECL_FRAMEARENA_HELPERS(nsTextFrame) + + friend class nsContinuingTextFrame; + + // nsQueryFrame + NS_DECL_QUERYFRAME + + // nsIFrame + void BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) final; + + void Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) override; + + void DestroyFrom(nsIFrame* aDestructRoot, + PostDestroyData& aPostDestroyData) override; + + mozilla::Maybe<Cursor> GetCursor(const nsPoint&) final; + + nsresult CharacterDataChanged(const CharacterDataChangeInfo&) final; + + nsTextFrame* GetPrevContinuation() const override { return nullptr; } + nsTextFrame* GetNextContinuation() const final { return mNextContinuation; } + void SetNextContinuation(nsIFrame* aNextContinuation) final { + NS_ASSERTION(!aNextContinuation || Type() == aNextContinuation->Type(), + "setting a next continuation with incorrect type!"); + NS_ASSERTION( + !nsSplittableFrame::IsInNextContinuationChain(aNextContinuation, this), + "creating a loop in continuation chain!"); + mNextContinuation = static_cast<nsTextFrame*>(aNextContinuation); + if (aNextContinuation) + aNextContinuation->RemoveStateBits(NS_FRAME_IS_FLUID_CONTINUATION); + // Setting a non-fluid continuation might affect our flow length (they're + // quite rare so we assume it always does) so we delete our cached value: + if (GetContent()->HasFlag(NS_HAS_FLOWLENGTH_PROPERTY)) { + GetContent()->RemoveProperty(nsGkAtoms::flowlength); + GetContent()->UnsetFlags(NS_HAS_FLOWLENGTH_PROPERTY); + } + } + nsTextFrame* GetNextInFlow() const final { + return mNextContinuation && mNextContinuation->HasAnyStateBits( + NS_FRAME_IS_FLUID_CONTINUATION) + ? mNextContinuation + : nullptr; + } + void SetNextInFlow(nsIFrame* aNextInFlow) final { + NS_ASSERTION(!aNextInFlow || Type() == aNextInFlow->Type(), + "setting a next in flow with incorrect type!"); + NS_ASSERTION( + !nsSplittableFrame::IsInNextContinuationChain(aNextInFlow, this), + "creating a loop in continuation chain!"); + mNextContinuation = static_cast<nsTextFrame*>(aNextInFlow); + if (mNextContinuation && + !mNextContinuation->HasAnyStateBits(NS_FRAME_IS_FLUID_CONTINUATION)) { + // Changing from non-fluid to fluid continuation might affect our flow + // length, so we delete our cached value: + if (GetContent()->HasFlag(NS_HAS_FLOWLENGTH_PROPERTY)) { + GetContent()->RemoveProperty(nsGkAtoms::flowlength); + GetContent()->UnsetFlags(NS_HAS_FLOWLENGTH_PROPERTY); + } + } + if (aNextInFlow) { + aNextInFlow->AddStateBits(NS_FRAME_IS_FLUID_CONTINUATION); + } + } + nsTextFrame* LastInFlow() const final; + nsTextFrame* LastContinuation() const final; + + bool IsFrameOfType(uint32_t aFlags) const final { + // Set the frame state bit for text frames to mark them as replaced. + // XXX kipp: temporary + return nsIFrame::IsFrameOfType( + aFlags & ~(nsIFrame::eReplaced | nsIFrame::eLineParticipant)); + } + + bool ShouldSuppressLineBreak() const { + // If the parent frame of the text frame is ruby content box, it must + // suppress line break inside. This check is necessary, because when + // a whitespace is only contained by pseudo ruby frames, its style + // context won't have SuppressLineBreak bit set. + if (mozilla::RubyUtils::IsRubyContentBox(GetParent()->Type())) { + return true; + } + return Style()->ShouldSuppressLineBreak(); + } + + void InvalidateFrame(uint32_t aDisplayItemKey = 0, + bool aRebuildDisplayItems = true) final; + void InvalidateFrameWithRect(const nsRect& aRect, + uint32_t aDisplayItemKey = 0, + bool aRebuildDisplayItems = true) final; + +#ifdef DEBUG_FRAME_DUMP + void List(FILE* out = stderr, const char* aPrefix = "", + ListFlags aFlags = ListFlags()) const final; + nsresult GetFrameName(nsAString& aResult) const final; + void ToCString(nsCString& aBuf, int32_t* aTotalContentLength) const; + void ListTextRuns(FILE* out, + nsTHashtable<nsVoidPtrHashKey>& aSeen) const final; +#endif + + // Returns this text frame's content's text fragment. + // + // Assertions in Init() ensure we only ever get a Text node as content. + const nsTextFragment* TextFragment() const { + return &mContent->AsText()->TextFragment(); + } + + ContentOffsets CalcContentOffsetsFromFramePoint(const nsPoint& aPoint) final; + ContentOffsets GetCharacterOffsetAtFramePoint(const nsPoint& aPoint); + + /** + * This is called only on the primary text frame. It indicates that + * the selection state of the given character range has changed. + * Frames corresponding to the character range are unconditionally invalidated + * (Selection::Repaint depends on this). + * @param aStart start of character range. + * @param aEnd end (exclusive) of character range. + * @param aSelected true iff the character range is now selected. + * @param aType the type of the changed selection. + */ + void SelectionStateChanged(uint32_t aStart, uint32_t aEnd, bool aSelected, + SelectionType aSelectionType); + + FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) final; + FrameSearchResult PeekOffsetCharacter( + bool aForward, int32_t* aOffset, + PeekOffsetCharacterOptions aOptions = PeekOffsetCharacterOptions()) final; + FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, + bool aIsKeyboardSelect, int32_t* aOffset, + PeekWordState* aState, + bool aTrimSpaces) final; + + nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, + int32_t aEndIndex, bool aRecurse, bool* aFinished, + bool* _retval) final; + + // Flags for aSetLengthFlags + enum { ALLOW_FRAME_CREATION_AND_DESTRUCTION = 0x01 }; + + // Update offsets to account for new length. This may clear mTextRun. + void SetLength(int32_t aLength, nsLineLayout* aLineLayout, + uint32_t aSetLengthFlags = 0); + + nsresult GetOffsets(int32_t& start, int32_t& end) const final; + + void AdjustOffsetsForBidi(int32_t start, int32_t end) final; + + nsresult GetPointFromOffset(int32_t inOffset, nsPoint* outPoint) final; + nsresult GetCharacterRectsInRange(int32_t aInOffset, int32_t aLength, + nsTArray<nsRect>& aRects) final; + + nsresult GetChildFrameContainingOffset(int32_t inContentOffset, bool inHint, + int32_t* outFrameContentOffset, + nsIFrame** outChildFrame) final; + + bool IsEmpty() final; + bool IsSelfEmpty() final { return IsEmpty(); } + nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const final; + + bool HasSignificantTerminalNewline() const final; + + /** + * Returns true if this text frame is logically adjacent to the end of the + * line. + */ + bool IsAtEndOfLine() const; + + /** + * Call this only after reflow the frame. Returns true if non-collapsed + * characters are present. + */ + bool HasNoncollapsedCharacters() const { + return HasAnyStateBits(TEXT_HAS_NONCOLLAPSED_CHARACTERS); + } + +#ifdef ACCESSIBILITY + mozilla::a11y::AccType AccessibleType() final; +#endif + + float GetFontSizeInflation() const; + bool IsCurrentFontInflation(float aInflation) const; + bool HasFontSizeInflation() const { + return HasAnyStateBits(TEXT_HAS_FONT_INFLATION); + } + void SetFontSizeInflation(float aInflation); + + void MarkIntrinsicISizesDirty() final; + nscoord GetMinISize(gfxContext* aRenderingContext) final; + nscoord GetPrefISize(gfxContext* aRenderingContext) final; + void AddInlineMinISize(gfxContext* aRenderingContext, + InlineMinISizeData* aData) override; + void AddInlinePrefISize(gfxContext* aRenderingContext, + InlinePrefISizeData* aData) override; + SizeComputationResult ComputeSize(gfxContext* aRenderingContext, + mozilla::WritingMode aWM, + const mozilla::LogicalSize& aCBSize, + nscoord aAvailableISize, + const mozilla::LogicalSize& aMargin, + const mozilla::LogicalSize& aBorderPadding, + mozilla::ComputeSizeFlags aFlags) final; + nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const final; + nsresult GetPrefWidthTightBounds(gfxContext* aContext, nscoord* aX, + nscoord* aXMost) final; + void Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics, + const ReflowInput& aReflowInput, nsReflowStatus& aStatus) final; + bool CanContinueTextRun() const final; + // Method that is called for a text frame that is logically + // adjacent to the end of the line (i.e. followed only by empty text frames, + // placeholders or inlines containing such). + struct TrimOutput { + // true if we trimmed some space or changed metrics in some other way. + // In this case, we should call RecomputeOverflow on this frame. + bool mChanged; + // an amount to *subtract* from the frame's width (zero if !mChanged) + nscoord mDeltaWidth; + }; + TrimOutput TrimTrailingWhiteSpace(DrawTarget* aDrawTarget); + RenderedText GetRenderedText( + uint32_t aStartOffset = 0, uint32_t aEndOffset = UINT32_MAX, + TextOffsetType aOffsetType = TextOffsetType::OffsetsInContentText, + TrailingWhitespace aTrimTrailingWhitespace = + TrailingWhitespace::Trim) final; + + mozilla::OverflowAreas RecomputeOverflow(nsIFrame* aBlockFrame, + bool aIncludeShadows = true); + + enum TextRunType : uint8_t { + // Anything in reflow (but not intrinsic width calculation) or + // painting should use the inflated text run (i.e., with font size + // inflation applied). + eInflated, + // Intrinsic width calculation should use the non-inflated text run. + // When there is font size inflation, it will be different. + eNotInflated + }; + + void AddInlineMinISizeForFlow(gfxContext* aRenderingContext, + nsIFrame::InlineMinISizeData* aData, + TextRunType aTextRunType); + void AddInlinePrefISizeForFlow(gfxContext* aRenderingContext, + InlinePrefISizeData* aData, + TextRunType aTextRunType); + + /** + * Calculate the horizontal bounds of the grapheme clusters that fit entirely + * inside the given left[top]/right[bottom] edges (which are positive lengths + * from the respective frame edge). If an input value is zero it is ignored + * and the result for that edge is zero. All out parameter values are + * undefined when the method returns false. + * @return true if at least one whole grapheme cluster fit between the edges + */ + bool MeasureCharClippedText(nscoord aVisIStartEdge, nscoord aVisIEndEdge, + nscoord* aSnappedStartEdge, + nscoord* aSnappedEndEdge); + /** + * Same as above; this method also the returns the corresponding text run + * offset and number of characters that fit. All out parameter values are + * undefined when the method returns false. + * @return true if at least one whole grapheme cluster fit between the edges + */ + bool MeasureCharClippedText(PropertyProvider& aProvider, + nscoord aVisIStartEdge, nscoord aVisIEndEdge, + uint32_t* aStartOffset, uint32_t* aMaxLength, + nscoord* aSnappedStartEdge, + nscoord* aSnappedEndEdge); + + /** + * Return true if this box has some text to display. + * It returns false if at least one of these conditions are met: + * a. the frame hasn't been reflowed yet + * b. GetContentLength() == 0 + * c. it contains only non-significant white-space + */ + bool HasNonSuppressedText() const; + + /** + * Object with various callbacks for PaintText() to invoke for different parts + * of the frame's text rendering, when we're generating paths rather than + * painting. + * + * Callbacks are invoked in the following order: + * + * NotifySelectionBackgroundNeedsFill? + * PaintDecorationLine* + * NotifyBeforeText + * NotifyGlyphPathEmitted* + * NotifyAfterText + * PaintDecorationLine* + * PaintSelectionDecorationLine* + * + * The color of each part of the frame's text rendering is passed as an + * argument to the NotifyBefore* callback for that part. The nscolor can take + * on one of the three selection special colors defined in LookAndFeel.h -- + * NS_TRANSPARENT, NS_SAME_AS_FOREGROUND_COLOR and + * NS_40PERCENT_FOREGROUND_COLOR. + */ + struct DrawPathCallbacks : gfxTextRunDrawCallbacks { + /** + * @param aShouldPaintSVGGlyphs Whether SVG glyphs should be painted. + */ + explicit DrawPathCallbacks(bool aShouldPaintSVGGlyphs = false) + : gfxTextRunDrawCallbacks(aShouldPaintSVGGlyphs) {} + + /** + * Called to have the selection highlight drawn before the text is drawn + * over the top. + */ + virtual void NotifySelectionBackgroundNeedsFill(const Rect& aBackgroundRect, + nscolor aColor, + DrawTarget& aDrawTarget) {} + + /** + * Called before (for under/over-line) or after (for line-through) the text + * is drawn to have a text decoration line drawn. + */ + virtual void PaintDecorationLine(Rect aPath, nscolor aColor) {} + + /** + * Called after selected text is drawn to have a decoration line drawn over + * the text. (All types of text decoration are drawn after the text when + * text is selected.) + */ + virtual void PaintSelectionDecorationLine(Rect aPath, nscolor aColor) {} + + /** + * Called just before any paths have been emitted to the gfxContext + * for the glyphs of the frame's text. + */ + virtual void NotifyBeforeText(nscolor aColor) {} + + /** + * Called just after all the paths have been emitted to the gfxContext + * for the glyphs of the frame's text. + */ + virtual void NotifyAfterText() {} + + /** + * Called just before a path corresponding to a selection decoration line + * has been emitted to the gfxContext. + */ + virtual void NotifyBeforeSelectionDecorationLine(nscolor aColor) {} + + /** + * Called just after a path corresponding to a selection decoration line + * has been emitted to the gfxContext. + */ + virtual void NotifySelectionDecorationLinePathEmitted() {} + }; + + struct PaintTextParams { + gfxContext* context; + mozilla::gfx::Point framePt; + LayoutDeviceRect dirtyRect; + mozilla::SVGContextPaint* contextPaint = nullptr; + DrawPathCallbacks* callbacks = nullptr; + enum { + PaintText, // Normal text painting. + GenerateTextMask // To generate a mask from a text frame. Should + // only paint text itself with opaque color. + // Text shadow, text selection color and text + // decoration are all discarded in this state. + }; + uint8_t state = PaintText; + explicit PaintTextParams(gfxContext* aContext) : context(aContext) {} + + bool IsPaintText() const { return state == PaintText; } + bool IsGenerateTextMask() const { return state == GenerateTextMask; } + }; + + struct PaintTextSelectionParams : PaintTextParams { + mozilla::gfx::Point textBaselinePt; + PropertyProvider* provider = nullptr; + Range contentRange; + nsTextPaintStyle* textPaintStyle = nullptr; + Range glyphRange; + explicit PaintTextSelectionParams(const PaintTextParams& aParams) + : PaintTextParams(aParams) {} + }; + + struct DrawTextRunParams { + gfxContext* context; + PropertyProvider* provider = nullptr; + gfxFloat* advanceWidth = nullptr; + mozilla::SVGContextPaint* contextPaint = nullptr; + DrawPathCallbacks* callbacks = nullptr; + nscolor textColor = NS_RGBA(0, 0, 0, 0); + nscolor textStrokeColor = NS_RGBA(0, 0, 0, 0); + float textStrokeWidth = 0.0f; + bool drawSoftHyphen = false; + explicit DrawTextRunParams(gfxContext* aContext) : context(aContext) {} + }; + + struct DrawTextParams : DrawTextRunParams { + mozilla::gfx::Point framePt; + LayoutDeviceRect dirtyRect; + const nsTextPaintStyle* textStyle = nullptr; + const nsDisplayText::ClipEdges* clipEdges = nullptr; + const nscolor* decorationOverrideColor = nullptr; + Range glyphRange; + explicit DrawTextParams(gfxContext* aContext) + : DrawTextRunParams(aContext) {} + }; + + // Primary frame paint method called from nsDisplayText. Can also be used + // to generate paths rather than paint the frame's text by passing a callback + // object. The private DrawText() is what applies the text to a graphics + // context. + void PaintText(const PaintTextParams& aParams, const nscoord aVisIStartEdge, + const nscoord aVisIEndEdge, const nsPoint& aToReferenceFrame, + const bool aIsSelected, float aOpacity = 1.0f); + // helper: paint text frame when we're impacted by at least one selection. + // Return false if the text was not painted and we should continue with + // the fast path. + bool PaintTextWithSelection(const PaintTextSelectionParams& aParams, + const nsDisplayText::ClipEdges& aClipEdges); + // helper: paint text with foreground and background colors determined + // by selection(s). Also computes a mask of all selection types applying to + // our text, returned in aAllSelectionTypeMask. + // Return false if the text was not painted and we should continue with + // the fast path. + bool PaintTextWithSelectionColors( + const PaintTextSelectionParams& aParams, + const mozilla::UniquePtr<SelectionDetails>& aDetails, + SelectionTypeMask* aAllSelectionTypeMask, + const nsDisplayText::ClipEdges& aClipEdges); + // helper: paint text decorations for text selected by aSelectionType + void PaintTextSelectionDecorations( + const PaintTextSelectionParams& aParams, + const mozilla::UniquePtr<SelectionDetails>& aDetails, + SelectionType aSelectionType); + + void DrawEmphasisMarks(gfxContext* aContext, mozilla::WritingMode aWM, + const mozilla::gfx::Point& aTextBaselinePt, + const mozilla::gfx::Point& aFramePt, Range aRange, + const nscolor* aDecorationOverrideColor, + PropertyProvider* aProvider); + + nscolor GetCaretColorAt(int32_t aOffset) final; + + // @param aSelectionFlags may be multiple of nsISelectionDisplay::DISPLAY_*. + // @return nsISelectionController.idl's `getDisplaySelection`. + int16_t GetSelectionStatus(int16_t* aSelectionFlags); + + int32_t GetContentOffset() const { return mContentOffset; } + int32_t GetContentLength() const { + NS_ASSERTION(GetContentEnd() - mContentOffset >= 0, "negative length"); + return GetContentEnd() - mContentOffset; + } + int32_t GetContentEnd() const; + // This returns the length the frame thinks it *should* have after it was + // last reflowed (0 if it hasn't been reflowed yet). This should be used only + // when setting up the text offsets for a new continuation frame. + int32_t GetContentLengthHint() const { return mContentLengthHint; } + + // Compute the length of the content mapped by this frame + // and all its in-flow siblings. Basically this means starting at + // mContentOffset and going to the end of the text node or the next bidi + // continuation boundary. + int32_t GetInFlowContentLength(); + + /** + * Acquires the text run for this content, if necessary. + * @param aWhichTextRun indicates whether to get an inflated or non-inflated + * text run + * @param aRefDrawTarget the DrawTarget to use as a reference for creating the + * textrun, if available (if not, we'll create one which will just be slower) + * @param aLineContainer the block ancestor for this frame, or nullptr if + * unknown + * @param aFlowEndInTextRun if non-null, this returns the textrun offset of + * end of the text associated with this frame and its in-flow siblings + * @return a gfxSkipCharsIterator set up to map DOM offsets for this frame + * to offsets into the textrun; its initial offset is set to this frame's + * content offset + */ + gfxSkipCharsIterator EnsureTextRun( + TextRunType aWhichTextRun, DrawTarget* aRefDrawTarget = nullptr, + nsIFrame* aLineContainer = nullptr, + const nsLineList::iterator* aLine = nullptr, + uint32_t* aFlowEndInTextRun = nullptr); + + gfxTextRun* GetTextRun(TextRunType aWhichTextRun) const { + if (aWhichTextRun == eInflated || !HasFontSizeInflation()) return mTextRun; + return GetUninflatedTextRun(); + } + gfxTextRun* GetUninflatedTextRun() const; + void SetTextRun(gfxTextRun* aTextRun, TextRunType aWhichTextRun, + float aInflation); + bool IsInTextRunUserData() const { + return HasAnyStateBits(TEXT_IN_TEXTRUN_USER_DATA | + TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA); + } + /** + * Notify the frame that it should drop its pointer to a text run. + * Returns whether the text run was removed (i.e., whether it was + * associated with this frame, either as its inflated or non-inflated + * text run. + */ + bool RemoveTextRun(gfxTextRun* aTextRun); + /** + * Clears out |mTextRun| (or the uninflated text run, when aInflated + * is nsTextFrame::eNotInflated and there is inflation) from all frames that + * hold a reference to it, starting at |aStartContinuation|, or if it's + * nullptr, starting at |this|. Deletes the text run if all references + * were cleared and it's not cached. + */ + void ClearTextRun(nsTextFrame* aStartContinuation, TextRunType aWhichTextRun); + + void ClearTextRuns() { + ClearTextRun(nullptr, nsTextFrame::eInflated); + if (HasFontSizeInflation()) { + ClearTextRun(nullptr, nsTextFrame::eNotInflated); + } + } + + /** + * Wipe out references to textrun(s) without deleting the textruns. + */ + void DisconnectTextRuns(); + + // Get the DOM content range mapped by this frame after excluding + // whitespace subject to start-of-line and end-of-line trimming. + // The textrun must have been created before calling this. + struct TrimmedOffsets { + int32_t mStart; + int32_t mLength; + int32_t GetEnd() const { return mStart + mLength; } + }; + enum class TrimmedOffsetFlags : uint8_t { + Default = 0, + NotPostReflow = 1 << 0, + NoTrimAfter = 1 << 1, + NoTrimBefore = 1 << 2 + }; + TrimmedOffsets GetTrimmedOffsets( + const nsTextFragment* aFrag, + TrimmedOffsetFlags aFlags = TrimmedOffsetFlags::Default) const; + + // Similar to Reflow(), but for use from nsLineLayout + void ReflowText(nsLineLayout& aLineLayout, nscoord aAvailableWidth, + DrawTarget* aDrawTarget, ReflowOutput& aMetrics, + nsReflowStatus& aStatus); + + bool IsFloatingFirstLetterChild() const; + + bool IsInitialLetterChild() const; + + bool ComputeCustomOverflow(mozilla::OverflowAreas& aOverflowAreas) final; + bool ComputeCustomOverflowInternal(mozilla::OverflowAreas& aOverflowAreas, + bool aIncludeShadows); + + void AssignJustificationGaps(const mozilla::JustificationAssignment& aAssign); + mozilla::JustificationAssignment GetJustificationAssignment() const; + + uint32_t CountGraphemeClusters() const; + + bool HasAnyNoncollapsedCharacters() final; + + /** + * Call this after you have manually changed the text node contents without + * notifying that change. This behaves as if all the text contents changed. + * (You should only use this for native anonymous content.) + */ + void NotifyNativeAnonymousTextnodeChange(uint32_t aOldLength); + + void SetInflatedFontMetrics(nsFontMetrics* aMetrics) { + mFontMetrics = aMetrics; + } + nsFontMetrics* InflatedFontMetrics() const { return mFontMetrics; } + + nsRect WebRenderBounds(); + + protected: + virtual ~nsTextFrame(); + + friend class nsDisplayTextGeometry; + friend class nsDisplayText; + + RefPtr<nsFontMetrics> mFontMetrics; + RefPtr<gfxTextRun> mTextRun; + nsTextFrame* mNextContinuation; + // The key invariant here is that mContentOffset never decreases along + // a next-continuation chain. And of course mContentOffset is always <= the + // the text node's content length, and the mContentOffset for the first frame + // is always 0. Furthermore the text mapped by a frame is determined by + // GetContentOffset() and GetContentLength()/GetContentEnd(), which get + // the length from the difference between this frame's offset and the next + // frame's offset, or the text length if there is no next frame. This means + // the frames always map the text node without overlapping or leaving any + // gaps. + int32_t mContentOffset; + // This does *not* indicate the length of text currently mapped by the frame; + // instead it's a hint saying that this frame *wants* to map this much text + // so if we create a new continuation, this is where that continuation should + // start. + int32_t mContentLengthHint; + nscoord mAscent; + + /** + * Return true if the frame is part of a Selection. + * Helper method to implement the public IsSelected() API. + */ + bool IsFrameSelected() const final; + + mozilla::UniquePtr<SelectionDetails> GetSelectionDetails(); + + void UnionAdditionalOverflow(nsPresContext* aPresContext, nsIFrame* aBlock, + PropertyProvider& aProvider, + nsRect* aInkOverflowRect, + bool aIncludeTextDecorations, + bool aIncludeShadows); + + // Update information of emphasis marks, and return the visial + // overflow rect of the emphasis marks. + nsRect UpdateTextEmphasis(mozilla::WritingMode aWM, + PropertyProvider& aProvider); + + struct PaintShadowParams { + gfxTextRun::Range range; + LayoutDeviceRect dirtyRect; + mozilla::gfx::Point framePt; + mozilla::gfx::Point textBaselinePt; + gfxContext* context; + nscolor foregroundColor = NS_RGBA(0, 0, 0, 0); + const nsDisplayText::ClipEdges* clipEdges = nullptr; + PropertyProvider* provider = nullptr; + nscoord leftSideOffset = 0; + explicit PaintShadowParams(const PaintTextParams& aParams) + : dirtyRect(aParams.dirtyRect), + framePt(aParams.framePt), + context(aParams.context) {} + }; + + void PaintOneShadow(const PaintShadowParams& aParams, + const mozilla::StyleSimpleShadow& aShadowDetails, + gfxRect& aBoundingBox, uint32_t aBlurFlags); + + void PaintShadows(mozilla::Span<const mozilla::StyleSimpleShadow>, + const PaintShadowParams& aParams); + + struct LineDecoration { + nsIFrame* mFrame; + + // This is represents the offset from our baseline to mFrame's baseline; + // positive offsets are *above* the baseline and negative offsets below + nscoord mBaselineOffset; + + // This represents the offset from the initial position of the underline + const mozilla::LengthPercentageOrAuto mTextUnderlineOffset; + + // for CSS property text-decoration-thickness, the width refers to the + // thickness of the decoration line + const mozilla::StyleTextDecorationLength mTextDecorationThickness; + nscolor mColor; + uint8_t mStyle; + + // The text-underline-position property; affects the underline offset only + // if mTextUnderlineOffset is auto. + const mozilla::StyleTextUnderlinePosition mTextUnderlinePosition; + + LineDecoration(nsIFrame* const aFrame, const nscoord aOff, + mozilla::StyleTextUnderlinePosition aUnderlinePosition, + const mozilla::LengthPercentageOrAuto& aUnderlineOffset, + const mozilla::StyleTextDecorationLength& aDecThickness, + const nscolor aColor, const uint8_t aStyle) + : mFrame(aFrame), + mBaselineOffset(aOff), + mTextUnderlineOffset(aUnderlineOffset), + mTextDecorationThickness(aDecThickness), + mColor(aColor), + mStyle(aStyle), + mTextUnderlinePosition(aUnderlinePosition) {} + + LineDecoration(const LineDecoration& aOther) = default; + + bool operator==(const LineDecoration& aOther) const { + return mFrame == aOther.mFrame && mStyle == aOther.mStyle && + mColor == aOther.mColor && + mBaselineOffset == aOther.mBaselineOffset && + mTextUnderlinePosition == aOther.mTextUnderlinePosition && + mTextUnderlineOffset == aOther.mTextUnderlineOffset && + mTextDecorationThickness == aOther.mTextDecorationThickness; + } + + bool operator!=(const LineDecoration& aOther) const { + return !(*this == aOther); + } + }; + struct TextDecorations { + AutoTArray<LineDecoration, 1> mOverlines, mUnderlines, mStrikes; + + TextDecorations() = default; + + bool HasDecorationLines() const { + return HasUnderline() || HasOverline() || HasStrikeout(); + } + bool HasUnderline() const { return !mUnderlines.IsEmpty(); } + bool HasOverline() const { return !mOverlines.IsEmpty(); } + bool HasStrikeout() const { return !mStrikes.IsEmpty(); } + bool operator==(const TextDecorations& aOther) const { + return mOverlines == aOther.mOverlines && + mUnderlines == aOther.mUnderlines && mStrikes == aOther.mStrikes; + } + bool operator!=(const TextDecorations& aOther) const { + return !(*this == aOther); + } + }; + enum TextDecorationColorResolution { eResolvedColors, eUnresolvedColors }; + void GetTextDecorations(nsPresContext* aPresContext, + TextDecorationColorResolution aColorResolution, + TextDecorations& aDecorations); + + void DrawTextRun(Range aRange, const mozilla::gfx::Point& aTextBaselinePt, + const DrawTextRunParams& aParams); + + void DrawTextRunAndDecorations(Range aRange, + const mozilla::gfx::Point& aTextBaselinePt, + const DrawTextParams& aParams, + const TextDecorations& aDecorations); + + void DrawText(Range aRange, const mozilla::gfx::Point& aTextBaselinePt, + const DrawTextParams& aParams); + + // Set non empty rect to aRect, it should be overflow rect or frame rect. + // If the result rect is larger than the given rect, this returns true. + bool CombineSelectionUnderlineRect(nsPresContext* aPresContext, + nsRect& aRect); + + /** + * Utility methods to paint selection. + */ + void DrawSelectionDecorations( + gfxContext* aContext, const LayoutDeviceRect& aDirtyRect, + mozilla::SelectionType aSelectionType, nsTextPaintStyle& aTextPaintStyle, + const TextRangeStyle& aRangeStyle, const Point& aPt, + gfxFloat aICoordInFrame, gfxFloat aWidth, gfxFloat aAscent, + const gfxFont::Metrics& aFontMetrics, DrawPathCallbacks* aCallbacks, + bool aVertical, mozilla::StyleTextDecorationLine aDecoration); + + struct PaintDecorationLineParams; + void PaintDecorationLine(const PaintDecorationLineParams& aParams); + /** + * ComputeDescentLimitForSelectionUnderline() computes the most far position + * where we can put selection underline. + * + * @return The maximum underline offset from the baseline (positive value + * means that the underline can put below the baseline). + */ + gfxFloat ComputeDescentLimitForSelectionUnderline( + nsPresContext* aPresContext, const gfxFont::Metrics& aFontMetrics); + /** + * This function encapsulates all knowledge of how selections affect + * foreground and background colors. + * @param aForeground the foreground color to use + * @param aBackground the background color to use, or RGBA(0,0,0,0) if no + * background should be painted + * @return true if the selection affects colors, false otherwise + */ + static bool GetSelectionTextColors(SelectionType aSelectionType, + nsTextPaintStyle& aTextPaintStyle, + const TextRangeStyle& aRangeStyle, + nscolor* aForeground, + nscolor* aBackground); + /** + * ComputeSelectionUnderlineHeight() computes selection underline height of + * the specified selection type from the font metrics. + */ + static gfxFloat ComputeSelectionUnderlineHeight( + nsPresContext* aPresContext, const gfxFont::Metrics& aFontMetrics, + SelectionType aSelectionType); + + ContentOffsets GetCharacterOffsetAtFramePointInternal( + const nsPoint& aPoint, bool aForInsertionPoint); + + static float GetTextCombineScaleFactor(nsTextFrame* aFrame); + + void ClearFrameOffsetCache(); + + void ClearMetrics(ReflowOutput& aMetrics); + + /** + * UpdateIteratorFromOffset() updates the iterator from a given offset. + * Also, aInOffset may be updated to cluster start if aInOffset isn't + * the offset of cluster start. + */ + void UpdateIteratorFromOffset(const PropertyProvider& aProperties, + int32_t& aInOffset, + gfxSkipCharsIterator& aIter); + + nsPoint GetPointFromIterator(const gfxSkipCharsIterator& aIter, + PropertyProvider& aProperties); + + public: +}; + +MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsTextFrame::TrimmedOffsetFlags) + +#endif |