331 lines
11 KiB
C++
331 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* 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_FONTCONFIG_UTILS_H
|
|
#define GFX_FONTCONFIG_UTILS_H
|
|
|
|
#include "gfxPlatform.h"
|
|
|
|
#include "mozilla/MathAlgorithms.h"
|
|
#include "nsAutoRef.h"
|
|
#include "nsTArray.h"
|
|
#include "nsTHashtable.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "gfxFT2FontBase.h"
|
|
|
|
#include <fontconfig/fontconfig.h>
|
|
|
|
|
|
template <>
|
|
class nsAutoRefTraits<FcPattern> : public nsPointerRefTraits<FcPattern>
|
|
{
|
|
public:
|
|
static void Release(FcPattern *ptr) { FcPatternDestroy(ptr); }
|
|
static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
|
|
};
|
|
|
|
template <>
|
|
class nsAutoRefTraits<FcFontSet> : public nsPointerRefTraits<FcFontSet>
|
|
{
|
|
public:
|
|
static void Release(FcFontSet *ptr) { FcFontSetDestroy(ptr); }
|
|
};
|
|
|
|
template <>
|
|
class nsAutoRefTraits<FcCharSet> : public nsPointerRefTraits<FcCharSet>
|
|
{
|
|
public:
|
|
static void Release(FcCharSet *ptr) { FcCharSetDestroy(ptr); }
|
|
};
|
|
|
|
class gfxIgnoreCaseCStringComparator
|
|
{
|
|
public:
|
|
bool Equals(const nsACString& a, const nsACString& b) const
|
|
{
|
|
return nsCString(a).Equals(b, nsCaseInsensitiveCStringComparator());
|
|
}
|
|
|
|
bool LessThan(const nsACString& a, const nsACString& b) const
|
|
{
|
|
return a < b;
|
|
}
|
|
};
|
|
|
|
class gfxFontconfigUtils {
|
|
public:
|
|
gfxFontconfigUtils();
|
|
|
|
static gfxFontconfigUtils* GetFontconfigUtils() {
|
|
if (!sUtils)
|
|
sUtils = new gfxFontconfigUtils();
|
|
return sUtils;
|
|
}
|
|
|
|
static void Shutdown();
|
|
|
|
nsresult GetFontList(nsIAtom *aLangGroup,
|
|
const nsACString& aGenericFamily,
|
|
nsTArray<nsString>& aListOfFonts);
|
|
|
|
nsresult UpdateFontList();
|
|
|
|
nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
|
|
|
|
const nsTArray< nsCountedRef<FcPattern> >&
|
|
GetFontsForFamily(const FcChar8 *aFamilyName);
|
|
|
|
const nsTArray< nsCountedRef<FcPattern> >&
|
|
GetFontsForFullname(const FcChar8 *aFullname);
|
|
|
|
// Returns the best support that any font offers for |aLang|.
|
|
FcLangResult GetBestLangSupport(const FcChar8 *aLang);
|
|
// Returns the fonts offering this best level of support.
|
|
const nsTArray< nsCountedRef<FcPattern> >&
|
|
GetFontsForLang(const FcChar8 *aLang);
|
|
|
|
// Retuns the language support for a fontconfig font pattern
|
|
static FcLangResult GetLangSupport(FcPattern *aFont, const FcChar8 *aLang);
|
|
|
|
// Conversions between FcChar8*, which is unsigned char*,
|
|
// and (signed) char*, that check the type of the argument.
|
|
static const FcChar8 *ToFcChar8(const char *aCharPtr)
|
|
{
|
|
return reinterpret_cast<const FcChar8*>(aCharPtr);
|
|
}
|
|
static const FcChar8 *ToFcChar8(const nsCString& aCString)
|
|
{
|
|
return ToFcChar8(aCString.get());
|
|
}
|
|
static const char *ToCString(const FcChar8 *aChar8Ptr)
|
|
{
|
|
return reinterpret_cast<const char*>(aChar8Ptr);
|
|
}
|
|
|
|
static uint8_t FcSlantToThebesStyle(int aFcSlant);
|
|
static uint8_t GetThebesStyle(FcPattern *aPattern); // slant
|
|
static uint16_t GetThebesWeight(FcPattern *aPattern);
|
|
static int16_t GetThebesStretch(FcPattern *aPattern);
|
|
|
|
static int GetFcSlant(const gfxFontStyle& aFontStyle);
|
|
// Returns a precise FC_WEIGHT from |aBaseWeight|,
|
|
// which is a CSS absolute weight / 100.
|
|
static int FcWeightForBaseWeight(int8_t aBaseWeight);
|
|
|
|
static int FcWidthForThebesStretch(int16_t aStretch);
|
|
|
|
static bool GetFullnameFromFamilyAndStyle(FcPattern *aFont,
|
|
nsACString *aFullname);
|
|
|
|
// This doesn't consider which faces exist, and so initializes the pattern
|
|
// using a guessed weight, and doesn't consider sizeAdjust.
|
|
static nsReturnRef<FcPattern>
|
|
NewPattern(const nsTArray<nsString>& aFamilies,
|
|
const gfxFontStyle& aFontStyle, const char *aLang);
|
|
|
|
/**
|
|
* @param aLangGroup [in] a Mozilla langGroup.
|
|
* @param aFcLang [out] returns a language suitable for fontconfig
|
|
* matching |aLangGroup| or an empty string if no match is found.
|
|
*/
|
|
static void GetSampleLangForGroup(nsIAtom *aLangGroup,
|
|
nsACString *aFcLang);
|
|
|
|
protected:
|
|
// Base class for hash table entries with case-insensitive FcChar8
|
|
// string keys.
|
|
class FcStrEntryBase : public PLDHashEntryHdr {
|
|
public:
|
|
typedef const FcChar8 *KeyType;
|
|
typedef const FcChar8 *KeyTypePointer;
|
|
|
|
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
|
|
// Case-insensitive hash.
|
|
//
|
|
// fontconfig always ignores case of ASCII characters in family
|
|
// names and languages, but treatment of whitespace in families is
|
|
// not consistent. FcFontSort and FcFontMatch ignore whitespace
|
|
// except for whitespace in the first character, while FcFontList
|
|
// and config subsitution tests require whitespace to match
|
|
// exactly. CSS 2.1 implies that whitespace is important in the
|
|
// font-family property. FcStrCmpIgnoreCase considers whitespace
|
|
// important.
|
|
static PLDHashNumber HashKey(const FcChar8 *aKey) {
|
|
uint32_t hash = 0;
|
|
for (const FcChar8 *c = aKey; *c != '\0'; ++c) {
|
|
hash = mozilla::RotateLeft(hash, 3) ^ FcToLower(*c);
|
|
}
|
|
return hash;
|
|
}
|
|
enum { ALLOW_MEMMOVE = true };
|
|
};
|
|
|
|
public:
|
|
// Hash entry with a dependent const FcChar8* pointer to an external
|
|
// string for a key (and no data). The user must ensure that the string
|
|
// associated with the pointer is not destroyed. This entry type is
|
|
// useful for family name keys as the family name string is held in the
|
|
// font pattern.
|
|
class DepFcStrEntry : public FcStrEntryBase {
|
|
public:
|
|
// When constructing a new entry in the hashtable, the key is left
|
|
// nullptr. The caller of PutEntry() must fill in mKey when nullptr.
|
|
// This provides a mechanism for the caller of PutEntry() to determine
|
|
// whether the entry has been initialized.
|
|
explicit DepFcStrEntry(KeyTypePointer aName)
|
|
: mKey(nullptr) { }
|
|
|
|
DepFcStrEntry(const DepFcStrEntry& toCopy)
|
|
: mKey(toCopy.mKey) { }
|
|
|
|
bool KeyEquals(KeyTypePointer aKey) const {
|
|
return FcStrCmpIgnoreCase(aKey, mKey) == 0;
|
|
}
|
|
|
|
const FcChar8 *mKey;
|
|
};
|
|
|
|
// Hash entry that uses a copy of an FcChar8 string to store the key.
|
|
// This entry type is useful for language keys, as languages are usually
|
|
// not stored as strings in font patterns.
|
|
class CopiedFcStrEntry : public FcStrEntryBase {
|
|
public:
|
|
// When constructing a new entry in the hashtable, the key is void.
|
|
// The caller of PutEntry() must call InitKey() when IsKeyInitialized()
|
|
// returns false. This provides a mechanism for the caller of
|
|
// PutEntry() to determine whether the entry has been initialized.
|
|
explicit CopiedFcStrEntry(KeyTypePointer aName) {
|
|
mKey.SetIsVoid(true);
|
|
}
|
|
|
|
CopiedFcStrEntry(const CopiedFcStrEntry& toCopy)
|
|
: mKey(toCopy.mKey) { }
|
|
|
|
bool KeyEquals(KeyTypePointer aKey) const {
|
|
return FcStrCmpIgnoreCase(aKey, ToFcChar8(mKey)) == 0;
|
|
}
|
|
|
|
bool IsKeyInitialized() { return !mKey.IsVoid(); }
|
|
void InitKey(const FcChar8* aKey) { mKey.Assign(ToCString(aKey)); }
|
|
|
|
private:
|
|
nsCString mKey;
|
|
};
|
|
|
|
protected:
|
|
class FontsByFcStrEntry : public DepFcStrEntry {
|
|
public:
|
|
explicit FontsByFcStrEntry(KeyTypePointer aName)
|
|
: DepFcStrEntry(aName) { }
|
|
|
|
FontsByFcStrEntry(const FontsByFcStrEntry& toCopy)
|
|
: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
|
|
|
|
bool AddFont(FcPattern *aFont) {
|
|
return mFonts.AppendElement(aFont) != nullptr;
|
|
}
|
|
const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
|
|
return mFonts;
|
|
}
|
|
private:
|
|
nsTArray< nsCountedRef<FcPattern> > mFonts;
|
|
};
|
|
|
|
// FontsByFullnameEntry is similar to FontsByFcStrEntry (used for
|
|
// mFontsByFamily) except for two differences:
|
|
//
|
|
// * The font does not always contain a single string for the fullname, so
|
|
// the key is sometimes a combination of family and style.
|
|
//
|
|
// * There is usually only one font.
|
|
class FontsByFullnameEntry : public DepFcStrEntry {
|
|
public:
|
|
// When constructing a new entry in the hashtable, the key is left
|
|
// nullptr. The caller of PutEntry() is must fill in mKey when adding
|
|
// the first font if the key is not derived from the family and style.
|
|
// If the key is derived from family and style, a font must be added.
|
|
explicit FontsByFullnameEntry(KeyTypePointer aName)
|
|
: DepFcStrEntry(aName) { }
|
|
|
|
FontsByFullnameEntry(const FontsByFullnameEntry& toCopy)
|
|
: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
|
|
|
|
bool KeyEquals(KeyTypePointer aKey) const;
|
|
|
|
bool AddFont(FcPattern *aFont) {
|
|
return mFonts.AppendElement(aFont) != nullptr;
|
|
}
|
|
const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
|
|
return mFonts;
|
|
}
|
|
|
|
// Don't memmove the AutoTArray.
|
|
enum { ALLOW_MEMMOVE = false };
|
|
private:
|
|
// There is usually only one font, but sometimes more.
|
|
AutoTArray<nsCountedRef<FcPattern>,1> mFonts;
|
|
};
|
|
|
|
class LangSupportEntry : public CopiedFcStrEntry {
|
|
public:
|
|
explicit LangSupportEntry(KeyTypePointer aName)
|
|
: CopiedFcStrEntry(aName) { }
|
|
|
|
LangSupportEntry(const LangSupportEntry& toCopy)
|
|
: CopiedFcStrEntry(toCopy), mSupport(toCopy.mSupport) { }
|
|
|
|
FcLangResult mSupport;
|
|
nsTArray< nsCountedRef<FcPattern> > mFonts;
|
|
};
|
|
|
|
static gfxFontconfigUtils* sUtils;
|
|
|
|
bool IsExistingFamily(const nsCString& aFamilyName);
|
|
|
|
nsresult GetFontListInternal(nsTArray<nsCString>& aListOfFonts,
|
|
nsIAtom *aLangGroup);
|
|
nsresult UpdateFontListInternal(bool aForce = false);
|
|
|
|
void AddFullnameEntries();
|
|
|
|
LangSupportEntry *GetLangSupportEntry(const FcChar8 *aLang,
|
|
bool aWithFonts);
|
|
|
|
// mFontsByFamily and mFontsByFullname contain entries only for families
|
|
// and fullnames for which there are fonts.
|
|
nsTHashtable<FontsByFcStrEntry> mFontsByFamily;
|
|
nsTHashtable<FontsByFullnameEntry> mFontsByFullname;
|
|
// mLangSupportTable contains an entry for each language that has been
|
|
// looked up through GetLangSupportEntry, even when the language is not
|
|
// supported.
|
|
nsTHashtable<LangSupportEntry> mLangSupportTable;
|
|
const nsTArray< nsCountedRef<FcPattern> > mEmptyPatternArray;
|
|
|
|
FcConfig *mLastConfig;
|
|
|
|
#ifdef MOZ_BUNDLED_FONTS
|
|
void ActivateBundledFonts();
|
|
|
|
nsCString mBundledFontsPath;
|
|
bool mBundledFontsInitialized;
|
|
#endif
|
|
};
|
|
|
|
class gfxFontconfigFontBase : public gfxFT2FontBase {
|
|
public:
|
|
gfxFontconfigFontBase(cairo_scaled_font_t *aScaledFont,
|
|
FcPattern *aPattern,
|
|
gfxFontEntry *aFontEntry,
|
|
const gfxFontStyle *aFontStyle);
|
|
|
|
virtual FontType GetType() const override { return FONT_TYPE_FONTCONFIG; }
|
|
virtual FcPattern *GetPattern() const { return mPattern; }
|
|
|
|
private:
|
|
nsCountedRef<FcPattern> mPattern;
|
|
};
|
|
|
|
#endif /* GFX_FONTCONFIG_UTILS_H */
|