зеркало из https://github.com/mozilla/gecko-dev.git
backout b=449356 e8665c7cfdf2 and 20113c4780d2
This commit is contained in:
Karl Tomlinson
Родитель
3e90d9d020
Коммит
05179c6434
|
|
@ -43,10 +43,7 @@
|
|||
#include "gfxTypes.h"
|
||||
#include "gfxFont.h"
|
||||
|
||||
#include "nsAutoRef.h"
|
||||
|
||||
#include <pango/pango.h>
|
||||
#include <fontconfig/fontconfig.h>
|
||||
|
||||
// Control when we bypass Pango
|
||||
// Enable this to use FreeType to glyph-convert 8bit-only textruns, but use Pango
|
||||
|
|
@ -57,7 +54,21 @@
|
|||
// anything other than simple Latin work though!
|
||||
//#define ENABLE_FAST_PATH_ALWAYS
|
||||
|
||||
class gfxFcPangoFontSet;
|
||||
#include "nsDataHashtable.h"
|
||||
#include "nsClassHashtable.h"
|
||||
|
||||
class gfxPangoTextRun;
|
||||
|
||||
// stub class until fuller implementation is flushed out
|
||||
class gfxPangoFontEntry : public gfxFontEntry {
|
||||
public:
|
||||
gfxPangoFontEntry(const nsAString& aName)
|
||||
: gfxFontEntry(aName)
|
||||
{ }
|
||||
|
||||
~gfxPangoFontEntry() {}
|
||||
|
||||
};
|
||||
|
||||
class THEBES_API gfxPangoFontGroup : public gfxFontGroup {
|
||||
public:
|
||||
|
|
@ -78,33 +89,9 @@ public:
|
|||
|
||||
static void Shutdown();
|
||||
|
||||
// Interfaces used internally
|
||||
// (but public so that they can be accessed from non-member functions):
|
||||
|
||||
// The FontGroup holds the reference to the PangoFont (through the FontSet).
|
||||
PangoFont *GetBasePangoFont();
|
||||
|
||||
// A language guessed from the gfxFontStyle
|
||||
PangoLanguage *GetPangoLanguage() { return mPangoLanguage; }
|
||||
|
||||
// @param aLang [in] language to use for pref fonts and system default font
|
||||
// selection, or NULL for the language guessed from the gfxFontStyle.
|
||||
// The FontGroup holds a reference to this set.
|
||||
gfxFcPangoFontSet *GetFontSet(PangoLanguage *aLang = NULL);
|
||||
|
||||
protected:
|
||||
class FontSetByLangEntry {
|
||||
public:
|
||||
FontSetByLangEntry(PangoLanguage *aLang, gfxFcPangoFontSet *aFontSet);
|
||||
PangoLanguage *mLang;
|
||||
nsRefPtr<gfxFcPangoFontSet> mFontSet;
|
||||
};
|
||||
// There is only one of entry in this array unless characters from scripts
|
||||
// of other languages are measured.
|
||||
nsAutoTArray<FontSetByLangEntry,1> mFontSets;
|
||||
|
||||
gfxFloat mSizeAdjustFactor;
|
||||
PangoLanguage *mPangoLanguage;
|
||||
PangoFont *mBasePangoFont;
|
||||
gfxFloat mAdjustedSize;
|
||||
|
||||
// ****** Textrun glyph conversion helpers ******
|
||||
|
||||
|
|
@ -136,24 +123,55 @@ protected:
|
|||
const gchar *aUTF8, PRUint32 aUTF8Length);
|
||||
#endif
|
||||
|
||||
void GetFcFamilies(nsStringArray *aFcFamilyList,
|
||||
const nsACString& aLangGroup);
|
||||
void GetFcFamilies(nsAString &aFcFamilies);
|
||||
PangoFont *GetBasePangoFont();
|
||||
|
||||
// @param aLang [in] language to use for pref fonts and system font
|
||||
// resolution, or NULL to guess a language from the gfxFontStyle.
|
||||
// @param aMatchPattern [out] if non-NULL, will return the pattern used.
|
||||
already_AddRefed<gfxFcPangoFontSet>
|
||||
MakeFontSet(PangoLanguage *aLang, gfxFloat aSizeAdjustFactor,
|
||||
nsAutoRef<FcPattern> *aMatchPattern = NULL);
|
||||
|
||||
gfxFcPangoFontSet *GetBaseFontSet();
|
||||
|
||||
gfxFloat GetSizeAdjustFactor()
|
||||
// Check GetStyle()->sizeAdjust != 0.0 before calling this
|
||||
gfxFloat GetAdjustedSize()
|
||||
{
|
||||
if (mFontSets.Length() == 0)
|
||||
GetBaseFontSet();
|
||||
return mSizeAdjustFactor;
|
||||
if (!mBasePangoFont)
|
||||
GetBasePangoFont();
|
||||
return mAdjustedSize;
|
||||
}
|
||||
};
|
||||
|
||||
class gfxPangoFontWrapper {
|
||||
public:
|
||||
gfxPangoFontWrapper(PangoFont *aFont) {
|
||||
mFont = aFont;
|
||||
g_object_ref(mFont);
|
||||
}
|
||||
~gfxPangoFontWrapper() {
|
||||
if (mFont)
|
||||
g_object_unref(mFont);
|
||||
}
|
||||
PangoFont* Get() { return mFont; }
|
||||
private:
|
||||
PangoFont *mFont;
|
||||
};
|
||||
|
||||
class gfxPangoFontCache
|
||||
{
|
||||
public:
|
||||
gfxPangoFontCache();
|
||||
~gfxPangoFontCache();
|
||||
|
||||
static gfxPangoFontCache* GetPangoFontCache() {
|
||||
if (!sPangoFontCache)
|
||||
sPangoFontCache = new gfxPangoFontCache();
|
||||
return sPangoFontCache;
|
||||
}
|
||||
static void Shutdown() {
|
||||
if (sPangoFontCache)
|
||||
delete sPangoFontCache;
|
||||
sPangoFontCache = nsnull;
|
||||
}
|
||||
|
||||
void Put(const PangoFontDescription *aFontDesc, PangoFont *aPangoFont);
|
||||
PangoFont* Get(const PangoFontDescription *aFontDesc);
|
||||
private:
|
||||
static gfxPangoFontCache *sPangoFontCache;
|
||||
nsClassHashtable<nsUint32HashKey, gfxPangoFontWrapper> mPangoFonts;
|
||||
};
|
||||
|
||||
#endif /* GFX_PANGOFONTS_H */
|
||||
|
|
|
|||
|
|
@ -40,7 +40,6 @@
|
|||
#define GFX_PLATFORM_GTK_H
|
||||
|
||||
#include "gfxPlatform.h"
|
||||
#include "nsAutoRef.h"
|
||||
|
||||
extern "C" {
|
||||
typedef struct _GdkDrawable GdkDrawable;
|
||||
|
|
@ -53,12 +52,7 @@ class FontEntry;
|
|||
typedef struct FT_LibraryRec_ *FT_Library;
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
class gfxGObjectRefTraits : public nsPointerRefTraits<T> {
|
||||
public:
|
||||
static void Release(T *aPtr) { g_object_unref(aPtr); }
|
||||
static void AddRef(T *aPtr) { g_object_ref(aPtr); }
|
||||
};
|
||||
|
||||
|
||||
class THEBES_API gfxPlatformGtk : public gfxPlatform {
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -77,17 +77,6 @@ gfxFontconfigUtils::GetThebesStyle(FcPattern *aPattern)
|
|||
return FONT_STYLE_NORMAL;
|
||||
}
|
||||
|
||||
/* static */ int
|
||||
gfxFontconfigUtils::GetFcSlant(const gfxFontStyle& aFontStyle)
|
||||
{
|
||||
if (aFontStyle.style == FONT_STYLE_ITALIC)
|
||||
return FC_SLANT_ITALIC;
|
||||
if (aFontStyle.style == FONT_STYLE_OBLIQUE)
|
||||
return FC_SLANT_OBLIQUE;
|
||||
|
||||
return FC_SLANT_ROMAN;
|
||||
}
|
||||
|
||||
// OS/2 weight classes were introduced in fontconfig-2.1.93 (2003).
|
||||
#ifndef FC_WEIGHT_THIN
|
||||
#define FC_WEIGHT_THIN 0 // 2.1.93
|
||||
|
|
@ -99,10 +88,6 @@ gfxFontconfigUtils::GetFcSlant(const gfxFontStyle& aFontStyle)
|
|||
#ifndef FC_WEIGHT_BOOK
|
||||
#define FC_WEIGHT_BOOK 75
|
||||
#endif
|
||||
// extra black was introduced in fontconfig-2.4.91 (2007)
|
||||
#ifndef FC_WEIGHT_EXTRABLACK
|
||||
#define FC_WEIGHT_EXTRABLACK 215
|
||||
#endif
|
||||
|
||||
/* static */ PRUint16
|
||||
gfxFontconfigUtils::GetThebesWeight(FcPattern *aPattern)
|
||||
|
|
@ -131,134 +116,14 @@ gfxFontconfigUtils::GetThebesWeight(FcPattern *aPattern)
|
|||
if (weight <= FC_WEIGHT_BLACK)
|
||||
return 900;
|
||||
|
||||
// including FC_WEIGHT_EXTRABLACK
|
||||
// FC_WEIGHT_EXTRABLACK was introduced in fontconfig-2.4.91 (2007)
|
||||
return 901;
|
||||
}
|
||||
|
||||
/* static */ int
|
||||
gfxFontconfigUtils::FcWeightForBaseWeight(PRInt8 aBaseWeight)
|
||||
{
|
||||
switch (aBaseWeight) {
|
||||
case 2:
|
||||
return FC_WEIGHT_EXTRALIGHT;
|
||||
case 3:
|
||||
return FC_WEIGHT_LIGHT;
|
||||
case 4:
|
||||
return FC_WEIGHT_REGULAR;
|
||||
case 5:
|
||||
return FC_WEIGHT_MEDIUM;
|
||||
case 6:
|
||||
return FC_WEIGHT_DEMIBOLD;
|
||||
case 7:
|
||||
return FC_WEIGHT_BOLD;
|
||||
case 8:
|
||||
return FC_WEIGHT_EXTRABOLD;
|
||||
case 9:
|
||||
return FC_WEIGHT_BLACK;
|
||||
}
|
||||
|
||||
// extremes
|
||||
return aBaseWeight < 2 ? FC_WEIGHT_THIN : FC_WEIGHT_EXTRABLACK;
|
||||
}
|
||||
|
||||
// This makes a guess at an FC_WEIGHT corresponding to a base weight and
|
||||
// offset (without any knowledge of which weights are available).
|
||||
|
||||
/* static */ int
|
||||
GuessFcWeight(const gfxFontStyle& aFontStyle)
|
||||
{
|
||||
/*
|
||||
* weights come in two parts crammed into one
|
||||
* integer -- the "base" weight is weight / 100,
|
||||
* the rest of the value is the "offset" from that
|
||||
* weight -- the number of steps to move to adjust
|
||||
* the weight in the list of supported font weights,
|
||||
* this value can be negative or positive.
|
||||
*/
|
||||
PRInt8 weight;
|
||||
PRInt8 offset;
|
||||
aFontStyle.ComputeWeightAndOffset(&weight, &offset);
|
||||
|
||||
// ComputeWeightAndOffset trimmed the range of weights for us
|
||||
NS_ASSERTION(weight >= 0 && weight <= 10,
|
||||
"base weight out of range");
|
||||
|
||||
// Most font families do not support every weight. The tables here are
|
||||
// chosen such that a normal (4) base weight and an offset of +1 will
|
||||
// guess bold.
|
||||
|
||||
// Mapping from weight to a guess of the nearest available lighter weight
|
||||
static const int lighterGuess[11] =
|
||||
{ 0, 0, 1, 1, 2, 3, 4, 4, 6, 7, 8 };
|
||||
// Mapping from weight to a guess of the nearest available bolder weight
|
||||
static const int bolderGuess[11] =
|
||||
{ 2, 3, 4, 6, 7, 7, 8, 9, 10, 10, 10 };
|
||||
|
||||
while (offset < 0) {
|
||||
weight = lighterGuess[weight];
|
||||
offset++;
|
||||
}
|
||||
while (offset > 0) {
|
||||
weight = bolderGuess[weight];
|
||||
offset--;
|
||||
}
|
||||
|
||||
return gfxFontconfigUtils::FcWeightForBaseWeight(weight);
|
||||
}
|
||||
|
||||
static void
|
||||
AddString(FcPattern *aPattern, const char *object, const char *aString)
|
||||
{
|
||||
// Cast from signed chars used in nsString to unsigned in fontconfig
|
||||
const FcChar8 *fcString = gfxFontconfigUtils::ToFcChar8(aString);
|
||||
// and cast away the const for fontconfig, that will merely make a copy.
|
||||
FcPatternAddString(aPattern, object, const_cast<FcChar8*>(fcString));
|
||||
}
|
||||
|
||||
static void
|
||||
AddLangGroup(FcPattern *aPattern, const nsACString& aLangGroup)
|
||||
{
|
||||
// Translate from mozilla's internal mapping into fontconfig's
|
||||
nsCAutoString lang;
|
||||
gfxFontconfigUtils::GetSampleLangForGroup(aLangGroup, &lang);
|
||||
|
||||
if (!lang.IsEmpty()) {
|
||||
AddString(aPattern, FC_LANG, lang.get());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
nsReturnRef<FcPattern>
|
||||
gfxFontconfigUtils::NewPattern(const nsStringArray& aFamilies,
|
||||
const gfxFontStyle& aFontStyle,
|
||||
const char *aLang)
|
||||
{
|
||||
nsAutoRef<FcPattern> pattern(FcPatternCreate());
|
||||
if (!pattern)
|
||||
return nsReturnRef<FcPattern>();
|
||||
|
||||
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, aFontStyle.size);
|
||||
FcPatternAddInteger(pattern, FC_SLANT, GetFcSlant(aFontStyle));
|
||||
FcPatternAddInteger(pattern, FC_WEIGHT, GuessFcWeight(aFontStyle));
|
||||
|
||||
if (aLang) {
|
||||
AddString(pattern, FC_LANG, aLang);
|
||||
}
|
||||
|
||||
for (PRInt32 i = 0; i < aFamilies.Count(); ++i) {
|
||||
NS_ConvertUTF16toUTF8 family(*aFamilies[i]);
|
||||
AddString(pattern, FC_FAMILY, family.get());
|
||||
}
|
||||
|
||||
return pattern.out();
|
||||
}
|
||||
|
||||
gfxFontconfigUtils::gfxFontconfigUtils()
|
||||
: mLastConfig(NULL)
|
||||
{
|
||||
mFontsByFamily.Init(50);
|
||||
mLangSupportTable.Init(20);
|
||||
UpdateFontListInternal();
|
||||
mAliasTable.Init(50);
|
||||
}
|
||||
|
||||
nsresult
|
||||
|
|
@ -268,15 +133,22 @@ gfxFontconfigUtils::GetFontList(const nsACString& aLangGroup,
|
|||
{
|
||||
aListOfFonts.Clear();
|
||||
|
||||
nsCStringArray fonts;
|
||||
nsresult rv = GetFontListInternal(fonts, aLangGroup);
|
||||
nsresult rv = UpdateFontListInternal();
|
||||
if (NS_FAILED(rv))
|
||||
return rv;
|
||||
|
||||
for (PRInt32 i = 0; i < fonts.Count(); ++i) {
|
||||
aListOfFonts.AppendString(NS_ConvertUTF8toUTF16(*fonts.CStringAt(i)));
|
||||
nsCStringArray tmpFonts;
|
||||
nsCStringArray *fonts = &mFonts;
|
||||
if (!aLangGroup.IsEmpty() || !aGenericFamily.IsEmpty()) {
|
||||
rv = GetFontListInternal(tmpFonts, &aLangGroup);
|
||||
if (NS_FAILED(rv))
|
||||
return rv;
|
||||
fonts = &tmpFonts;
|
||||
}
|
||||
|
||||
for (PRInt32 i = 0; i < fonts->Count(); ++i)
|
||||
aListOfFonts.AppendString(NS_ConvertUTF8toUTF16(*fonts->CStringAt(i)));
|
||||
|
||||
aListOfFonts.Sort();
|
||||
|
||||
PRInt32 serif = 0, sansSerif = 0, monospace = 0;
|
||||
|
|
@ -382,7 +254,7 @@ gfxFontconfigUtils::GetSampleLangForGroup(const nsACString& aLangGroup,
|
|||
|
||||
const MozLangGroupData *langGroup = nsnull;
|
||||
|
||||
for (unsigned int i = 0; i < NS_ARRAY_LENGTH(MozLangGroups); ++i) {
|
||||
for (unsigned int i=0; i < NS_ARRAY_LENGTH(MozLangGroups); ++i) {
|
||||
if (aLangGroup.Equals(MozLangGroups[i].mozLangGroup,
|
||||
nsCaseInsensitiveCStringComparator())) {
|
||||
langGroup = &MozLangGroups[i];
|
||||
|
|
@ -437,9 +309,25 @@ gfxFontconfigUtils::GetSampleLangForGroup(const nsACString& aLangGroup,
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
AddLangGroup(FcPattern *aPattern, const nsACString& aLangGroup)
|
||||
{
|
||||
// Translate from mozilla's internal mapping into fontconfig's
|
||||
nsCAutoString lang;
|
||||
gfxFontconfigUtils::GetSampleLangForGroup(aLangGroup, &lang);
|
||||
|
||||
if (!lang.IsEmpty()) {
|
||||
// cast from signed chars used in nsString to unsigned in fontconfig
|
||||
const FcChar8 *fcString = reinterpret_cast<const FcChar8*>(lang.get());
|
||||
// and cast away the const for fontconfig, that will merely make a copy.
|
||||
FcPatternAddString(aPattern, FC_LANG, const_cast<FcChar8*>(fcString));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
nsresult
|
||||
gfxFontconfigUtils::GetFontListInternal(nsCStringArray& aListOfFonts,
|
||||
const nsACString& aLangGroup)
|
||||
const nsACString *aLangGroup)
|
||||
{
|
||||
FcPattern *pat = NULL;
|
||||
FcObjectSet *os = NULL;
|
||||
|
|
@ -457,8 +345,8 @@ gfxFontconfigUtils::GetFontListInternal(nsCStringArray& aListOfFonts,
|
|||
goto end;
|
||||
|
||||
// take the pattern and add the lang group to it
|
||||
if (!aLangGroup.IsEmpty()) {
|
||||
AddLangGroup(pat, aLangGroup);
|
||||
if (aLangGroup && !aLangGroup->IsEmpty()) {
|
||||
AddLangGroup(pat, *aLangGroup);
|
||||
}
|
||||
|
||||
fs = FcFontList(NULL, pat, os);
|
||||
|
|
@ -525,38 +413,16 @@ gfxFontconfigUtils::UpdateFontListInternal(PRBool aForce)
|
|||
if (currentConfig == mLastConfig)
|
||||
return NS_OK;
|
||||
|
||||
// This FcFontSet is owned by fontconfig
|
||||
FcFontSet *fontSet = FcConfigGetFonts(currentConfig, FcSetSystem);
|
||||
|
||||
mFontsByFamily.Clear();
|
||||
mLangSupportTable.Clear();
|
||||
mFonts.Clear();
|
||||
mAliasForSingleFont.Clear();
|
||||
mAliasForMultiFonts.Clear();
|
||||
mNonExistingFonts.Clear();
|
||||
|
||||
// Record the existing font families
|
||||
for (int f = 0; f < fontSet->nfont; ++f) {
|
||||
FcPattern *font = fontSet->fonts[f];
|
||||
mAliasTable.Clear();
|
||||
|
||||
FcChar8 *family;
|
||||
for (int v = 0;
|
||||
FcPatternGetString(font, FC_FAMILY, v, &family) == FcResultMatch;
|
||||
++v) {
|
||||
FontsByFcStrEntry *entry = mFontsByFamily.PutEntry(family);
|
||||
if (entry) {
|
||||
PRBool added = entry->AddFont(font);
|
||||
|
||||
if (!entry->mKey) {
|
||||
// The reference to the font pattern keeps the pointer to
|
||||
// string for the key valid. If adding the font failed
|
||||
// then the entry must be removed.
|
||||
if (added) {
|
||||
entry->mKey = family;
|
||||
} else {
|
||||
mFontsByFamily.RawRemoveEntry(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
nsresult rv = GetFontListInternal(mFonts);
|
||||
if (NS_FAILED(rv))
|
||||
return rv;
|
||||
|
||||
// XXX we don't support all alias names.
|
||||
// Because if we don't check whether the given font name is alias name,
|
||||
|
|
@ -597,10 +463,72 @@ gfxFontconfigUtils::UpdateFontListInternal(PRBool aForce)
|
|||
}
|
||||
}
|
||||
|
||||
for (PRInt32 i = 0; i < mAliasForMultiFonts.Count(); i++) {
|
||||
nsRefPtr<gfxFontNameList> fonts = new gfxFontNameList;
|
||||
nsCAutoString fontname(*mAliasForMultiFonts.CStringAt(i));
|
||||
rv = GetResolvedFonts(fontname, fonts);
|
||||
if (NS_FAILED(rv))
|
||||
return rv;
|
||||
|
||||
nsCAutoString key;
|
||||
ToLowerCase(fontname, key);
|
||||
mAliasTable.Put(key, fonts);
|
||||
}
|
||||
|
||||
mLastConfig = currentConfig;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsresult
|
||||
gfxFontconfigUtils::GetResolvedFonts(const nsACString& aName,
|
||||
gfxFontNameList* aResult)
|
||||
{
|
||||
FcPattern *pat = NULL;
|
||||
FcFontSet *fs = NULL;
|
||||
FcResult fresult;
|
||||
aResult->Clear();
|
||||
nsresult rv = NS_ERROR_FAILURE;
|
||||
|
||||
pat = FcPatternCreate();
|
||||
if (!pat)
|
||||
goto end;
|
||||
|
||||
FcDefaultSubstitute(pat);
|
||||
FcPatternAddString(pat, FC_FAMILY,
|
||||
(FcChar8 *)nsPromiseFlatCString(aName).get());
|
||||
// Delete the lang param. We need lang independent alias list.
|
||||
FcPatternDel(pat, FC_LANG);
|
||||
FcConfigSubstitute(NULL, pat, FcMatchPattern);
|
||||
|
||||
fs = FcFontSort(NULL, pat, FcTrue, NULL, &fresult);
|
||||
if (!fs)
|
||||
goto end;
|
||||
|
||||
rv = NS_OK;
|
||||
for (int i = 0; i < fs->nfont; i++) {
|
||||
char *family;
|
||||
|
||||
if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0,
|
||||
(FcChar8 **) &family) != FcResultMatch ||
|
||||
mAliasForMultiFonts.IndexOfIgnoreCase(nsDependentCString(family)) >= 0 ||
|
||||
IsExistingFont(nsDependentCString(family)) == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
NS_ConvertUTF8toUTF16 actualName(family);
|
||||
if (aResult->Exists(actualName))
|
||||
continue;
|
||||
aResult->AppendElement(actualName);
|
||||
}
|
||||
|
||||
end:
|
||||
if (pat)
|
||||
FcPatternDestroy(pat);
|
||||
if (fs)
|
||||
FcFontSetDestroy(fs);
|
||||
return rv;
|
||||
}
|
||||
|
||||
nsresult
|
||||
gfxFontconfigUtils::GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName)
|
||||
{
|
||||
|
|
@ -620,8 +548,12 @@ gfxFontconfigUtils::GetStandardFamilyName(const nsAString& aFontName, nsAString&
|
|||
|
||||
NS_ConvertUTF16toUTF8 fontname(aFontName);
|
||||
|
||||
// return empty string if no such family exists
|
||||
if (!IsExistingFamily(fontname))
|
||||
if (mFonts.IndexOf(fontname) >= 0) {
|
||||
aFamilyName.Assign(aFontName);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
if (mNonExistingFonts.IndexOf(fontname) >= 0)
|
||||
return NS_OK;
|
||||
|
||||
FcPattern *pat = NULL;
|
||||
|
|
@ -723,210 +655,87 @@ gfxFontconfigUtils::ResolveFontName(const nsAString& aFontName,
|
|||
return rv;
|
||||
|
||||
NS_ConvertUTF16toUTF8 fontname(aFontName);
|
||||
// Sometimes, the font has two or more names (e.g., "Sazanami Gothic" has
|
||||
// Japanese localized name). We should not resolve to a single name
|
||||
// because different names sometimes have different behavior. e.g., with
|
||||
// the default settings of "Sazanami" on Fedora Core 5, the non-localized
|
||||
// name uses anti-alias, but the localized name uses it. So, we should
|
||||
// check just whether the font is existing, without resolving to regular
|
||||
// name.
|
||||
//
|
||||
// The family names in mAliasForMultiFonts are names understood by
|
||||
// fontconfig. The actual font to which they resolve depends on the
|
||||
// entire match pattern. That info is not available here, but there
|
||||
// will be a font so leave the resolving to the gfxFontGroup.
|
||||
if (IsExistingFamily(fontname) ||
|
||||
mAliasForMultiFonts.IndexOfIgnoreCase(fontname))
|
||||
aAborted = !(*aCallback)(aFontName, aClosure);
|
||||
if (mAliasForMultiFonts.IndexOfIgnoreCase(fontname) >= 0) {
|
||||
nsCAutoString key;
|
||||
ToLowerCase(fontname, key);
|
||||
nsRefPtr<gfxFontNameList> fonts;
|
||||
if (!mAliasTable.Get(key, &fonts))
|
||||
NS_ERROR("The mAliasTable was broken!");
|
||||
for (PRUint32 i = 0; i < fonts->Length(); i++) {
|
||||
aAborted = !(*aCallback)(fonts->ElementAt(i), aClosure);
|
||||
if (aAborted)
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
PRInt32 result = IsExistingFont(fontname);
|
||||
if (result < 0)
|
||||
return NS_ERROR_FAILURE;
|
||||
|
||||
if (result > 0)
|
||||
aAborted = !(*aCallback)(aFontName, aClosure);
|
||||
}
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
PRBool
|
||||
gfxFontconfigUtils::IsExistingFamily(const nsCString& aFamilyName)
|
||||
PRInt32
|
||||
gfxFontconfigUtils::IsExistingFont(const nsACString &aFontName)
|
||||
{
|
||||
return mFontsByFamily.GetEntry(ToFcChar8(aFamilyName.get())) != nsnull;
|
||||
}
|
||||
// Very many sites may specify the font-family only for Windows and Mac.
|
||||
// We should check negative cache at first.
|
||||
if (mNonExistingFonts.IndexOf(aFontName) >= 0)
|
||||
return 0;
|
||||
if (mAliasForSingleFont.IndexOf(aFontName) >= 0)
|
||||
return 1;
|
||||
if (mFonts.IndexOf(aFontName) >= 0)
|
||||
return 1;
|
||||
|
||||
static nsTArray< nsCountedRef<FcPattern> >&
|
||||
EmptyPatternArray()
|
||||
{
|
||||
static nsTArray< nsCountedRef<FcPattern> > empty;
|
||||
return empty;
|
||||
}
|
||||
// XXX Sometimes, the font has two or more names (e.g., "Sazanami Gothic"
|
||||
// has Japanese localized name). The another name doesn't including the
|
||||
// cache. Therefore, we need to check the name.
|
||||
// But we don't need to resolve the name. Because both names are not same
|
||||
// behavior. E.g., the default settings of "Sazanami" on Fedora Core 5,
|
||||
// the non-localized name uses Anti-alias, but the localized name uses it.
|
||||
// So, we should check just whether the font is existing, don't resolve
|
||||
// to regular name.
|
||||
|
||||
const nsTArray< nsCountedRef<FcPattern> >&
|
||||
gfxFontconfigUtils::GetFontsForFamily(const FcChar8 *aFamilyName)
|
||||
{
|
||||
FontsByFcStrEntry *entry = mFontsByFamily.GetEntry(aFamilyName);
|
||||
FcPattern *pat = NULL;
|
||||
FcObjectSet *os = NULL;
|
||||
FcFontSet *fs = NULL;
|
||||
PRInt32 result = -1;
|
||||
|
||||
if (!entry)
|
||||
return EmptyPatternArray();
|
||||
pat = FcPatternCreate();
|
||||
if (!pat)
|
||||
goto end;
|
||||
|
||||
return entry->GetFonts();
|
||||
}
|
||||
FcPatternAddString(pat, FC_FAMILY,
|
||||
(FcChar8 *)nsPromiseFlatCString(aFontName).get());
|
||||
|
||||
static FcLangResult
|
||||
CompareLangString(const FcChar8 *aLangA, const FcChar8 *aLangB) {
|
||||
FcLangResult result = FcLangDifferentLang;
|
||||
for (PRUint32 i = 0; ; ++i) {
|
||||
FcChar8 a = FcToLower(aLangA[i]);
|
||||
FcChar8 b = FcToLower(aLangB[i]);
|
||||
os = FcObjectSetBuild(FC_FAMILY, NULL);
|
||||
if (!os)
|
||||
goto end;
|
||||
|
||||
if (a != b) {
|
||||
if ((a == '\0' && b == '-') || (a == '-' && b == '\0'))
|
||||
return FcLangDifferentCountry;
|
||||
fs = FcFontList(NULL, pat, os);
|
||||
if (!fs)
|
||||
goto end;
|
||||
|
||||
return result;
|
||||
}
|
||||
if (a == '\0')
|
||||
return FcLangEqual;
|
||||
|
||||
if (a == '-') {
|
||||
result = FcLangDifferentCountry;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* static */
|
||||
FcLangResult
|
||||
gfxFontconfigUtils::GetLangSupport(FcPattern *aFont, const FcChar8 *aLang)
|
||||
{
|
||||
// When fontconfig builds a pattern for the font, it will set a single
|
||||
// LangSet property value for the font. That value may be removed and
|
||||
// additional string values may be added through FcConfigSubsitute with
|
||||
// FcMatchScan. Values that are neither LangSet nor string are considered
|
||||
// errors in fontconfig sort and match functions.
|
||||
FcValue value;
|
||||
FcLangResult best = FcLangDifferentLang;
|
||||
int v = 0;
|
||||
while (FcPatternGet(aFont, FC_LANG, v, &value) == FcResultMatch) {
|
||||
++v;
|
||||
|
||||
FcLangResult support;
|
||||
switch (value.type) {
|
||||
case FcTypeLangSet:
|
||||
support = FcLangSetHasLang(value.u.l, aLang);
|
||||
break;
|
||||
case FcTypeString:
|
||||
support = CompareLangString(value.u.s, aLang);
|
||||
break;
|
||||
default:
|
||||
// error
|
||||
return FcLangEqual;
|
||||
}
|
||||
|
||||
if (support < best) { // lower is better
|
||||
if (support == FcLangEqual)
|
||||
return support;
|
||||
best = support;
|
||||
}
|
||||
}
|
||||
|
||||
// A missing FC_LANG property is considered a match in fontconfig sort
|
||||
// and match functions.
|
||||
if (v == 0)
|
||||
return FcLangEqual;
|
||||
|
||||
return best;
|
||||
}
|
||||
|
||||
gfxFontconfigUtils::LangSupportEntry *
|
||||
gfxFontconfigUtils::GetLangSupportEntry(const FcChar8 *aLang, PRBool aWithFonts)
|
||||
{
|
||||
// Currently any unrecognized languages from documents will be converted
|
||||
// to x-unicode by nsILanguageAtomService, so there is a limit on the
|
||||
// langugages that will be added here. Reconsider when/if document
|
||||
// languages are passed to this routine.
|
||||
|
||||
LangSupportEntry *entry = mLangSupportTable.PutEntry(aLang);
|
||||
if (!entry)
|
||||
return nsnull;
|
||||
|
||||
FcLangResult best = FcLangDifferentLang;
|
||||
|
||||
if (!entry->IsKeyInitialized()) {
|
||||
entry->InitKey(aLang);
|
||||
// There can be more than one matching set of family names: see bug 393819.
|
||||
if (fs->nfont > 0) {
|
||||
mAliasForSingleFont.AppendCString(aFontName);
|
||||
result = 1;
|
||||
} else {
|
||||
// mSupport is already initialized.
|
||||
if (!aWithFonts)
|
||||
return entry;
|
||||
|
||||
best = entry->mSupport;
|
||||
// If there is support for this language, an empty font list indicates
|
||||
// that the list hasn't been initialized yet.
|
||||
if (best == FcLangDifferentLang || entry->mFonts.Length() > 0)
|
||||
return entry;
|
||||
mNonExistingFonts.AppendCString(aFontName);
|
||||
result = 0;
|
||||
}
|
||||
|
||||
// This FcFontSet is owned by fontconfig
|
||||
FcFontSet *fontSet = FcConfigGetFonts(NULL, FcSetSystem);
|
||||
|
||||
nsAutoTArray<FcPattern*,100> fonts;
|
||||
|
||||
for (int f = 0; f < fontSet->nfont; ++f) {
|
||||
FcPattern *font = fontSet->fonts[f];
|
||||
|
||||
FcLangResult support = GetLangSupport(font, aLang);
|
||||
|
||||
if (support < best) { // lower is better
|
||||
best = support;
|
||||
if (aWithFonts) {
|
||||
fonts.Clear();
|
||||
} else if (best == FcLangEqual) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// The font list in the LangSupportEntry is expected to be used only
|
||||
// when no default fonts support the language. There would be a large
|
||||
// number of fonts in entries for languages using Latin script but
|
||||
// these do not need to be created because default fonts already
|
||||
// support these languages.
|
||||
if (aWithFonts && support != FcLangDifferentLang && support == best) {
|
||||
fonts.AppendElement(font);
|
||||
}
|
||||
}
|
||||
|
||||
entry->mSupport = best;
|
||||
if (aWithFonts) {
|
||||
if (fonts.Length() != 0) {
|
||||
entry->mFonts.AppendElements(fonts.Elements(), fonts.Length());
|
||||
} else if (best != FcLangDifferentLang) {
|
||||
// Previously there was a font that supported this language at the
|
||||
// level of entry->mSupport, but it has now disappeared. At least
|
||||
// entry->mSupport needs to be recalculated, but this is an
|
||||
// indication that the set of installed fonts has changed, so
|
||||
// update all caches.
|
||||
mLastConfig = NULL; // invalidates caches
|
||||
UpdateFontListInternal(PR_TRUE);
|
||||
return GetLangSupportEntry(aLang, aWithFonts);
|
||||
}
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
||||
FcLangResult
|
||||
gfxFontconfigUtils::GetBestLangSupport(const FcChar8 *aLang)
|
||||
{
|
||||
UpdateFontListInternal();
|
||||
|
||||
LangSupportEntry *entry = GetLangSupportEntry(aLang, PR_FALSE);
|
||||
if (!entry)
|
||||
return FcLangEqual;
|
||||
|
||||
return entry->mSupport;
|
||||
}
|
||||
|
||||
const nsTArray< nsCountedRef<FcPattern> >&
|
||||
gfxFontconfigUtils::GetFontsForLang(const FcChar8 *aLang)
|
||||
{
|
||||
LangSupportEntry *entry = GetLangSupportEntry(aLang, PR_TRUE);
|
||||
if (!entry)
|
||||
return EmptyPatternArray();
|
||||
|
||||
return entry->mFonts;
|
||||
end:
|
||||
if (pat)
|
||||
FcPatternDestroy(pat);
|
||||
if (os)
|
||||
FcObjectSetDestroy(os);
|
||||
if (fs)
|
||||
FcFontSetDestroy(fs);
|
||||
return result;
|
||||
}
|
||||
|
||||
PRBool
|
||||
|
|
@ -937,3 +746,4 @@ gfxFontNameList::Exists(nsAString& aName) {
|
|||
}
|
||||
return PR_FALSE;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@
|
|||
*
|
||||
* Contributor(s):
|
||||
* Masayuki Nakano <masayuki@d-toybox.com>
|
||||
* Karl Tomlinson <karlt+@karlt.net>, Mozilla Corporation
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of
|
||||
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
||||
|
|
@ -41,40 +40,15 @@
|
|||
|
||||
#include "gfxPlatform.h"
|
||||
|
||||
#include "nsAutoRef.h"
|
||||
#include "nsTArray.h"
|
||||
#include "nsTHashtable.h"
|
||||
#include "nsDataHashtable.h"
|
||||
|
||||
#include <fontconfig/fontconfig.h>
|
||||
|
||||
|
||||
NS_SPECIALIZE_TEMPLATE
|
||||
class nsAutoRefTraits<FcPattern> : public nsPointerRefTraits<FcPattern>
|
||||
{
|
||||
public:
|
||||
static void Release(FcPattern *ptr) { FcPatternDestroy(ptr); }
|
||||
static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
|
||||
};
|
||||
|
||||
NS_SPECIALIZE_TEMPLATE
|
||||
class nsAutoRefTraits<FcFontSet> : public nsPointerRefTraits<FcFontSet>
|
||||
{
|
||||
public:
|
||||
static void Release(FcFontSet *ptr) { FcFontSetDestroy(ptr); }
|
||||
};
|
||||
|
||||
NS_SPECIALIZE_TEMPLATE
|
||||
class nsAutoRefTraits<FcCharSet> : public nsPointerRefTraits<FcCharSet>
|
||||
{
|
||||
public:
|
||||
static void Release(FcCharSet *ptr) { FcCharSetDestroy(ptr); }
|
||||
};
|
||||
|
||||
|
||||
class gfxFontNameList : public nsTArray<nsString>
|
||||
{
|
||||
public:
|
||||
THEBES_INLINE_DECL_REFCOUNTING(gfxFontNameList)
|
||||
THEBES_INLINE_DECL_REFCOUNTING(gfxFontList)
|
||||
PRBool Exists(nsAString& aName);
|
||||
};
|
||||
|
||||
|
|
@ -102,42 +76,9 @@ public:
|
|||
|
||||
nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
|
||||
|
||||
const nsTArray< nsCountedRef<FcPattern> >&
|
||||
GetFontsForFamily(const FcChar8 *aFamilyName);
|
||||
|
||||
// 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 char *ToCString(const FcChar8 *aChar8Ptr)
|
||||
{
|
||||
return reinterpret_cast<const char*>(aChar8Ptr);
|
||||
}
|
||||
|
||||
static PRUint8 GetThebesStyle(FcPattern *aPattern); // slant
|
||||
static PRUint16 GetThebesWeight(FcPattern *aPattern);
|
||||
|
||||
static int GetFcSlant(const gfxFontStyle& aFontStyle);
|
||||
// Returns a precise FC_WEIGHT from CSS weight |aBaseWeight|.
|
||||
static int FcWeightForBaseWeight(PRInt8 aBaseWeight);
|
||||
|
||||
// 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 nsStringArray& aFamilies, const gfxFontStyle& aFontStyle,
|
||||
const char *aLang);
|
||||
|
||||
/**
|
||||
* @param aLangGroup [in] a Mozilla langGroup.
|
||||
* @param aFcLang [out] returns a language suitable for fontconfig
|
||||
|
|
@ -147,133 +88,23 @@ public:
|
|||
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) {
|
||||
PRUint32 hash = 0;
|
||||
for (const FcChar8* c = aKey; *c != '\0'; ++c) {
|
||||
hash = PR_ROTATE_LEFT32(hash, 3) ^ FcToLower(*c);
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
enum { ALLOW_MEMMOVE = PR_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
|
||||
// blank. The caller of PutEntry() must fill in mKey when NULL. This
|
||||
// provides a mechanism for the caller of PutEntry() to determine
|
||||
// whether the entry has been initialized.
|
||||
DepFcStrEntry(KeyTypePointer aName)
|
||||
: mKey(NULL) { }
|
||||
|
||||
DepFcStrEntry(const DepFcStrEntry& toCopy)
|
||||
: mKey(toCopy.mKey) { }
|
||||
|
||||
PRBool 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.
|
||||
CopiedFcStrEntry(KeyTypePointer aName) {
|
||||
mKey.SetIsVoid(PR_TRUE);
|
||||
}
|
||||
|
||||
CopiedFcStrEntry(const CopiedFcStrEntry& toCopy)
|
||||
: mKey(toCopy.mKey) { }
|
||||
|
||||
PRBool KeyEquals(KeyTypePointer aKey) const {
|
||||
return FcStrCmpIgnoreCase(aKey, ToFcChar8(mKey.get())) == 0;
|
||||
}
|
||||
|
||||
PRBool IsKeyInitialized() { return !mKey.IsVoid(); }
|
||||
void InitKey(const FcChar8* aKey) { mKey.Assign(ToCString(aKey)); }
|
||||
|
||||
private:
|
||||
nsCString mKey;
|
||||
};
|
||||
|
||||
protected:
|
||||
class FontsByFcStrEntry : public DepFcStrEntry {
|
||||
public:
|
||||
FontsByFcStrEntry(KeyTypePointer aName)
|
||||
: DepFcStrEntry(aName) { }
|
||||
|
||||
FontsByFcStrEntry(const FontsByFcStrEntry& toCopy)
|
||||
: DepFcStrEntry(toCopy), mFonts(toCopy.mFonts) { }
|
||||
|
||||
PRBool AddFont(FcPattern *aFont) {
|
||||
return mFonts.AppendElement(aFont) != nsnull;
|
||||
}
|
||||
const nsTArray< nsCountedRef<FcPattern> >& GetFonts() {
|
||||
return mFonts;
|
||||
}
|
||||
private:
|
||||
nsTArray< nsCountedRef<FcPattern> > mFonts;
|
||||
};
|
||||
|
||||
class LangSupportEntry : public CopiedFcStrEntry {
|
||||
public:
|
||||
LangSupportEntry(KeyTypePointer aName)
|
||||
: CopiedFcStrEntry(aName) { }
|
||||
|
||||
LangSupportEntry(const LangSupportEntry& toCopy)
|
||||
: CopiedFcStrEntry(toCopy), mSupport(toCopy.mSupport) { }
|
||||
|
||||
FcLangResult mSupport;
|
||||
nsTArray< nsCountedRef<FcPattern> > mFonts;
|
||||
};
|
||||
|
||||
static gfxFontconfigUtils* sUtils;
|
||||
|
||||
PRBool IsExistingFamily(const nsCString& aFamilyName);
|
||||
PRInt32 IsExistingFont(const nsACString& aFontName);
|
||||
nsresult GetResolvedFonts(const nsACString& aName,
|
||||
gfxFontNameList* aResult);
|
||||
|
||||
nsresult GetFontListInternal(nsCStringArray& aListOfFonts,
|
||||
const nsACString& aLangGroup);
|
||||
const nsACString *aLangGroup = nsnull);
|
||||
nsresult UpdateFontListInternal(PRBool aForce = PR_FALSE);
|
||||
|
||||
LangSupportEntry *GetLangSupportEntry(const FcChar8 *aLang,
|
||||
PRBool aWithFonts);
|
||||
|
||||
nsTHashtable<FontsByFcStrEntry> mFontsByFamily;
|
||||
nsTHashtable<LangSupportEntry> mLangSupportTable;
|
||||
|
||||
nsCStringArray mFonts;
|
||||
nsCStringArray mNonExistingFonts;
|
||||
nsCStringArray mAliasForSingleFont;
|
||||
nsCStringArray mAliasForMultiFonts;
|
||||
|
||||
nsDataHashtable<nsCStringHashKey, nsRefPtr<gfxFontNameList> > mAliasTable;
|
||||
|
||||
FcConfig *mLastConfig;
|
||||
};
|
||||
|
||||
|
|
|
|||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
Загрузка…
Ссылка в новой задаче