Quelle gfxCoreTextShaper.cpp Sprache: C

/* -*- Mode: C++; tab-width: 20; 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 "mozilla/ArrayUtils.h"
#include "gfxCoreTextShaper.h"
#include "gfxMacFont.h"
#include "gfxFontUtils.h"
#include "gfxTextRun.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/ScaledFontMac.h"
#include "mozilla/UniquePtrExtensions.h"

#include <algorithm>

#include <dlfcn.h>

using namespace mozilla;
using namespace mozilla::gfx;

// standard font descriptors that we construct the first time they're needed
CTFontDescriptorRef gfxCoreTextShaper::sFeaturesDescriptor[kMaxFontInstances];

// Helper to create a CFDictionary with the right attributes for shaping our
// text, including imposing the given directionality.
CFDictionaryRef gfxCoreTextShaper::CreateAttrDict(bool aRightToLeft) {
  // Because we always shape unidirectional runs, and may have applied
  // directional overrides, we want to force a direction rather than
  // allowing CoreText to do its own unicode-based bidi processing.
  SInt16 dirOverride = kCTWritingDirectionOverride |
                       (aRightToLeft ? kCTWritingDirectionRightToLeft
                                     : kCTWritingDirectionLeftToRight);
  CFNumberRef dirNumber =
      ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &dirOverride);
  CFArrayRef dirArray = ::CFArrayCreate(
      kCFAllocatorDefault, (const void**)&dirNumber, 1, &kCFTypeArrayCallBacks);
  ::CFRelease(dirNumber);
  CFTypeRef attrs[] = {kCTFontAttributeName, kCTWritingDirectionAttributeName};
  CFTypeRef values[] = {mCTFont[0], dirArray};
  CFDictionaryRef attrDict = ::CFDictionaryCreate(
      kCFAllocatorDefault, attrs, values, std::size(attrs),
      &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
  ::CFRelease(dirArray);
  return attrDict;
}

gfxCoreTextShaper::gfxCoreTextShaper(gfxMacFont* aFont)
    : gfxFontShaper(aFont),
      mAttributesDictLTR(nullptr),
      mAttributesDictRTL(nullptr) {
  for (size_t i = 0; i < kMaxFontInstances; i++) {
    mCTFont[i] = nullptr;
  }
  // Create our default CTFontRef
  mCTFont[0] = CreateCTFontWithFeatures(
      aFont->GetAdjustedSize(), GetFeaturesDescriptor(kDefaultFeatures));
}

gfxCoreTextShaper::~gfxCoreTextShaper() {
  if (mAttributesDictLTR) {
    ::CFRelease(mAttributesDictLTR);
  }
  if (mAttributesDictRTL) {
    ::CFRelease(mAttributesDictRTL);
  }
  for (size_t i = 0; i < kMaxFontInstances; i++) {
    if (mCTFont[i]) {
      ::CFRelease(mCTFont[i]);
    }
  }
}

static bool IsBuggyIndicScript(intl::Script aScript) {
  return aScript == intl::Script::BENGALI || aScript == intl::Script::KANNADA ||
         aScript == intl::Script::ORIYA || aScript == intl::Script::KHMER;
}

bool gfxCoreTextShaper::ShapeText(DrawTarget* aDrawTarget,
                                  const char16_t* aText, uint32_t aOffset,
                                  uint32_t aLength, Script aScript,
                                  nsAtom* aLanguage, bool aVertical,
                                  RoundingFlags aRounding,
                                  gfxShapedText* aShapedText) {
  // Create a CFAttributedString with text and style info, so we can use
  // CoreText to lay it out.
  bool isRightToLeft = aShapedText->IsRightToLeft();
  const UniChar* text = reinterpret_cast<const UniChar*>(aText);

  CFStringRef stringObj = ::CFStringCreateWithCharactersNoCopy(
      kCFAllocatorDefault, text, aLength, kCFAllocatorNull);

  // Figure out whether we should try to set the AAT small-caps feature:
  // examine OpenType tags for the requested style, and see if 'smcp' is
  // among them.
  const gfxFontStyle* style = mFont->GetStyle();
  gfxFontEntry* entry = mFont->GetFontEntry();
  auto handleFeatureTag = [](uint32_t aTag, uint32_t aValue,
                             void* aUserArg) -> void {
    if (aTag == HB_TAG('s', 'm', 'c', 'p') && aValue) {
      *static_cast<bool*>(aUserArg) = true;
    }
  };
  bool addSmallCaps = false;
  MergeFontFeatures(style, entry->mFeatureSettings, false, entry->FamilyName(),
                    false, handleFeatureTag, &addSmallCaps);

  // Get an attributes dictionary suitable for shaping text in the
  // current direction, creating it if necessary.
  CFDictionaryRef attrObj =
      isRightToLeft ? mAttributesDictRTL : mAttributesDictLTR;
  if (!attrObj) {
    attrObj = CreateAttrDict(isRightToLeft);
    (isRightToLeft ? mAttributesDictRTL : mAttributesDictLTR) = attrObj;
  }

  FeatureFlags featureFlags = kDefaultFeatures;
  if (IsBuggyIndicScript(aScript)) {
    // To work around buggy Indic AAT fonts shipped with OS X,
    // we re-enable the Line Initial Smart Swashes feature that is needed
    // for "split vowels" to work in at least Bengali and Kannada fonts.
    // Affected fonts include Bangla MN, Bangla Sangam MN, Kannada MN,
    // Kannada Sangam MN. See bugs 686225, 728557, 953231, 1145515.
    // Also applies to Oriya and Khmer, see bug 1370927 and bug 1403166.
    featureFlags |= kIndicFeatures;
  }
  if (aShapedText->DisableLigatures()) {
    // For letterspacing (or maybe other situations) we need to make
    // a copy of the CTFont with the ligature feature disabled.
    featureFlags |= kDisableLigatures;
  }
  if (addSmallCaps) {
    featureFlags |= kAddSmallCaps;
  }

  // For the disabled-ligature, buggy-indic-font or small-caps case, replace
  // the default CTFont in the attribute dictionary with a tweaked version.
  CFMutableDictionaryRef mutableAttr = nullptr;
  if (featureFlags != 0) {
    if (!mCTFont[featureFlags]) {
      mCTFont[featureFlags] = CreateCTFontWithFeatures(
          mFont->GetAdjustedSize(), GetFeaturesDescriptor(featureFlags));
    }
    mutableAttr =
        ::CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 2, attrObj);
    ::CFDictionaryReplaceValue(mutableAttr, kCTFontAttributeName,
                               mCTFont[featureFlags]);
    attrObj = mutableAttr;
  }

  // Now we can create an attributed string
  CFAttributedStringRef attrStringObj =
      ::CFAttributedStringCreate(kCFAllocatorDefault, stringObj, attrObj);
  ::CFRelease(stringObj);

  // Create the CoreText line from our string, then we're done with it
  CTLineRef line = ::CTLineCreateWithAttributedString(attrStringObj);
  ::CFRelease(attrStringObj);

  // and finally retrieve the glyph data and store into the gfxTextRun
  CFArrayRef glyphRuns = ::CTLineGetGlyphRuns(line);
  uint32_t numRuns = ::CFArrayGetCount(glyphRuns);

  // Iterate through the glyph runs.
  bool success = true;
  for (uint32_t runIndex = 0; runIndex < numRuns; runIndex++) {
    CTRunRef aCTRun = (CTRunRef)::CFArrayGetValueAtIndex(glyphRuns, runIndex);
    CFRange range = ::CTRunGetStringRange(aCTRun);
    CFDictionaryRef runAttr = ::CTRunGetAttributes(aCTRun);
    if (runAttr != attrObj) {
      // If Core Text manufactured a new dictionary, this may indicate
      // unexpected font substitution. In that case, we fail (and fall
      // back to harfbuzz shaping)...
      const void* font1 = ::CFDictionaryGetValue(attrObj, kCTFontAttributeName);
      const void* font2 = ::CFDictionaryGetValue(runAttr, kCTFontAttributeName);
      if (font1 != font2) {
        // ...except that if the fallback was only for a variation
        // selector or join control that is otherwise unsupported,
        // we just ignore it.
        if (range.length == 1) {
          char16_t ch = aText[range.location];
          if (gfxFontUtils::IsJoinControl(ch) ||
              gfxFontUtils::IsVarSelector(ch)) {
            continue;
          }
        }
        NS_WARNING("unexpected font fallback in Core Text");
        success = false;
        break;
      }
    }
    if (SetGlyphsFromRun(aShapedText, aOffset, aLength, aCTRun) != NS_OK) {
      success = false;
      break;
    }
  }

  if (mutableAttr) {
    ::CFRelease(mutableAttr);
  }
  ::CFRelease(line);

  return success;
}

#define SMALL_GLYPH_RUN \
  128  // preallocated size of our auto arrays for per-glyph data;
       // some testing indicates that 90%+ of glyph runs will fit
       // without requiring a separate allocation

nsresult gfxCoreTextShaper::SetGlyphsFromRun(gfxShapedText* aShapedText,
                                             uint32_t aOffset, uint32_t aLength,
                                             CTRunRef aCTRun) {
  typedef gfxShapedText::CompressedGlyph CompressedGlyph;

  int32_t direction = aShapedText->IsRightToLeft() ? -1 : 1;

  int32_t numGlyphs = ::CTRunGetGlyphCount(aCTRun);
  if (numGlyphs == 0) {
    return NS_OK;
  }

  int32_t wordLength = aLength;

  // character offsets get really confusing here, as we have to keep track of
  // (a) the text in the actual textRun we're constructing
  // (c) the string that was handed to CoreText, which contains the text of
  // the font run
  // (d) the CTRun currently being processed, which may be a sub-run of the
  // CoreText line

  // get the source string range within the CTLine's text
  CFRange stringRange = ::CTRunGetStringRange(aCTRun);
  // skip the run if it is entirely outside the actual range of the font run
  if (stringRange.location + stringRange.length <= 0 ||
      stringRange.location >= wordLength) {
    return NS_OK;
  }

  // retrieve the laid-out glyph data from the CTRun
  UniquePtr<CGGlyph[]> glyphsArray;
  UniquePtr<CGPoint[]> positionsArray;
  UniquePtr<CFIndex[]> glyphToCharArray;
  const CGGlyph* glyphs = nullptr;
  const CGPoint* positions = nullptr;
  const CFIndex* glyphToChar = nullptr;

  // Testing indicates that CTRunGetGlyphsPtr (almost?) always succeeds,
  // and so allocating a new array and copying data with CTRunGetGlyphs
  // will be extremely rare.
  // If this were not the case, we could use an AutoTArray<> to
  // try and avoid the heap allocation for small runs.
  // It's possible that some future change to CoreText will mean that
  // CTRunGetGlyphsPtr fails more often; if this happens, AutoTArray<>
  // may become an attractive option.
  glyphs = ::CTRunGetGlyphsPtr(aCTRun);
  if (!glyphs) {
    glyphsArray = MakeUniqueFallible<CGGlyph[]>(numGlyphs);
    if (!glyphsArray) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
    ::CTRunGetGlyphs(aCTRun, ::CFRangeMake(0, 0), glyphsArray.get());
    glyphs = glyphsArray.get();
  }

  positions = ::CTRunGetPositionsPtr(aCTRun);
  if (!positions) {
    positionsArray = MakeUniqueFallible<CGPoint[]>(numGlyphs);
    if (!positionsArray) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
    ::CTRunGetPositions(aCTRun, ::CFRangeMake(0, 0), positionsArray.get());
    positions = positionsArray.get();
  }

  // Remember that the glyphToChar indices relate to the CoreText line,
  // not to the beginning of the textRun, the font run,
  // or the stringRange of the glyph run
  glyphToChar = ::CTRunGetStringIndicesPtr(aCTRun);
  if (!glyphToChar) {
    glyphToCharArray = MakeUniqueFallible<CFIndex[]>(numGlyphs);
    if (!glyphToCharArray) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
    ::CTRunGetStringIndices(aCTRun, ::CFRangeMake(0, 0),
                            glyphToCharArray.get());
    glyphToChar = glyphToCharArray.get();
  }

  double runWidth = ::CTRunGetTypographicBounds(aCTRun, ::CFRangeMake(0, 0),
                                                nullptr, nullptr, nullptr);

  AutoTArray<gfxShapedText::DetailedGlyph, 1> detailedGlyphs;
  CompressedGlyph* charGlyphs = aShapedText->GetCharacterGlyphs() + aOffset;

  // CoreText gives us the glyphindex-to-charindex mapping, which relates each
  // glyph to a source text character; we also need the charindex-to-glyphindex
  // mapping to find the glyph for a given char. Note that some chars may not
  // map to any glyph (ligature continuations), and some may map to several
  // glyphs (eg Indic split vowels). We set the glyph index to NO_GLYPH for
  // chars that have no associated glyph, and we record the last glyph index for
  // cases where the char maps to several glyphs, so that our clumping will
  // include all the glyph fragments for the character.

  // The charToGlyph array is indexed by char position within the stringRange of
  // the glyph run.

  static const int32_t NO_GLYPH = -1;
  AutoTArray<int32_t, SMALL_GLYPH_RUN> charToGlyphArray;
  if (!charToGlyphArray.SetLength(stringRange.length, fallible)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  int32_t* charToGlyph = charToGlyphArray.Elements();
  for (int32_t offset = 0; offset < stringRange.length; ++offset) {
    charToGlyph[offset] = NO_GLYPH;
  }
  for (int32_t i = 0; i < numGlyphs; ++i) {
    int32_t loc = glyphToChar[i] - stringRange.location;
    if (loc >= 0 && loc < stringRange.length) {
      charToGlyph[loc] = i;
    }
  }

  // Find character and glyph clumps that correspond, allowing for ligatures,
  // indic reordering, split glyphs, etc.
  //
  // The idea is that we'll find a character sequence starting at the first char
  // of stringRange, and extend it until it includes the character associated
  // with the first glyph; we also extend it as long as there are "holes" in the
  // range of glyphs. So we will eventually have a contiguous sequence of
  // characters, starting at the beginning of the range, that map to a
  // contiguous sequence of glyphs, starting at the beginning of the glyph
  // array. That's a clump; then we update the starting positions and repeat.
  //
  // NB: In the case of RTL layouts, we iterate over the stringRange in reverse.
  //

  // This may find characters that fall outside the range 0:wordLength,
  // so we won't necessarily use everything we find here.

  bool isRightToLeft = aShapedText->IsRightToLeft();
  int32_t glyphStart =
      0;  // looking for a clump that starts at this glyph index
  int32_t charStart =
      isRightToLeft
          ? stringRange.length - 1
          : 0;  // and this char index (in the stringRange of the glyph run)

  while (glyphStart <
         numGlyphs) {  // keep finding groups until all glyphs are accounted for
    bool inOrder = true;
    int32_t charEnd = glyphToChar[glyphStart] - stringRange.location;
    NS_WARNING_ASSERTION(charEnd >= 0 && charEnd < stringRange.length,
                         "glyph-to-char mapping points outside string range");
    // clamp charEnd to the valid range of the string
    charEnd = std::max(charEnd, 0);
    charEnd = std::min(charEnd, int32_t(stringRange.length));

    int32_t glyphEnd = glyphStart;
    int32_t charLimit = isRightToLeft ? -1 : stringRange.length;
    do {
      // This is normally executed once for each iteration of the outer loop,
      // but in unusual cases where the character/glyph association is complex,
      // the initial character range might correspond to a non-contiguous
      // glyph range with "holes" in it. If so, we will repeat this loop to
      // extend the character range until we have a contiguous glyph sequence.
      NS_ASSERTION((direction > 0 && charEnd < charLimit) ||
                       (direction < 0 && charEnd > charLimit),
                   "no characters left in range?");
      charEnd += direction;
      while (charEnd != charLimit && charToGlyph[charEnd] == NO_GLYPH) {
        charEnd += direction;
      }

      // find the maximum glyph index covered by the clump so far
      if (isRightToLeft) {
        for (int32_t i = charStart; i > charEnd; --i) {
          if (charToGlyph[i] != NO_GLYPH) {
            // update extent of glyph range
            glyphEnd = std::max(glyphEnd, charToGlyph[i] + 1);
          }
        }
      } else {
        for (int32_t i = charStart; i < charEnd; ++i) {
          if (charToGlyph[i] != NO_GLYPH) {
            // update extent of glyph range
            glyphEnd = std::max(glyphEnd, charToGlyph[i] + 1);
          }
        }
      }

      if (glyphEnd == glyphStart + 1) {
        // for the common case of a single-glyph clump, we can skip the
        // following checks
        break;
      }

      if (glyphEnd == glyphStart) {
        // no glyphs, try to extend the clump
        continue;
      }

      // check whether all glyphs in the range are associated with the
      // characters in our clump; if not, we have a discontinuous range, and
      // should extend it unless we've reached the end of the text
      bool allGlyphsAreWithinCluster = true;
      int32_t prevGlyphCharIndex = charStart;
      for (int32_t i = glyphStart; i < glyphEnd; ++i) {
        int32_t glyphCharIndex = glyphToChar[i] - stringRange.location;
        if (isRightToLeft) {
          if (glyphCharIndex > charStart || glyphCharIndex <= charEnd) {
            allGlyphsAreWithinCluster = false;
            break;
          }
          if (glyphCharIndex > prevGlyphCharIndex) {
            inOrder = false;
          }
          prevGlyphCharIndex = glyphCharIndex;
        } else {
          if (glyphCharIndex < charStart || glyphCharIndex >= charEnd) {
            allGlyphsAreWithinCluster = false;
            break;
          }
          if (glyphCharIndex < prevGlyphCharIndex) {
            inOrder = false;
          }
          prevGlyphCharIndex = glyphCharIndex;
        }
      }
      if (allGlyphsAreWithinCluster) {
        break;
      }
    } while (charEnd != charLimit);

    NS_WARNING_ASSERTION(glyphStart < glyphEnd,
                         "character/glyph clump contains no glyphs!");
    if (glyphStart == glyphEnd) {
      ++glyphStart;  // make progress - avoid potential infinite loop
      charStart = charEnd;
      continue;
    }

    NS_WARNING_ASSERTION(charStart != charEnd,
                         "character/glyph clump contains no characters!");
    if (charStart == charEnd) {
      glyphStart = glyphEnd;  // this is bad - we'll discard the glyph(s),
                              // as there's nowhere to attach them
      continue;
    }

    // Now charStart..charEnd is a ligature clump, corresponding to
    // glyphStart..glyphEnd; Set baseCharIndex to the char we'll actually attach
    // the glyphs to (1st of ligature), and endCharIndex to the limit (position
    // beyond the last char), adjusting for the offset of the stringRange
    // relative to the textRun.
    int32_t baseCharIndex, endCharIndex;
    if (isRightToLeft) {
      while (charEnd >= 0 && charToGlyph[charEnd] == NO_GLYPH) {
        charEnd--;
      }
      baseCharIndex = charEnd + stringRange.location + 1;
      endCharIndex = charStart + stringRange.location + 1;
    } else {
      while (charEnd < stringRange.length && charToGlyph[charEnd] == NO_GLYPH) {
        charEnd++;
      }
      baseCharIndex = charStart + stringRange.location;
      endCharIndex = charEnd + stringRange.location;
    }

    // Then we check if the clump falls outside our actual string range; if so,
    // just go to the next.
    if (endCharIndex <= 0 || baseCharIndex >= wordLength) {
      glyphStart = glyphEnd;
      charStart = charEnd;
      continue;
    }
    // Ensure we won't try to go beyond the valid length of the word's text
    baseCharIndex = std::max(baseCharIndex, 0);
    endCharIndex = std::min(endCharIndex, wordLength);

    // Now we're ready to set the glyph info in the textRun; measure the glyph
    // width of the first (perhaps only) glyph, to see if it is "Simple"
    int32_t appUnitsPerDevUnit = aShapedText->GetAppUnitsPerDevUnit();
    double toNextGlyph;
    if (glyphStart < numGlyphs - 1) {
      toNextGlyph = positions[glyphStart + 1].x - positions[glyphStart].x;
    } else {
      toNextGlyph = positions[0].x + runWidth - positions[glyphStart].x;
    }
    int32_t advance = int32_t(toNextGlyph * appUnitsPerDevUnit);

    // Check if it's a simple one-to-one mapping
    int32_t glyphsInClump = glyphEnd - glyphStart;
    if (glyphsInClump == 1 &&
        gfxTextRun::CompressedGlyph::IsSimpleGlyphID(glyphs[glyphStart]) &&
        gfxTextRun::CompressedGlyph::IsSimpleAdvance(advance) &&
        charGlyphs[baseCharIndex].IsClusterStart() &&
        positions[glyphStart].y == 0.0) {
      charGlyphs[baseCharIndex].SetSimpleGlyph(advance, glyphs[glyphStart]);
    } else {
      // collect all glyphs in a list to be assigned to the first char;
      // there must be at least one in the clump, and we already measured its
      // advance, hence the placement of the loop-exit test and the measurement
      // of the next glyph
      while (true) {
        gfxTextRun::DetailedGlyph* details = detailedGlyphs.AppendElement();
        details->mGlyphID = glyphs[glyphStart];
        details->mOffset.y = -positions[glyphStart].y * appUnitsPerDevUnit;
        details->mAdvance = advance;
        if (++glyphStart >= glyphEnd) {
          break;
        }
        if (glyphStart < numGlyphs - 1) {
          toNextGlyph = positions[glyphStart + 1].x - positions[glyphStart].x;
        } else {
          toNextGlyph = positions[0].x + runWidth - positions[glyphStart].x;
        }
        advance = int32_t(toNextGlyph * appUnitsPerDevUnit);
      }

      aShapedText->SetDetailedGlyphs(aOffset + baseCharIndex,
                                     detailedGlyphs.Length(),
                                     detailedGlyphs.Elements());

      detailedGlyphs.Clear();
    }

    // the rest of the chars in the group are ligature continuations, no
    // associated glyphs
    while (++baseCharIndex != endCharIndex && baseCharIndex < wordLength) {
      CompressedGlyph& shapedTextGlyph = charGlyphs[baseCharIndex];
      NS_ASSERTION(!shapedTextGlyph.IsSimpleGlyph(),
                   "overwriting a simple glyph");
      shapedTextGlyph.SetComplex(inOrder && shapedTextGlyph.IsClusterStart(),
                                 false);
    }

    glyphStart = glyphEnd;
    charStart = charEnd;
  }

  return NS_OK;
}

#undef SMALL_GLYPH_RUN

// Construct the font attribute descriptor that we'll apply by default when
// creating a CTFontRef. This will turn off line-edge swashes by default,
// because we don't know the actual line breaks when doing glyph shaping.

// We also cache feature descriptors for shaping with disabled ligatures, and
// for buggy Indic AAT font workarounds, created on an as-needed basis.

#define MAX_FEATURES 5  // max used by any of our Get*Descriptor functions

CTFontDescriptorRef gfxCoreTextShaper::CreateFontFeaturesDescriptor(
    const std::pair<SInt16, SInt16>* aFeatures, size_t aCount) {
  MOZ_ASSERT(aCount <= MAX_FEATURES);

  CFDictionaryRef featureSettings[MAX_FEATURES];

  for (size_t i = 0; i < aCount; i++) {
    CFNumberRef type = ::CFNumberCreate(
        kCFAllocatorDefault, kCFNumberSInt16Type, &aFeatures[i].first);
    CFNumberRef selector = ::CFNumberCreate(
        kCFAllocatorDefault, kCFNumberSInt16Type, &aFeatures[i].second);

    CFTypeRef keys[] = {kCTFontFeatureTypeIdentifierKey,
                        kCTFontFeatureSelectorIdentifierKey};
    CFTypeRef values[] = {type, selector};
    featureSettings[i] = ::CFDictionaryCreate(
        kCFAllocatorDefault, (const void**)keys, (const void**)values,
        std::size(keys), &kCFTypeDictionaryKeyCallBacks,
        &kCFTypeDictionaryValueCallBacks);

    ::CFRelease(selector);
    ::CFRelease(type);
  }

  CFArrayRef featuresArray =
      ::CFArrayCreate(kCFAllocatorDefault, (const void**)featureSettings,
                      aCount,  // not std::size(featureSettings), as we
                               // may not have used all the allocated slots
                      &kCFTypeArrayCallBacks);

  for (size_t i = 0; i < aCount; i++) {
    ::CFRelease(featureSettings[i]);
  }

  const CFTypeRef attrKeys[] = {kCTFontFeatureSettingsAttribute};
  const CFTypeRef attrValues[] = {featuresArray};
  CFDictionaryRef attributesDict = ::CFDictionaryCreate(
      kCFAllocatorDefault, (const void**)attrKeys, (const void**)attrValues,
      std::size(attrKeys), &kCFTypeDictionaryKeyCallBacks,
      &kCFTypeDictionaryValueCallBacks);
  ::CFRelease(featuresArray);

  CTFontDescriptorRef descriptor =
      ::CTFontDescriptorCreateWithAttributes(attributesDict);
  ::CFRelease(attributesDict);

  return descriptor;
}

CTFontDescriptorRef gfxCoreTextShaper::GetFeaturesDescriptor(
    FeatureFlags aFeatureFlags) {
  MOZ_ASSERT(aFeatureFlags < kMaxFontInstances);
  if (!sFeaturesDescriptor[aFeatureFlags]) {
    typedef std::pair<SInt16, SInt16> FeatT;
    AutoTArray<FeatT, MAX_FEATURES> features;
    features.AppendElement(
        FeatT(kSmartSwashType, kLineFinalSwashesOffSelector));
    if ((aFeatureFlags & kIndicFeatures) == 0) {
      features.AppendElement(
          FeatT(kSmartSwashType, kLineInitialSwashesOffSelector));
    }
    if (aFeatureFlags & kAddSmallCaps) {
      features.AppendElement(FeatT(kLetterCaseType, kSmallCapsSelector));
      features.AppendElement(
          FeatT(kLowerCaseType, kLowerCaseSmallCapsSelector));
    }
    if (aFeatureFlags & kDisableLigatures) {
      features.AppendElement(
          FeatT(kLigaturesType, kCommonLigaturesOffSelector));
    }
    MOZ_ASSERT(features.Length() <= MAX_FEATURES);
    sFeaturesDescriptor[aFeatureFlags] =
        CreateFontFeaturesDescriptor(features.Elements(), features.Length());
  }
  return sFeaturesDescriptor[aFeatureFlags];
}

CTFontRef gfxCoreTextShaper::CreateCTFontWithFeatures(
    CGFloat aSize, CTFontDescriptorRef aDescriptor) {
  const gfxFontEntry* fe = mFont->GetFontEntry();
  bool isInstalledFont = !fe->IsUserFont() || fe->IsLocalUserFont();
  CGFontRef cgFont = static_cast<gfxMacFont*>(mFont)->GetCGFontRef();
  return CreateCTFontFromCGFontWithVariations(cgFont, aSize, isInstalledFont,
                                              aDescriptor);
}

void gfxCoreTextShaper::Shutdown()  // [static]
{
  for (size_t i = 0; i < kMaxFontInstances; i++) {
    if (sFeaturesDescriptor[i] != nullptr) {
      ::CFRelease(sFeaturesDescriptor[i]);
      sFeaturesDescriptor[i] = nullptr;
    }
  }
}

quality90%

¤ Dauer der Verarbeitung: 0.19 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.