diff options
Diffstat (limited to 'layout/generic/nsTextRunTransformations.cpp')
| -rw-r--r-- | layout/generic/nsTextRunTransformations.cpp | 692 |
1 files changed, 692 insertions, 0 deletions
diff --git a/layout/generic/nsTextRunTransformations.cpp b/layout/generic/nsTextRunTransformations.cpp new file mode 100644 index 000000000..84d669ed6 --- /dev/null +++ b/layout/generic/nsTextRunTransformations.cpp @@ -0,0 +1,692 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsTextRunTransformations.h" + +#include "mozilla/MemoryReporting.h" +#include "mozilla/Move.h" + +#include "nsGkAtoms.h" +#include "nsStyleConsts.h" +#include "nsUnicharUtils.h" +#include "nsUnicodeProperties.h" +#include "nsSpecialCasingData.h" +#include "mozilla/gfx/2D.h" +#include "nsTextFrameUtils.h" +#include "nsIPersistentProperties2.h" +#include "GreekCasing.h" +#include "IrishCasing.h" + +using namespace mozilla; + +// Unicode characters needing special casing treatment in tr/az languages +#define LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE 0x0130 +#define LATIN_SMALL_LETTER_DOTLESS_I 0x0131 + +// Greek sigma needs custom handling for the lowercase transform; for details +// see comments under "case NS_STYLE_TEXT_TRANSFORM_LOWERCASE" within +// nsCaseTransformTextRunFactory::RebuildTextRun(), and bug 740120. +#define GREEK_CAPITAL_LETTER_SIGMA 0x03A3 +#define GREEK_SMALL_LETTER_FINAL_SIGMA 0x03C2 +#define GREEK_SMALL_LETTER_SIGMA 0x03C3 + +already_AddRefed<nsTransformedTextRun> +nsTransformedTextRun::Create(const gfxTextRunFactory::Parameters* aParams, + nsTransformingTextRunFactory* aFactory, + gfxFontGroup* aFontGroup, + const char16_t* aString, uint32_t aLength, + const uint32_t aFlags, + nsTArray<RefPtr<nsTransformedCharStyle>>&& aStyles, + bool aOwnsFactory) +{ + NS_ASSERTION(!(aFlags & gfxTextRunFactory::TEXT_IS_8BIT), + "didn't expect text to be marked as 8-bit here"); + + void *storage = AllocateStorageForTextRun(sizeof(nsTransformedTextRun), aLength); + if (!storage) { + return nullptr; + } + + RefPtr<nsTransformedTextRun> result = + new (storage) nsTransformedTextRun(aParams, aFactory, aFontGroup, + aString, aLength, aFlags, + Move(aStyles), aOwnsFactory); + return result.forget(); +} + +void +nsTransformedTextRun::SetCapitalization(uint32_t aStart, uint32_t aLength, + bool* aCapitalization) +{ + if (mCapitalize.IsEmpty()) { + if (!mCapitalize.AppendElements(GetLength())) + return; + memset(mCapitalize.Elements(), 0, GetLength()*sizeof(bool)); + } + memcpy(mCapitalize.Elements() + aStart, aCapitalization, aLength*sizeof(bool)); + mNeedsRebuild = true; +} + +bool +nsTransformedTextRun::SetPotentialLineBreaks(Range aRange, + const uint8_t* aBreakBefore) +{ + bool changed = gfxTextRun::SetPotentialLineBreaks(aRange, aBreakBefore); + if (changed) { + mNeedsRebuild = true; + } + return changed; +} + +size_t +nsTransformedTextRun::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) +{ + size_t total = gfxTextRun::SizeOfExcludingThis(aMallocSizeOf); + total += mStyles.ShallowSizeOfExcludingThis(aMallocSizeOf); + total += mCapitalize.ShallowSizeOfExcludingThis(aMallocSizeOf); + if (mOwnsFactory) { + total += aMallocSizeOf(mFactory); + } + return total; +} + +size_t +nsTransformedTextRun::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) +{ + return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); +} + +already_AddRefed<nsTransformedTextRun> +nsTransformingTextRunFactory::MakeTextRun(const char16_t* aString, uint32_t aLength, + const gfxTextRunFactory::Parameters* aParams, + gfxFontGroup* aFontGroup, uint32_t aFlags, + nsTArray<RefPtr<nsTransformedCharStyle>>&& aStyles, + bool aOwnsFactory) +{ + return nsTransformedTextRun::Create(aParams, this, aFontGroup, + aString, aLength, aFlags, Move(aStyles), + aOwnsFactory); +} + +already_AddRefed<nsTransformedTextRun> +nsTransformingTextRunFactory::MakeTextRun(const uint8_t* aString, uint32_t aLength, + const gfxTextRunFactory::Parameters* aParams, + gfxFontGroup* aFontGroup, uint32_t aFlags, + nsTArray<RefPtr<nsTransformedCharStyle>>&& aStyles, + bool aOwnsFactory) +{ + // We'll only have a Unicode code path to minimize the amount of code needed + // for these rarely used features + NS_ConvertASCIItoUTF16 unicodeString(reinterpret_cast<const char*>(aString), aLength); + return MakeTextRun(unicodeString.get(), aLength, aParams, aFontGroup, + aFlags & ~(gfxFontGroup::TEXT_IS_PERSISTENT | gfxFontGroup::TEXT_IS_8BIT), + Move(aStyles), aOwnsFactory); +} + +void +MergeCharactersInTextRun(gfxTextRun* aDest, gfxTextRun* aSrc, + const bool* aCharsToMerge, const bool* aDeletedChars) +{ + aDest->ResetGlyphRuns(); + + gfxTextRun::GlyphRunIterator iter(aSrc, gfxTextRun::Range(aSrc)); + uint32_t offset = 0; + AutoTArray<gfxTextRun::DetailedGlyph,2> glyphs; + while (iter.NextRun()) { + const gfxTextRun::GlyphRun* run = iter.GetGlyphRun(); + nsresult rv = aDest->AddGlyphRun(run->mFont, run->mMatchType, + offset, false, run->mOrientation); + if (NS_FAILED(rv)) + return; + + bool anyMissing = false; + uint32_t mergeRunStart = iter.GetStringStart(); + const gfxTextRun::CompressedGlyph *srcGlyphs = aSrc->GetCharacterGlyphs(); + gfxTextRun::CompressedGlyph mergedGlyph = srcGlyphs[mergeRunStart]; + uint32_t stringEnd = iter.GetStringEnd(); + for (uint32_t k = iter.GetStringStart(); k < stringEnd; ++k) { + const gfxTextRun::CompressedGlyph g = srcGlyphs[k]; + if (g.IsSimpleGlyph()) { + if (!anyMissing) { + gfxTextRun::DetailedGlyph details; + details.mGlyphID = g.GetSimpleGlyph(); + details.mAdvance = g.GetSimpleAdvance(); + details.mXOffset = 0; + details.mYOffset = 0; + glyphs.AppendElement(details); + } + } else { + if (g.IsMissing()) { + anyMissing = true; + glyphs.Clear(); + } + if (g.GetGlyphCount() > 0) { + glyphs.AppendElements(aSrc->GetDetailedGlyphs(k), g.GetGlyphCount()); + } + } + + if (k + 1 < iter.GetStringEnd() && aCharsToMerge[k + 1]) { + // next char is supposed to merge with current, so loop without + // writing current merged glyph to the destination + continue; + } + + // If the start of the merge run is actually a character that should + // have been merged with the previous character (this can happen + // if there's a font change in the middle of a case-mapped character, + // that decomposed into a sequence of base+diacritics, for example), + // just discard the entire merge run. See comment at start of this + // function. + NS_WARNING_ASSERTION( + !aCharsToMerge[mergeRunStart], + "unable to merge across a glyph run boundary, glyph(s) discarded"); + if (!aCharsToMerge[mergeRunStart]) { + if (anyMissing) { + mergedGlyph.SetMissing(glyphs.Length()); + } else { + mergedGlyph.SetComplex(mergedGlyph.IsClusterStart(), + mergedGlyph.IsLigatureGroupStart(), + glyphs.Length()); + } + aDest->SetGlyphs(offset, mergedGlyph, glyphs.Elements()); + ++offset; + + while (offset < aDest->GetLength() && aDeletedChars[offset]) { + aDest->SetGlyphs(offset++, gfxTextRun::CompressedGlyph(), nullptr); + } + } + + glyphs.Clear(); + anyMissing = false; + mergeRunStart = k + 1; + if (mergeRunStart < stringEnd) { + mergedGlyph = srcGlyphs[mergeRunStart]; + } + } + NS_ASSERTION(glyphs.Length() == 0, + "Leftover glyphs, don't request merging of the last character with its next!"); + } + NS_ASSERTION(offset == aDest->GetLength(), "Bad offset calculations"); +} + +gfxTextRunFactory::Parameters +GetParametersForInner(nsTransformedTextRun* aTextRun, uint32_t* aFlags, + DrawTarget* aRefDrawTarget) +{ + gfxTextRunFactory::Parameters params = + { aRefDrawTarget, nullptr, nullptr, + nullptr, 0, aTextRun->GetAppUnitsPerDevUnit() + }; + *aFlags = aTextRun->GetFlags() & ~gfxFontGroup::TEXT_IS_PERSISTENT; + return params; +} + +// Some languages have special casing conventions that differ from the +// default Unicode mappings. +// The enum values here are named for well-known exemplar languages that +// exhibit the behavior in question; multiple lang tags may map to the +// same setting here, if the behavior is shared by other languages. +enum LanguageSpecificCasingBehavior { + eLSCB_None, // default non-lang-specific behavior + eLSCB_Dutch, // treat "ij" digraph as a unit for capitalization + eLSCB_Greek, // strip accent when uppercasing Greek vowels + eLSCB_Irish, // keep prefix letters as lowercase when uppercasing Irish + eLSCB_Turkish // preserve dotted/dotless-i distinction in uppercase +}; + +static LanguageSpecificCasingBehavior +GetCasingFor(const nsIAtom* aLang) +{ + if (!aLang) { + return eLSCB_None; + } + if (aLang == nsGkAtoms::tr || + aLang == nsGkAtoms::az || + aLang == nsGkAtoms::ba || + aLang == nsGkAtoms::crh || + aLang == nsGkAtoms::tt) { + return eLSCB_Turkish; + } + if (aLang == nsGkAtoms::nl) { + return eLSCB_Dutch; + } + if (aLang == nsGkAtoms::el) { + return eLSCB_Greek; + } + if (aLang == nsGkAtoms::ga) { + return eLSCB_Irish; + } + + // Is there a region subtag we should ignore? + nsAtomString langStr(const_cast<nsIAtom*>(aLang)); + int index = langStr.FindChar('-'); + if (index > 0) { + langStr.Truncate(index); + nsCOMPtr<nsIAtom> truncatedLang = NS_Atomize(langStr); + return GetCasingFor(truncatedLang); + } + + return eLSCB_None; +} + +bool +nsCaseTransformTextRunFactory::TransformString( + const nsAString& aString, + nsString& aConvertedString, + bool aAllUppercase, + const nsIAtom* aLanguage, + nsTArray<bool>& aCharsToMergeArray, + nsTArray<bool>& aDeletedCharsArray, + const nsTransformedTextRun* aTextRun, + uint32_t aOffsetInTextRun, + nsTArray<uint8_t>* aCanBreakBeforeArray, + nsTArray<RefPtr<nsTransformedCharStyle>>* aStyleArray) +{ + bool auxiliaryOutputArrays = aCanBreakBeforeArray && aStyleArray; + MOZ_ASSERT(!auxiliaryOutputArrays || aTextRun, + "text run must be provided to use aux output arrays"); + + uint32_t length = aString.Length(); + const char16_t* str = aString.BeginReading(); + + bool mergeNeeded = false; + + bool capitalizeDutchIJ = false; + bool prevIsLetter = false; + bool ntPrefix = false; // true immediately after a word-initial 'n' or 't' + // when doing Irish lowercasing + uint32_t sigmaIndex = uint32_t(-1); + nsIUGenCategory::nsUGenCategory cat; + + uint8_t style = aAllUppercase ? NS_STYLE_TEXT_TRANSFORM_UPPERCASE : 0; + bool forceNonFullWidth = false; + const nsIAtom* lang = aLanguage; + + LanguageSpecificCasingBehavior languageSpecificCasing = GetCasingFor(lang); + mozilla::GreekCasing::State greekState; + mozilla::IrishCasing::State irishState; + uint32_t irishMark = uint32_t(-1); // location of possible prefix letter(s) + // in the output string + uint32_t irishMarkSrc = uint32_t(-1); // corresponding location in source + // string (may differ from output due to + // expansions like eszet -> 'SS') + + for (uint32_t i = 0; i < length; ++i, ++aOffsetInTextRun) { + uint32_t ch = str[i]; + + RefPtr<nsTransformedCharStyle> charStyle; + if (aTextRun) { + charStyle = aTextRun->mStyles[aOffsetInTextRun]; + style = aAllUppercase ? NS_STYLE_TEXT_TRANSFORM_UPPERCASE : + charStyle->mTextTransform; + forceNonFullWidth = charStyle->mForceNonFullWidth; + + nsIAtom* newLang = charStyle->mExplicitLanguage + ? charStyle->mLanguage.get() : nullptr; + if (lang != newLang) { + lang = newLang; + languageSpecificCasing = GetCasingFor(lang); + greekState.Reset(); + irishState.Reset(); + irishMark = uint32_t(-1); + irishMarkSrc = uint32_t(-1); + } + } + + int extraChars = 0; + const mozilla::unicode::MultiCharMapping *mcm; + bool inhibitBreakBefore = false; // have we just deleted preceding hyphen? + + if (NS_IS_HIGH_SURROGATE(ch) && i < length - 1 && + NS_IS_LOW_SURROGATE(str[i + 1])) { + ch = SURROGATE_TO_UCS4(ch, str[i + 1]); + } + + switch (style) { + case NS_STYLE_TEXT_TRANSFORM_LOWERCASE: + if (languageSpecificCasing == eLSCB_Turkish) { + if (ch == 'I') { + ch = LATIN_SMALL_LETTER_DOTLESS_I; + prevIsLetter = true; + sigmaIndex = uint32_t(-1); + break; + } + if (ch == LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE) { + ch = 'i'; + prevIsLetter = true; + sigmaIndex = uint32_t(-1); + break; + } + } + + cat = mozilla::unicode::GetGenCategory(ch); + + if (languageSpecificCasing == eLSCB_Irish && + cat == nsIUGenCategory::kLetter) { + // See bug 1018805 for Irish lowercasing requirements + if (!prevIsLetter && (ch == 'n' || ch == 't')) { + ntPrefix = true; + } else { + if (ntPrefix && mozilla::IrishCasing::IsUpperVowel(ch)) { + aConvertedString.Append('-'); + ++extraChars; + } + ntPrefix = false; + } + } else { + ntPrefix = false; + } + + // Special lowercasing behavior for Greek Sigma: note that this is listed + // as context-sensitive in Unicode's SpecialCasing.txt, but is *not* a + // language-specific mapping; it applies regardless of the language of + // the element. + // + // The lowercase mapping for CAPITAL SIGMA should be to SMALL SIGMA (i.e. + // the non-final form) whenever there is a following letter, or when the + // CAPITAL SIGMA occurs in isolation (neither preceded nor followed by a + // LETTER); and to FINAL SIGMA when it is preceded by another letter but + // not followed by one. + // + // To implement the context-sensitive nature of this mapping, we keep + // track of whether the previous character was a letter. If not, CAPITAL + // SIGMA will map directly to SMALL SIGMA. If the previous character + // was a letter, CAPITAL SIGMA maps to FINAL SIGMA and we record the + // position in the converted string; if we then encounter another letter, + // that FINAL SIGMA is replaced with a standard SMALL SIGMA. + + // If sigmaIndex is not -1, it marks where we have provisionally mapped + // a CAPITAL SIGMA to FINAL SIGMA; if we now find another letter, we + // need to change it to SMALL SIGMA. + if (sigmaIndex != uint32_t(-1)) { + if (cat == nsIUGenCategory::kLetter) { + aConvertedString.SetCharAt(GREEK_SMALL_LETTER_SIGMA, sigmaIndex); + } + } + + if (ch == GREEK_CAPITAL_LETTER_SIGMA) { + // If preceding char was a letter, map to FINAL instead of SMALL, + // and note where it occurred by setting sigmaIndex; we'll change it + // to standard SMALL SIGMA later if another letter follows + if (prevIsLetter) { + ch = GREEK_SMALL_LETTER_FINAL_SIGMA; + sigmaIndex = aConvertedString.Length(); + } else { + // CAPITAL SIGMA not preceded by a letter is unconditionally mapped + // to SMALL SIGMA + ch = GREEK_SMALL_LETTER_SIGMA; + sigmaIndex = uint32_t(-1); + } + prevIsLetter = true; + break; + } + + // ignore diacritics for the purpose of contextual sigma mapping; + // otherwise, reset prevIsLetter appropriately and clear the + // sigmaIndex marker + if (cat != nsIUGenCategory::kMark) { + prevIsLetter = (cat == nsIUGenCategory::kLetter); + sigmaIndex = uint32_t(-1); + } + + mcm = mozilla::unicode::SpecialLower(ch); + if (mcm) { + int j = 0; + while (j < 2 && mcm->mMappedChars[j + 1]) { + aConvertedString.Append(mcm->mMappedChars[j]); + ++extraChars; + ++j; + } + ch = mcm->mMappedChars[j]; + break; + } + + ch = ToLowerCase(ch); + break; + + case NS_STYLE_TEXT_TRANSFORM_UPPERCASE: + if (languageSpecificCasing == eLSCB_Turkish && ch == 'i') { + ch = LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE; + break; + } + + if (languageSpecificCasing == eLSCB_Greek) { + ch = mozilla::GreekCasing::UpperCase(ch, greekState); + break; + } + + if (languageSpecificCasing == eLSCB_Irish) { + bool mark; + uint8_t action; + ch = mozilla::IrishCasing::UpperCase(ch, irishState, mark, action); + if (mark) { + irishMark = aConvertedString.Length(); + irishMarkSrc = i; + break; + } else if (action) { + nsString& str = aConvertedString; // shorthand + switch (action) { + case 1: + // lowercase a single prefix letter + NS_ASSERTION(str.Length() > 0 && irishMark < str.Length(), + "bad irishMark!"); + str.SetCharAt(ToLowerCase(str[irishMark]), irishMark); + irishMark = uint32_t(-1); + irishMarkSrc = uint32_t(-1); + break; + case 2: + // lowercase two prefix letters (immediately before current pos) + NS_ASSERTION(str.Length() >= 2 && irishMark == str.Length() - 2, + "bad irishMark!"); + str.SetCharAt(ToLowerCase(str[irishMark]), irishMark); + str.SetCharAt(ToLowerCase(str[irishMark + 1]), irishMark + 1); + irishMark = uint32_t(-1); + irishMarkSrc = uint32_t(-1); + break; + case 3: + // lowercase one prefix letter, and delete following hyphen + // (which must be the immediately-preceding char) + NS_ASSERTION(str.Length() >= 2 && irishMark == str.Length() - 2, + "bad irishMark!"); + MOZ_ASSERT(irishMark != uint32_t(-1) && irishMarkSrc != uint32_t(-1), + "failed to set irishMarks"); + str.Replace(irishMark, 2, ToLowerCase(str[irishMark])); + aDeletedCharsArray[irishMarkSrc + 1] = true; + // Remove the trailing entries (corresponding to the deleted hyphen) + // from the auxiliary arrays. + aCharsToMergeArray.SetLength(aCharsToMergeArray.Length() - 1); + if (auxiliaryOutputArrays) { + aStyleArray->SetLength(aStyleArray->Length() - 1); + aCanBreakBeforeArray->SetLength(aCanBreakBeforeArray->Length() - 1); + inhibitBreakBefore = true; + } + mergeNeeded = true; + irishMark = uint32_t(-1); + irishMarkSrc = uint32_t(-1); + break; + } + // ch has been set to the uppercase for current char; + // No need to check for SpecialUpper here as none of the characters + // that could trigger an Irish casing action have special mappings. + break; + } + // If we didn't have any special action to perform, fall through + // to check for special uppercase (ß) + } + + mcm = mozilla::unicode::SpecialUpper(ch); + if (mcm) { + int j = 0; + while (j < 2 && mcm->mMappedChars[j + 1]) { + aConvertedString.Append(mcm->mMappedChars[j]); + ++extraChars; + ++j; + } + ch = mcm->mMappedChars[j]; + break; + } + + ch = ToUpperCase(ch); + break; + + case NS_STYLE_TEXT_TRANSFORM_CAPITALIZE: + if (aTextRun) { + if (capitalizeDutchIJ && ch == 'j') { + ch = 'J'; + capitalizeDutchIJ = false; + break; + } + capitalizeDutchIJ = false; + if (aOffsetInTextRun < aTextRun->mCapitalize.Length() && + aTextRun->mCapitalize[aOffsetInTextRun]) { + if (languageSpecificCasing == eLSCB_Turkish && ch == 'i') { + ch = LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE; + break; + } + if (languageSpecificCasing == eLSCB_Dutch && ch == 'i') { + ch = 'I'; + capitalizeDutchIJ = true; + break; + } + + mcm = mozilla::unicode::SpecialTitle(ch); + if (mcm) { + int j = 0; + while (j < 2 && mcm->mMappedChars[j + 1]) { + aConvertedString.Append(mcm->mMappedChars[j]); + ++extraChars; + ++j; + } + ch = mcm->mMappedChars[j]; + break; + } + + ch = ToTitleCase(ch); + } + } + break; + + case NS_STYLE_TEXT_TRANSFORM_FULL_WIDTH: + ch = mozilla::unicode::GetFullWidth(ch); + break; + + default: + break; + } + + if (forceNonFullWidth) { + ch = mozilla::unicode::GetFullWidthInverse(ch); + } + + if (ch == uint32_t(-1)) { + aDeletedCharsArray.AppendElement(true); + mergeNeeded = true; + } else { + aDeletedCharsArray.AppendElement(false); + aCharsToMergeArray.AppendElement(false); + if (auxiliaryOutputArrays) { + aStyleArray->AppendElement(charStyle); + aCanBreakBeforeArray->AppendElement( + inhibitBreakBefore ? gfxShapedText::CompressedGlyph::FLAG_BREAK_TYPE_NONE + : aTextRun->CanBreakBefore(aOffsetInTextRun)); + } + + if (IS_IN_BMP(ch)) { + aConvertedString.Append(ch); + } else { + aConvertedString.Append(H_SURROGATE(ch)); + aConvertedString.Append(L_SURROGATE(ch)); + i++; + aOffsetInTextRun++; + aDeletedCharsArray.AppendElement(true); // not exactly deleted, but the + // trailing surrogate is skipped + ++extraChars; + } + + while (extraChars-- > 0) { + mergeNeeded = true; + aCharsToMergeArray.AppendElement(true); + if (auxiliaryOutputArrays) { + aStyleArray->AppendElement(charStyle); + aCanBreakBeforeArray->AppendElement( + gfxShapedText::CompressedGlyph::FLAG_BREAK_TYPE_NONE); + } + } + } + } + + return mergeNeeded; +} + +void +nsCaseTransformTextRunFactory::RebuildTextRun(nsTransformedTextRun* aTextRun, + DrawTarget* aRefDrawTarget, + gfxMissingFontRecorder* aMFR) +{ + nsAutoString convertedString; + AutoTArray<bool,50> charsToMergeArray; + AutoTArray<bool,50> deletedCharsArray; + AutoTArray<uint8_t,50> canBreakBeforeArray; + AutoTArray<RefPtr<nsTransformedCharStyle>,50> styleArray; + + bool mergeNeeded = TransformString(aTextRun->mString, + convertedString, + mAllUppercase, + nullptr, + charsToMergeArray, + deletedCharsArray, + aTextRun, 0, + &canBreakBeforeArray, + &styleArray); + + uint32_t flags; + gfxTextRunFactory::Parameters innerParams = + GetParametersForInner(aTextRun, &flags, aRefDrawTarget); + gfxFontGroup* fontGroup = aTextRun->GetFontGroup(); + + RefPtr<nsTransformedTextRun> transformedChild; + RefPtr<gfxTextRun> cachedChild; + gfxTextRun* child; + + if (mInnerTransformingTextRunFactory) { + transformedChild = mInnerTransformingTextRunFactory->MakeTextRun( + convertedString.BeginReading(), convertedString.Length(), + &innerParams, fontGroup, flags, Move(styleArray), false); + child = transformedChild.get(); + } else { + cachedChild = fontGroup->MakeTextRun( + convertedString.BeginReading(), convertedString.Length(), + &innerParams, flags, aMFR); + child = cachedChild.get(); + } + if (!child) + return; + // Copy potential linebreaks into child so they're preserved + // (and also child will be shaped appropriately) + NS_ASSERTION(convertedString.Length() == canBreakBeforeArray.Length(), + "Dropped characters or break-before values somewhere!"); + gfxTextRun::Range range(0, uint32_t(canBreakBeforeArray.Length())); + child->SetPotentialLineBreaks(range, canBreakBeforeArray.Elements()); + if (transformedChild) { + transformedChild->FinishSettingProperties(aRefDrawTarget, aMFR); + } + + if (mergeNeeded) { + // Now merge multiple characters into one multi-glyph character as required + // and deal with skipping deleted accent chars + NS_ASSERTION(charsToMergeArray.Length() == child->GetLength(), + "source length mismatch"); + NS_ASSERTION(deletedCharsArray.Length() == aTextRun->GetLength(), + "destination length mismatch"); + MergeCharactersInTextRun(aTextRun, child, charsToMergeArray.Elements(), + deletedCharsArray.Elements()); + } else { + // No merging to do, so just copy; this produces a more optimized textrun. + // We can't steal the data because the child may be cached and stealing + // the data would break the cache. + aTextRun->ResetGlyphRuns(); + aTextRun->CopyGlyphDataFrom(child, gfxTextRun::Range(child), 0); + } +} |