merge in ics-release history after reset to master
diff --git a/src/ports/SkFontHost_android.cpp b/src/ports/SkFontHost_android.cpp
index 2b3d976..bccd869 100644
--- a/src/ports/SkFontHost_android.cpp
+++ b/src/ports/SkFontHost_android.cpp
@@ -73,29 +73,17 @@
static SkTDArray<NameFamilyPair> gNameList;
struct FamilyRec {
- FamilyRec* fPrev;
FamilyRec* fNext;
SkTypeface* fFaces[4];
FamilyRec()
{
- static FamilyRec* tail = 0;
- if (!gFamilyHead) {
- gFamilyHead = this;
- }
- fPrev = tail;
- fNext = 0;
+ fNext = gFamilyHead;
memset(fFaces, 0, sizeof(fFaces));
- if (tail) {
- tail->fNext = this;
- }
- tail = this;
-// SkDebugf("FamilyRec::FamilyRec(%p) fPrev=%p fNext=%p fFaces=[%p,%p,%p,%p]",
-// this, fPrev, fNext, fFaces[0], fFaces[1], fFaces[2], fFaces[3]);
+ gFamilyHead = this;
}
};
-// Styles are spread across a family. Fallback fonts, as a whole, are treated as one family
static SkTypeface* find_best_face(const FamilyRec* family,
SkTypeface::Style style) {
SkTypeface* const* faces = family->fFaces;
@@ -173,20 +161,26 @@
return family; // return the empty family
}
+// maybe we should make FamilyRec be doubly-linked
static void detach_and_delete_family(FamilyRec* family) {
- FamilyRec* prev = family->fPrev;
- FamilyRec* next = family->fNext;
+ FamilyRec* curr = gFamilyHead;
+ FamilyRec* prev = NULL;
- if (family == gFamilyHead) {
- gFamilyHead = next;
+ while (curr != NULL) {
+ FamilyRec* next = curr->fNext;
+ if (curr == family) {
+ if (prev == NULL) {
+ gFamilyHead = next;
+ } else {
+ prev->fNext = next;
+ }
+ SkDELETE(family);
+ return;
+ }
+ prev = curr;
+ curr = next;
}
- if (prev) {
- prev->fNext = next;
- }
- if (next) {
- next->fPrev = prev;
- }
- SkDELETE(family);
+ SkASSERT(!"Yikes, couldn't find family in our list to remove/delete");
}
static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) {
@@ -371,7 +365,8 @@
///////////////////////////////////////////////////////////////////////////////
static bool get_name_and_style(const char path[], SkString* name,
- SkTypeface::Style* style, bool* isFixedWidth) {
+ SkTypeface::Style* style,
+ bool* isFixedWidth, bool isExpected) {
SkString fullpath;
GetFullPathForSysFonts(&fullpath, path);
@@ -387,7 +382,10 @@
return true;
}
}
- SkDebugf("get_name_and_style() 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;
}
@@ -430,14 +428,11 @@
them in the order we want them to be accessed by NextLogicalFont().
*/
{ "DroidSansArabic.ttf", gFBNames },
- { "DroidSansHebrew-Regular.ttf",gFBNames },
- { "DroidSansHebrew-Bold.ttf", NULL },
+ { "DroidSansHebrew.ttf", gFBNames },
{ "DroidSansThai.ttf", gFBNames },
{ "MTLmr3m.ttf", gFBNames }, // Motoya Japanese Font
{ "MTLc3m.ttf", gFBNames }, // Motoya Japanese Font
{ "DroidSansJapanese.ttf", gFBNames },
- { "DroidSansEthiopic-Regular.ttf",gFBNames },
- { "DroidSansEthiopic-Bold.ttf", NULL },
{ "DroidSansFallback.ttf", gFBNames }
};
@@ -447,10 +442,14 @@
static FamilyRec* gDefaultFamily;
static SkTypeface* gDefaultNormal;
-/* Fallback fonts are a segment of the linked list that starts at gFamilyHead,
- configured by 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 FamilyRec* gFallbackHead;
+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.
@@ -463,6 +462,7 @@
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
@@ -475,8 +475,9 @@
SkTypeface::Style style;
// we expect all the fonts, except the "fallback" fonts
- // after one fallback is received, all the rest are fallbacks, too
- if (!get_name_and_style(rec[i].fFileName, &name, &style, &isFixedWidth)) {
+ bool isExpected = (rec[i].fNames != gFBNames);
+ if (!get_name_and_style(rec[i].fFileName, &name, &style,
+ &isFixedWidth, isExpected)) {
continue;
}
@@ -488,10 +489,14 @@
isFixedWidth) // filename
);
-// SkDebugf("load_system_fonts() %s, %d, %d, %d\n",
-// rec[i].fFileName, style, firstInFamily, tf->uniqueID());
-
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;
@@ -505,20 +510,14 @@
add_name(*names, family);
names += 1;
}
- // see if this is one of our fallback fonts
- if (rec[i].fNames == gFBNames) {
- if (!gFallbackHead) {
- // record the first of the fallback families
- gFallbackHead = family;
- }
- }
-
}
}
// 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;
}
///////////////////////////////////////////////////////////////////////////////
@@ -583,15 +582,13 @@
if (NULL != familyFace) {
tf = find_typeface(familyFace, style);
-// SkDebugf("SkFontHost::CreateTypeface find_typeface for familyFace returns %p", tf);
} else if (NULL != familyName) {
+// SkDebugf("======= familyName <%s>\n", familyName);
tf = find_typeface(familyName, style);
-// SkDebugf("SkFontHost::CreateTypeface find_typeface for familyName returns %p", tf);
}
if (NULL == tf) {
tf = find_best_face(gDefaultFamily, style);
-// SkDebugf("SkFontHost::CreateTypeface find_best_face for gDefaultFamily returns %p", tf);
}
// we ref(), since the symantic is to return a new instance
@@ -647,27 +644,13 @@
in our list. Note: list is zero-terminated, and returning zero means
we have no more fonts to use for fallbacks.
*/
-
- SkTypeface* origTypeface = find_from_uniqueID(origFontID);
- SkTypeface::Style origStyle = origTypeface ? origTypeface->style() : SkTypeface::kNormal;
-
- FamilyRec* family = gFallbackHead;
- while (family) {
- SkTypeface* typeface = find_best_face(family, origStyle);
- family = family->fNext;
- if (typeface && typeface->uniqueID() == currFontID) {
- if (family) {
- return find_best_face(family, origStyle)->uniqueID();
- } else {
- return 0;
- }
+ const uint32_t* list = gFallbackFonts;
+ for (int i = 0; list[i] != 0; i++) {
+ if (list[i] == currFontID) {
+ return list[i+1];
}
}
-
- if (gFallbackHead) {
- return find_best_face(gFallbackHead, origStyle)->uniqueID();
- }
- return 0;
+ return list[0];
}
///////////////////////////////////////////////////////////////////////////////
