Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2018 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <jni.h> |
| 18 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 19 | #include <android/font.h> |
| 20 | #include <android/font_matcher.h> |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 21 | #include <android/system_fonts.h> |
| 22 | |
| 23 | #include <memory> |
| 24 | #include <string> |
| 25 | #include <vector> |
| 26 | |
| 27 | #include <errno.h> |
| 28 | #include <fcntl.h> |
| 29 | #include <libxml/tree.h> |
| 30 | #include <log/log.h> |
| 31 | #include <sys/stat.h> |
| 32 | #include <unistd.h> |
| 33 | |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 34 | #include <hwui/MinikinSkia.h> |
| 35 | #include <minikin/FontCollection.h> |
| 36 | #include <minikin/LocaleList.h> |
| 37 | #include <minikin/SystemFonts.h> |
| 38 | |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 39 | struct XmlCharDeleter { |
| 40 | void operator()(xmlChar* b) { xmlFree(b); } |
| 41 | }; |
| 42 | |
| 43 | struct XmlDocDeleter { |
| 44 | void operator()(xmlDoc* d) { xmlFreeDoc(d); } |
| 45 | }; |
| 46 | |
| 47 | using XmlCharUniquePtr = std::unique_ptr<xmlChar, XmlCharDeleter>; |
| 48 | using XmlDocUniquePtr = std::unique_ptr<xmlDoc, XmlDocDeleter>; |
| 49 | |
| 50 | struct ASystemFontIterator { |
| 51 | XmlDocUniquePtr mXmlDoc; |
| 52 | xmlNode* mFontNode; |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 53 | |
| 54 | // The OEM customization XML. |
| 55 | XmlDocUniquePtr mCustomizationXmlDoc; |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 56 | }; |
| 57 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 58 | struct AFont { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 59 | std::string mFilePath; |
| 60 | std::unique_ptr<std::string> mLocale; |
| 61 | uint16_t mWeight; |
| 62 | bool mItalic; |
| 63 | uint32_t mCollectionIndex; |
| 64 | std::vector<std::pair<uint32_t, float>> mAxes; |
| 65 | }; |
| 66 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 67 | struct AFontMatcher { |
| 68 | minikin::FontStyle mFontStyle; |
| 69 | uint32_t mLocaleListId = 0; // 0 is reserved for empty locale ID. |
| 70 | bool mFamilyVariant = AFAMILY_VARIANT_DEFAULT; |
| 71 | }; |
| 72 | |
| 73 | static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_DEFAULT) == |
| 74 | static_cast<uint32_t>(minikin::FamilyVariant::DEFAULT)); |
| 75 | static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_COMPACT) == |
| 76 | static_cast<uint32_t>(minikin::FamilyVariant::COMPACT)); |
| 77 | static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_ELEGANT) == |
| 78 | static_cast<uint32_t>(minikin::FamilyVariant::ELEGANT)); |
| 79 | |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 80 | namespace { |
| 81 | |
| 82 | std::string xmlTrim(const std::string& in) { |
| 83 | if (in.empty()) { |
| 84 | return in; |
| 85 | } |
| 86 | const char XML_SPACES[] = "\u0020\u000D\u000A\u0009"; |
| 87 | const size_t start = in.find_first_not_of(XML_SPACES); // inclusive |
| 88 | if (start == std::string::npos) { |
| 89 | return ""; |
| 90 | } |
| 91 | const size_t end = in.find_last_not_of(XML_SPACES); // inclusive |
| 92 | if (end == std::string::npos) { |
| 93 | return ""; |
| 94 | } |
| 95 | return in.substr(start, end - start + 1 /* +1 since end is inclusive */); |
| 96 | } |
| 97 | |
| 98 | const xmlChar* FAMILY_TAG = BAD_CAST("family"); |
| 99 | const xmlChar* FONT_TAG = BAD_CAST("font"); |
| 100 | |
| 101 | xmlNode* firstElement(xmlNode* node, const xmlChar* tag) { |
| 102 | for (xmlNode* child = node->children; child; child = child->next) { |
| 103 | if (xmlStrEqual(child->name, tag)) { |
| 104 | return child; |
| 105 | } |
| 106 | } |
| 107 | return nullptr; |
| 108 | } |
| 109 | |
| 110 | xmlNode* nextSibling(xmlNode* node, const xmlChar* tag) { |
| 111 | while ((node = node->next) != nullptr) { |
| 112 | if (xmlStrEqual(node->name, tag)) { |
| 113 | return node; |
| 114 | } |
| 115 | } |
| 116 | return nullptr; |
| 117 | } |
| 118 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 119 | void copyFont(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode, AFont* out, |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 120 | const std::string& pathPrefix) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 121 | const xmlChar* LOCALE_ATTR_NAME = BAD_CAST("lang"); |
| 122 | XmlCharUniquePtr filePathStr( |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 123 | xmlNodeListGetString(xmlDoc.get(), fontNode->xmlChildrenNode, 1)); |
| 124 | out->mFilePath = pathPrefix + xmlTrim( |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 125 | std::string(filePathStr.get(), filePathStr.get() + xmlStrlen(filePathStr.get()))); |
| 126 | |
| 127 | const xmlChar* WEIGHT_ATTR_NAME = BAD_CAST("weight"); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 128 | XmlCharUniquePtr weightStr(xmlGetProp(fontNode, WEIGHT_ATTR_NAME)); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 129 | out->mWeight = weightStr ? |
| 130 | strtol(reinterpret_cast<const char*>(weightStr.get()), nullptr, 10) : 400; |
| 131 | |
| 132 | const xmlChar* STYLE_ATTR_NAME = BAD_CAST("style"); |
| 133 | const xmlChar* ITALIC_ATTR_VALUE = BAD_CAST("italic"); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 134 | XmlCharUniquePtr styleStr(xmlGetProp(fontNode, STYLE_ATTR_NAME)); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 135 | out->mItalic = styleStr ? xmlStrEqual(styleStr.get(), ITALIC_ATTR_VALUE) : false; |
| 136 | |
| 137 | const xmlChar* INDEX_ATTR_NAME = BAD_CAST("index"); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 138 | XmlCharUniquePtr indexStr(xmlGetProp(fontNode, INDEX_ATTR_NAME)); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 139 | out->mCollectionIndex = indexStr ? |
| 140 | strtol(reinterpret_cast<const char*>(indexStr.get()), nullptr, 10) : 0; |
| 141 | |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 142 | XmlCharUniquePtr localeStr(xmlGetProp(xmlDoc->parent, LOCALE_ATTR_NAME)); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 143 | out->mLocale.reset( |
| 144 | localeStr ? new std::string(reinterpret_cast<const char*>(localeStr.get())) : nullptr); |
| 145 | |
| 146 | const xmlChar* TAG_ATTR_NAME = BAD_CAST("tag"); |
| 147 | const xmlChar* STYLEVALUE_ATTR_NAME = BAD_CAST("stylevalue"); |
| 148 | const xmlChar* AXIS_TAG = BAD_CAST("axis"); |
| 149 | out->mAxes.clear(); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 150 | for (xmlNode* axis = firstElement(fontNode, AXIS_TAG); axis; |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 151 | axis = nextSibling(axis, AXIS_TAG)) { |
| 152 | XmlCharUniquePtr tagStr(xmlGetProp(axis, TAG_ATTR_NAME)); |
| 153 | if (!tagStr || xmlStrlen(tagStr.get()) != 4) { |
| 154 | continue; // Tag value must be 4 char string |
| 155 | } |
| 156 | |
| 157 | XmlCharUniquePtr styleValueStr(xmlGetProp(axis, STYLEVALUE_ATTR_NAME)); |
| 158 | if (!styleValueStr) { |
| 159 | continue; |
| 160 | } |
| 161 | |
| 162 | uint32_t tag = |
| 163 | static_cast<uint32_t>(tagStr.get()[0] << 24) | |
| 164 | static_cast<uint32_t>(tagStr.get()[1] << 16) | |
| 165 | static_cast<uint32_t>(tagStr.get()[2] << 8) | |
| 166 | static_cast<uint32_t>(tagStr.get()[3]); |
| 167 | float styleValue = strtod(reinterpret_cast<const char*>(styleValueStr.get()), nullptr); |
| 168 | out->mAxes.push_back(std::make_pair(tag, styleValue)); |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | bool isFontFileAvailable(const std::string& filePath) { |
| 173 | std::string fullPath = filePath; |
| 174 | struct stat st = {}; |
| 175 | if (stat(fullPath.c_str(), &st) != 0) { |
| 176 | return false; |
| 177 | } |
| 178 | return S_ISREG(st.st_mode); |
| 179 | } |
| 180 | |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 181 | xmlNode* findFirstFontNode(const XmlDocUniquePtr& doc) { |
| 182 | xmlNode* familySet = xmlDocGetRootElement(doc.get()); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 183 | if (familySet == nullptr) { |
| 184 | return nullptr; |
| 185 | } |
| 186 | xmlNode* family = firstElement(familySet, FAMILY_TAG); |
| 187 | if (family == nullptr) { |
| 188 | return nullptr; |
| 189 | } |
| 190 | |
| 191 | xmlNode* font = firstElement(family, FONT_TAG); |
| 192 | while (font == nullptr) { |
| 193 | family = nextSibling(family, FAMILY_TAG); |
| 194 | if (family == nullptr) { |
| 195 | return nullptr; |
| 196 | } |
| 197 | font = firstElement(family, FONT_TAG); |
| 198 | } |
| 199 | return font; |
| 200 | } |
| 201 | |
| 202 | } // namespace |
| 203 | |
| 204 | ASystemFontIterator* ASystemFontIterator_open() { |
| 205 | std::unique_ptr<ASystemFontIterator> ite(new ASystemFontIterator()); |
| 206 | ite->mXmlDoc.reset(xmlReadFile("/system/etc/fonts.xml", nullptr, 0)); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 207 | ite->mCustomizationXmlDoc.reset(xmlReadFile("/product/etc/fonts_customization.xml", nullptr, 0)); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 208 | return ite.release(); |
| 209 | } |
| 210 | |
| 211 | void ASystemFontIterator_close(ASystemFontIterator* ite) { |
| 212 | delete ite; |
| 213 | } |
| 214 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 215 | AFontMatcher* _Nonnull AFontMatcher_create() { |
| 216 | return new AFontMatcher(); |
| 217 | } |
| 218 | |
| 219 | void AFontMatcher_destroy(AFontMatcher* matcher) { |
| 220 | delete matcher; |
| 221 | } |
| 222 | |
| 223 | void AFontMatcher_setStyle( |
| 224 | AFontMatcher* _Nonnull matcher, |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 225 | uint16_t weight, |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 226 | bool italic) { |
| 227 | matcher->mFontStyle = minikin::FontStyle( |
| 228 | weight, static_cast<minikin::FontStyle::Slant>(italic)); |
| 229 | } |
| 230 | |
| 231 | void AFontMatcher_setLocales( |
| 232 | AFontMatcher* _Nonnull matcher, |
| 233 | const char* _Nonnull languageTags) { |
| 234 | matcher->mLocaleListId = minikin::registerLocaleList(languageTags); |
| 235 | } |
| 236 | |
| 237 | void AFontMatcher_setFamilyVariant(AFontMatcher* _Nonnull matcher, uint32_t familyVariant) { |
| 238 | matcher->mFamilyVariant = familyVariant; |
| 239 | } |
| 240 | |
| 241 | AFont* _Nonnull AFontMatcher_match( |
| 242 | const AFontMatcher* _Nonnull matcher, |
| 243 | const char* _Nonnull familyName, |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 244 | const uint16_t* _Nonnull text, |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 245 | const uint32_t textLength, |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 246 | uint32_t* _Nullable runLength) { |
| 247 | std::shared_ptr<minikin::FontCollection> fc = |
| 248 | minikin::SystemFonts::findFontCollection(familyName); |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 249 | std::vector<minikin::FontCollection::Run> runs = fc->itemize( |
| 250 | minikin::U16StringPiece(text, textLength), |
| 251 | matcher->mFontStyle, |
| 252 | matcher->mLocaleListId, |
Seigo Nonaka | ddc8773 | 2019-04-05 15:20:19 -0700 | [diff] [blame] | 253 | static_cast<minikin::FamilyVariant>(matcher->mFamilyVariant), |
| 254 | 1 /* maxRun */); |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 255 | |
| 256 | const minikin::Font* font = runs[0].fakedFont.font; |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 257 | std::unique_ptr<AFont> result = std::make_unique<AFont>(); |
Seigo Nonaka | 75b841b | 2018-10-30 11:39:49 -0700 | [diff] [blame] | 258 | const android::MinikinFontSkia* minikinFontSkia = |
| 259 | reinterpret_cast<android::MinikinFontSkia*>(font->typeface().get()); |
| 260 | result->mFilePath = minikinFontSkia->getFilePath(); |
| 261 | result->mWeight = font->style().weight(); |
| 262 | result->mItalic = font->style().slant() == minikin::FontStyle::Slant::ITALIC; |
| 263 | result->mCollectionIndex = minikinFontSkia->GetFontIndex(); |
| 264 | const std::vector<minikin::FontVariation>& axes = minikinFontSkia->GetAxes(); |
| 265 | result->mAxes.reserve(axes.size()); |
| 266 | for (auto axis : axes) { |
| 267 | result->mAxes.push_back(std::make_pair(axis.axisTag, axis.value)); |
| 268 | } |
| 269 | if (runLength != nullptr) { |
| 270 | *runLength = runs[0].end; |
| 271 | } |
| 272 | return result.release(); |
| 273 | } |
| 274 | |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 275 | xmlNode* findNextFontNode(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode) { |
| 276 | if (fontNode == nullptr) { |
| 277 | if (!xmlDoc) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 278 | return nullptr; // Already at the end. |
| 279 | } else { |
| 280 | // First time to query font. |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 281 | return findFirstFontNode(xmlDoc); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 282 | } |
| 283 | } else { |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 284 | xmlNode* nextNode = nextSibling(fontNode, FONT_TAG); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 285 | while (nextNode == nullptr) { |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 286 | xmlNode* family = nextSibling(fontNode->parent, FAMILY_TAG); |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 287 | if (family == nullptr) { |
| 288 | break; |
| 289 | } |
| 290 | nextNode = firstElement(family, FONT_TAG); |
| 291 | } |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 292 | return nextNode; |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 293 | } |
| 294 | } |
| 295 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 296 | AFont* ASystemFontIterator_next(ASystemFontIterator* ite) { |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 297 | LOG_ALWAYS_FATAL_IF(ite == nullptr, "nullptr has passed as iterator argument"); |
| 298 | if (ite->mXmlDoc) { |
| 299 | ite->mFontNode = findNextFontNode(ite->mXmlDoc, ite->mFontNode); |
| 300 | if (ite->mFontNode == nullptr) { |
| 301 | // Reached end of the XML file. Continue OEM customization. |
| 302 | ite->mXmlDoc.reset(); |
| 303 | ite->mFontNode = nullptr; |
| 304 | } else { |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 305 | std::unique_ptr<AFont> font = std::make_unique<AFont>(); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 306 | copyFont(ite->mXmlDoc, ite->mFontNode, font.get(), "/system/fonts/"); |
| 307 | if (!isFontFileAvailable(font->mFilePath)) { |
| 308 | return ASystemFontIterator_next(ite); |
| 309 | } |
| 310 | return font.release(); |
| 311 | } |
| 312 | } |
| 313 | if (ite->mCustomizationXmlDoc) { |
| 314 | // TODO: Filter only customizationType="new-named-family" |
| 315 | ite->mFontNode = findNextFontNode(ite->mCustomizationXmlDoc, ite->mFontNode); |
| 316 | if (ite->mFontNode == nullptr) { |
| 317 | // Reached end of the XML file. Finishing |
| 318 | ite->mCustomizationXmlDoc.reset(); |
| 319 | ite->mFontNode = nullptr; |
| 320 | return nullptr; |
| 321 | } else { |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 322 | std::unique_ptr<AFont> font = std::make_unique<AFont>(); |
Seigo Nonaka | 3675898 | 2018-10-01 19:06:11 -0700 | [diff] [blame] | 323 | copyFont(ite->mCustomizationXmlDoc, ite->mFontNode, font.get(), "/product/fonts/"); |
| 324 | if (!isFontFileAvailable(font->mFilePath)) { |
| 325 | return ASystemFontIterator_next(ite); |
| 326 | } |
| 327 | return font.release(); |
| 328 | } |
| 329 | } |
| 330 | return nullptr; |
| 331 | } |
| 332 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 333 | void AFont_close(AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 334 | delete font; |
| 335 | } |
| 336 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 337 | const char* AFont_getFontFilePath(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 338 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); |
| 339 | return font->mFilePath.c_str(); |
| 340 | } |
| 341 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 342 | uint16_t AFont_getWeight(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 343 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); |
| 344 | return font->mWeight; |
| 345 | } |
| 346 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 347 | bool AFont_isItalic(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 348 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); |
| 349 | return font->mItalic; |
| 350 | } |
| 351 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 352 | const char* AFont_getLocale(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 353 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); |
| 354 | return font->mLocale ? nullptr : font->mLocale->c_str(); |
| 355 | } |
| 356 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 357 | size_t AFont_getCollectionIndex(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 358 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); |
| 359 | return font->mCollectionIndex; |
| 360 | } |
| 361 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 362 | size_t AFont_getAxisCount(const AFont* font) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 363 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); |
| 364 | return font->mAxes.size(); |
| 365 | } |
| 366 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 367 | uint32_t AFont_getAxisTag(const AFont* font, uint32_t axisIndex) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 368 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); |
| 369 | LOG_ALWAYS_FATAL_IF(axisIndex >= font->mAxes.size(), |
| 370 | "given axis index is out of bounds. (< %zd", font->mAxes.size()); |
| 371 | return font->mAxes[axisIndex].first; |
| 372 | } |
| 373 | |
Seigo Nonaka | b3a7bce | 2019-03-29 14:24:57 -0700 | [diff] [blame] | 374 | float AFont_getAxisValue(const AFont* font, uint32_t axisIndex) { |
Seigo Nonaka | 50692ca | 2018-08-31 12:27:15 -0700 | [diff] [blame] | 375 | LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); |
| 376 | LOG_ALWAYS_FATAL_IF(axisIndex >= font->mAxes.size(), |
| 377 | "given axis index is out of bounds. (< %zd", font->mAxes.size()); |
| 378 | return font->mAxes[axisIndex].second; |
| 379 | } |