From fcce647c0bec614a3dbfbf672a8c1297fe79e58c Mon Sep 17 00:00:00 2001 From: "reed@android.com" Date: Fri, 20 Mar 2009 12:23:07 +0000 Subject: [PATCH] pull latest from android git-svn-id: http://skia.googlecode.com/svn/trunk@132 2bbb7eff-a529-9590-31e7-b0007b416f81 --- src/ports/SkFontHost_android.cpp | 144 ++++++++++++++++--------------- 1 file changed, 75 insertions(+), 69 deletions(-) diff --git a/src/ports/SkFontHost_android.cpp b/src/ports/SkFontHost_android.cpp index 6ee75dc5d3..e6d134a583 100644 --- a/src/ports/SkFontHost_android.cpp +++ b/src/ports/SkFontHost_android.cpp @@ -33,8 +33,7 @@ SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name); -static void GetFullPathForSysFonts(SkString* full, const char name[]) -{ +static void GetFullPathForSysFonts(SkString* full, const char name[]) { full->set(getenv("ANDROID_ROOT")); full->append(SK_FONT_FILE_PREFIX); full->append(name); @@ -53,13 +52,12 @@ struct NameFamilyPair { const char* fName; // we own this FamilyRec* fFamily; // we don't own this, we just reference it - void construct(const char name[], FamilyRec* family) - { + void construct(const char name[], FamilyRec* family) { fName = strdup(name); fFamily = family; // we don't own this, so just record the referene } - void destruct() - { + + void destruct() { free((char*)fName); // we don't own family, so just ignore our reference } @@ -86,8 +84,7 @@ struct FamilyRec { }; static SkTypeface* find_best_face(const FamilyRec* family, - SkTypeface::Style style) -{ + SkTypeface::Style style) { SkTypeface* const* faces = family->fFaces; if (faces[style] != NULL) { // exact match @@ -113,8 +110,7 @@ static SkTypeface* find_best_face(const FamilyRec* family, return NULL; } -static FamilyRec* find_family(const SkTypeface* member) -{ +static FamilyRec* find_family(const SkTypeface* member) { FamilyRec* curr = gFamilyHead; while (curr != NULL) { for (int i = 0; i < 4; i++) { @@ -130,8 +126,7 @@ static FamilyRec* find_family(const SkTypeface* member) /* Returns the matching typeface, or NULL. If a typeface is found, its refcnt is not modified. */ -static SkTypeface* find_from_uniqueID(uint32_t uniqueID) -{ +static SkTypeface* find_from_uniqueID(uint32_t uniqueID) { FamilyRec* curr = gFamilyHead; while (curr != NULL) { for (int i = 0; i < 4; i++) { @@ -148,8 +143,7 @@ static SkTypeface* find_from_uniqueID(uint32_t uniqueID) /* Remove reference to this face from its family. If the resulting family is empty (has no faces), return that family, otherwise return NULL */ -static FamilyRec* remove_from_family(const SkTypeface* face) -{ +static FamilyRec* remove_from_family(const SkTypeface* face) { FamilyRec* family = find_family(face); SkASSERT(family->fFaces[face->style()] == face); family->fFaces[face->style()] = NULL; @@ -163,8 +157,7 @@ static FamilyRec* remove_from_family(const SkTypeface* face) } // maybe we should make FamilyRec be doubly-linked -static void detach_and_delete_family(FamilyRec* family) -{ +static void detach_and_delete_family(FamilyRec* family) { FamilyRec* curr = gFamilyHead; FamilyRec* prev = NULL; @@ -185,8 +178,7 @@ static void detach_and_delete_family(FamilyRec* family) SkASSERT(!"Yikes, couldn't find family in our list to remove/delete"); } -static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) -{ +static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) { NameFamilyPair* list = gNameList.begin(); int count = gNameList.count(); @@ -199,14 +191,12 @@ static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) } static SkTypeface* find_typeface(const SkTypeface* familyMember, - SkTypeface::Style style) -{ + SkTypeface::Style style) { const FamilyRec* family = find_family(familyMember); return family ? find_best_face(family, style) : NULL; } -static void add_name(const char name[], FamilyRec* family) -{ +static void add_name(const char name[], FamilyRec* family) { SkAutoAsciiToLC tolc(name); name = tolc.lc(); @@ -246,8 +236,7 @@ static void remove_from_names(FamilyRec* emptyFamily) class FamilyTypeface : public SkTypeface { public: FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember) - : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1) - { + : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1) { fIsSysFont = sysFont; SkAutoMutexAcquire ac(gFamilyMutex); @@ -262,8 +251,7 @@ public: rec->fFaces[style] = this; } - virtual ~FamilyTypeface() - { + virtual ~FamilyTypeface() { SkAutoMutexAcquire ac(gFamilyMutex); // remove us from our family. If the family is now empty, we return @@ -292,8 +280,7 @@ class StreamTypeface : public FamilyTypeface { public: StreamTypeface(Style style, bool sysFont, SkTypeface* familyMember, SkStream* stream) - : INHERITED(style, sysFont, familyMember) - { + : INHERITED(style, sysFont, familyMember) { SkASSERT(stream); stream->ref(); fStream = stream; @@ -321,8 +308,7 @@ class FileTypeface : public FamilyTypeface { public: FileTypeface(Style style, bool sysFont, SkTypeface* familyMember, const char path[]) - : INHERITED(style, sysFont, familyMember) - { + : INHERITED(style, sysFont, familyMember) { SkString fullpath; if (sysFont) { @@ -333,8 +319,7 @@ public: } // overrides - virtual SkStream* openStream() - { + virtual SkStream* openStream() { SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str())); // check for failure @@ -367,8 +352,7 @@ private: /////////////////////////////////////////////////////////////////////////////// static bool get_name_and_style(const char path[], SkString* name, - SkTypeface::Style* style) -{ + SkTypeface::Style* style, bool isExpected) { SkString fullpath; GetFullPathForSysFonts(&fullpath, path); @@ -385,10 +369,13 @@ static bool get_name_and_style(const char path[], SkString* name, } } - SkDebugf("---- failed to open <%s> as a font\n", fullpath.c_str()); + if (isExpected) { + SkDebugf("---- failed to open <%s> as a font\n", fullpath.c_str()); + } return false; } +// used to record our notion of the pre-existing fonts struct FontInitRec { const char* fFileName; const char* const* fNames; // null-terminated list @@ -407,6 +394,7 @@ static const char* gMonoNames[] = { "monospace", "courier", "courier new", "monaco", NULL }; +// deliberately empty, but we use the address to identify fallback fonts static const char* gFBNames[] = { NULL }; /* Fonts must be grouped by family, with the first font in a family having the @@ -421,29 +409,41 @@ static const FontInitRec gSystemFonts[] = { { "DroidSerif-Italic.ttf", NULL }, { "DroidSerif-BoldItalic.ttf", NULL }, { "DroidSansMono.ttf", gMonoNames }, -#ifdef NO_FALLBACK_FONT - { "DroidSans.ttf", gFBNames } -#else + /* These are optional, and can be ignored if not found in the file system. + These are appended to gFallbackFonts[] as they are seen, so we list + them in the order we want them to be accessed by NextLogicalFont(). + */ + { "DroidSansJapanese.ttf", gFBNames }, { "DroidSansFallback.ttf", gFBNames } -#endif }; #define DEFAULT_NAMES gSansNames // these globals are assigned (once) by load_system_fonts() -static SkTypeface* gFallBackTypeface; static FamilyRec* gDefaultFamily; static SkTypeface* gDefaultNormal; -static void load_system_fonts() -{ +/* This is sized conservatively, assuming that it will never be a size issue. + It will be initialized in load_system_fonts(), and will be filled with the + fontIDs that can be used for fallback consideration, in sorted order (sorted + meaning element[0] should be used first, then element[1], etc. When we hit + a fontID==0 in the array, the list is done, hence our allocation size is + +1 the total number of possible system fonts. Also see NextLogicalFont(). + */ +static uint32_t gFallbackFonts[SK_ARRAY_COUNT(gSystemFonts)+1]; + +/* Called once (ensured by the sentinel check at the beginning of our body). + Initializes all the globals, and register the system fonts. + */ +static void load_system_fonts() { // check if we've already be called if (NULL != gDefaultNormal) { return; } - + const FontInitRec* rec = gSystemFonts; SkTypeface* firstInFamily = NULL; + int fallbackCount = 0; for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) { // if we're the first in a new family, clear firstInFamily @@ -453,9 +453,10 @@ static void load_system_fonts() SkString name; SkTypeface::Style style; - - if (!get_name_and_style(rec[i].fFileName, &name, &style)) { - SkDebugf("------ can't load <%s> as a font\n", rec[i].fFileName); + + // we expect all the fonts, except the "fallback" fonts + bool isExpected = (rec[i].fNames != gFBNames); + if (!get_name_and_style(rec[i].fFileName, &name, &style, isExpected)) { continue; } @@ -467,30 +468,34 @@ static void load_system_fonts() ); if (rec[i].fNames != NULL) { + // see if this is one of our fallback fonts + if (rec[i].fNames == gFBNames) { + // SkDebugf("---- adding %s as fallback[%d] fontID %d\n", + // rec[i].fFileName, fallbackCount, tf->uniqueID()); + gFallbackFonts[fallbackCount++] = tf->uniqueID(); + } + firstInFamily = tf; + FamilyRec* family = find_family(tf); const char* const* names = rec[i].fNames; - // record the fallback if this is it - if (names == gFBNames) { - gFallBackTypeface = tf; - } // record the default family if this is it if (names == DEFAULT_NAMES) { - gDefaultFamily = find_family(tf); + gDefaultFamily = family; } // add the names to map to this family - FamilyRec* family = find_family(tf); while (*names) { add_name(*names, family); names += 1; } } - } // do this after all fonts are loaded. This is our default font, and it // acts as a sentinel so we only execute load_system_fonts() once gDefaultNormal = find_best_face(gDefaultFamily, SkTypeface::kNormal); + // now terminate our fallback list with the sentinel value + gFallbackFonts[fallbackCount] = 0; } /////////////////////////////////////////////////////////////////////////////// @@ -542,8 +547,7 @@ SkTypeface* SkFontHost::Deserialize(SkStream* stream) { SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace, const char familyName[], - SkTypeface::Style style) -{ + SkTypeface::Style style) { load_system_fonts(); SkAutoMutexAcquire ac(gFamilyMutex); @@ -569,15 +573,13 @@ SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace, return tf; } -bool SkFontHost::ValidFontID(uint32_t fontID) -{ +bool SkFontHost::ValidFontID(uint32_t fontID) { SkAutoMutexAcquire ac(gFamilyMutex); return find_from_uniqueID(fontID) != NULL; } -SkStream* SkFontHost::OpenStream(uint32_t fontID) -{ +SkStream* SkFontHost::OpenStream(uint32_t fontID) { SkAutoMutexAcquire ac(gFamilyMutex); FamilyTypeface* tf = (FamilyTypeface*)find_from_uniqueID(fontID); @@ -593,17 +595,23 @@ SkStream* SkFontHost::OpenStream(uint32_t fontID) uint32_t SkFontHost::NextLogicalFont(uint32_t fontID) { load_system_fonts(); - if (gFallBackTypeface->uniqueID() == fontID) { - // no where to go, just return NULL - return 0; + /* First see if fontID is already one of our fallbacks. If so, return + its successor. If fontID is not in our list, then return the first one + in our list. Note: list is zero-terminated, and returning zero means + we have no more fonts to use for fallbacks. + */ + const uint32_t* list = gFallbackFonts; + for (int i = 0; list[i] != 0; i++) { + if (list[i] == fontID) { + return list[i+1]; + } } - return gFallBackTypeface->uniqueID(); + return list[0]; } /////////////////////////////////////////////////////////////////////////////// -SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) -{ +SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) { if (NULL == stream || stream->getLength() <= 0) { return NULL; } @@ -614,8 +622,7 @@ SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream)); } -SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) -{ +SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) { SkStream* stream = SkNEW_ARGS(SkMMAPStream, (path)); SkTypeface* face = SkFontHost::CreateTypefaceFromStream(stream); // since we created the stream, we let go of our ref() here @@ -625,8 +632,7 @@ SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) /////////////////////////////////////////////////////////////////////////////// -size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) -{ +size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) { if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET) return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET; else