Language and variant selection

This patch adds a "lang" pseudo-CSS property and uses it both to select
an appropriate font and control the "locl" OpenType feature to get the
most appropriate rendering for the langauge and script.  In addition,
the "-minikin-variant" property selects between "compact" and "elegant"
variants of a font, as the former is needed for vertically cramped
spaces.

This is part of the fix for bug 15179652 "Japanese font isn't shown on
LMP".

Change-Id: I7fab23c12d4c797a6d339a16e497b79a3afe9df1

3 files changed, 77 insertions, 10 deletions

diff --git a/include/minikin/CssParse.h b/include/minikin/CssParse.h
index 2dceb4a..519056d 100644
--- a/include/minikin/CssParse.h
+++ b/include/minikin/CssParse.h
@@ -25,26 +25,31 @@ namespace android {
 enum CssTag {
     unknown,
     fontSize,
-    fontWeight,
     fontStyle,
-    minikinHinting,
+    fontWeight,
+    cssLang,
     minikinBidi,
+    minikinHinting,
+    minikinVariant,
 };
 
 const std::string cssTagNames[] = {
     "unknown",
     "font-size",
-    "font-weight",
     "font-style",
-    "-minikin-hinting",
+    "font-weight",
+    "lang",
     "-minikin-bidi",
+    "-minikin-hinting",
+    "-minikin-variant",
 };
 
 class CssValue {
 public:
     enum Type {
         UNKNOWN,
-        FLOAT
+        FLOAT,
+        STRING
     };
     enum Units {
         SCALAR,
@@ -58,14 +63,20 @@ public:
     Type getType() const { return mType; }
     double getFloatValue() const { return floatValue; }
     int getIntValue() const { return floatValue; }
+    std::string getStringValue() const { return stringValue; }
     std::string toString(CssTag tag) const;
     void setFloatValue(double v) {
         mType = FLOAT;
         floatValue = v;
     }
+    void setStringValue(const std::string& v) {
+        mType = STRING;
+        stringValue = v;
+    }
 private:
     Type mType;
     double floatValue;
+    std::string stringValue;
     Units mUnits;
 };
 
@@ -85,4 +96,4 @@ private:
 
 }  // namespace android
 
-#endif  // MINIKIN_CSS_PARSE_H
\ No newline at end of file
+#endif  // MINIKIN_CSS_PARSE_H
diff --git a/include/minikin/FontCollection.h b/include/minikin/FontCollection.h
index c6c2ed0..a350237 100644
--- a/include/minikin/FontCollection.h
+++ b/include/minikin/FontCollection.h
@@ -32,7 +32,8 @@ public:
 
     ~FontCollection();
 
-    const FontFamily* getFamilyForChar(uint32_t ch) const;
+    const FontFamily* getFamilyForChar(uint32_t ch, FontLanguage lang, int variant) const;
+
     class Run {
     public:
         // Do copy constructor, assignment, destructor so it can be used in vectors
diff --git a/include/minikin/FontFamily.h b/include/minikin/FontFamily.h
index a4fe9cb..6bdf5d6 100644
--- a/include/minikin/FontFamily.h
+++ b/include/minikin/FontFamily.h
@@ -25,6 +25,36 @@
 
 namespace android {
 
+class MinikinFont;
+
+// FontLanguage is a compact representation of a bcp-47 language tag. It
+// does not capture all possible information, only what directly affects
+// font rendering.
+class FontLanguage {
+    friend class FontStyle;
+public:
+    FontLanguage() : mBits(0) { }
+
+    // Parse from string
+    FontLanguage(const char* buf, size_t size);
+
+    bool operator==(const FontLanguage other) const { return mBits == other.mBits; }
+
+    // 0 = no match, 1 = language matches, 2 = language and script match
+    int match(const FontLanguage other) const;
+
+private:
+    explicit FontLanguage(uint32_t bits) : mBits(bits) { }
+
+    uint32_t bits() const { return mBits; }
+
+    static const uint32_t kBaseLangMask = 0xffff;
+    static const uint32_t kScriptMask = (1 << 18) - (1 << 16);
+    static const uint32_t kHansFlag = 1 << 16;
+    static const uint32_t kHantFlag = 1 << 17;
+    uint32_t mBits;
+};
+
 // FontStyle represents all style information needed to select an actual font
 // from a collection. The implementation is packed into a single 32-bit word
 // so it can be efficiently copied, embedded in other objects, etc.
@@ -33,24 +63,44 @@ public:
     FontStyle(int weight = 4, bool italic = false) {
         bits = (weight & kWeightMask) | (italic ? kItalicMask : 0);
     }
+    FontStyle(FontLanguage lang, int variant = 0, int weight = 4, bool italic = false) {
+        bits = (weight & kWeightMask) | (italic ? kItalicMask : 0)
+                | (variant << kVariantShift) | (lang.bits() << kLangShift);
+    }
     int getWeight() const { return bits & kWeightMask; }
     bool getItalic() const { return (bits & kItalicMask) != 0; }
+    int getVariant() const { return (bits >> kVariantShift) & kVariantMask; }
+    FontLanguage getLanguage() const { return FontLanguage(bits >> kLangShift); }
+
     bool operator==(const FontStyle other) const { return bits == other.bits; }
-    // TODO: language, variant
 
     hash_t hash() const { return bits; }
 private:
-    static const int kWeightMask = 0xf;
-    static const int kItalicMask = 16;
+    static const uint32_t kWeightMask = (1 << 4) - 1;
+    static const uint32_t kItalicMask = 1 << 4;
+    static const int kVariantShift = 5;
+    static const uint32_t kVariantMask = (1 << 2) - 1;
+    static const int kLangShift = 7;
     uint32_t bits;
 };
 
+enum FontVariant {
+    VARIANT_DEFAULT = 0,
+    VARIANT_COMPACT = 1,
+    VARIANT_ELEGANT = 2,
+};
+
 inline hash_t hash_type(const FontStyle &style) {
     return style.hash();
 }
 
 class FontFamily : public MinikinRefCounted {
 public:
+    FontFamily() { }
+
+    FontFamily(FontLanguage lang, int variant) : mLang(lang), mVariant(variant) {
+    }
+
     ~FontFamily();
 
     // Add font to family, extracting style information from the font
@@ -59,6 +109,9 @@ public:
     void addFont(MinikinFont* typeface, FontStyle style);
     MinikinFont* getClosestMatch(FontStyle style) const;
 
+    FontLanguage lang() const { return mLang; }
+    int variant() const { return mVariant; }
+
     // API's for enumerating the fonts in a family. These don't guarantee any particular order
     size_t getNumFonts() const;
     MinikinFont* getFont(size_t index) const;
@@ -73,6 +126,8 @@ private:
         MinikinFont* typeface;
         FontStyle style;
     };
+    FontLanguage mLang;
+    int mVariant;
     std::vector<Font> mFonts;
 };