diff options
Diffstat (limited to 'gfx/thebes/gfxTextRun.h')
| -rw-r--r-- | gfx/thebes/gfxTextRun.h | 1565 |
1 files changed, 1565 insertions, 0 deletions
diff --git a/gfx/thebes/gfxTextRun.h b/gfx/thebes/gfxTextRun.h new file mode 100644 index 0000000000..b49298c4e4 --- /dev/null +++ b/gfx/thebes/gfxTextRun.h @@ -0,0 +1,1565 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=4 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 GFX_TEXTRUN_H +#define GFX_TEXTRUN_H + +#include <stdint.h> + +#include "gfxTypes.h" +#include "gfxPoint.h" +#include "gfxFont.h" +#include "gfxFontConstants.h" +#include "gfxSkipChars.h" +#include "gfxPlatform.h" +#include "gfxPlatformFontList.h" +#include "gfxUserFontSet.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/RefPtr.h" +#include "mozilla/intl/UnicodeScriptCodes.h" +#include "nsPoint.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsTHashSet.h" +#include "nsTextFrameUtils.h" +#include "DrawMode.h" +#include "harfbuzz/hb.h" +#include "nsColor.h" +#include "nsFrameList.h" +#include "X11UndefineNone.h" + +#ifdef DEBUG_FRAME_DUMP +# include <stdio.h> +#endif + +class gfxContext; +class gfxFontGroup; +class nsAtom; +class nsLanguageAtomService; +class gfxMissingFontRecorder; + +namespace mozilla { +class PostTraversalTask; +class SVGContextPaint; +enum class StyleHyphens : uint8_t; +}; // namespace mozilla + +/** + * Callback for Draw() to use when drawing text with mode + * DrawMode::GLYPH_PATH. + */ +struct MOZ_STACK_CLASS gfxTextRunDrawCallbacks { + /** + * Constructs a new DrawCallbacks object. + * + * @param aShouldPaintSVGGlyphs If true, SVG glyphs will be painted. If + * false, SVG glyphs will not be painted; fallback plain glyphs are not + * emitted either. + */ + explicit gfxTextRunDrawCallbacks(bool aShouldPaintSVGGlyphs = false) + : mShouldPaintSVGGlyphs(aShouldPaintSVGGlyphs) {} + + /** + * Called when a path has been emitted to the gfxContext when + * painting a text run. This can be called any number of times, + * due to partial ligatures and intervening SVG glyphs. + */ + virtual void NotifyGlyphPathEmitted() = 0; + + bool mShouldPaintSVGGlyphs; +}; + +/** + * gfxTextRun is an abstraction for drawing and measuring substrings of a run + * of text. It stores runs of positioned glyph data, each run having a single + * gfxFont. The glyphs are associated with a string of source text, and the + * gfxTextRun APIs take parameters that are offsets into that source text. + * + * gfxTextRuns are mostly immutable. The only things that can change are + * inter-cluster spacing and line break placement. Spacing is always obtained + * lazily by methods that need it, it is not cached. Line breaks are stored + * persistently (insofar as they affect the shaping of glyphs; gfxTextRun does + * not actually do anything to explicitly account for line breaks). Initially + * there are no line breaks. The textrun can record line breaks before or after + * any given cluster. (Line breaks specified inside clusters are ignored.) + * + * It is important that zero-length substrings are handled correctly. This will + * be on the test! + */ +class gfxTextRun : public gfxShapedText { + NS_INLINE_DECL_REFCOUNTING(gfxTextRun); + + protected: + // Override operator delete to properly free the object that was + // allocated via malloc. + void operator delete(void* p) { free(p); } + + virtual ~gfxTextRun(); + + public: + typedef gfxFont::RunMetrics Metrics; + typedef mozilla::gfx::DrawTarget DrawTarget; + + // Public textrun API for general use + + bool IsClusterStart(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].IsClusterStart(); + } + bool IsLigatureGroupStart(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].IsLigatureGroupStart(); + } + bool CanBreakLineBefore(uint32_t aPos) const { + return CanBreakBefore(aPos) == CompressedGlyph::FLAG_BREAK_TYPE_NORMAL; + } + bool CanHyphenateBefore(uint32_t aPos) const { + return CanBreakBefore(aPos) == CompressedGlyph::FLAG_BREAK_TYPE_HYPHEN; + } + + // Returns a gfxShapedText::CompressedGlyph::FLAG_BREAK_TYPE_* value + // as defined in gfxFont.h (may be NONE, NORMAL or HYPHEN). + uint8_t CanBreakBefore(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CanBreakBefore(); + } + + bool CharIsSpace(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CharIsSpace(); + } + bool CharIsTab(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CharIsTab(); + } + bool CharIsNewline(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CharIsNewline(); + } + bool CharMayHaveEmphasisMark(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CharMayHaveEmphasisMark(); + } + bool CharIsFormattingControl(uint32_t aPos) const { + MOZ_ASSERT(aPos < GetLength()); + return mCharacterGlyphs[aPos].CharIsFormattingControl(); + } + + // All offsets are in terms of the string passed into MakeTextRun. + + // Describe range [start, end) of a text run. The range is + // restricted to grapheme cluster boundaries. + struct Range { + uint32_t start; + uint32_t end; + uint32_t Length() const { return end - start; } + + Range() : start(0), end(0) {} + Range(uint32_t aStart, uint32_t aEnd) : start(aStart), end(aEnd) {} + explicit Range(const gfxTextRun* aTextRun) + : start(0), end(aTextRun->GetLength()) {} + }; + + // All coordinates are in layout/app units + + /** + * Set the potential linebreaks for a substring of the textrun. These are + * the "allow break before" points. Initially, there are no potential + * linebreaks. + * + * This can change glyphs and/or geometry! Some textruns' shapes + * depend on potential line breaks (e.g., title-case-converting textruns). + * This function is virtual so that those textruns can reshape themselves. + * + * @return true if this changed the linebreaks, false if the new line + * breaks are the same as the old + */ + virtual bool SetPotentialLineBreaks(Range aRange, + const uint8_t* aBreakBefore); + + enum class HyphenType : uint8_t { + // Code in BreakAndMeasureText depends on the ordering of these values! + None, + Explicit, + Soft, + AutoWithManualInSameWord, + AutoWithoutManualInSameWord + }; + + static bool IsOptionalHyphenBreak(HyphenType aType) { + return aType >= HyphenType::Soft; + } + + struct HyphenationState { + uint32_t mostRecentBoundary = 0; + bool hasManualHyphen = false; + bool hasExplicitHyphen = false; + bool hasAutoHyphen = false; + }; + + /** + * Layout provides PropertyProvider objects. These allow detection of + * potential line break points and computation of spacing. We pass the data + * this way to allow lazy data acquisition; for example BreakAndMeasureText + * will want to only ask for properties of text it's actually looking at. + * + * NOTE that requested spacing may not actually be applied, if the textrun + * is unable to apply it in some context. Exception: spacing around a + * whitespace character MUST always be applied. + */ + class PropertyProvider { + public: + // Detect hyphenation break opportunities in the given range; breaks + // not at cluster boundaries will be ignored. + virtual void GetHyphenationBreaks(Range aRange, + HyphenType* aBreakBefore) const = 0; + + // Returns the provider's hyphenation setting, so callers can decide + // whether it is necessary to call GetHyphenationBreaks. + // Result is an StyleHyphens value. + virtual mozilla::StyleHyphens GetHyphensOption() const = 0; + + // Returns the extra width that will be consumed by a hyphen. This should + // be constant for a given textrun. + virtual gfxFloat GetHyphenWidth() const = 0; + + // Return orientation flags to be used when creating a hyphen textrun. + virtual mozilla::gfx::ShapedTextFlags GetShapedTextFlags() const = 0; + + typedef gfxFont::Spacing Spacing; + + /** + * Get the spacing around the indicated characters. Spacing must be zero + * inside clusters. In other words, if character i is not + * CLUSTER_START, then character i-1 must have zero after-spacing and + * character i must have zero before-spacing. + */ + virtual void GetSpacing(Range aRange, Spacing* aSpacing) const = 0; + + // Returns a gfxContext that can be used to measure the hyphen glyph. + // Only called if the hyphen width is requested. + virtual already_AddRefed<DrawTarget> GetDrawTarget() const = 0; + + // Return the appUnitsPerDevUnit value to be used when measuring. + // Only called if the hyphen width is requested. + virtual uint32_t GetAppUnitsPerDevUnit() const = 0; + }; + + struct MOZ_STACK_CLASS DrawParams { + gfxContext* context; + DrawMode drawMode = DrawMode::GLYPH_FILL; + nscolor textStrokeColor = 0; + nsAtom* fontPalette = nullptr; + mozilla::gfx::FontPaletteValueSet* paletteValueSet = nullptr; + gfxPattern* textStrokePattern = nullptr; + const mozilla::gfx::StrokeOptions* strokeOpts = nullptr; + const mozilla::gfx::DrawOptions* drawOpts = nullptr; + PropertyProvider* provider = nullptr; + // If non-null, the advance width of the substring is set. + gfxFloat* advanceWidth = nullptr; + mozilla::SVGContextPaint* contextPaint = nullptr; + gfxTextRunDrawCallbacks* callbacks = nullptr; + bool allowGDI = true; + explicit DrawParams(gfxContext* aContext) : context(aContext) {} + }; + + /** + * Draws a substring. Uses only GetSpacing from aBreakProvider. + * The provided point is the baseline origin on the left of the string + * for LTR, on the right of the string for RTL. + * + * Drawing should respect advance widths in the sense that for LTR runs, + * Draw(Range(start, middle), pt, ...) followed by + * Draw(Range(middle, end), gfxPoint(pt.x + advance, pt.y), ...) + * should have the same effect as + * Draw(Range(start, end), pt, ...) + * + * For RTL runs the rule is: + * Draw(Range(middle, end), pt, ...) followed by + * Draw(Range(start, middle), gfxPoint(pt.x + advance, pt.y), ...) + * should have the same effect as + * Draw(Range(start, end), pt, ...) + * + * Glyphs should be drawn in logical content order, which can be significant + * if they overlap (perhaps due to negative spacing). + */ + void Draw(const Range aRange, const mozilla::gfx::Point aPt, + const DrawParams& aParams) const; + + /** + * Draws the emphasis marks for this text run. Uses only GetSpacing + * from aProvider. The provided point is the baseline origin of the + * line of emphasis marks. + */ + void DrawEmphasisMarks(gfxContext* aContext, gfxTextRun* aMark, + gfxFloat aMarkAdvance, mozilla::gfx::Point aPt, + Range aRange, PropertyProvider* aProvider) const; + + /** + * Computes the ReflowMetrics for a substring. + * Uses GetSpacing from aBreakProvider. + * @param aBoundingBoxType which kind of bounding box (loose/tight) + */ + Metrics MeasureText(Range aRange, gfxFont::BoundingBoxType aBoundingBoxType, + DrawTarget* aDrawTargetForTightBoundingBox, + PropertyProvider* aProvider) const; + + Metrics MeasureText(gfxFont::BoundingBoxType aBoundingBoxType, + DrawTarget* aDrawTargetForTightBoundingBox, + PropertyProvider* aProvider = nullptr) const { + return MeasureText(Range(this), aBoundingBoxType, + aDrawTargetForTightBoundingBox, aProvider); + } + + void GetLineHeightMetrics(Range aRange, gfxFloat& aAscent, + gfxFloat& aDescent) const; + void GetLineHeightMetrics(gfxFloat& aAscent, gfxFloat& aDescent) const { + GetLineHeightMetrics(Range(this), aAscent, aDescent); + } + + /** + * Computes just the advance width for a substring. + * Uses GetSpacing from aBreakProvider. + * If aSpacing is not null, the spacing attached before and after + * the substring would be returned in it. NOTE: the spacing is + * included in the advance width. + */ + gfxFloat GetAdvanceWidth(Range aRange, PropertyProvider* aProvider, + PropertyProvider::Spacing* aSpacing = nullptr) const; + + gfxFloat GetAdvanceWidth() const { + return GetAdvanceWidth(Range(this), nullptr); + } + + /** + * Computes the minimum advance width for a substring assuming line + * breaking is allowed everywhere. + */ + gfxFloat GetMinAdvanceWidth(Range aRange); + + /** + * Clear all stored line breaks for the given range (both before and after), + * and then set the line-break state before aRange.start to aBreakBefore and + * after the last cluster to aBreakAfter. + * + * We require that before and after line breaks be consistent. For clusters + * i and i+1, we require that if there is a break after cluster i, a break + * will be specified before cluster i+1. This may be temporarily violated + * (e.g. after reflowing line L and before reflowing line L+1); to handle + * these temporary violations, we say that there is a break betwen i and i+1 + * if a break is specified after i OR a break is specified before i+1. + * + * This can change textrun geometry! The existence of a linebreak can affect + * the advance width of the cluster before the break (when kerning) or the + * geometry of one cluster before the break or any number of clusters + * after the break. (The one-cluster-before-the-break limit is somewhat + * arbitrary; if some scripts require breaking it, then we need to + * alter nsTextFrame::TrimTrailingWhitespace, perhaps drastically becase + * it could affect the layout of frames before it...) + * + * We return true if glyphs or geometry changed, false otherwise. This + * function is virtual so that gfxTextRun subclasses can reshape + * properly. + * + * @param aAdvanceWidthDelta if non-null, returns the change in advance + * width of the given range. + */ + virtual bool SetLineBreaks(Range aRange, bool aLineBreakBefore, + bool aLineBreakAfter, + gfxFloat* aAdvanceWidthDelta); + + enum SuppressBreak { + eNoSuppressBreak, + // Measure the range of text as if there is no break before it. + eSuppressInitialBreak, + // Measure the range of text as if it contains no break + eSuppressAllBreaks + }; + + void ClassifyAutoHyphenations(uint32_t aStart, Range aRange, + nsTArray<HyphenType>& aHyphenBuffer, + HyphenationState* aWordState); + + /** + * Finds the longest substring that will fit into the given width. + * Uses GetHyphenationBreaks and GetSpacing from aProvider. + * Guarantees the following: + * -- 0 <= result <= aMaxLength + * -- result is the maximal value of N such that either + * N < aMaxLength && line break at N && + * GetAdvanceWidth(Range(aStart, N), aProvider) <= aWidth + * OR N < aMaxLength && hyphen break at N && + * GetAdvanceWidth(Range(aStart, N), aProvider) + + * GetHyphenWidth() <= aWidth + * OR N == aMaxLength && + * GetAdvanceWidth(Range(aStart, N), aProvider) <= aWidth + * where GetAdvanceWidth assumes the effect of + * SetLineBreaks(Range(aStart, N), + * aLineBreakBefore, N < aMaxLength, aProvider) + * -- if no such N exists, then result is the smallest N such that + * N < aMaxLength && line break at N + * OR N < aMaxLength && hyphen break at N + * OR N == aMaxLength + * + * The call has the effect of + * SetLineBreaks(Range(aStart, result), aLineBreakBefore, + * result < aMaxLength, aProvider) + * and the returned metrics and the invariants above reflect this. + * + * @param aMaxLength this can be UINT32_MAX, in which case the length used + * is up to the end of the string + * @param aLineBreakBefore set to true if and only if there is an actual + * line break at the start of this string. + * @param aSuppressBreak what break should be suppressed. + * @param aTrimWhitespace if non-null, then we allow a trailing run of + * spaces to be trimmed; the width of the space(s) will not be included in + * the measured string width for comparison with the limit aWidth, and + * trimmed spaces will not be included in returned metrics. The width + * of the trimmed spaces will be returned in aTrimWhitespace. + * Trimmed spaces are still counted in the "characters fit" result. + * @param aHangWhitespace true if we allow whitespace to overflow the + * container at a soft-wrap + * @param aMetrics if non-null, we fill this in for the returned substring. + * If a hyphenation break was used, the hyphen is NOT included in the returned + * metrics. + * @param aBoundingBoxType whether to make the bounding box in aMetrics tight + * @param aDrawTargetForTightBoundingbox a reference DrawTarget to get the + * tight bounding box, if requested + * @param aUsedHyphenation if non-null, records if we selected a hyphenation + * break + * @param aLastBreak if non-null and result is aMaxLength, we set this to + * the maximal N such that + * N < aMaxLength && line break at N && + * GetAdvanceWidth(Range(aStart, N), aProvider) <= aWidth + * OR N < aMaxLength && hyphen break at N && + * GetAdvanceWidth(Range(aStart, N), aProvider) + + * GetHyphenWidth() <= aWidth + * or UINT32_MAX if no such N exists, where GetAdvanceWidth assumes + * the effect of + * SetLineBreaks(Range(aStart, N), aLineBreakBefore, + * N < aMaxLength, aProvider) + * + * @param aCanWordWrap true if we can break between any two grapheme + * clusters. This is set by overflow-wrap|word-wrap: break-word + * + * @param aBreakPriority in/out the priority of the break opportunity + * saved in the line. If we are prioritizing break opportunities, we will + * not set a break with a lower priority. @see gfxBreakPriority. + * + * Note that negative advance widths are possible especially if negative + * spacing is provided. + */ + uint32_t BreakAndMeasureText(uint32_t aStart, uint32_t aMaxLength, + bool aLineBreakBefore, gfxFloat aWidth, + PropertyProvider* aProvider, + SuppressBreak aSuppressBreak, + gfxFloat* aTrimWhitespace, bool aHangWhitespace, + Metrics* aMetrics, + gfxFont::BoundingBoxType aBoundingBoxType, + DrawTarget* aDrawTargetForTightBoundingBox, + bool* aUsedHyphenation, uint32_t* aLastBreak, + bool aCanWordWrap, bool aCanWhitespaceWrap, + gfxBreakPriority* aBreakPriority); + + // Utility getters + + void* GetUserData() const { return mUserData; } + void SetUserData(void* aUserData) { mUserData = aUserData; } + + void SetFlagBits(nsTextFrameUtils::Flags aFlags) { mFlags2 |= aFlags; } + void ClearFlagBits(nsTextFrameUtils::Flags aFlags) { mFlags2 &= ~aFlags; } + const gfxSkipChars& GetSkipChars() const { return mSkipChars; } + gfxFontGroup* GetFontGroup() const { return mFontGroup; } + + // Call this, don't call "new gfxTextRun" directly. This does custom + // allocation and initialization + static already_AddRefed<gfxTextRun> Create( + const gfxTextRunFactory::Parameters* aParams, uint32_t aLength, + gfxFontGroup* aFontGroup, mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2); + + // The text is divided into GlyphRuns as necessary. (In the vast majority + // of cases, a gfxTextRun contains just a single GlyphRun.) + struct GlyphRun { + RefPtr<gfxFont> mFont; // never null in a valid GlyphRun + uint32_t mCharacterOffset; // into original UTF16 string + mozilla::gfx::ShapedTextFlags + mOrientation; // gfxTextRunFactory::TEXT_ORIENT_* value + FontMatchType mMatchType; + bool mIsCJK; // Whether the text was a CJK script run (used to decide if + // text-decoration-skip-ink should not be applied) + + // Set up the properties (but NOT offset) of the GlyphRun. + void SetProperties(gfxFont* aFont, + mozilla::gfx::ShapedTextFlags aOrientation, bool aIsCJK, + FontMatchType aMatchType) { + mFont = aFont; + mOrientation = aOrientation; + mIsCJK = aIsCJK; + mMatchType = aMatchType; + } + + // Return whether the GlyphRun matches the given properties; + // the given FontMatchType will be added to the run if not present. + bool Matches(gfxFont* aFont, mozilla::gfx::ShapedTextFlags aOrientation, + bool aIsCJK, FontMatchType aMatchType) { + if (mFont == aFont && mOrientation == aOrientation && mIsCJK == aIsCJK) { + mMatchType.kind |= aMatchType.kind; + if (mMatchType.generic == mozilla::StyleGenericFontFamily::None) { + mMatchType.generic = aMatchType.generic; + } + return true; + } + return false; + } + + bool IsSidewaysLeft() const { + return (mOrientation & mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_MASK) == + mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT; + } + + bool IsSidewaysRight() const { + return (mOrientation & mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_MASK) == + mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT; + } + }; + + // Script run codes that we will mark as CJK to suppress skip-ink behavior. + static inline bool IsCJKScript(Script aScript) { + switch (aScript) { + case Script::BOPOMOFO: + case Script::HAN: + case Script::HANGUL: + case Script::HIRAGANA: + case Script::KATAKANA: + case Script::KATAKANA_OR_HIRAGANA: + case Script::SIMPLIFIED_HAN: + case Script::TRADITIONAL_HAN: + case Script::JAPANESE: + case Script::KOREAN: + case Script::HAN_WITH_BOPOMOFO: + case Script::JAMO: + return true; + default: + return false; + } + } + + class MOZ_STACK_CLASS GlyphRunIterator { + public: + GlyphRunIterator(const gfxTextRun* aTextRun, Range aRange, + bool aReverse = false) + : mTextRun(aTextRun), + mDirection(aReverse ? -1 : 1), + mStartOffset(aRange.start), + mEndOffset(aRange.end) { + mNextIndex = mTextRun->FindFirstGlyphRunContaining( + aReverse ? aRange.end - 1 : aRange.start); + } + bool NextRun(); + const GlyphRun* GetGlyphRun() const { return mGlyphRun; } + uint32_t GetStringStart() const { return mStringStart; } + uint32_t GetStringEnd() const { return mStringEnd; } + + private: + const gfxTextRun* mTextRun; + MOZ_INIT_OUTSIDE_CTOR const GlyphRun* mGlyphRun; + MOZ_INIT_OUTSIDE_CTOR uint32_t mStringStart; + MOZ_INIT_OUTSIDE_CTOR uint32_t mStringEnd; + const int32_t mDirection; + int32_t mNextIndex; + uint32_t mStartOffset; + uint32_t mEndOffset; + }; + + class GlyphRunOffsetComparator { + public: + bool Equals(const GlyphRun& a, const GlyphRun& b) const { + return a.mCharacterOffset == b.mCharacterOffset; + } + + bool LessThan(const GlyphRun& a, const GlyphRun& b) const { + return a.mCharacterOffset < b.mCharacterOffset; + } + }; + + friend class GlyphRunIterator; + friend class FontSelector; + + // API for setting up the textrun glyphs. Should only be called by + // things that construct textruns. + /** + * We've found a run of text that should use a particular font. Call this + * only during initialization when font substitution has been computed. + * Call it before setting up the glyphs for the characters in this run; + * SetMissingGlyph requires that the correct glyphrun be installed. + * + * If aForceNewRun, a new glyph run will be added, even if the + * previously added run uses the same font. If glyph runs are + * added out of strictly increasing aStartCharIndex order (via + * force), then SortGlyphRuns must be called after all glyph runs + * are added before any further operations are performed with this + * TextRun. + */ + void AddGlyphRun(gfxFont* aFont, FontMatchType aMatchType, + uint32_t aUTF16Offset, bool aForceNewRun, + mozilla::gfx::ShapedTextFlags aOrientation, bool aIsCJK); + void ResetGlyphRuns() { + if (mHasGlyphRunArray) { + MOZ_ASSERT(mGlyphRunArray.Length() > 1); + // Discard all but the first GlyphRun... + mGlyphRunArray.TruncateLength(1); + // ...and then convert to the single-run representation. + ConvertFromGlyphRunArray(); + } + // Clear out the one remaining GlyphRun. + mSingleGlyphRun.mFont = nullptr; + } + void SortGlyphRuns(); + void SanitizeGlyphRuns(); + + const CompressedGlyph* GetCharacterGlyphs() const final { + MOZ_ASSERT(mCharacterGlyphs, "failed to initialize mCharacterGlyphs"); + return mCharacterGlyphs; + } + CompressedGlyph* GetCharacterGlyphs() final { + MOZ_ASSERT(mCharacterGlyphs, "failed to initialize mCharacterGlyphs"); + return mCharacterGlyphs; + } + + // clean out results from shaping in progress, used for fallback scenarios + void ClearGlyphsAndCharacters(); + + void SetSpaceGlyph(gfxFont* aFont, DrawTarget* aDrawTarget, + uint32_t aCharIndex, + mozilla::gfx::ShapedTextFlags aOrientation); + + // Set the glyph data for the given character index to the font's + // space glyph, IF this can be done as a "simple" glyph record + // (not requiring a DetailedGlyph entry). This avoids the need to call + // the font shaper and go through the shaped-word cache for most spaces. + // + // The parameter aSpaceChar is the original character code for which + // this space glyph is being used; if this is U+0020, we need to record + // that it could be trimmed at a run edge, whereas other kinds of space + // (currently just U+00A0) would not be trimmable/breakable. + // + // Returns true if it was able to set simple glyph data for the space; + // if it returns false, the caller needs to fall back to some other + // means to create the necessary (detailed) glyph data. + bool SetSpaceGlyphIfSimple(gfxFont* aFont, uint32_t aCharIndex, + char16_t aSpaceChar, + mozilla::gfx::ShapedTextFlags aOrientation); + + // Record the positions of specific characters that layout may need to + // detect in the textrun, even though it doesn't have an explicit copy + // of the original text. These are recorded using flag bits in the + // CompressedGlyph record; if necessary, we convert "simple" glyph records + // to "complex" ones as the Tab and Newline flags are not present in + // simple CompressedGlyph records. + void SetIsTab(uint32_t aIndex) { EnsureComplexGlyph(aIndex).SetIsTab(); } + void SetIsNewline(uint32_t aIndex) { + EnsureComplexGlyph(aIndex).SetIsNewline(); + } + void SetNoEmphasisMark(uint32_t aIndex) { + EnsureComplexGlyph(aIndex).SetNoEmphasisMark(); + } + void SetIsFormattingControl(uint32_t aIndex) { + EnsureComplexGlyph(aIndex).SetIsFormattingControl(); + } + + /** + * Prefetch all the glyph extents needed to ensure that Measure calls + * on this textrun not requesting tight boundingBoxes will succeed. Note + * that some glyph extents might not be fetched due to OOM or other + * errors. + */ + void FetchGlyphExtents(DrawTarget* aRefDrawTarget) const; + + const GlyphRun* GetGlyphRuns(uint32_t* aNumGlyphRuns) const { + if (mHasGlyphRunArray) { + *aNumGlyphRuns = mGlyphRunArray.Length(); + return mGlyphRunArray.Elements(); + } else { + *aNumGlyphRuns = mSingleGlyphRun.mFont ? 1 : 0; + return &mSingleGlyphRun; + } + } + + const GlyphRun* TrailingGlyphRun() const { + uint32_t count; + const GlyphRun* runs = GetGlyphRuns(&count); + return count ? runs + count - 1 : nullptr; + } + + // Returns the index of the GlyphRun containing the given offset. + // Returns mGlyphRuns.Length() when aOffset is mCharacterCount. + uint32_t FindFirstGlyphRunContaining(uint32_t aOffset) const; + + // Copy glyph data from a ShapedWord into this textrun. + void CopyGlyphDataFrom(gfxShapedWord* aSource, uint32_t aStart); + + // Copy glyph data for a range of characters from aSource to this + // textrun. + void CopyGlyphDataFrom(gfxTextRun* aSource, Range aRange, uint32_t aDest); + + // Tell the textrun to release its reference to its creating gfxFontGroup + // immediately, rather than on destruction. This is used for textruns + // that are actually owned by a gfxFontGroup, so that they don't keep it + // permanently alive due to a circular reference. (The caller of this is + // taking responsibility for ensuring the textrun will not outlive its + // mFontGroup.) + void ReleaseFontGroup(); + + struct LigatureData { + // textrun range of the containing ligature + Range mRange; + // appunits advance to the start of the ligature part within the ligature; + // never includes any spacing + gfxFloat mPartAdvance; + // appunits width of the ligature part; includes before-spacing + // when the part is at the start of the ligature, and after-spacing + // when the part is as the end of the ligature + gfxFloat mPartWidth; + + bool mClipBeforePart; + bool mClipAfterPart; + }; + + // return storage used by this run, for memory reporter; + // nsTransformedTextRun needs to override this as it holds additional data + virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) + MOZ_MUST_OVERRIDE; + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) + MOZ_MUST_OVERRIDE; + + nsTextFrameUtils::Flags GetFlags2() const { return mFlags2; } + + // Get the size, if it hasn't already been gotten, marking as it goes. + size_t MaybeSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) { + if (mFlags2 & nsTextFrameUtils::Flags::RunSizeAccounted) { + return 0; + } + mFlags2 |= nsTextFrameUtils::Flags::RunSizeAccounted; + return SizeOfIncludingThis(aMallocSizeOf); + } + void ResetSizeOfAccountingFlags() { + mFlags2 &= ~nsTextFrameUtils::Flags::RunSizeAccounted; + } + + // shaping state - for some font features, fallback is required that + // affects the entire run. for example, fallback for one script/font + // portion of a textrun requires fallback to be applied to the entire run + + enum ShapingState : uint8_t { + eShapingState_Normal, // default state + eShapingState_ShapingWithFeature, // have shaped with feature + eShapingState_ShapingWithFallback, // have shaped with fallback + eShapingState_Aborted, // abort initial iteration + eShapingState_ForceFallbackFeature // redo with fallback forced on + }; + + ShapingState GetShapingState() const { return mShapingState; } + void SetShapingState(ShapingState aShapingState) { + mShapingState = aShapingState; + } + + int32_t GetAdvanceForGlyph(uint32_t aIndex) const { + const CompressedGlyph& glyphData = mCharacterGlyphs[aIndex]; + if (glyphData.IsSimpleGlyph()) { + return glyphData.GetSimpleAdvance(); + } + uint32_t glyphCount = glyphData.GetGlyphCount(); + if (!glyphCount) { + return 0; + } + const DetailedGlyph* details = GetDetailedGlyphs(aIndex); + int32_t advance = 0; + for (uint32_t j = 0; j < glyphCount; ++j, ++details) { + advance += details->mAdvance; + } + return advance; + } + +#ifdef DEBUG_FRAME_DUMP + void Dump(FILE* aOutput = stderr); +#endif + + protected: + /** + * Create a textrun, and set its mCharacterGlyphs to point immediately + * after the base object; this is ONLY used in conjunction with placement + * new, after allocating a block large enough for the glyph records to + * follow the base textrun object. + */ + gfxTextRun(const gfxTextRunFactory::Parameters* aParams, uint32_t aLength, + gfxFontGroup* aFontGroup, mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2); + + // Whether we need to fetch actual glyph extents from the fonts. + bool NeedsGlyphExtents() const; + + /** + * Helper for the Create() factory method to allocate the required + * glyph storage for a textrun object with the basic size aSize, + * plus room for aLength glyph records. + */ + static void* AllocateStorageForTextRun(size_t aSize, uint32_t aLength); + + // Pointer to the array of CompressedGlyph records; must be initialized + // when the object is constructed. + CompressedGlyph* mCharacterGlyphs; + + private: + // **** general helpers **** + + // Get the total advance for a range of glyphs. + int32_t GetAdvanceForGlyphs(Range aRange) const; + + // Spacing for characters outside the range aSpacingStart/aSpacingEnd + // is assumed to be zero; such characters are not passed to aProvider. + // This is useful to protect aProvider from being passed character indices + // it is not currently able to handle. + bool GetAdjustedSpacingArray( + Range aRange, PropertyProvider* aProvider, Range aSpacingRange, + nsTArray<PropertyProvider::Spacing>* aSpacing) const; + + CompressedGlyph& EnsureComplexGlyph(uint32_t aIndex) { + gfxShapedText::EnsureComplexGlyph(aIndex, mCharacterGlyphs[aIndex]); + return mCharacterGlyphs[aIndex]; + } + + // **** ligature helpers **** + // (Platforms do the actual ligaturization, but we need to do a bunch of stuff + // to handle requests that begin or end inside a ligature) + + // if aProvider is null then mBeforeSpacing and mAfterSpacing are set to zero + LigatureData ComputeLigatureData(Range aPartRange, + PropertyProvider* aProvider) const; + gfxFloat ComputePartialLigatureWidth(Range aPartRange, + PropertyProvider* aProvider) const; + void DrawPartialLigature(gfxFont* aFont, Range aRange, + mozilla::gfx::Point* aPt, + PropertyProvider* aProvider, + TextRunDrawParams& aParams, + mozilla::gfx::ShapedTextFlags aOrientation) const; + // Advance aRange.start to the start of the nearest ligature, back + // up aRange.end to the nearest ligature end; may result in + // aRange->start == aRange->end. + // Returns whether any adjustment was made. + bool ShrinkToLigatureBoundaries(Range* aRange) const; + // result in appunits + gfxFloat GetPartialLigatureWidth(Range aRange, + PropertyProvider* aProvider) const; + void AccumulatePartialLigatureMetrics( + gfxFont* aFont, Range aRange, gfxFont::BoundingBoxType aBoundingBoxType, + DrawTarget* aRefDrawTarget, PropertyProvider* aProvider, + mozilla::gfx::ShapedTextFlags aOrientation, Metrics* aMetrics) const; + + // **** measurement helper **** + void AccumulateMetricsForRun(gfxFont* aFont, Range aRange, + gfxFont::BoundingBoxType aBoundingBoxType, + DrawTarget* aRefDrawTarget, + PropertyProvider* aProvider, Range aSpacingRange, + mozilla::gfx::ShapedTextFlags aOrientation, + Metrics* aMetrics) const; + + // **** drawing helper **** + void DrawGlyphs(gfxFont* aFont, Range aRange, mozilla::gfx::Point* aPt, + PropertyProvider* aProvider, Range aSpacingRange, + TextRunDrawParams& aParams, + mozilla::gfx::ShapedTextFlags aOrientation) const; + + // The textrun holds either a single GlyphRun -or- an array; + // the flag mHasGlyphRunArray tells us which is present. + union { + GlyphRun mSingleGlyphRun; + nsTArray<GlyphRun> mGlyphRunArray; + }; + + void ConvertToGlyphRunArray() { + MOZ_ASSERT(!mHasGlyphRunArray && mSingleGlyphRun.mFont); + GlyphRun tmp = std::move(mSingleGlyphRun); + mSingleGlyphRun.~GlyphRun(); + new (&mGlyphRunArray) nsTArray<GlyphRun>(2); + mGlyphRunArray.AppendElement(std::move(tmp)); + mHasGlyphRunArray = true; + } + + void ConvertFromGlyphRunArray() { + MOZ_ASSERT(mHasGlyphRunArray && mGlyphRunArray.Length() == 1); + GlyphRun tmp = std::move(mGlyphRunArray[0]); + mGlyphRunArray.~nsTArray<GlyphRun>(); + new (&mSingleGlyphRun) GlyphRun(std::move(tmp)); + mHasGlyphRunArray = false; + } + + void* mUserData; + + // mFontGroup is usually a strong reference, but refcounting is managed + // manually because it may be explicitly released by ReleaseFontGroup() + // in the case where the font group actually owns the textrun. + gfxFontGroup* MOZ_OWNING_REF mFontGroup; + + gfxSkipChars mSkipChars; + + nsTextFrameUtils::Flags + mFlags2; // additional flags (see also gfxShapedText::mFlags) + + bool mDontSkipDrawing; // true if the text run must not skip drawing, even if + // waiting for a user font download, e.g. because we + // are using it to draw canvas text + bool mReleasedFontGroup; // we already called NS_RELEASE on + // mFontGroup, so don't do it again + bool mReleasedFontGroupSkippedDrawing; // whether our old mFontGroup value + // was set to skip drawing + bool mHasGlyphRunArray; // whether we're using an array or + // just storing a single glyphrun + + // shaping state for handling variant fallback features + // such as subscript/superscript variant glyphs + ShapingState mShapingState; +}; + +class gfxFontGroup final : public gfxTextRunFactory { + public: + typedef mozilla::intl::Script Script; + typedef gfxShapedText::CompressedGlyph CompressedGlyph; + + static void + Shutdown(); // platform must call this to release the languageAtomService + + gfxFontGroup(nsPresContext* aPresContext, + const mozilla::StyleFontFamilyList& aFontFamilyList, + const gfxFontStyle* aStyle, nsAtom* aLanguage, + bool aExplicitLanguage, gfxTextPerfMetrics* aTextPerf, + gfxUserFontSet* aUserFontSet, gfxFloat aDevToCssSize, + StyleFontVariantEmoji aVariantEmoji); + + virtual ~gfxFontGroup(); + + gfxFontGroup(const gfxFontGroup& aOther) = delete; + + // Returns first valid font in the fontlist or default font. + // Initiates userfont loads if userfont not loaded. + // aGeneric: if non-null, returns the CSS generic type that was mapped to + // this font + already_AddRefed<gfxFont> GetFirstValidFont( + uint32_t aCh = 0x20, mozilla::StyleGenericFontFamily* aGeneric = nullptr); + + // Returns the first font in the font-group that has an OpenType MATH table, + // or null if no such font is available. The GetMathConstant methods may be + // called on the returned font. + already_AddRefed<gfxFont> GetFirstMathFont(); + + const gfxFontStyle* GetStyle() const { return &mStyle; } + + // Get the presContext for which this fontGroup was constructed. This may be + // null! (In the case of canvas not connected to a document.) + nsPresContext* GetPresContext() const { return mPresContext; } + + /** + * The listed characters should be treated as invisible and zero-width + * when creating textruns. + */ + static bool IsInvalidChar(uint8_t ch); + static bool IsInvalidChar(char16_t ch); + + /** + * Make a textrun for a given string. + * If aText is not persistent (aFlags & TEXT_IS_PERSISTENT), the + * textrun will copy it. + * This calls FetchGlyphExtents on the textrun. + */ + already_AddRefed<gfxTextRun> MakeTextRun(const char16_t* aString, + uint32_t aLength, + const Parameters* aParams, + mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2, + gfxMissingFontRecorder* aMFR); + /** + * Make a textrun for a given string. + * If aText is not persistent (aFlags & TEXT_IS_PERSISTENT), the + * textrun will copy it. + * This calls FetchGlyphExtents on the textrun. + */ + already_AddRefed<gfxTextRun> MakeTextRun(const uint8_t* aString, + uint32_t aLength, + const Parameters* aParams, + mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2, + gfxMissingFontRecorder* aMFR); + + /** + * Textrun creation helper for clients that don't want to pass + * a full Parameters record. + */ + template <typename T> + already_AddRefed<gfxTextRun> MakeTextRun(const T* aString, uint32_t aLength, + DrawTarget* aRefDrawTarget, + int32_t aAppUnitsPerDevUnit, + mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2, + gfxMissingFontRecorder* aMFR) { + gfxTextRunFactory::Parameters params = { + aRefDrawTarget, nullptr, nullptr, nullptr, 0, aAppUnitsPerDevUnit}; + return MakeTextRun(aString, aLength, ¶ms, aFlags, aFlags2, aMFR); + } + + // Get the (possibly-cached) width of the hyphen character. + gfxFloat GetHyphenWidth(const gfxTextRun::PropertyProvider* aProvider); + + /** + * Make a text run representing a single hyphen character. + * This will use U+2010 HYPHEN if available in the first font, + * otherwise fall back to U+002D HYPHEN-MINUS. + * The caller is responsible for deleting the returned text run + * when no longer required. + */ + already_AddRefed<gfxTextRun> MakeHyphenTextRun( + DrawTarget* aDrawTarget, mozilla::gfx::ShapedTextFlags aFlags, + uint32_t aAppUnitsPerDevUnit); + + /** + * Check whether a given font (specified by its gfxFontEntry) + * is already in the fontgroup's list of actual fonts + */ + bool HasFont(const gfxFontEntry* aFontEntry); + + // This returns the preferred underline for this font group. + // Some CJK fonts have wrong underline offset in its metrics. + // If this group has such "bad" font, each platform's gfxFontGroup + // initialized mUnderlineOffset. The value should be lower value of + // first font's metrics and the bad font's metrics. Otherwise, this + // returns from first font's metrics. + static constexpr gfxFloat UNDERLINE_OFFSET_NOT_SET = INT16_MAX; + gfxFloat GetUnderlineOffset(); + + already_AddRefed<gfxFont> FindFontForChar(uint32_t ch, uint32_t prevCh, + uint32_t aNextCh, Script aRunScript, + gfxFont* aPrevMatchedFont, + FontMatchType* aMatchType); + + gfxUserFontSet* GetUserFontSet(); + + // With downloadable fonts, the composition of the font group can change as + // fonts are downloaded for each change in state of the user font set, the + // generation value is bumped to avoid picking up previously created text runs + // in the text run word cache. For font groups based on stylesheets with no + // @font-face rule, this always returns 0. + uint64_t GetGeneration(); + + // generation of the latest fontset rebuild, 0 when no fontset present + uint64_t GetRebuildGeneration(); + + // used when logging text performance + gfxTextPerfMetrics* GetTextPerfMetrics() const { return mTextPerf; } + + // This will call UpdateUserFonts() if the user font set is changed. + void SetUserFontSet(gfxUserFontSet* aUserFontSet); + + void ClearCachedData() { + mUnderlineOffset = UNDERLINE_OFFSET_NOT_SET; + mSkipDrawing = false; + mHyphenWidth = -1; + mCachedEllipsisTextRun = nullptr; + } + + // If there is a user font set, check to see whether the font list or any + // caches need updating. + void UpdateUserFonts(); + + // search for a specific userfont in the list of fonts + bool ContainsUserFont(const gfxUserFontEntry* aUserFont); + + bool ShouldSkipDrawing() const { return mSkipDrawing; } + + class LazyReferenceDrawTargetGetter { + public: + virtual already_AddRefed<DrawTarget> GetRefDrawTarget() = 0; + }; + // The gfxFontGroup keeps ownership of this textrun. + // It is only guaranteed to exist until the next call to GetEllipsisTextRun + // (which might use a different appUnitsPerDev value or flags) for the font + // group, or until UpdateUserFonts is called, or the fontgroup is destroyed. + // Get it/use it/forget it :) - don't keep a reference that might go stale. + gfxTextRun* GetEllipsisTextRun( + int32_t aAppUnitsPerDevPixel, mozilla::gfx::ShapedTextFlags aFlags, + LazyReferenceDrawTargetGetter& aRefDrawTargetGetter); + + void CheckForUpdatedPlatformList() { + auto* pfl = gfxPlatformFontList::PlatformFontList(); + if (mFontListGeneration != pfl->GetGeneration()) { + // Forget cached fonts that may no longer be valid. + mLastPrefFamily = FontFamily(); + mLastPrefFont = nullptr; + mDefaultFont = nullptr; + mFonts.Clear(); + BuildFontList(); + } + } + + nsAtom* Language() const { return mLanguage.get(); } + + protected: + friend class mozilla::PostTraversalTask; + + struct TextRange { + TextRange(uint32_t aStart, uint32_t aEnd, gfxFont* aFont, + FontMatchType aMatchType, + mozilla::gfx::ShapedTextFlags aOrientation) + : start(aStart), + end(aEnd), + font(aFont), + matchType(aMatchType), + orientation(aOrientation) {} + uint32_t Length() const { return end - start; } + uint32_t start, end; + RefPtr<gfxFont> font; + FontMatchType matchType; + mozilla::gfx::ShapedTextFlags orientation; + }; + + // search through pref fonts for a character, return nullptr if no matching + // pref font + already_AddRefed<gfxFont> WhichPrefFontSupportsChar( + uint32_t aCh, uint32_t aNextCh, eFontPresentation aPresentation); + + already_AddRefed<gfxFont> WhichSystemFontSupportsChar( + uint32_t aCh, uint32_t aNextCh, Script aRunScript, + eFontPresentation aPresentation); + + template <typename T> + void ComputeRanges(nsTArray<TextRange>& aRanges, const T* aString, + uint32_t aLength, Script aRunScript, + mozilla::gfx::ShapedTextFlags aOrientation); + + class FamilyFace { + public: + FamilyFace() + : mOwnedFamily(nullptr), + mFontEntry(nullptr), + mGeneric(mozilla::StyleGenericFontFamily::None), + mFontCreated(false), + mLoading(false), + mInvalid(false), + mCheckForFallbackFaces(false), + mIsSharedFamily(false), + mHasFontEntry(false) {} + + FamilyFace(gfxFontFamily* aFamily, gfxFont* aFont, + mozilla::StyleGenericFontFamily aGeneric) + : mOwnedFamily(aFamily), + mGeneric(aGeneric), + mFontCreated(true), + mLoading(false), + mInvalid(false), + mCheckForFallbackFaces(false), + mIsSharedFamily(false), + mHasFontEntry(false) { + NS_ASSERTION(aFont, "font pointer must not be null"); + NS_ASSERTION(!aFamily || aFamily->ContainsFace(aFont->GetFontEntry()), + "font is not a member of the given family"); + NS_IF_ADDREF(aFamily); + mFont = aFont; + NS_ADDREF(aFont); + } + + FamilyFace(gfxFontFamily* aFamily, gfxFontEntry* aFontEntry, + mozilla::StyleGenericFontFamily aGeneric) + : mOwnedFamily(aFamily), + mGeneric(aGeneric), + mFontCreated(false), + mLoading(false), + mInvalid(false), + mCheckForFallbackFaces(false), + mIsSharedFamily(false), + mHasFontEntry(true) { + NS_ASSERTION(aFontEntry, "font entry pointer must not be null"); + NS_ASSERTION(!aFamily || aFamily->ContainsFace(aFontEntry), + "font is not a member of the given family"); + NS_IF_ADDREF(aFamily); + mFontEntry = aFontEntry; + NS_ADDREF(aFontEntry); + } + + FamilyFace(mozilla::fontlist::Family* aFamily, gfxFontEntry* aFontEntry, + mozilla::StyleGenericFontFamily aGeneric) + : mSharedFamily(aFamily), + mGeneric(aGeneric), + mFontCreated(false), + mLoading(false), + mInvalid(false), + mCheckForFallbackFaces(false), + mIsSharedFamily(true), + mHasFontEntry(true) { + MOZ_ASSERT(aFamily && aFontEntry && aFontEntry->mShmemFace); + mFontEntry = aFontEntry; + NS_ADDREF(aFontEntry); + } + + FamilyFace(const FamilyFace& aOtherFamilyFace) + : mGeneric(aOtherFamilyFace.mGeneric), + mFontCreated(aOtherFamilyFace.mFontCreated), + mLoading(aOtherFamilyFace.mLoading), + mInvalid(aOtherFamilyFace.mInvalid), + mCheckForFallbackFaces(aOtherFamilyFace.mCheckForFallbackFaces), + mIsSharedFamily(aOtherFamilyFace.mIsSharedFamily), + mHasFontEntry(aOtherFamilyFace.mHasFontEntry) { + if (mIsSharedFamily) { + mSharedFamily = aOtherFamilyFace.mSharedFamily; + if (mFontCreated) { + mFont = aOtherFamilyFace.mFont; + NS_ADDREF(mFont); + } else if (mHasFontEntry) { + mFontEntry = aOtherFamilyFace.mFontEntry; + NS_ADDREF(mFontEntry); + } else { + mSharedFace = aOtherFamilyFace.mSharedFace; + } + } else { + mOwnedFamily = aOtherFamilyFace.mOwnedFamily; + NS_IF_ADDREF(mOwnedFamily); + if (mFontCreated) { + mFont = aOtherFamilyFace.mFont; + NS_ADDREF(mFont); + } else { + mFontEntry = aOtherFamilyFace.mFontEntry; + NS_IF_ADDREF(mFontEntry); + } + } + } + + ~FamilyFace() { + if (mFontCreated) { + NS_RELEASE(mFont); + } + if (!mIsSharedFamily) { + NS_IF_RELEASE(mOwnedFamily); + } + if (mHasFontEntry) { + NS_RELEASE(mFontEntry); + } + } + + FamilyFace& operator=(const FamilyFace& aOther) { + if (mFontCreated) { + NS_RELEASE(mFont); + } + if (!mIsSharedFamily) { + NS_IF_RELEASE(mOwnedFamily); + } + if (mHasFontEntry) { + NS_RELEASE(mFontEntry); + } + + mGeneric = aOther.mGeneric; + mFontCreated = aOther.mFontCreated; + mLoading = aOther.mLoading; + mInvalid = aOther.mInvalid; + mIsSharedFamily = aOther.mIsSharedFamily; + mHasFontEntry = aOther.mHasFontEntry; + + if (mIsSharedFamily) { + mSharedFamily = aOther.mSharedFamily; + if (mFontCreated) { + mFont = aOther.mFont; + NS_ADDREF(mFont); + } else if (mHasFontEntry) { + mFontEntry = aOther.mFontEntry; + NS_ADDREF(mFontEntry); + } else { + mSharedFace = aOther.mSharedFace; + } + } else { + mOwnedFamily = aOther.mOwnedFamily; + NS_IF_ADDREF(mOwnedFamily); + if (mFontCreated) { + mFont = aOther.mFont; + NS_ADDREF(mFont); + } else { + mFontEntry = aOther.mFontEntry; + NS_IF_ADDREF(mFontEntry); + } + } + + return *this; + } + + gfxFontFamily* OwnedFamily() const { + MOZ_ASSERT(!mIsSharedFamily); + return mOwnedFamily; + } + mozilla::fontlist::Family* SharedFamily() const { + MOZ_ASSERT(mIsSharedFamily); + return mSharedFamily; + } + gfxFont* Font() const { return mFontCreated ? mFont : nullptr; } + + gfxFontEntry* FontEntry() const { + if (mFontCreated) { + return mFont->GetFontEntry(); + } + if (mHasFontEntry) { + return mFontEntry; + } + if (mIsSharedFamily) { + return gfxPlatformFontList::PlatformFontList()->GetOrCreateFontEntry( + mSharedFace, SharedFamily()); + } + return nullptr; + } + + mozilla::StyleGenericFontFamily Generic() const { return mGeneric; } + + bool IsSharedFamily() const { return mIsSharedFamily; } + bool IsUserFontContainer() const { + gfxFontEntry* fe = FontEntry(); + return fe && fe->mIsUserFontContainer; + } + bool IsLoading() const { return mLoading; } + bool IsInvalid() const { return mInvalid; } + void CheckState(bool& aSkipDrawing); + void SetLoading(bool aIsLoading) { mLoading = aIsLoading; } + void SetInvalid() { mInvalid = true; } + bool CheckForFallbackFaces() const { return mCheckForFallbackFaces; } + void SetCheckForFallbackFaces() { mCheckForFallbackFaces = true; } + + // Return true if we're currently loading (or waiting for) a resource that + // may support the given character. + bool IsLoadingFor(uint32_t aCh) { + if (!IsLoading()) { + return false; + } + MOZ_ASSERT(IsUserFontContainer()); + auto* ufe = static_cast<gfxUserFontEntry*>(FontEntry()); + return ufe && ufe->CharacterInUnicodeRange(aCh); + } + + void SetFont(gfxFont* aFont) { + NS_ASSERTION(aFont, "font pointer must not be null"); + NS_ADDREF(aFont); + if (mFontCreated) { + NS_RELEASE(mFont); + } else if (mHasFontEntry) { + NS_RELEASE(mFontEntry); + mHasFontEntry = false; + } + mFont = aFont; + mFontCreated = true; + mLoading = false; + } + + bool EqualsUserFont(const gfxUserFontEntry* aUserFont) const; + + private: + union { + gfxFontFamily* MOZ_OWNING_REF mOwnedFamily; + mozilla::fontlist::Family* MOZ_NON_OWNING_REF mSharedFamily; + }; + // either a font or a font entry exists + union { + // Whichever of these fields is actually present will be a strong + // reference, with refcounting handled manually. + gfxFont* MOZ_OWNING_REF mFont; + gfxFontEntry* MOZ_OWNING_REF mFontEntry; + mozilla::fontlist::Face* MOZ_NON_OWNING_REF mSharedFace; + }; + mozilla::StyleGenericFontFamily mGeneric; + bool mFontCreated : 1; + bool mLoading : 1; + bool mInvalid : 1; + bool mCheckForFallbackFaces : 1; + bool mIsSharedFamily : 1; + bool mHasFontEntry : 1; + }; + + nsPresContext* mPresContext = nullptr; + + // List of font families, either named or generic. + // Generic names map to system pref fonts based on language. + mozilla::StyleFontFamilyList mFamilyList; + + // Fontlist containing a font entry for each family found. gfxFont objects + // are created as needed and userfont loads are initiated when needed. + // Code should be careful about addressing this array directly. + nsTArray<FamilyFace> mFonts; + + RefPtr<gfxFont> mDefaultFont; + gfxFontStyle mStyle; + + RefPtr<nsAtom> mLanguage; + + gfxFloat mUnderlineOffset; + gfxFloat mHyphenWidth; + gfxFloat mDevToCssSize; + + RefPtr<gfxUserFontSet> mUserFontSet; + uint64_t mCurrGeneration; // track the current user font set generation, + // rebuild font list if needed + + gfxTextPerfMetrics* mTextPerf; + + // Cache a textrun representing an ellipsis (useful for CSS text-overflow) + // at a specific appUnitsPerDevPixel size and orientation + RefPtr<gfxTextRun> mCachedEllipsisTextRun; + + // cache the most recent pref font to avoid general pref font lookup + FontFamily mLastPrefFamily; + RefPtr<gfxFont> mLastPrefFont; + eFontPrefLang mLastPrefLang; // lang group for last pref font + eFontPrefLang mPageLang; + bool mLastPrefFirstFont; // is this the first font in the list of pref fonts + // for this lang group? + + bool mSkipDrawing; // hide text while waiting for a font + // download to complete (or fallback + // timer to fire) + + bool mExplicitLanguage; // Does mLanguage come from an explicit attribute? + + eFontPresentation mEmojiPresentation = eFontPresentation::Any; + + // Generic font family used to select among font prefs during fallback. + mozilla::StyleGenericFontFamily mFallbackGeneric = + mozilla::StyleGenericFontFamily::None; + + uint32_t mFontListGeneration = 0; // platform font list generation for this + // fontgroup + + /** + * Textrun creation short-cuts for special cases where we don't need to + * call a font shaper to generate glyphs. + */ + already_AddRefed<gfxTextRun> MakeEmptyTextRun( + const Parameters* aParams, mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2); + + already_AddRefed<gfxTextRun> MakeSpaceTextRun( + const Parameters* aParams, mozilla::gfx::ShapedTextFlags aFlags, + nsTextFrameUtils::Flags aFlags2); + + template <typename T> + already_AddRefed<gfxTextRun> MakeBlankTextRun( + const T* aString, uint32_t aLength, const Parameters* aParams, + mozilla::gfx::ShapedTextFlags aFlags, nsTextFrameUtils::Flags aFlags2); + + // Initialize the list of fonts + void BuildFontList(); + + // Get the font at index i within the fontlist, for character aCh (in case + // of fonts with multiple resources and unicode-range partitioning). + // Will initiate userfont load if not already loaded. + // May return null if userfont not loaded or if font invalid. + // If *aLoading is true, a relevant resource is already being loaded so no + // new download will be initiated; if a download is started, *aLoading will + // be set to true on return. + already_AddRefed<gfxFont> GetFontAt(int32_t i, uint32_t aCh, bool* aLoading); + + // Simplified version of GetFontAt() for use where we just need a font for + // metrics, math layout tables, etc. + already_AddRefed<gfxFont> GetFontAt(int32_t i, uint32_t aCh = 0x20) { + bool loading = false; + return GetFontAt(i, aCh, &loading); + } + + // will always return a font or force a shutdown + already_AddRefed<gfxFont> GetDefaultFont(); + + // Init this font group's font metrics. If there no bad fonts, you don't need + // to call this. But if there are one or more bad fonts which have bad + // underline offset, you should call this with the *first* bad font. + void InitMetricsForBadFont(gfxFont* aBadFont); + + // Set up the textrun glyphs for an entire text run: + // find script runs, and then call InitScriptRun for each + template <typename T> + void InitTextRun(DrawTarget* aDrawTarget, gfxTextRun* aTextRun, + const T* aString, uint32_t aLength, + gfxMissingFontRecorder* aMFR); + + // InitTextRun helper to handle a single script run, by finding font ranges + // and calling each font's InitTextRun() as appropriate + template <typename T> + void InitScriptRun(DrawTarget* aDrawTarget, gfxTextRun* aTextRun, + const T* aString, uint32_t aScriptRunStart, + uint32_t aScriptRunEnd, Script aRunScript, + gfxMissingFontRecorder* aMFR); + + // Helper for font-matching: + // search all faces in a family for a fallback in cases where it's unclear + // whether the family might have a font for a given character + already_AddRefed<gfxFont> FindFallbackFaceForChar( + const FamilyFace& aFamily, uint32_t aCh, uint32_t aNextCh, + eFontPresentation aPresentation); + + already_AddRefed<gfxFont> FindFallbackFaceForChar( + mozilla::fontlist::Family* aFamily, uint32_t aCh, uint32_t aNextCh, + eFontPresentation aPresentation); + + already_AddRefed<gfxFont> FindFallbackFaceForChar( + gfxFontFamily* aFamily, uint32_t aCh, uint32_t aNextCh, + eFontPresentation aPresentation); + + // helper methods for looking up fonts + + // lookup and add a font with a given name (i.e. *not* a generic!) + void AddPlatformFont(const nsACString& aName, bool aQuotedName, + nsTArray<FamilyAndGeneric>& aFamilyList); + + // do style selection and add entries to list + void AddFamilyToFontList(gfxFontFamily* aFamily, + mozilla::StyleGenericFontFamily aGeneric); + void AddFamilyToFontList(mozilla::fontlist::Family* aFamily, + mozilla::StyleGenericFontFamily aGeneric); +}; + +// A "missing font recorder" is to be used during text-run creation to keep +// a record of any scripts encountered for which font coverage was lacking; +// when Flush() is called, it sends a notification that front-end code can use +// to download fonts on demand (or whatever else it wants to do). + +#define GFX_MISSING_FONTS_NOTIFY_PREF "gfx.missing_fonts.notify" + +class gfxMissingFontRecorder { + public: + gfxMissingFontRecorder() { + MOZ_COUNT_CTOR(gfxMissingFontRecorder); + memset(&mMissingFonts, 0, sizeof(mMissingFonts)); + } + + ~gfxMissingFontRecorder() { +#ifdef DEBUG + for (uint32_t i = 0; i < kNumScriptBitsWords; i++) { + NS_ASSERTION(mMissingFonts[i] == 0, + "failed to flush the missing-font recorder"); + } +#endif + MOZ_COUNT_DTOR(gfxMissingFontRecorder); + } + + // record this script code in our mMissingFonts bitset + void RecordScript(mozilla::intl::Script aScriptCode) { + mMissingFonts[static_cast<uint32_t>(aScriptCode) >> 5] |= + (1 << (static_cast<uint32_t>(aScriptCode) & 0x1f)); + } + + // send a notification of any missing-scripts that have been + // recorded, and clear the mMissingFonts set for re-use + void Flush(); + + // forget any missing-scripts that have been recorded up to now; + // called before discarding a recorder we no longer care about + void Clear() { memset(&mMissingFonts, 0, sizeof(mMissingFonts)); } + + private: + // Number of 32-bit words needed for the missing-script flags + static const uint32_t kNumScriptBitsWords = + ((static_cast<int>(mozilla::intl::Script::NUM_SCRIPT_CODES) + 31) / 32); + uint32_t mMissingFonts[kNumScriptBitsWords]; +}; + +#endif |