Remove SkPaintOptionsAndroid

src/ports/SkFontConfigParser_android.cpp

 /*
  * Copyright 2011 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigParser_android.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
@@ skipping 91 matching lines @@
         size_t valueLen = strlen(value);
         if (nameLen == 4 && !strncmp("name", name, nameLen)) {
             SkAutoAsciiToLC tolc(value);
             family->fNames.push_back().set(tolc.lc());
             family->fIsFallbackFont = false;
         } else if (nameLen == 4 && !strncmp("lang", name, nameLen)) {
             family->fLanguage = SkLanguage (value);
         } else if (nameLen == 7 && !strncmp("variant", name, nameLen)) {
             // Value should be either elegant or compact.
             if (valueLen == 7 && !strncmp("elegant", value, valueLen)) {
-                family->fVariant = SkPaintOptionsAndroid::kElegant_Variant;
+                family->fVariant = kElegant_FontVariant;
             } else if (valueLen == 7 && !strncmp("compact", value, valueLen)) {
-                family->fVariant = SkPaintOptionsAndroid::kCompact_Variant;
+                family->fVariant = kCompact_FontVariant;
             }
         }
     }
 }
 
 void fontFileNameHandler(void* data, const char* s, int len) {
     FamilyData* familyData = (FamilyData*) data;
     familyData->currentFontInfo->fFileName.set(s, len);
 }
 
-void familyElementEndHandler(FontFamily* family) {
-    for (int i = 0; i < family->fFonts.count(); i++) {
-        family->fFonts[i].fPaintOptions.setLanguage(family->fLanguage);
-        family->fFonts[i].fPaintOptions.setFontVariant(family->fVariant);
-    }
-}
-
 void fontElementHandler(XML_Parser* parser, FontFileInfo* file, const char** attributes) {
     // A <font> should have weight (integer) and style (normal, italic) attributes.
     // NOTE: we ignore the style.
     // The element should contain a filename.
     for (size_t i = 0; attributes[i] != NULL &&
                        attributes[i+1] != NULL; i += 2) {
         const char* name = attributes[i];
         const char* value = attributes[i+1];
         size_t nameLen = strlen(name);
         if (nameLen == 6 && !strncmp("weight", name, nameLen)) {
@@ skipping 129 matching lines @@
         aliasElementHandler(familyData, attributes);
     }
 }
 
 void endElementHandler(void* data, const char* tag) {
     FamilyData* familyData = (FamilyData*) data;
     size_t len = strlen(tag);
     if (len == 9 && strncmp(tag, "familyset", len) == 0) {
         familysetElementEndHandler(familyData);
     } else if (len == 6 && strncmp(tag, "family", len) == 0) {
-        familyElementEndHandler(familyData->currentFamily);
         *familyData->families.append() = familyData->currentFamily;
         familyData->currentFamily = NULL;
     } else if (len == 4 && !strncmp(tag, "font", len)) {
         XML_SetCharacterDataHandler(*familyData->parser, NULL);
     }
 }
 
 } // lmpParser
 
 namespace jbParser {
@@ skipping 33 matching lines @@
     FontFileInfo& newFileInfo = familyData->currentFamily->fFonts.push_back();
     if (attributes) {
         size_t currentAttributeIndex = 0;
         while (attributes[currentAttributeIndex] &&
                attributes[currentAttributeIndex + 1]) {
             const char* attributeName = attributes[currentAttributeIndex];
             const char* attributeValue = attributes[currentAttributeIndex+1];
             size_t nameLength = strlen(attributeName);
             size_t valueLength = strlen(attributeValue);
             if (nameLength == 7 && strncmp(attributeName, "variant", nameLength) == 0) {
+                const FontVariant prevVariant = familyData->currentFamily->fVariant;
                 if (valueLength == 7 && strncmp(attributeValue, "elegant", valueLength) == 0) {
-                    newFileInfo.fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kElegant_Variant);
+                    familyData->currentFamily->fVariant = kElegant_FontVariant;
                 } else if (valueLength == 7 &&
                            strncmp(attributeValue, "compact", valueLength) == 0) {
-                    newFileInfo.fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kCompact_Variant);
+                    familyData->currentFamily->fVariant = kCompact_FontVariant;
                 }
+                if (familyData->currentFamily->fFonts.count() > 1 &&
+                        familyData->currentFamily->fVariant != prevVariant) {
+                    SkDebugf("Every font file within a family must have identical variants");
+                    sk_throw();
+                }
+
             } else if (nameLength == 4 && strncmp(attributeName, "lang", nameLength) == 0) {
-                newFileInfo.fPaintOptions.setLanguage(attributeValue);
+                SkLanguage prevLang = familyData->currentFamily->fLanguage;
+                familyData->currentFamily->fLanguage = SkLanguage(attributeValue);
+                if (familyData->currentFamily->fFonts.count() > 1 &&
+                        familyData->currentFamily->fLanguage != prevLang) {
+                    SkDebugf("Every font file within a family must have identical languages");
+                    sk_throw();
+                }
             } else if (nameLength == 5 && strncmp(attributeName, "index", nameLength) == 0) {
                 int value;
                 if (parseNonNegativeInteger(attributeValue, &value)) {
                     newFileInfo.fIndex = value;
                 } else {
                     SkDebugf("---- SystemFonts index=%s (INVALID)", attributeValue);
                 }
             }
             //each element is a pair of attributeName/attributeValue string pairs
             currentAttributeIndex += 2;
@@ skipping 153 matching lines @@
                                 fileName.size() - fixedLen);
 
                 SkString absoluteFilename;
                 absoluteFilename.printf("%s/%s", dir, fileName.c_str());
 
                 SkTDArray<FontFamily*> langSpecificFonts;
                 parseConfigFile(absoluteFilename.c_str(), langSpecificFonts);
 
                 for (int i = 0; i < langSpecificFonts.count(); ++i) {
                     FontFamily* family = langSpecificFonts[i];
-                    for (int j = 0; j < family->fFonts.count(); ++j) {
-                        family->fFonts[j].fPaintOptions.setLanguage(locale);
-                    }
+                    family->fLanguage = SkLanguage(locale);
                     *fallbackFonts.append() = family;
                 }
             }
 
             // proceed to the next entry in the directory
             dirEntry = readdir(fontDirectory);
         }
         // cleanup the directory reference
         closedir(fontDirectory);
     }
@@ skipping 57 matching lines @@
     if (NULL != testFallbackConfigFile) {
         parseConfigFile(testFallbackConfigFile, fallbackFonts);
     }
 
     // Append all fallback fonts to system fonts
     for (int i = 0; i < fallbackFonts.count(); ++i) {
         fallbackFonts[i]->fIsFallbackFont = true;
         *fontFamilies.append() = fallbackFonts[i];
     }
 }
+
+SkLanguage SkLanguage::getParent() const {
+    SkASSERT(!fTag.isEmpty());
+    const char* tag = fTag.c_str();
+
+    // strip off the rightmost "-.*"
+    const char* parentTagEnd = strrchr(tag, '-');
+    if (parentTagEnd == NULL) {
+        return SkLanguage();
+    }
+    size_t parentTagLen = parentTagEnd - tag;
+    return SkLanguage(tag, parentTagLen);
+}