DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (a3c823cb659e)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
/* -*- 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/. */

#ifndef GFX_FONT_FEATURES_H
#define GFX_FONT_FEATURES_H

#include "nsTHashtable.h"
#include "nsTArray.h"
#include "nsString.h"

// An OpenType feature tag and value pair
struct gfxFontFeature {
  uint32_t
      mTag;  // see http://www.microsoft.com/typography/otspec/featuretags.htm
  uint32_t mValue;  // 0 = off, 1 = on, larger values may be used as parameters
                    // to features that select among multiple alternatives
};

inline bool operator<(const gfxFontFeature& a, const gfxFontFeature& b) {
  return (a.mTag < b.mTag) || ((a.mTag == b.mTag) && (a.mValue < b.mValue));
}

inline bool operator==(const gfxFontFeature& a, const gfxFontFeature& b) {
  return (a.mTag == b.mTag) && (a.mValue == b.mValue);
}

struct gfxAlternateValue {
  uint32_t alternate;  // constants in gfxFontConstants.h
  nsString value;      // string value to be looked up
};

inline bool operator<(const gfxAlternateValue& a, const gfxAlternateValue& b) {
  return (a.alternate < b.alternate) ||
         ((a.alternate == b.alternate) && (a.value < b.value));
}

inline bool operator==(const gfxAlternateValue& a, const gfxAlternateValue& b) {
  return (a.alternate == b.alternate) && (a.value == b.value);
}

class gfxFontFeatureValueSet final {
 public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(gfxFontFeatureValueSet)

  gfxFontFeatureValueSet();

  struct ValueList {
    ValueList(const nsAString& aName, const nsTArray<uint32_t>& aSelectors)
        : name(aName), featureSelectors(aSelectors) {}
    nsString name;
    nsTArray<uint32_t> featureSelectors;
  };

  struct FeatureValues {
    uint32_t alternate;
    nsTArray<ValueList> valuelist;
  };

  // returns true if found, false otherwise
  bool GetFontFeatureValuesFor(const nsACString& aFamily,
                               uint32_t aVariantProperty,
                               const nsAString& aName,
                               nsTArray<uint32_t>& aValues);
  void AddFontFeatureValues(
      const nsACString& aFamily,
      const nsTArray<gfxFontFeatureValueSet::FeatureValues>& aValues);

  // Appends a new hash entry with given key values and returns a pointer to
  // mValues array to fill. This should be filled first.
  nsTArray<uint32_t>* AppendFeatureValueHashEntry(const nsACString& aFamily,
                                                  const nsAString& aName,
                                                  uint32_t aAlternate);

 private:
  // Private destructor, to discourage deletion outside of Release():
  ~gfxFontFeatureValueSet() {}

  struct FeatureValueHashKey {
    nsCString mFamily;
    uint32_t mPropVal;
    nsString mName;

    FeatureValueHashKey() : mPropVal(0) {}
    FeatureValueHashKey(const nsACString& aFamily, uint32_t aPropVal,
                        const nsAString& aName)
        : mFamily(aFamily), mPropVal(aPropVal), mName(aName) {}
    FeatureValueHashKey(const FeatureValueHashKey& aKey)
        : mFamily(aKey.mFamily), mPropVal(aKey.mPropVal), mName(aKey.mName) {}
  };

  class FeatureValueHashEntry : public PLDHashEntryHdr {
   public:
    typedef const FeatureValueHashKey& KeyType;
    typedef const FeatureValueHashKey* KeyTypePointer;

    explicit FeatureValueHashEntry(KeyTypePointer aKey) {}
    FeatureValueHashEntry(FeatureValueHashEntry&& other)
        : PLDHashEntryHdr(std::move(other)),
          mKey(std::move(other.mKey)),
          mValues(std::move(other.mValues)) {
      NS_ERROR("Should not be called");
    }
    ~FeatureValueHashEntry() {}

    bool KeyEquals(const KeyTypePointer aKey) const;
    static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
    static PLDHashNumber HashKey(const KeyTypePointer aKey);
    enum { ALLOW_MEMMOVE = true };

    FeatureValueHashKey mKey;
    nsTArray<uint32_t> mValues;
  };

  nsTHashtable<FeatureValueHashEntry> mFontFeatureValues;
};

#endif