OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 The Android Open Source Project | 2 * Copyright 2011 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #ifndef SKFONTCONFIGPARSER_ANDROID_H_ | 8 #ifndef SKFONTCONFIGPARSER_ANDROID_H_ |
9 #define SKFONTCONFIGPARSER_ANDROID_H_ | 9 #define SKFONTCONFIGPARSER_ANDROID_H_ |
10 | 10 |
11 #include "SkFontMgr_android.h" | 11 #include "SkFontMgr_android.h" |
12 #include "SkString.h" | 12 #include "SkString.h" |
13 #include "SkTDArray.h" | 13 #include "SkTDArray.h" |
14 | 14 |
| 15 #include <climits> |
| 16 #include <limits> |
| 17 |
15 /** \class SkLanguage | 18 /** \class SkLanguage |
16 | 19 |
17 The SkLanguage class represents a human written language, and is used by | 20 The SkLanguage class represents a human written language, and is used by |
18 text draw operations to determine which glyph to draw when drawing | 21 text draw operations to determine which glyph to draw when drawing |
19 characters with variants (ie Han-derived characters). | 22 characters with variants (ie Han-derived characters). |
20 */ | 23 */ |
21 class SkLanguage { | 24 class SkLanguage { |
22 public: | 25 public: |
23 SkLanguage() { } | 26 SkLanguage() { } |
24 SkLanguage(const SkString& tag) : fTag(tag) { } | 27 SkLanguage(const SkString& tag) : fTag(tag) { } |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 typedef uint32_t FontVariant; | 64 typedef uint32_t FontVariant; |
62 | 65 |
63 // Must remain trivially movable (can be memmoved). | 66 // Must remain trivially movable (can be memmoved). |
64 struct FontFileInfo { | 67 struct FontFileInfo { |
65 FontFileInfo() : fIndex(0), fWeight(0), fStyle(Style::kAuto) { } | 68 FontFileInfo() : fIndex(0), fWeight(0), fStyle(Style::kAuto) { } |
66 | 69 |
67 SkString fFileName; | 70 SkString fFileName; |
68 int fIndex; | 71 int fIndex; |
69 int fWeight; | 72 int fWeight; |
70 enum class Style { kAuto, kNormal, kItalic } fStyle; | 73 enum class Style { kAuto, kNormal, kItalic } fStyle; |
| 74 struct Axis { |
| 75 Axis() : fTag(SkSetFourByteTag('\0','\0','\0','\0')), fValue(0) { } |
| 76 SkFourByteTag fTag; |
| 77 SkFixed fValue; |
| 78 }; |
| 79 SkSTArray<4, Axis, true> fAxes; |
71 }; | 80 }; |
72 | 81 |
73 /** | 82 /** |
74 * A font family provides one or more names for a collection of fonts, each of | 83 * A font family provides one or more names for a collection of fonts, each of |
75 * which has a different style (normal, italic) or weight (thin, light, bold, | 84 * which has a different style (normal, italic) or weight (thin, light, bold, |
76 * etc). | 85 * etc). |
77 * Some fonts may occur in compact variants for use in the user interface. | 86 * Some fonts may occur in compact variants for use in the user interface. |
78 * Android distinguishes "fallback" fonts to support non-ASCII character sets. | 87 * Android distinguishes "fallback" fonts to support non-ASCII character sets. |
79 */ | 88 */ |
80 struct FontFamily { | 89 struct FontFamily { |
(...skipping 20 matching lines...) Expand all Loading... |
101 | 110 |
102 /** Parses font configuration files and appends result to fontFamilies. */ | 111 /** Parses font configuration files and appends result to fontFamilies. */ |
103 void GetCustomFontFamilies(SkTDArray<FontFamily*>& fontFamilies, | 112 void GetCustomFontFamilies(SkTDArray<FontFamily*>& fontFamilies, |
104 const SkString& basePath, | 113 const SkString& basePath, |
105 const char* fontsXml, | 114 const char* fontsXml, |
106 const char* fallbackFontsXml, | 115 const char* fallbackFontsXml, |
107 const char* langFallbackFontsDir = NULL); | 116 const char* langFallbackFontsDir = NULL); |
108 | 117 |
109 } // SkFontConfigParser namespace | 118 } // SkFontConfigParser namespace |
110 | 119 |
| 120 |
| 121 /** Parses a null terminated string into an integer type, checking for overflow. |
| 122 * http://www.w3.org/TR/html-markup/datatypes.html#common.data.integer.non-nega
tive-def |
| 123 * |
| 124 * If the string cannot be parsed into 'value', returns false and does not chan
ge 'value'. |
| 125 */ |
| 126 template <typename T> static bool parse_non_negative_integer(const char* s, T* v
alue) { |
| 127 SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer); |
| 128 |
| 129 if (*s == '\0') { |
| 130 return false; |
| 131 } |
| 132 |
| 133 const T nMax = std::numeric_limits<T>::max() / 10; |
| 134 const T dMax = std::numeric_limits<T>::max() - (nMax * 10); |
| 135 T n = 0; |
| 136 for (; *s; ++s) { |
| 137 // Check if digit |
| 138 if (*s < '0' || '9' < *s) { |
| 139 return false; |
| 140 } |
| 141 T d = *s - '0'; |
| 142 // Check for overflow |
| 143 if (n > nMax || (n == nMax && d > dMax)) { |
| 144 return false; |
| 145 } |
| 146 n = (n * 10) + d; |
| 147 } |
| 148 *value = n; |
| 149 return true; |
| 150 } |
| 151 |
| 152 /** Parses a null terminated string into a signed fixed point value with bias N. |
| 153 * |
| 154 * Like http://www.w3.org/TR/html-markup/datatypes.html#common.data.float-def , |
| 155 * but may start with '.' and does not support 'e'. '-?((:digit:+(.:digit:+)?)|
(.:digit:+))' |
| 156 * |
| 157 * Checks for overflow. |
| 158 * Low bit rounding is not defined (is currently truncate). |
| 159 * Bias (N) required to allow for the sign bit and 4 bits of integer. |
| 160 * |
| 161 * If the string cannot be parsed into 'value', returns false and does not chan
ge 'value'. |
| 162 */ |
| 163 template <int N, typename T> static bool parse_fixed(const char* s, T* value) { |
| 164 SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer); |
| 165 SK_COMPILE_ASSERT(std::numeric_limits<T>::is_signed, T_must_be_signed); |
| 166 SK_COMPILE_ASSERT(sizeof(T) * CHAR_BIT - N >= 5, N_must_leave_four_bits_plus
_sign); |
| 167 |
| 168 bool negate = false; |
| 169 if (*s == '-') { |
| 170 ++s; |
| 171 negate = true; |
| 172 } |
| 173 if (*s == '\0') { |
| 174 return false; |
| 175 } |
| 176 |
| 177 const T nMax = (std::numeric_limits<T>::max() >> N) / 10; |
| 178 const T dMax = (std::numeric_limits<T>::max() >> N) - (nMax * 10); |
| 179 T n = 0; |
| 180 T frac = 0; |
| 181 for (; *s; ++s) { |
| 182 // Check if digit |
| 183 if (*s < '0' || '9' < *s) { |
| 184 // If it wasn't a digit, check if it is a '.' followed by something. |
| 185 if (*s != '.' || s[1] == '\0') { |
| 186 return false; |
| 187 } |
| 188 // Find the end, verify digits. |
| 189 for (++s; *s; ++s) { |
| 190 if (*s < '0' || '9' < *s) { |
| 191 return false; |
| 192 } |
| 193 } |
| 194 // Read back toward the '.'. |
| 195 for (--s; *s != '.'; --s) { |
| 196 T d = *s - '0'; |
| 197 frac = (frac + (d << N)) / 10; // This requires four bits overhe
ad. |
| 198 } |
| 199 break; |
| 200 } |
| 201 T d = *s - '0'; |
| 202 // Check for overflow |
| 203 if (n > nMax || (n == nMax && d > dMax)) { |
| 204 return false; |
| 205 } |
| 206 n = (n * 10) + d; |
| 207 } |
| 208 if (negate) { |
| 209 n = -n; |
| 210 frac = -frac; |
| 211 } |
| 212 *value = (n << N) + frac; |
| 213 return true; |
| 214 } |
| 215 |
111 #endif /* SKFONTCONFIGPARSER_ANDROID_H_ */ | 216 #endif /* SKFONTCONFIGPARSER_ANDROID_H_ */ |
OLD | NEW |