diff --git a/core/jni/android/graphics/FontFamily.cpp b/core/jni/android/graphics/FontFamily.cpp index 9e6985ca300e5..1a19a4099e12a 100644 --- a/core/jni/android/graphics/FontFamily.cpp +++ b/core/jni/android/graphics/FontFamily.cpp @@ -36,6 +36,7 @@ #include #include #include +#include #include @@ -43,9 +44,10 @@ namespace android { struct NativeFamilyBuilder { NativeFamilyBuilder(uint32_t langId, int variant) - : langId(langId), variant(variant), allowUnsupportedFont(false) {} + : langId(langId), variant(static_cast(variant)), + allowUnsupportedFont(false) {} uint32_t langId; - int variant; + minikin::FontVariant variant; bool allowUnsupportedFont; std::vector fonts; std::vector axes; @@ -55,10 +57,9 @@ static jlong FontFamily_initBuilder(JNIEnv* env, jobject clazz, jstring langs, j NativeFamilyBuilder* builder; if (langs != nullptr) { ScopedUtfChars str(env, langs); - builder = new NativeFamilyBuilder( - minikin::FontStyle::registerLocaleList(str.c_str()), variant); + builder = new NativeFamilyBuilder(minikin::registerLocaleList(str.c_str()), variant); } else { - builder = new NativeFamilyBuilder(minikin::FontStyle::registerLocaleList(""), variant); + builder = new NativeFamilyBuilder(minikin::registerLocaleList(""), variant); } return reinterpret_cast(builder); } @@ -121,14 +122,14 @@ static bool addSkTypeface(NativeFamilyBuilder* builder, sk_sp&& data, in std::make_shared(std::move(face), fontPtr, fontSize, ttcIndex, builder->axes); - int weight = givenWeight / 100; + int weight = givenWeight; bool italic = givenItalic == 1; if (givenWeight == RESOLVE_BY_FONT_TABLE || givenItalic == RESOLVE_BY_FONT_TABLE) { int os2Weight; bool os2Italic; if (!minikin::FontFamily::analyzeStyle(minikinFont, &os2Weight, &os2Italic)) { ALOGE("analyzeStyle failed. Using default style"); - os2Weight = 4; + os2Weight = 400; os2Italic = false; } if (givenWeight == RESOLVE_BY_FONT_TABLE) { @@ -139,7 +140,8 @@ static bool addSkTypeface(NativeFamilyBuilder* builder, sk_sp&& data, in } } - builder->fonts.push_back(minikin::Font(minikinFont, minikin::FontStyle(weight, italic))); + builder->fonts.push_back(minikin::Font(minikinFont, + minikin::FontStyle(weight, static_cast(italic)))); builder->axes.clear(); return true; } diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp index e8e3f57c718ba..5f32d379af243 100644 --- a/core/jni/android/graphics/Paint.cpp +++ b/core/jni/android/graphics/Paint.cpp @@ -41,6 +41,7 @@ #include #include #include +#include #include #include @@ -546,9 +547,9 @@ namespace PaintGlue { static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) { Paint* obj = reinterpret_cast(objHandle); ScopedUtfChars localesChars(env, locales); - jint minikinLangListId = minikin::FontStyle::registerLocaleList(localesChars.c_str()); - obj->setMinikinLangListId(minikinLangListId); - return minikinLangListId; + jint minikinLocaleListId = minikin::registerLocaleList(localesChars.c_str()); + obj->setMinikinLocaleListId(minikinLocaleListId); + return minikinLocaleListId; } static void setFontFeatureSettings(JNIEnv* env, jobject clazz, jlong paintHandle, jstring settings) { @@ -580,7 +581,7 @@ namespace PaintGlue { // restore the original settings. paint->setTextSkewX(saveSkewX); paint->setFakeBoldText(savefakeBold); - if (paint->getFontVariant() == minikin::VARIANT_ELEGANT) { + if (paint->getFontVariant() == minikin::FontVariant::ELEGANT) { SkScalar size = paint->getTextSize(); metrics->fTop = -size * kElegantTop / 2048; metrics->fBottom = -size * kElegantBottom / 2048; @@ -871,20 +872,20 @@ namespace PaintGlue { obj->setTextAlign(align); } - static void setTextLocalesByMinikinLangListId(jlong objHandle, - jint minikinLangListId) { + static void setTextLocalesByMinikinLocaleListId(jlong objHandle, + jint minikinLocaleListId) { Paint* obj = reinterpret_cast(objHandle); - obj->setMinikinLangListId(minikinLangListId); + obj->setMinikinLocaleListId(minikinLocaleListId); } static jboolean isElegantTextHeight(jlong paintHandle) { Paint* obj = reinterpret_cast(paintHandle); - return obj->getFontVariant() == minikin::VARIANT_ELEGANT; + return obj->getFontVariant() == minikin::FontVariant::ELEGANT; } static void setElegantTextHeight(jlong paintHandle, jboolean aa) { Paint* obj = reinterpret_cast(paintHandle); - obj->setFontVariant(aa ? minikin::VARIANT_ELEGANT : minikin::VARIANT_DEFAULT); + obj->setFontVariant(aa ? minikin::FontVariant::ELEGANT : minikin::FontVariant::DEFAULT); } static jfloat getTextSize(jlong paintHandle) { @@ -1080,8 +1081,8 @@ static const JNINativeMethod methods[] = { {"nSetTypeface","(JJ)V", (void*) PaintGlue::setTypeface}, {"nGetTextAlign","(J)I", (void*) PaintGlue::getTextAlign}, {"nSetTextAlign","(JI)V", (void*) PaintGlue::setTextAlign}, - {"nSetTextLocalesByMinikinLangListId","(JI)V", - (void*) PaintGlue::setTextLocalesByMinikinLangListId}, + {"nSetTextLocalesByMinikinLocaleListId","(JI)V", + (void*) PaintGlue::setTextLocalesByMinikinLocaleListId}, {"nIsElegantTextHeight","(J)Z", (void*) PaintGlue::isElegantTextHeight}, {"nSetElegantTextHeight","(JZ)V", (void*) PaintGlue::setElegantTextHeight}, {"nGetTextSize","(J)F", (void*) PaintGlue::getTextSize}, diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp index d5f2a5c649a93..3e4073f6f2155 100644 --- a/core/jni/android/graphics/Typeface.cpp +++ b/core/jni/android/graphics/Typeface.cpp @@ -83,7 +83,7 @@ static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) { static jint Typeface_getWeight(JNIEnv* env, jobject obj, jlong faceHandle) { Typeface* face = reinterpret_cast(faceHandle); - return face->fStyle.getWeight() * 100; + return face->fStyle.weight; } static jlong Typeface_createFromArray(JNIEnv *env, jobject, jlongArray familyArray, diff --git a/core/jni/android_text_StaticLayout.cpp b/core/jni/android_text_StaticLayout.cpp index c1419ba6c7c6f..3ab78a4a0963d 100644 --- a/core/jni/android_text_StaticLayout.cpp +++ b/core/jni/android_text_StaticLayout.cpp @@ -126,19 +126,17 @@ class Run { class StyleRun : public Run { public: StyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint, - std::shared_ptr&& collection, - minikin::FontStyle&& style, bool isRtl) + std::shared_ptr&& collection, bool isRtl) : Run(start, end), mPaint(std::move(paint)), mCollection(std::move(collection)), - mStyle(std::move(style)), mIsRtl(isRtl) {} + mIsRtl(isRtl) {} void addTo(minikin::LineBreaker* lineBreaker) override { - lineBreaker->addStyleRun(&mPaint, mCollection, mStyle, mStart, mEnd, mIsRtl); + lineBreaker->addStyleRun(&mPaint, mCollection, mStart, mEnd, mIsRtl); } private: minikin::MinikinPaint mPaint; std::shared_ptr mCollection; - minikin::FontStyle mStyle; const bool mIsRtl; }; @@ -167,10 +165,9 @@ class StaticLayoutNative { mRightPaddings(std::move(rightPaddings)) {} void addStyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint, - std::shared_ptr collection, - minikin::FontStyle&& style, bool isRtl) { + std::shared_ptr collection, bool isRtl) { mRuns.emplace_back(std::make_unique( - start, end, std::move(paint), std::move(collection), std::move(style), isRtl)); + start, end, std::move(paint), std::move(collection), isRtl)); } void addReplacementRun(int32_t start, int32_t end, float width, uint32_t localeListId) { @@ -323,15 +320,9 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr, static void nAddStyleRun(jlong nativePtr, jlong nativePaint, jint start, jint end, jboolean isRtl) { StaticLayoutNative* builder = toNative(nativePtr); Paint* paint = reinterpret_cast(nativePaint); - const Typeface* typeface = paint->getAndroidTypeface(); - minikin::MinikinPaint minikinPaint; - const Typeface* resolvedTypeface = Typeface::resolveDefault(typeface); - minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, paint, - typeface); - - builder->addStyleRun( - start, end, std::move(minikinPaint), resolvedTypeface->fFontCollection, std::move(style), - isRtl); + const Typeface* typeface = Typeface::resolveDefault(paint->getAndroidTypeface()); + minikin::MinikinPaint minikinPaint = MinikinUtils::prepareMinikinPaint(paint, typeface); + builder->addStyleRun(start, end, std::move(minikinPaint), typeface->fFontCollection, isRtl); } // CriticalNative @@ -339,7 +330,7 @@ static void nAddReplacementRun(jlong nativePtr, jlong nativePaint, jint start, j jfloat width) { StaticLayoutNative* builder = toNative(nativePtr); Paint* paint = reinterpret_cast(nativePaint); - builder->addReplacementRun(start, end, width, paint->getMinikinLangListId()); + builder->addReplacementRun(start, end, width, paint->getMinikinLocaleListId()); } static const JNINativeMethod gMethods[] = { diff --git a/graphics/java/android/graphics/Paint.java b/graphics/java/android/graphics/Paint.java index 1a06a5683cd31..317144a21d329 100644 --- a/graphics/java/android/graphics/Paint.java +++ b/graphics/java/android/graphics/Paint.java @@ -88,7 +88,7 @@ public class Paint { * A map from a string representation of the LocaleList to Minikin's language list ID. */ @GuardedBy("sCacheLock") - private static final HashMap sMinikinLangListIdCache = new HashMap<>(); + private static final HashMap sMinikinLocaleListIdCache = new HashMap<>(); /** * @hide @@ -1445,16 +1445,16 @@ public class Paint { private void syncTextLocalesWithMinikin() { final String languageTags = mLocales.toLanguageTags(); - final Integer minikinLangListId; + final Integer minikinLocaleListId; synchronized (sCacheLock) { - minikinLangListId = sMinikinLangListIdCache.get(languageTags); - if (minikinLangListId == null) { + minikinLocaleListId = sMinikinLocaleListIdCache.get(languageTags); + if (minikinLocaleListId == null) { final int newID = nSetTextLocales(mNativePaint, languageTags); - sMinikinLangListIdCache.put(languageTags, newID); + sMinikinLocaleListIdCache.put(languageTags, newID); return; } } - nSetTextLocalesByMinikinLangListId(mNativePaint, minikinLangListId.intValue()); + nSetTextLocalesByMinikinLocaleListId(mNativePaint, minikinLocaleListId.intValue()); } /** @@ -2918,8 +2918,8 @@ public class Paint { @CriticalNative private static native void nSetTextAlign(long paintPtr, int align); @CriticalNative - private static native void nSetTextLocalesByMinikinLangListId(long paintPtr, - int mMinikinLangListId); + private static native void nSetTextLocalesByMinikinLocaleListId(long paintPtr, + int mMinikinLocaleListId); @CriticalNative private static native void nSetShadowLayer(long paintPtr, float radius, float dx, float dy, int color); diff --git a/libs/hwui/hwui/MinikinUtils.cpp b/libs/hwui/hwui/MinikinUtils.cpp index f739634391140..90fe0b74dcec2 100644 --- a/libs/hwui/hwui/MinikinUtils.cpp +++ b/libs/hwui/hwui/MinikinUtils.cpp @@ -26,39 +26,38 @@ namespace android { -minikin::FontStyle MinikinUtils::prepareMinikinPaint(minikin::MinikinPaint* minikinPaint, - const Paint* paint, const Typeface* typeface) { +minikin::MinikinPaint MinikinUtils::prepareMinikinPaint(const Paint* paint, + const Typeface* typeface) { const Typeface* resolvedFace = Typeface::resolveDefault(typeface); minikin::FontStyle resolved = resolvedFace->fStyle; - /* Prepare minikin FontStyle */ - minikin::FontVariant minikinVariant = (paint->getFontVariant() == minikin::VARIANT_ELEGANT) - ? minikin::VARIANT_ELEGANT - : minikin::VARIANT_COMPACT; - const uint32_t langListId = paint->getMinikinLangListId(); - minikin::FontStyle minikinStyle(langListId, minikinVariant, resolved.getWeight(), - resolved.getItalic()); + const minikin::FontVariant minikinVariant = + (paint->getFontVariant() == minikin::FontVariant::ELEGANT) + ? minikin::FontVariant::ELEGANT + : minikin::FontVariant::COMPACT; + minikin::MinikinPaint minikinPaint; /* Prepare minikin Paint */ - minikinPaint->size = + minikinPaint.size = paint->isLinearText() ? paint->getTextSize() : static_cast(paint->getTextSize()); - minikinPaint->scaleX = paint->getTextScaleX(); - minikinPaint->skewX = paint->getTextSkewX(); - minikinPaint->letterSpacing = paint->getLetterSpacing(); - minikinPaint->wordSpacing = paint->getWordSpacing(); - minikinPaint->paintFlags = MinikinFontSkia::packPaintFlags(paint); - minikinPaint->fontFeatureSettings = paint->getFontFeatureSettings(); - minikinPaint->hyphenEdit = minikin::HyphenEdit(paint->getHyphenEdit()); - return minikinStyle; + minikinPaint.scaleX = paint->getTextScaleX(); + minikinPaint.skewX = paint->getTextSkewX(); + minikinPaint.letterSpacing = paint->getLetterSpacing(); + minikinPaint.wordSpacing = paint->getWordSpacing(); + minikinPaint.paintFlags = MinikinFontSkia::packPaintFlags(paint); + minikinPaint.localeListId = paint->getMinikinLocaleListId(); + minikinPaint.fontStyle = minikin::FontStyle(minikinVariant, resolved.weight, resolved.slant); + minikinPaint.fontFeatureSettings = paint->getFontFeatureSettings(); + minikinPaint.hyphenEdit = minikin::HyphenEdit(paint->getHyphenEdit()); + return minikinPaint; } minikin::Layout MinikinUtils::doLayout(const Paint* paint, minikin::Bidi bidiFlags, const Typeface* typeface, const uint16_t* buf, size_t start, size_t count, size_t bufSize) { - minikin::MinikinPaint minikinPaint; - minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, paint, typeface); + minikin::MinikinPaint minikinPaint = prepareMinikinPaint(paint, typeface); minikin::Layout layout; - layout.doLayout(buf, start, count, bufSize, bidiFlags, minikinStyle, minikinPaint, + layout.doLayout(buf, start, count, bufSize, bidiFlags, minikinPaint, Typeface::resolveDefault(typeface)->fFontCollection); return layout; } @@ -66,11 +65,10 @@ minikin::Layout MinikinUtils::doLayout(const Paint* paint, minikin::Bidi bidiFla float MinikinUtils::measureText(const Paint* paint, minikin::Bidi bidiFlags, const Typeface* typeface, const uint16_t* buf, size_t start, size_t count, size_t bufSize, float* advances) { - minikin::MinikinPaint minikinPaint; - minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, paint, typeface); + minikin::MinikinPaint minikinPaint = prepareMinikinPaint(paint, typeface); const Typeface* resolvedTypeface = Typeface::resolveDefault(typeface); - return minikin::Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinStyle, - minikinPaint, resolvedTypeface->fFontCollection, advances, + return minikin::Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinPaint, + resolvedTypeface->fFontCollection, advances, nullptr /* extent */, nullptr /* overhangs */); } @@ -109,4 +107,4 @@ float MinikinUtils::hOffsetForTextAlign(Paint* paint, const minikin::Layout& lay SkPathMeasure measure(path, false); return align * (layout.getAdvance() - measure.getLength()); } -} +} // namespace android diff --git a/libs/hwui/hwui/MinikinUtils.h b/libs/hwui/hwui/MinikinUtils.h index 8bb9179585ae5..7036cbee79f9c 100644 --- a/libs/hwui/hwui/MinikinUtils.h +++ b/libs/hwui/hwui/MinikinUtils.h @@ -34,9 +34,8 @@ namespace android { class MinikinUtils { public: - ANDROID_API static minikin::FontStyle prepareMinikinPaint(minikin::MinikinPaint* minikinPaint, - const Paint* paint, - const Typeface* typeface); + ANDROID_API static minikin::MinikinPaint prepareMinikinPaint(const Paint* paint, + const Typeface* typeface); ANDROID_API static minikin::Layout doLayout(const Paint* paint, minikin::Bidi bidiFlags, const Typeface* typeface, const uint16_t* buf, diff --git a/libs/hwui/hwui/Paint.h b/libs/hwui/hwui/Paint.h index da7417a4bf2dc..76beb119b6da8 100644 --- a/libs/hwui/hwui/Paint.h +++ b/libs/hwui/hwui/Paint.h @@ -67,11 +67,11 @@ public: std::string getFontFeatureSettings() const { return mFontFeatureSettings; } - void setMinikinLangListId(uint32_t minikinLangListId) { - mMinikinLangListId = minikinLangListId; + void setMinikinLocaleListId(uint32_t minikinLocaleListId) { + mMinikinLocaleListId = minikinLocaleListId; } - uint32_t getMinikinLangListId() const { return mMinikinLangListId; } + uint32_t getMinikinLocaleListId() const { return mMinikinLocaleListId; } void setFontVariant(minikin::FontVariant variant) { mFontVariant = variant; } @@ -89,12 +89,13 @@ private: float mLetterSpacing = 0; float mWordSpacing = 0; std::string mFontFeatureSettings; - uint32_t mMinikinLangListId; + uint32_t mMinikinLocaleListId; minikin::FontVariant mFontVariant; uint32_t mHyphenEdit = 0; - // The native Typeface object has the same lifetime of the Java Typeface object. The Java Paint - // object holds a strong reference to the Java Typeface object. Thus, following pointer can - // never be a dangling pointer. Note that nullptr is valid: it means the default typeface. + // The native Typeface object has the same lifetime of the Java Typeface + // object. The Java Paint object holds a strong reference to the Java Typeface + // object. Thus, following pointer can never be a dangling pointer. Note that + // nullptr is valid: it means the default typeface. const Typeface* mTypeface = nullptr; }; diff --git a/libs/hwui/hwui/PaintImpl.cpp b/libs/hwui/hwui/PaintImpl.cpp index 4f2b3bbcd7baa..94492c52f365f 100644 --- a/libs/hwui/hwui/PaintImpl.cpp +++ b/libs/hwui/hwui/PaintImpl.cpp @@ -23,15 +23,15 @@ Paint::Paint() , mLetterSpacing(0) , mWordSpacing(0) , mFontFeatureSettings() - , mMinikinLangListId(0) - , mFontVariant(minikin::VARIANT_DEFAULT) {} + , mMinikinLocaleListId(0) + , mFontVariant(minikin::FontVariant::DEFAULT) {} Paint::Paint(const Paint& paint) : SkPaint(paint) , mLetterSpacing(paint.mLetterSpacing) , mWordSpacing(paint.mWordSpacing) , mFontFeatureSettings(paint.mFontFeatureSettings) - , mMinikinLangListId(paint.mMinikinLangListId) + , mMinikinLocaleListId(paint.mMinikinLocaleListId) , mFontVariant(paint.mFontVariant) , mHyphenEdit(paint.mHyphenEdit) , mTypeface(paint.mTypeface) {} @@ -41,8 +41,8 @@ Paint::Paint(const SkPaint& paint) , mLetterSpacing(0) , mWordSpacing(0) , mFontFeatureSettings() - , mMinikinLangListId(0) - , mFontVariant(minikin::VARIANT_DEFAULT) {} + , mMinikinLocaleListId(0) + , mFontVariant(minikin::FontVariant::DEFAULT) {} Paint::~Paint() {} @@ -51,7 +51,7 @@ Paint& Paint::operator=(const Paint& other) { mLetterSpacing = other.mLetterSpacing; mWordSpacing = other.mWordSpacing; mFontFeatureSettings = other.mFontFeatureSettings; - mMinikinLangListId = other.mMinikinLangListId; + mMinikinLocaleListId = other.mMinikinLocaleListId; mFontVariant = other.mFontVariant; mHyphenEdit = other.mHyphenEdit; mTypeface = other.mTypeface; @@ -62,7 +62,7 @@ bool operator==(const Paint& a, const Paint& b) { return static_cast(a) == static_cast(b) && a.mLetterSpacing == b.mLetterSpacing && a.mWordSpacing == b.mWordSpacing && a.mFontFeatureSettings == b.mFontFeatureSettings && - a.mMinikinLangListId == b.mMinikinLangListId && a.mFontVariant == b.mFontVariant && + a.mMinikinLocaleListId == b.mMinikinLocaleListId && a.mFontVariant == b.mFontVariant && a.mHyphenEdit == b.mHyphenEdit && a.mTypeface == b.mTypeface; } -} +} // namespace android diff --git a/libs/hwui/hwui/Typeface.cpp b/libs/hwui/hwui/Typeface.cpp index c798e663bdddf..e527adc08fd71 100644 --- a/libs/hwui/hwui/Typeface.cpp +++ b/libs/hwui/hwui/Typeface.cpp @@ -44,9 +44,8 @@ static Typeface::Style computeAPIStyle(int weight, bool italic) { } static minikin::FontStyle computeMinikinStyle(int weight, bool italic) { - // TODO: Better to use raw base weight value for font selection instead of dividing by 100. - const int minikinWeight = uirenderer::MathUtils::clamp((weight + 50) / 100, 1, 10); - return minikin::FontStyle(minikinWeight, italic); + return minikin::FontStyle(uirenderer::MathUtils::clamp(weight, 1, 1000), + static_cast(italic)); } // Resolve the relative weight from the baseWeight and target style. @@ -192,8 +191,8 @@ void Typeface::setRobotoTypefaceForTest() { hwTypeface->fFontCollection = collection; hwTypeface->fAPIStyle = Typeface::kNormal; hwTypeface->fBaseWeight = SkFontStyle::kNormal_Weight; - hwTypeface->fStyle = minikin::FontStyle(4 /* weight */, false /* italic */); + hwTypeface->fStyle = minikin::FontStyle(); Typeface::setDefault(hwTypeface); } -} +} // namespace android diff --git a/libs/hwui/tests/unit/TypefaceTests.cpp b/libs/hwui/tests/unit/TypefaceTests.cpp index aad1fd6c5b76e..1fcc028b890fe 100644 --- a/libs/hwui/tests/unit/TypefaceTests.cpp +++ b/libs/hwui/tests/unit/TypefaceTests.cpp @@ -81,127 +81,139 @@ TEST(TypefaceTest, resolveDefault_and_setDefaultTest) { TEST(TypefaceTest, createWithDifferentBaseWeight) { std::unique_ptr bold(Typeface::createWithDifferentBaseWeight(nullptr, 700)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kNormal, bold->fAPIStyle); std::unique_ptr light(Typeface::createWithDifferentBaseWeight(nullptr, 300)); - EXPECT_EQ(3, light->fStyle.getWeight()); - EXPECT_FALSE(light->fStyle.getItalic()); + EXPECT_EQ(300, light->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, light->fStyle.slant); EXPECT_EQ(Typeface::kNormal, light->fAPIStyle); } TEST(TypefaceTest, createRelativeTest_fromRegular) { // In Java, Typeface.create(Typeface.DEFAULT, Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(nullptr, Typeface::kNormal)); - EXPECT_EQ(4, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(400, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(nullptr, Typeface::kBold)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); // In Java, Typeface.create(Typeface.DEFAULT, Typeface.ITALIC); std::unique_ptr italic(Typeface::createRelative(nullptr, Typeface::kItalic)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC); std::unique_ptr boldItalic(Typeface::createRelative(nullptr, Typeface::kBoldItalic)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } TEST(TypefaceTest, createRelativeTest_BoldBase) { std::unique_ptr base(Typeface::createWithDifferentBaseWeight(nullptr, 700)); - // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.NORMAL); + // In Java, Typeface.create(Typeface.create("sans-serif-bold"), + // Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(base.get(), Typeface::kNormal)); - EXPECT_EQ(7, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(700, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD); + // In Java, Typeface.create(Typeface.create("sans-serif-bold"), + // Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(base.get(), Typeface::kBold)); - EXPECT_EQ(10, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(1000, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.ITALIC); + // In Java, Typeface.create(Typeface.create("sans-serif-bold"), + // Typeface.ITALIC); std::unique_ptr italic(Typeface::createRelative(base.get(), Typeface::kItalic)); - EXPECT_EQ(7, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(700, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD_ITALIC); + // In Java, Typeface.create(Typeface.create("sans-serif-bold"), + // Typeface.BOLD_ITALIC); std::unique_ptr boldItalic( Typeface::createRelative(base.get(), Typeface::kBoldItalic)); - EXPECT_EQ(10, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(1000, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } TEST(TypefaceTest, createRelativeTest_LightBase) { std::unique_ptr base(Typeface::createWithDifferentBaseWeight(nullptr, 300)); - // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.NORMAL); + // In Java, Typeface.create(Typeface.create("sans-serif-light"), + // Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(base.get(), Typeface::kNormal)); - EXPECT_EQ(3, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(300, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD); + // In Java, Typeface.create(Typeface.create("sans-serif-light"), + // Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(base.get(), Typeface::kBold)); - EXPECT_EQ(6, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(600, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.ITLIC); + // In Java, Typeface.create(Typeface.create("sans-serif-light"), + // Typeface.ITLIC); std::unique_ptr italic(Typeface::createRelative(base.get(), Typeface::kItalic)); - EXPECT_EQ(3, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(300, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); - // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD_ITALIC); + // In Java, Typeface.create(Typeface.create("sans-serif-light"), + // Typeface.BOLD_ITALIC); std::unique_ptr boldItalic( Typeface::createRelative(base.get(), Typeface::kBoldItalic)); - EXPECT_EQ(6, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(600, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } TEST(TypefaceTest, createRelativeTest_fromBoldStyled) { std::unique_ptr base(Typeface::createRelative(nullptr, Typeface::kBold)); - // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.NORMAL); + // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), + // Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(base.get(), Typeface::kNormal)); - EXPECT_EQ(4, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(400, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); - // In Java Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD); + // In Java Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), + // Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(base.get(), Typeface::kBold)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); - // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.ITALIC); + // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), + // Typeface.ITALIC); std::unique_ptr italic(Typeface::createRelative(base.get(), Typeface::kItalic)); - EXPECT_EQ(4, normal->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, - // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD_ITALIC); + // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), + // Typeface.BOLD_ITALIC); std::unique_ptr boldItalic( Typeface::createRelative(base.get(), Typeface::kBoldItalic)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } @@ -209,31 +221,35 @@ TEST(TypefaceTest, createRelativeTest_fromItalicStyled) { std::unique_ptr base(Typeface::createRelative(nullptr, Typeface::kItalic)); // In Java, - // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.NORMAL); + // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), + // Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(base.get(), Typeface::kNormal)); - EXPECT_EQ(4, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(400, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); - // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD); + // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, + // Typeface.ITALIC), Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(base.get(), Typeface::kBold)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); // In Java, - // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.ITALIC); + // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), + // Typeface.ITALIC); std::unique_ptr italic(Typeface::createRelative(base.get(), Typeface::kItalic)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, - // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD_ITALIC); + // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), + // Typeface.BOLD_ITALIC); std::unique_ptr boldItalic( Typeface::createRelative(base.get(), Typeface::kBoldItalic)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } @@ -245,8 +261,8 @@ TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) { // .setWeight(700).setItalic(false).build(); // Typeface.create(typeface, Typeface.NORMAL); std::unique_ptr normal(Typeface::createRelative(base.get(), Typeface::kNormal)); - EXPECT_EQ(4, normal->fStyle.getWeight()); - EXPECT_FALSE(normal->fStyle.getItalic()); + EXPECT_EQ(400, normal->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, normal->fStyle.slant); EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle); // In Java, @@ -254,8 +270,8 @@ TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) { // .setWeight(700).setItalic(false).build(); // Typeface.create(typeface, Typeface.BOLD); std::unique_ptr bold(Typeface::createRelative(base.get(), Typeface::kBold)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); // In Java, @@ -263,8 +279,8 @@ TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) { // .setWeight(700).setItalic(false).build(); // Typeface.create(typeface, Typeface.ITALIC); std::unique_ptr italic(Typeface::createRelative(base.get(), Typeface::kItalic)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, @@ -273,89 +289,99 @@ TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) { // Typeface.create(typeface, Typeface.BOLD_ITALIC); std::unique_ptr boldItalic( Typeface::createRelative(base.get(), Typeface::kBoldItalic)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); } TEST(TypefaceTest, createAbsolute) { // In Java, - // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(false) + // new + // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(false) // .build(); std::unique_ptr regular(Typeface::createAbsolute(nullptr, 400, false)); - EXPECT_EQ(4, regular->fStyle.getWeight()); - EXPECT_FALSE(regular->fStyle.getItalic()); + EXPECT_EQ(400, regular->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, regular->fStyle.slant); EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle); // In Java, - // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(false) + // new + // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(false) // .build(); std::unique_ptr bold(Typeface::createAbsolute(nullptr, 700, false)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); // In Java, - // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(true) + // new + // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(true) // .build(); std::unique_ptr italic(Typeface::createAbsolute(nullptr, 400, true)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, - // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(true) + // new + // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(true) // .build(); std::unique_ptr boldItalic(Typeface::createAbsolute(nullptr, 700, true)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle); // In Java, - // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(1100).setItalic(true) + // new + // Typeface.Builder(invalid).setFallback("sans-serif").setWeight(1100).setItalic(true) // .build(); std::unique_ptr over1000(Typeface::createAbsolute(nullptr, 1100, false)); - EXPECT_EQ(10, over1000->fStyle.getWeight()); - EXPECT_FALSE(over1000->fStyle.getItalic()); + EXPECT_EQ(1000, over1000->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, over1000->fStyle.slant); EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle); } TEST(TypefaceTest, createFromFamilies_Single) { - // In Java, new Typeface.Builder("Roboto-Regular.ttf").setWeight(400).setItalic(false).build(); + // In Java, new + // Typeface.Builder("Roboto-Regular.ttf").setWeight(400).setItalic(false).build(); std::unique_ptr regular( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoRegular), 400, false)); - EXPECT_EQ(4, regular->fStyle.getWeight()); - EXPECT_FALSE(regular->fStyle.getItalic()); + EXPECT_EQ(400, regular->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, regular->fStyle.slant); EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle); - // In Java, new Typeface.Builder("Roboto-Bold.ttf").setWeight(700).setItalic(false).build(); + // In Java, new + // Typeface.Builder("Roboto-Bold.ttf").setWeight(700).setItalic(false).build(); std::unique_ptr bold( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 700, false)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); - // In Java, new Typeface.Builder("Roboto-Italic.ttf").setWeight(400).setItalic(true).build(); + // In Java, new + // Typeface.Builder("Roboto-Italic.ttf").setWeight(400).setItalic(true).build(); std::unique_ptr italic( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoItalic), 400, true)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, - // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(700).setItalic(true).build(); + // new + // Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(700).setItalic(true).build(); std::unique_ptr boldItalic( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBoldItalic), 700, true)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, - // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(1100).setItalic(false).build(); + // new + // Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(1100).setItalic(false).build(); std::unique_ptr over1000( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 1100, false)); - EXPECT_EQ(10, over1000->fStyle.getWeight()); - EXPECT_FALSE(over1000->fStyle.getItalic()); + EXPECT_EQ(1000, over1000->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, over1000->fStyle.slant); EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle); } @@ -363,30 +389,30 @@ TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) { // In Java, new Typeface.Builder("Roboto-Regular.ttf").build(); std::unique_ptr regular(Typeface::createFromFamilies( makeSingleFamlyVector(kRobotoRegular), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(4, regular->fStyle.getWeight()); - EXPECT_FALSE(regular->fStyle.getItalic()); + EXPECT_EQ(400, regular->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, regular->fStyle.slant); EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle); // In Java, new Typeface.Builder("Roboto-Bold.ttf").build(); std::unique_ptr bold(Typeface::createFromFamilies( makeSingleFamlyVector(kRobotoBold), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(7, bold->fStyle.getWeight()); - EXPECT_FALSE(bold->fStyle.getItalic()); + EXPECT_EQ(700, bold->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, bold->fStyle.slant); EXPECT_EQ(Typeface::kBold, bold->fAPIStyle); // In Java, new Typeface.Builder("Roboto-Italic.ttf").build(); std::unique_ptr italic(Typeface::createFromFamilies( makeSingleFamlyVector(kRobotoItalic), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(4, italic->fStyle.getWeight()); - EXPECT_TRUE(italic->fStyle.getItalic()); + EXPECT_EQ(400, italic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, italic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); // In Java, new Typeface.Builder("Roboto-BoldItalic.ttf").build(); std::unique_ptr boldItalic( Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBoldItalic), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(7, boldItalic->fStyle.getWeight()); - EXPECT_TRUE(boldItalic->fStyle.getItalic()); + EXPECT_EQ(700, boldItalic->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::ITALIC, boldItalic->fStyle.slant); EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle); } @@ -396,8 +422,8 @@ TEST(TypefaceTest, createFromFamilies_Family) { buildFamily(kRobotoBoldItalic)}; std::unique_ptr typeface(Typeface::createFromFamilies( std::move(families), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(4, typeface->fStyle.getWeight()); - EXPECT_FALSE(typeface->fStyle.getItalic()); + EXPECT_EQ(400, typeface->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, typeface->fStyle.slant); } TEST(TypefaceTest, createFromFamilies_Family_withoutRegular) { @@ -405,8 +431,8 @@ TEST(TypefaceTest, createFromFamilies_Family_withoutRegular) { buildFamily(kRobotoBold), buildFamily(kRobotoItalic), buildFamily(kRobotoBoldItalic)}; std::unique_ptr typeface(Typeface::createFromFamilies( std::move(families), RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE)); - EXPECT_EQ(7, typeface->fStyle.getWeight()); - EXPECT_FALSE(typeface->fStyle.getItalic()); + EXPECT_EQ(700, typeface->fStyle.weight); + EXPECT_EQ(minikin::FontSlant::UPRIGHT, typeface->fStyle.slant); } } // namespace