Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Follow the minikin namespace changes"

Browse Source
This commit is contained in:
Seigo Nonaka
2016-06-17 03:59:51 +00:00
committed by Android (Google) Code Review
parent 16a630d945 ae1aa85d0c
commit 99a8e2faac
17 changed files with 141 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core/java/android/widget/TextView.java
View File

@@ -6761,6 +6761,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener
BoringLayout.Metrics boring,
BoringLayout.Metrics hintBoring,
int ellipsisWidth, boolean bringIntoView) {
android.util.Log.e("TextView", "makeNewLayout", new Exception());
stopMarquee();
// Update "old" cached values

23
core/jni/android/graphics/FontFamily.cpp
View File

@@ -41,21 +41,21 @@ namespace android {
static jlong FontFamily_create(JNIEnv* env, jobject clazz, jstring lang, jint variant) {
if (lang == NULL) {
return (jlong)new FontFamily(variant);
return (jlong)new minikin::FontFamily(variant);
}
ScopedUtfChars str(env, lang);
uint32_t langId = FontStyle::registerLanguageList(str.c_str());
return (jlong)new FontFamily(langId, variant);
uint32_t langId = minikin::FontStyle::registerLanguageList(str.c_str());
return (jlong)new minikin::FontFamily(langId, variant);
}
static void FontFamily_unref(JNIEnv* env, jobject clazz, jlong familyPtr) {
FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
fontFamily->Unref();
}
static jboolean addSkTypeface(FontFamily* family, SkTypeface* face, const void* fontData,
static jboolean addSkTypeface(minikin::FontFamily* family, SkTypeface* face, const void* fontData,
size_t fontSize, int ttcIndex) {
MinikinFont* minikinFont = new MinikinFontSkia(face, fontData, fontSize, ttcIndex);
minikin::MinikinFont* minikinFont = new MinikinFontSkia(face, fontData, fontSize, ttcIndex);
bool result = family->addFont(minikinFont);
minikinFont->Unref();
return result;
@@ -111,7 +111,7 @@ static jboolean FontFamily_addFont(JNIEnv* env, jobject clazz, jlong familyPtr,
ALOGE("addFont failed to create font");
return false;
}
FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
return addSkTypeface(fontFamily, face, fontPtr, (size_t)fontSize, ttcIndex);
}
@@ -177,9 +177,10 @@ static jboolean FontFamily_addFontWeightStyle(JNIEnv* env, jobject clazz, jlong
ALOGE("addFont failed to create font, invalid request");
return false;
}
FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
MinikinFont* minikinFont = new MinikinFontSkia(face, fontPtr, (size_t)fontSize, ttcIndex);
fontFamily->addFont(minikinFont, FontStyle(weight / 100, isItalic));
minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
minikin::MinikinFont* minikinFont =
new MinikinFontSkia(face, fontPtr, (size_t)fontSize, ttcIndex);
fontFamily->addFont(minikinFont, minikin::FontStyle(weight / 100, isItalic));
minikinFont->Unref();
return true;
}
@@ -219,7 +220,7 @@ static jboolean FontFamily_addFontFromAsset(JNIEnv* env, jobject, jlong familyPt
ALOGE("addFontFromAsset failed to create font %s", str.c_str());
return false;
}
FontFamily* fontFamily = reinterpret_cast<FontFamily*>(familyPtr);
minikin::FontFamily* fontFamily = reinterpret_cast<minikin::FontFamily*>(familyPtr);
return addSkTypeface(fontFamily, face, buf, bufSize, /* ttcIndex */ 0);
}

41
core/jni/android/graphics/Paint.cpp
View File

@@ -319,7 +319,7 @@ namespace PaintGlue {
static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) {
Paint* obj = reinterpret_cast<Paint*>(objHandle);
ScopedUtfChars localesChars(env, locales);
jint minikinLangListId = FontStyle::registerLanguageList(localesChars.c_str());
jint minikinLangListId = minikin::FontStyle::registerLanguageList(localesChars.c_str());
obj->setMinikinLangListId(minikinLangListId);
return minikinLangListId;
}
@@ -332,12 +332,12 @@ namespace PaintGlue {
static jboolean isElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle) {
Paint* obj = reinterpret_cast<Paint*>(paintHandle);
return obj->getFontVariant() == VARIANT_ELEGANT;
return obj->getFontVariant() == minikin::VARIANT_ELEGANT;
}
static void setElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle, jboolean aa) {
Paint* obj = reinterpret_cast<Paint*>(paintHandle);
obj->setFontVariant(aa ? VARIANT_ELEGANT : VARIANT_DEFAULT);
obj->setFontVariant(aa ? minikin::VARIANT_ELEGANT : minikin::VARIANT_DEFAULT);
}
static jfloat getTextSize(JNIEnv* env, jobject, jlong paintHandle) {
@@ -404,7 +404,7 @@ namespace PaintGlue {
Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
typeface = Typeface::resolveDefault(typeface);
FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
minikin::FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
float saveSkewX = paint->getTextSkewX();
bool savefakeBold = paint->isFakeBoldText();
MinikinFontSkia::populateSkPaint(paint, baseFont.font, baseFont.fakery);
@@ -414,7 +414,7 @@ namespace PaintGlue {
// restore the original settings.
paint->setTextSkewX(saveSkewX);
paint->setFakeBoldText(savefakeBold);
if (paint->getFontVariant() == VARIANT_ELEGANT) {
if (paint->getFontVariant() == minikin::VARIANT_ELEGANT) {
SkScalar size = paint->getTextSize();
metrics->fTop = -size * kElegantTop / 2048;
metrics->fBottom = -size * kElegantBottom / 2048;
@@ -534,8 +534,9 @@ namespace PaintGlue {
static jint doTextRunCursor(JNIEnv *env, Paint* paint, const jchar *text, jint start,
jint count, jint flags, jint offset, jint opt) {
GraphemeBreak::MoveOpt moveOpt = GraphemeBreak::MoveOpt(opt);
size_t result = GraphemeBreak::getTextRunCursor(text, start, count, offset, moveOpt);
minikin::GraphemeBreak::MoveOpt moveOpt = minikin::GraphemeBreak::MoveOpt(opt);
size_t result = minikin::GraphemeBreak::getTextRunCursor(text, start, count, offset,
moveOpt);
return static_cast<jint>(result);
}
@@ -561,8 +562,8 @@ namespace PaintGlue {
class GetTextFunctor {
public:
GetTextFunctor(const Layout& layout, SkPath* path, jfloat x, jfloat y, Paint* paint,
uint16_t* glyphs, SkPoint* pos)
GetTextFunctor(const minikin::Layout& layout, SkPath* path, jfloat x, jfloat y,
Paint* paint, uint16_t* glyphs, SkPoint* pos)
: layout(layout), path(path), x(x), y(y), paint(paint), glyphs(glyphs), pos(pos) {
}
@@ -580,7 +581,7 @@ namespace PaintGlue {
}
}
private:
const Layout& layout;
const minikin::Layout& layout;
SkPath* path;
jfloat x;
jfloat y;
@@ -592,7 +593,7 @@ namespace PaintGlue {
static void getTextPath(JNIEnv* env, Paint* paint, Typeface* typeface, const jchar* text,
jint count, jint bidiFlags, jfloat x, jfloat y, SkPath* path) {
Layout layout;
minikin::Layout layout;
MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, text, 0, count, count);
size_t nGlyphs = layout.nGlyphs();
uint16_t* glyphs = new uint16_t[nGlyphs];
@@ -728,9 +729,9 @@ namespace PaintGlue {
SkRect r;
SkIRect ir;
Layout layout;
minikin::Layout layout;
MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, 0, count, count);
MinikinRect rect;
minikin::MinikinRect rect;
layout.getBounds(&rect);
r.fLeft = rect.mLeft;
r.fTop = rect.mTop;
@@ -759,7 +760,7 @@ namespace PaintGlue {
JNI_ABORT);
}
static jboolean layoutContainsNotdef(const Layout& layout) {
static jboolean layoutContainsNotdef(const minikin::Layout& layout) {
for (size_t i = 0; i < layout.nGlyphs(); i++) {
if (layout.getGlyphId(i) == 0) {
return true;
@@ -828,7 +829,7 @@ namespace PaintGlue {
nChars++;
prevCp = cp;
}
Layout layout;
minikin::Layout layout;
MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, str.get(), 0, str.size(),
str.size());
size_t nGlyphs = layout.nGlyphs();
@@ -849,7 +850,7 @@ namespace PaintGlue {
// since ZZ is reserved for unknown or invalid territory.
// U+1F1FF (REGIONAL INDICATOR SYMBOL LETTER Z) is \uD83C\uDDFF in UTF16.
static const jchar ZZ_FLAG_STR[] = { 0xD83C, 0xDDFF, 0xD83C, 0xDDFF };
Layout zzLayout;
minikin::Layout zzLayout;
MinikinUtils::doLayout(&zzLayout, paint, bidiFlags, typeface, ZZ_FLAG_STR, 0, 4, 4);
if (zzLayout.nGlyphs() != 1 || layoutContainsNotdef(zzLayout)) {
// The font collection doesn't have a glyph for unknown flag. Just return true.
@@ -862,7 +863,7 @@ namespace PaintGlue {
static jfloat doRunAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
jint start, jint count, jint bufSize, jboolean isRtl, jint offset) {
int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
if (offset == start + count) {
return MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count,
bufSize, nullptr);
@@ -870,7 +871,7 @@ namespace PaintGlue {
std::unique_ptr<float[]> advancesArray(new float[count]);
MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
advancesArray.get());
return getRunAdvance(advancesArray.get(), buf, start, count, offset);
return minikin::getRunAdvance(advancesArray.get(), buf, start, count, offset);
}
static jfloat getRunAdvance___CIIIIZI_F(JNIEnv *env, jclass, jlong paintHandle,
@@ -888,11 +889,11 @@ namespace PaintGlue {
static jint doOffsetForAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
jint start, jint count, jint bufSize, jboolean isRtl, jfloat advance) {
int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
std::unique_ptr<float[]> advancesArray(new float[count]);
MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
advancesArray.get());
return getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
return minikin::getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
}
static jint getOffsetForAdvance___CIIIIZF_I(JNIEnv *env, jclass, jlong paintHandle,

4
core/jni/android/graphics/Typeface.cpp
View File

@@ -60,9 +60,9 @@ static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) {
static jlong Typeface_createFromArray(JNIEnv *env, jobject, jlongArray familyArray) {
ScopedLongArrayRO families(env, familyArray);
std::vector<FontFamily*> familyVec;
std::vector<minikin::FontFamily*> familyVec;
for (size_t i = 0; i < families.size(); i++) {
FontFamily* family = reinterpret_cast<FontFamily*>(families[i]);
minikin::FontFamily* family = reinterpret_cast<minikin::FontFamily*>(families[i]);
familyVec.push_back(family);
}
return reinterpret_cast<jlong>(Typeface::createFromFamilies(familyVec));

6
core/jni/android_graphics_Canvas.cpp
View File

@@ -503,7 +503,7 @@ static void drawTextRunChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArra
Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
const int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
const int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
jchar* jchars = env->GetCharArrayElements(text, NULL);
get_canvas(canvasHandle)->drawText(jchars + contextIndex, index - contextIndex, count,
contextCount, x, y, bidiFlags, *paint, typeface);
@@ -517,7 +517,7 @@ static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstr
Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
int bidiFlags = isRtl ? minikin::kBidi_Force_RTL : minikin::kBidi_Force_LTR;
jint count = end - start;
jint contextCount = contextEnd - contextStart;
const jchar* jchars = env->GetStringChars(text, NULL);
@@ -567,7 +567,7 @@ static void freeCaches(JNIEnv* env, jobject) {
}
static void freeTextLayoutCaches(JNIEnv* env, jobject) {
Layout::purgeCaches();
minikin::Layout::purgeCaches();
}
}; // namespace CanvasJNI

39
core/jni/android_text_StaticLayout.cpp
View File

@@ -55,7 +55,7 @@ static JLineBreaksID gLineBreaks_fieldID;
static void nSetupParagraph(JNIEnv* env, jclass, jlong nativePtr, jcharArray text, jint length,
jfloat firstWidth, jint firstWidthLineLimit, jfloat restWidth,
jintArray variableTabStops, jint defaultTabStop, jint strategy, jint hyphenFrequency) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
b->resize(length);
env->GetCharArrayRegion(text, 0, length, b->buffer());
b->setText();
@@ -66,8 +66,8 @@ static void nSetupParagraph(JNIEnv* env, jclass, jlong nativePtr, jcharArray tex
ScopedIntArrayRO stops(env, variableTabStops);
b->setTabStops(stops.get(), stops.size(), defaultTabStop);
}
b->setStrategy(static_cast<BreakStrategy>(strategy));
b->setHyphenationFrequency(static_cast<HyphenationFrequency>(hyphenFrequency));
b->setStrategy(static_cast<minikin::BreakStrategy>(strategy));
b->setHyphenationFrequency(static_cast<minikin::HyphenationFrequency>(hyphenFrequency));
}
static void recycleCopy(JNIEnv* env, jobject recycle, jintArray recycleBreaks,
@@ -94,7 +94,7 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
jobject recycle, jintArray recycleBreaks,
jfloatArray recycleWidths, jintArray recycleFlags,
jint recycleLength) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
size_t nBreaks = b->computeBreaks();
@@ -107,15 +107,15 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
}
static jlong nNewBuilder(JNIEnv*, jclass) {
return reinterpret_cast<jlong>(new LineBreaker);
return reinterpret_cast<jlong>(new minikin::LineBreaker);
}
static void nFreeBuilder(JNIEnv*, jclass, jlong nativePtr) {
delete reinterpret_cast<LineBreaker*>(nativePtr);
delete reinterpret_cast<minikin::LineBreaker*>(nativePtr);
}
static void nFinishBuilder(JNIEnv*, jclass, jlong nativePtr) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
b->finish();
}
@@ -129,15 +129,15 @@ static jlong nLoadHyphenator(JNIEnv* env, jclass, jobject buffer, jint offset) {
ALOGE("failed to get direct buffer address");
}
}
Hyphenator* hyphenator = Hyphenator::loadBinary(bytebuf);
minikin::Hyphenator* hyphenator = minikin::Hyphenator::loadBinary(bytebuf);
return reinterpret_cast<jlong>(hyphenator);
}
static void nSetLocale(JNIEnv* env, jclass, jlong nativePtr, jstring javaLocaleName,
jlong nativeHyphenator) {
ScopedIcuLocale icuLocale(env, javaLocaleName);
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
Hyphenator* hyphenator = reinterpret_cast<Hyphenator*>(nativeHyphenator);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
minikin::Hyphenator* hyphenator = reinterpret_cast<minikin::Hyphenator*>(nativeHyphenator);
if (icuLocale.valid()) {
b->setLocale(icuLocale.locale(), hyphenator);
@@ -147,38 +147,39 @@ static void nSetLocale(JNIEnv* env, jclass, jlong nativePtr, jstring javaLocaleN
static void nSetIndents(JNIEnv* env, jclass, jlong nativePtr, jintArray indents) {
ScopedIntArrayRO indentArr(env, indents);
std::vector<float> indentVec(indentArr.get(), indentArr.get() + indentArr.size());
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
b->setIndents(indentVec);
}
// Basically similar to Paint.getTextRunAdvances but with C++ interface
static jfloat nAddStyleRun(JNIEnv* env, jclass, jlong nativePtr,
jlong nativePaint, jlong nativeTypeface, jint start, jint end, jboolean isRtl) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
Paint* paint = reinterpret_cast<Paint*>(nativePaint);
Typeface* typeface = reinterpret_cast<Typeface*>(nativeTypeface);
FontCollection *font;
MinikinPaint minikinPaint;
FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
minikin::FontCollection *font;
minikin::MinikinPaint minikinPaint;
minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, &font, paint,
typeface);
return b->addStyleRun(&minikinPaint, font, style, start, end, isRtl);
}
// Accept width measurements for the run, passed in from Java
static void nAddMeasuredRun(JNIEnv* env, jclass, jlong nativePtr,
jint start, jint end, jfloatArray widths) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
env->GetFloatArrayRegion(widths, start, end - start, b->charWidths() + start);
b->addStyleRun(nullptr, nullptr, FontStyle{}, start, end, false);
b->addStyleRun(nullptr, nullptr, minikin::FontStyle{}, start, end, false);
}
static void nAddReplacementRun(JNIEnv* env, jclass, jlong nativePtr,
jint start, jint end, jfloat width) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
b->addReplacement(start, end, width);
}
static void nGetWidths(JNIEnv* env, jclass, jlong nativePtr, jfloatArray widths) {
LineBreaker* b = reinterpret_cast<LineBreaker*>(nativePtr);
minikin::LineBreaker* b = reinterpret_cast<minikin::LineBreaker*>(nativePtr);
env->SetFloatArrayRegion(widths, 0, b->size(), b->charWidths());
}

19
libs/hwui/hwui/Canvas.cpp
View File

@@ -79,8 +79,9 @@ static void simplifyPaint(int color, SkPaint* paint) {
class DrawTextFunctor {
public:
DrawTextFunctor(const Layout& layout, Canvas* canvas, uint16_t* glyphs, float* pos,
const SkPaint& paint, float x, float y, MinikinRect& bounds, float totalAdvance)
DrawTextFunctor(const minikin::Layout& layout, Canvas* canvas, uint16_t* glyphs, float* pos,
const SkPaint& paint, float x, float y, minikin::MinikinRect& bounds,
float totalAdvance)
: layout(layout)
, canvas(canvas)
, glyphs(glyphs)
@@ -135,14 +136,14 @@ public:
}
}
private:
const Layout& layout;
const minikin::Layout& layout;
Canvas* canvas;
uint16_t* glyphs;
float* pos;
const SkPaint& paint;
float x;
float y;
MinikinRect& bounds;
minikin::MinikinRect& bounds;
float totalAdvance;
};
@@ -151,7 +152,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
// minikin may modify the original paint
Paint paint(origPaint);
Layout layout;
minikin::Layout layout;
MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, start, count, contextCount);
size_t nGlyphs = layout.nGlyphs();
@@ -160,7 +161,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
x += MinikinUtils::xOffsetForTextAlign(&paint, layout);
MinikinRect bounds;
minikin::MinikinRect bounds;
layout.getBounds(&bounds);
if (!drawTextAbsolutePos()) {
bounds.offset(x, y);
@@ -178,7 +179,7 @@ void Canvas::drawText(const uint16_t* text, int start, int count, int contextCou
class DrawTextOnPathFunctor {
public:
DrawTextOnPathFunctor(const Layout& layout, Canvas* canvas, float hOffset,
DrawTextOnPathFunctor(const minikin::Layout& layout, Canvas* canvas, float hOffset,
float vOffset, const Paint& paint, const SkPath& path)
: layout(layout)
, canvas(canvas)
@@ -198,7 +199,7 @@ public:
}
}
private:
const Layout& layout;
const minikin::Layout& layout;
Canvas* canvas;
float hOffset;
float vOffset;
@@ -209,7 +210,7 @@ private:
void Canvas::drawTextOnPath(const uint16_t* text, int count, int bidiFlags, const SkPath& path,
float hOffset, float vOffset, const Paint& paint, Typeface* typeface) {
Paint paintCopy(paint);
Layout layout;
minikin::Layout layout;
MinikinUtils::doLayout(&layout, &paintCopy, bidiFlags, typeface, text, 0, count, count);
hOffset += MinikinUtils::hOffsetForTextAlign(&paintCopy, layout, path);

17
libs/hwui/hwui/MinikinSkia.cpp
View File

@@ -24,7 +24,7 @@ namespace android {
MinikinFontSkia::MinikinFontSkia(SkTypeface* typeface, const void* fontData, size_t fontSize,
int ttcIndex) :
MinikinFont(typeface->uniqueID()), mTypeface(typeface), mFontData(fontData),
minikin::MinikinFont(typeface->uniqueID()), mTypeface(typeface), mFontData(fontData),
mFontSize(fontSize), mTtcIndex(ttcIndex) {
}
@@ -32,7 +32,8 @@ MinikinFontSkia::~MinikinFontSkia() {
SkSafeUnref(mTypeface);
}
static void MinikinFontSkia_SetSkiaPaint(const MinikinFont* font, SkPaint* skPaint, const MinikinPaint& paint) {
static void MinikinFontSkia_SetSkiaPaint(const minikin::MinikinFont* font, SkPaint* skPaint,
const minikin::MinikinPaint& paint) {
skPaint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
skPaint->setTextSize(paint.size);
skPaint->setTextScaleX(paint.scaleX);
@@ -43,7 +44,7 @@ static void MinikinFontSkia_SetSkiaPaint(const MinikinFont* font, SkPaint* skPai
}
float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id,
const MinikinPaint &paint) const {
const minikin::MinikinPaint &paint) const {
SkPaint skPaint;
uint16_t glyph16 = glyph_id;
SkScalar skWidth;
@@ -55,8 +56,8 @@ float MinikinFontSkia::GetHorizontalAdvance(uint32_t glyph_id,
return skWidth;
}
void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id,
const MinikinPaint& paint) const {
void MinikinFontSkia::GetBounds(minikin::MinikinRect* bounds, uint32_t glyph_id,
const minikin::MinikinPaint& paint) const {
SkPaint skPaint;
uint16_t glyph16 = glyph_id;
SkRect skBounds;
@@ -68,7 +69,8 @@ void MinikinFontSkia::GetBounds(MinikinRect* bounds, uint32_t glyph_id,
bounds->mBottom = skBounds.fBottom;
}
const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy) {
const void* MinikinFontSkia::GetTable(uint32_t tag, size_t* size,
minikin::MinikinDestroyFunc* destroy) {
// we don't have a buffer to the font data, copy to own buffer
const size_t tableSize = mTypeface->getTableSize(tag);
*size = tableSize;
@@ -117,7 +119,8 @@ void MinikinFontSkia::unpackPaintFlags(SkPaint* paint, uint32_t paintFlags) {
paint->setHinting(static_cast<SkPaint::Hinting>(paintFlags >> 16));
}
void MinikinFontSkia::populateSkPaint(SkPaint* paint, const MinikinFont* font, FontFakery fakery) {
void MinikinFontSkia::populateSkPaint(SkPaint* paint, const MinikinFont* font,
minikin::FontFakery fakery) {
paint->setTypeface(reinterpret_cast<const MinikinFontSkia*>(font)->GetSkTypeface());
paint->setFakeBoldText(paint->isFakeBoldText() || fakery.isFakeBold());
if (fakery.isFakeItalic()) {

13
libs/hwui/hwui/MinikinSkia.h
View File

@@ -25,7 +25,7 @@ class SkTypeface;
namespace android {
class ANDROID_API MinikinFontSkia : public MinikinFont {
class ANDROID_API MinikinFontSkia : public minikin::MinikinFont {
public:
// Note: this takes ownership of the reference (will unref on dtor)
explicit MinikinFontSkia(SkTypeface *typeface, const void* fontData, size_t fontSize,
@@ -34,12 +34,12 @@ public:
~MinikinFontSkia();
float GetHorizontalAdvance(uint32_t glyph_id,
const MinikinPaint &paint) const;
const minikin::MinikinPaint &paint) const;
void GetBounds(MinikinRect* bounds, uint32_t glyph_id,
const MinikinPaint &paint) const;
void GetBounds(minikin::MinikinRect* bounds, uint32_t glyph_id,
const minikin::MinikinPaint &paint) const;
const void* GetTable(uint32_t tag, size_t* size, MinikinDestroyFunc* destroy);
const void* GetTable(uint32_t tag, size_t* size, minikin::MinikinDestroyFunc* destroy);
SkTypeface* GetSkTypeface() const;
@@ -52,7 +52,8 @@ public:
static void unpackPaintFlags(SkPaint* paint, uint32_t paintFlags);
// set typeface and fake bold/italic parameters
static void populateSkPaint(SkPaint* paint, const MinikinFont* font, FontFakery fakery);
static void populateSkPaint(SkPaint* paint, const minikin::MinikinFont* font,
minikin::FontFakery fakery);
private:
SkTypeface* mTypeface;

38
libs/hwui/hwui/MinikinUtils.cpp
View File

@@ -24,17 +24,18 @@
namespace android {
FontStyle MinikinUtils::prepareMinikinPaint(MinikinPaint* minikinPaint, FontCollection** pFont,
const Paint* paint, Typeface* typeface) {
minikin::FontStyle MinikinUtils::prepareMinikinPaint(minikin::MinikinPaint* minikinPaint,
minikin::FontCollection** pFont, const Paint* paint, Typeface* typeface) {
const Typeface* resolvedFace = Typeface::resolveDefault(typeface);
*pFont = resolvedFace->fFontCollection;
FontStyle resolved = resolvedFace->fStyle;
minikin::FontStyle resolved = resolvedFace->fStyle;
/* Prepare minikin FontStyle */
FontVariant minikinVariant = (paint->getFontVariant() == VARIANT_ELEGANT) ? VARIANT_ELEGANT
: VARIANT_COMPACT;
minikin::FontVariant minikinVariant = (paint->getFontVariant() == minikin::VARIANT_ELEGANT) ?
minikin::VARIANT_ELEGANT : minikin::VARIANT_COMPACT;
const uint32_t langListId = paint->getMinikinLangListId();
FontStyle minikinStyle(langListId, minikinVariant, resolved.getWeight(), resolved.getItalic());
minikin::FontStyle minikinStyle(langListId, minikinVariant, resolved.getWeight(),
resolved.getItalic());
/* Prepare minikin Paint */
// Note: it would be nice to handle fractional size values (it would improve smooth zoom
@@ -46,27 +47,27 @@ FontStyle MinikinUtils::prepareMinikinPaint(MinikinPaint* minikinPaint, FontColl
minikinPaint->letterSpacing = paint->getLetterSpacing();
minikinPaint->paintFlags = MinikinFontSkia::packPaintFlags(paint);
minikinPaint->fontFeatureSettings = paint->getFontFeatureSettings();
minikinPaint->hyphenEdit = HyphenEdit(paint->getHyphenEdit());
minikinPaint->hyphenEdit = minikin::HyphenEdit(paint->getHyphenEdit());
return minikinStyle;
}
void MinikinUtils::doLayout(Layout* layout, const Paint* paint, int bidiFlags,
void MinikinUtils::doLayout(minikin::Layout* layout, const Paint* paint, int bidiFlags,
Typeface* typeface, const uint16_t* buf, size_t start, size_t count,
size_t bufSize) {
FontCollection *font;
MinikinPaint minikinPaint;
FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
minikin::FontCollection *font;
minikin::MinikinPaint minikinPaint;
minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
layout->setFontCollection(font);
layout->doLayout(buf, start, count, bufSize, bidiFlags, minikinStyle, minikinPaint);
}
float MinikinUtils::measureText(const Paint* paint, int bidiFlags, Typeface* typeface,
const uint16_t* buf, size_t start, size_t count, size_t bufSize, float *advances) {
FontCollection *font;
MinikinPaint minikinPaint;
FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
return Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinStyle, minikinPaint,
font, advances);
minikin::FontCollection *font;
minikin::MinikinPaint minikinPaint;
minikin::FontStyle minikinStyle = prepareMinikinPaint(&minikinPaint, &font, paint, typeface);
return minikin::Layout::measureText(buf, start, count, bufSize, bidiFlags, minikinStyle,
minikinPaint, font, advances);
}
bool MinikinUtils::hasVariationSelector(Typeface* typeface, uint32_t codepoint, uint32_t vs) {
@@ -74,7 +75,7 @@ bool MinikinUtils::hasVariationSelector(Typeface* typeface, uint32_t codepoint,
return resolvedFace->fFontCollection->hasVariationSelector(codepoint, vs);
}
float MinikinUtils::xOffsetForTextAlign(Paint* paint, const Layout& layout) {
float MinikinUtils::xOffsetForTextAlign(Paint* paint, const minikin::Layout& layout) {
switch (paint->getTextAlign()) {
case Paint::kCenter_Align:
return layout.getAdvance() * -0.5f;
@@ -88,7 +89,8 @@ float MinikinUtils::xOffsetForTextAlign(Paint* paint, const Layout& layout) {
return 0;
}
float MinikinUtils::hOffsetForTextAlign(Paint* paint, const Layout& layout, const SkPath& path) {
float MinikinUtils::hOffsetForTextAlign(Paint* paint, const minikin::Layout& layout,
const SkPath& path) {
float align = 0;
switch (paint->getTextAlign()) {
case Paint::kCenter_Align:

20
libs/hwui/hwui/MinikinUtils.h
View File

@@ -34,31 +34,33 @@ namespace android {
class MinikinUtils {
public:
ANDROID_API static FontStyle prepareMinikinPaint(MinikinPaint* minikinPaint, FontCollection** pFont,
const Paint* paint, Typeface* typeface);
ANDROID_API static minikin::FontStyle prepareMinikinPaint(minikin::MinikinPaint* minikinPaint,
minikin::FontCollection** pFont, const Paint* paint, Typeface* typeface);
ANDROID_API static void doLayout(Layout* layout, const Paint* paint, int bidiFlags,
ANDROID_API static void doLayout(minikin::Layout* layout, const Paint* paint, int bidiFlags,
Typeface* typeface, const uint16_t* buf, size_t start, size_t count,
size_t bufSize);
ANDROID_API static float measureText(const Paint* paint, int bidiFlags, Typeface* typeface,
const uint16_t* buf, size_t start, size_t count, size_t bufSize, float *advances);
ANDROID_API static bool hasVariationSelector(Typeface* typeface, uint32_t codepoint, uint32_t vs);
ANDROID_API static bool hasVariationSelector(Typeface* typeface, uint32_t codepoint,
uint32_t vs);
ANDROID_API static float xOffsetForTextAlign(Paint* paint, const Layout& layout);
ANDROID_API static float xOffsetForTextAlign(Paint* paint, const minikin::Layout& layout);
ANDROID_API static float hOffsetForTextAlign(Paint* paint, const Layout& layout, const SkPath& path);
ANDROID_API static float hOffsetForTextAlign(Paint* paint, const minikin::Layout& layout,
const SkPath& path);
// f is a functor of type void f(size_t start, size_t end);
template <typename F>
ANDROID_API static void forFontRun(const Layout& layout, Paint* paint, F& f) {
ANDROID_API static void forFontRun(const minikin::Layout& layout, Paint* paint, F& f) {
float saveSkewX = paint->getTextSkewX();
bool savefakeBold = paint->isFakeBoldText();
MinikinFont* curFont = NULL;
minikin::MinikinFont* curFont = NULL;
size_t start = 0;
size_t nGlyphs = layout.nGlyphs();
for (size_t i = 0; i < nGlyphs; i++) {
MinikinFont* nextFont = layout.getFont(i);
minikin::MinikinFont* nextFont = layout.getFont(i);
if (i > 0 && nextFont != curFont) {
MinikinFontSkia::populateSkPaint(paint, curFont, layout.getFakery(start));
f(start, i);

6
libs/hwui/hwui/Paint.h
View File

@@ -64,11 +64,11 @@ public:
return mMinikinLangListId;
}
void setFontVariant(FontVariant variant) {
void setFontVariant(minikin::FontVariant variant) {
mFontVariant = variant;
}
FontVariant getFontVariant() const {
minikin::FontVariant getFontVariant() const {
return mFontVariant;
}
@@ -84,7 +84,7 @@ private:
float mLetterSpacing = 0;
std::string mFontFeatureSettings;
uint32_t mMinikinLangListId;
FontVariant mFontVariant;
minikin::FontVariant mFontVariant;
uint32_t mHyphenEdit = 0;
};

4
libs/hwui/hwui/PaintImpl.cpp
View File

@@ -20,7 +20,7 @@ namespace android {
Paint::Paint() :
SkPaint(), mLetterSpacing(0), mFontFeatureSettings(), mMinikinLangListId(0),
mFontVariant(VARIANT_DEFAULT) {
mFontVariant(minikin::VARIANT_DEFAULT) {
}
Paint::Paint(const Paint& paint) : SkPaint(paint),
@@ -31,7 +31,7 @@ Paint::Paint(const Paint& paint) : SkPaint(paint),
Paint::Paint(const SkPaint& paint) : SkPaint(paint),
mLetterSpacing(0), mFontFeatureSettings(), mMinikinLangListId(0),
mFontVariant(VARIANT_DEFAULT) {
mFontVariant(minikin::VARIANT_DEFAULT) {
}
Paint::~Paint() {

24
libs/hwui/hwui/Typeface.cpp
View File

@@ -43,7 +43,7 @@ static void resolveStyle(Typeface* typeface) {
weight = 9;
}
bool italic = (typeface->fSkiaStyle & SkTypeface::kItalic) != 0;
typeface->fStyle = FontStyle(weight, italic);
typeface->fStyle = minikin::FontStyle(weight, italic);
}
Typeface* gDefaultTypeface = NULL;
@@ -54,13 +54,13 @@ pthread_once_t gDefaultTypefaceOnce = PTHREAD_ONCE_INIT;
// typeface is set.
// TODO: investigate why layouts are being created before Typeface.java
// class initialization.
static FontCollection *makeFontCollection() {
std::vector<FontFamily *>typefaces;
static minikin::FontCollection *makeFontCollection() {
std::vector<minikin::FontFamily *>typefaces;
const char *fns[] = {
"/system/fonts/Roboto-Regular.ttf",
};
FontFamily *family = new FontFamily();
minikin::FontFamily *family = new minikin::FontFamily();
for (size_t i = 0; i < sizeof(fns)/sizeof(fns[0]); i++) {
const char *fn = fns[i];
ALOGD("makeFontCollection adding %s", fn);
@@ -69,7 +69,7 @@ static FontCollection *makeFontCollection() {
// TODO: might be a nice optimization to get access to the underlying font
// data, but would require us opening the file ourselves and passing that
// to the appropriate Create method of SkTypeface.
MinikinFont *font = new MinikinFontSkia(skFace, NULL, 0, 0);
minikin::MinikinFont *font = new MinikinFontSkia(skFace, NULL, 0, 0);
family->addFont(font);
font->Unref();
} else {
@@ -78,13 +78,13 @@ static FontCollection *makeFontCollection() {
}
typefaces.push_back(family);
FontCollection *result = new FontCollection(typefaces);
minikin::FontCollection *result = new minikin::FontCollection(typefaces);
family->Unref();
return result;
}
static void getDefaultTypefaceOnce() {
Layout::init();
minikin::Layout::init();
if (gDefaultTypeface == NULL) {
// We expect the client to set a default typeface, but provide a
// default so we can make progress before that happens.
@@ -131,16 +131,16 @@ Typeface* Typeface::createWeightAlias(Typeface* src, int weight) {
return result;
}
Typeface* Typeface::createFromFamilies(const std::vector<FontFamily*>& families) {
Typeface* Typeface::createFromFamilies(const std::vector<minikin::FontFamily*>& families) {
Typeface* result = new Typeface;
result->fFontCollection = new FontCollection(families);
result->fFontCollection = new minikin::FontCollection(families);
if (families.empty()) {
ALOGW("createFromFamilies creating empty collection");
result->fSkiaStyle = SkTypeface::kNormal;
} else {
const FontStyle defaultStyle;
FontFamily* firstFamily = reinterpret_cast<FontFamily*>(families[0]);
MinikinFont* mf = firstFamily->getClosestMatch(defaultStyle).font;
const minikin::FontStyle defaultStyle;
minikin::FontFamily* firstFamily = reinterpret_cast<minikin::FontFamily*>(families[0]);
minikin::MinikinFont* mf = firstFamily->getClosestMatch(defaultStyle).font;
if (mf != NULL) {
SkTypeface* skTypeface = reinterpret_cast<MinikinFontSkia*>(mf)->GetSkTypeface();
// TODO: probably better to query more precise style from family, will be important

6
libs/hwui/hwui/Typeface.h
View File

@@ -27,7 +27,7 @@
namespace android {
struct ANDROID_API Typeface {
FontCollection *fFontCollection;
minikin::FontCollection *fFontCollection;
// style used for constructing and querying Typeface objects
SkTypeface::Style fSkiaStyle;
@@ -35,7 +35,7 @@ struct ANDROID_API Typeface {
int fBaseWeight;
// resolved style actually used for rendering
FontStyle fStyle;
minikin::FontStyle fStyle;
void unref();
@@ -45,7 +45,7 @@ struct ANDROID_API Typeface {
static Typeface* createWeightAlias(Typeface* src, int baseweight);
static Typeface* createFromFamilies(const std::vector<FontFamily*>& families);
static Typeface* createFromFamilies(const std::vector<minikin::FontFamily*>& families);
static void setDefault(Typeface* face);
};

4
libs/hwui/tests/common/scenes/GlyphStressAnimation.cpp
View File

@@ -17,8 +17,8 @@
#include "TestSceneBase.h"
#include "utils/Color.h"
#include <minikin/Layout.h>
#include <hwui/Paint.h>
#include <minikin/Layout.h>
#include <cstdio>
@@ -56,7 +56,7 @@ public:
for (int i = 0; i < 5; i++) {
paint.setTextSize(10 + (frameNr % 20) + i * 20);
canvas.drawText(text.get(), 0, textLength, textLength,
0, 100 * (i + 2), kBidi_Force_LTR, paint, nullptr);
0, 100 * (i + 2), minikin::kBidi_Force_LTR, paint, nullptr);
}
container->setStagingDisplayList(canvas.finishRecording(), nullptr);

4
libs/hwui/tests/unit/RecordingCanvasTests.cpp
View File

@@ -716,7 +716,7 @@ TEST(RecordingCanvas, drawText) {
paint.setTextSize(20);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
std::unique_ptr<uint16_t[]> dst = TestUtils::asciiToUtf16("HELLO");
canvas.drawText(dst.get(), 0, 5, 5, 25, 25, kBidi_Force_LTR, paint, NULL);
canvas.drawText(dst.get(), 0, 5, 5, 25, 25, minikin::kBidi_Force_LTR, paint, NULL);
});
int count = 0;
@@ -740,7 +740,7 @@ TEST(RecordingCanvas, drawTextInHighContrast) {
paint.setTextSize(20);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
std::unique_ptr<uint16_t[]> dst = TestUtils::asciiToUtf16("HELLO");
canvas.drawText(dst.get(), 0, 5, 5, 25, 25, kBidi_Force_LTR, paint, NULL);
canvas.drawText(dst.get(), 0, 5, 5, 25, 25, minikin::kBidi_Force_LTR, paint, NULL);
});
int count = 0;