AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove SkPaintOptionsAndroid

Browse Source 
Committed: https://skia.googlesource.com/skia/+/f32331ffdb5de0440bb337aa7cbdd6f33e9ff23b

R=reed@google.com, mtklein@google.com, tomhudson@google.com

Author: djsollen@google.com

Review URL: https://codereview.chromium.org/447873003
This commit is contained in:
djsollen 2014-08-14 06:29:02 -07:00 committed by Commit bot
parent 30e26cdb41
commit 3b6255493e
14 changed files with 98 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gyp/core.gypi
View File

@ -117,7 +117,6 @@
'<(skia_src_path)/core/SkMipMap.cpp',
'<(skia_src_path)/core/SkPackBits.cpp',
'<(skia_src_path)/core/SkPaint.cpp',
'<(skia_src_path)/core/SkPaintOptionsAndroid.cpp',
'<(skia_src_path)/core/SkPaintPriv.cpp',
'<(skia_src_path)/core/SkPaintPriv.h',
'<(skia_src_path)/core/SkPath.cpp',

1
gyp/tests.gypi
View File

@ -46,7 +46,6 @@
'../tests/AAClipTest.cpp',
'../tests/ARGBImageEncoderTest.cpp',
'../tests/AndroidPaintTest.cpp',
'../tests/AnnotationTest.cpp',
'../tests/AsADashTest.cpp',
'../tests/AtomicTest.cpp',

10
include/core/SkPaint.h
View File

@ -15,9 +15,6 @@
#include "SkDrawLooper.h"
#include "SkMatrix.h"
#include "SkXfermode.h"
#ifdef SK_BUILD_FOR_ANDROID
#include "SkPaintOptionsAndroid.h"
#endif
class SkAnnotation;
class SkAutoGlyphCache;
@ -941,11 +938,6 @@ public:
#ifdef SK_BUILD_FOR_ANDROID
uint32_t getGenerationID() const;
void setGenerationID(uint32_t generationID);
const SkPaintOptionsAndroid& getPaintOptionsAndroid() const {
return fPaintOptionsAndroid;
}
void setPaintOptionsAndroid(const SkPaintOptionsAndroid& options);
#endif
// returns true if the paint's settings (e.g. xfermode + alpha) resolve to
@ -1138,8 +1130,6 @@ private:
friend class SkCanonicalizePaint;
#ifdef SK_BUILD_FOR_ANDROID
SkPaintOptionsAndroid fPaintOptionsAndroid;
// In order for the == operator to work properly this must be the last field
// in the struct so that we can do a memcmp to this field's offset.
uint32_t fGenerationID;

120
include/core/SkPaintOptionsAndroid.h
View File

@ -1,120 +0,0 @@
/*
* Copyright 2012 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPaintOptionsAndroid_DEFINED
#define SkPaintOptionsAndroid_DEFINED
#include "SkTypes.h"
#include "SkString.h"
class SkReadBuffer;
class SkWriteBuffer;
/** \class SkLanguage
The SkLanguage class represents a human written language, and is used by
text draw operations to determine which glyph to draw when drawing
characters with variants (ie Han-derived characters).
*/
class SkLanguage {
public:
SkLanguage() { }
SkLanguage(const SkString& tag) : fTag(tag) { }
SkLanguage(const char* tag) : fTag(tag) { }
SkLanguage(const char* tag, size_t len) : fTag(tag, len) { }
SkLanguage(const SkLanguage& b) : fTag(b.fTag) { }
/** Gets a BCP 47 language identifier for this SkLanguage.
@return a BCP 47 language identifier representing this language
*/
const SkString& getTag() const { return fTag; }
/** Performs BCP 47 fallback to return an SkLanguage one step more general.
@return an SkLanguage one step more general
*/
SkLanguage getParent() const;
bool operator==(const SkLanguage& b) const {
return fTag == b.fTag;
}
bool operator!=(const SkLanguage& b) const {
return fTag != b.fTag;
}
SkLanguage& operator=(const SkLanguage& b) {
fTag = b.fTag;
return *this;
}
private:
//! BCP 47 language identifier
SkString fTag;
};
class SkPaintOptionsAndroid {
public:
SkPaintOptionsAndroid() {
fFontVariant = kDefault_Variant;
}
SkPaintOptionsAndroid& operator=(const SkPaintOptionsAndroid& b) {
fLanguage = b.fLanguage;
fFontVariant = b.fFontVariant;
return *this;
}
bool operator==(const SkPaintOptionsAndroid& b) const {
return !(*this != b);
}
bool operator!=(const SkPaintOptionsAndroid& b) const {
return fLanguage != b.fLanguage ||
fFontVariant != b.fFontVariant;
}
void flatten(SkWriteBuffer&) const;
void unflatten(SkReadBuffer&);
/** Return the paint's language value used for drawing text.
@return the paint's language value used for drawing text.
*/
const SkLanguage& getLanguage() const { return fLanguage; }
/** Set the paint's language value used for drawing text.
@param language set the paint's language value for drawing text.
*/
void setLanguage(const SkLanguage& language) { fLanguage = language; }
void setLanguage(const char* languageTag) { fLanguage = SkLanguage(languageTag); }
enum FontVariant {
kDefault_Variant = 0x01,
kCompact_Variant = 0x02,
kElegant_Variant = 0x04,
kLast_Variant = kElegant_Variant,
};
/** Return the font variant
@return the font variant used by this paint object
*/
FontVariant getFontVariant() const { return fFontVariant; }
/** Set the font variant
@param fontVariant set the paint's font variant for choosing fonts
*/
void setFontVariant(FontVariant fontVariant) {
SkASSERT((unsigned)fontVariant <= kLast_Variant);
fFontVariant = fontVariant;
}
private:
SkLanguage fLanguage;
FontVariant fFontVariant;
};
#endif // #ifndef SkPaintOptionsAndroid_DEFINED

3
include/core/SkPicture.h
View File

@ -230,13 +230,14 @@ private:
// V29: Removed SaveFlags parameter from save().
// V30: Remove redundant SkMatrix from SkLocalMatrixShader.
// V31: Add a serialized UniqueID to SkImageFilter.
// V32: Removed SkPaintOptionsAndroid from SkPaint
// Note: If the picture version needs to be increased then please follow the
// steps to generate new SKPs in (only accessible to Googlers): http://goo.gl/qATVcw
// Only SKPs within the min/current picture version range (inclusive) can be read.
static const uint32_t MIN_PICTURE_VERSION = 19;
static const uint32_t CURRENT_PICTURE_VERSION = 31;
static const uint32_t CURRENT_PICTURE_VERSION = 32;
mutable uint32_t fUniqueID;

1
include/core/SkReadBuffer.h
View File

@ -47,6 +47,7 @@ public:
kNoMoreBitmapFlatten_Version = 28,
kSimplifyLocalMatrix_Version = 30,
kImageFilterUniqueID_Version = 31,
kRemoveAndroidPaintOpts_Version = 32,
};
/**

69
src/core/SkPaint.cpp
View File

@ -21,7 +21,6 @@
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
#include "SkPaintDefaults.h"
#include "SkPaintOptionsAndroid.h"
#include "SkPathEffect.h"
#include "SkRasterizer.h"
#include "SkScalar.h"
@ -55,7 +54,6 @@ enum {
kImageFilter_DirtyBit = 1 << 13,
kTypeface_DirtyBit = 1 << 14,
kAnnotation_DirtyBit = 1 << 15,
kPaintOptionsAndroid_DirtyBit = 1 << 16,
};
// define this to get a printf for out-of-range parameter in setters
@ -101,7 +99,6 @@ SkPaint::SkPaint() {
fDirtyBits = 0;
#ifdef SK_BUILD_FOR_ANDROID
new (&fPaintOptionsAndroid) SkPaintOptionsAndroid;
fGenerationID = 0;
#endif
}
@ -131,7 +128,6 @@ SkPaint::SkPaint(const SkPaint& src) {
COPY(fDirtyBits);
#ifdef SK_BUILD_FOR_ANDROID
new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
COPY(fGenerationID);
#endif
@ -183,8 +179,6 @@ SkPaint& SkPaint::operator=(const SkPaint& src) {
COPY(fDirtyBits);
#ifdef SK_BUILD_FOR_ANDROID
fPaintOptionsAndroid.~SkPaintOptionsAndroid();
new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
++fGenerationID;
#endif
@ -214,9 +208,6 @@ bool operator==(const SkPaint& a, const SkPaint& b) {
&& EQUAL(fWidth)
&& EQUAL(fMiterLimit)
&& EQUAL(fBitfieldsUInt)
#ifdef SK_BUILD_FOR_ANDROID
&& EQUAL(fPaintOptionsAndroid)
#endif
;
#undef EQUAL
}
@ -241,14 +232,6 @@ uint32_t SkPaint::getGenerationID() const {
void SkPaint::setGenerationID(uint32_t generationID) {
fGenerationID = generationID;
}
void SkPaint::setPaintOptionsAndroid(const SkPaintOptionsAndroid& options) {
if (options != fPaintOptionsAndroid) {
fPaintOptionsAndroid = options;
GEN_ID_INC;
fDirtyBits |= kPaintOptionsAndroid_DirtyBit;
}
}
#endif
void SkPaint::setFilterLevel(FilterLevel level) {
@ -1843,14 +1826,6 @@ void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
rec.fMaskFormat = SkMask::kA8_Format; // force antialiasing when we do the scan conversion
}
#ifdef SK_BUILD_FOR_ANDROID
char buffer[128];
SkWriteBuffer androidBuffer(buffer, sizeof(buffer));
fPaintOptionsAndroid.flatten(androidBuffer);
descSize += androidBuffer.bytesWritten();
entryCount += 1;
#endif
///////////////////////////////////////////////////////////////////////////
// Now that we're done tweaking the rec, call the PostMakeRec cleanup
SkScalerContext::PostMakeRec(*this, &rec);
@ -1863,10 +1838,6 @@ void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
desc->init();
desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
#ifdef SK_BUILD_FOR_ANDROID
add_flattenable(desc, kAndroidOpts_SkDescriptorTag, &androidBuffer);
#endif
if (pe) {
add_flattenable(desc, kPathEffect_SkDescriptorTag, &peBuffer);
}
@ -1901,11 +1872,6 @@ void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
desc1->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
desc2->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
#ifdef SK_BUILD_FOR_ANDROID
add_flattenable(desc1, kAndroidOpts_SkDescriptorTag, &androidBuffer);
add_flattenable(desc2, kAndroidOpts_SkDescriptorTag, &androidBuffer);
#endif
if (pe) {
add_flattenable(desc1, kPathEffect_SkDescriptorTag, &peBuffer);
add_flattenable(desc2, kPathEffect_SkDescriptorTag, &peBuffer);
@ -2122,11 +2088,6 @@ void SkPaint::flatten(SkWriteBuffer& buffer) const {
asint(this->getImageFilter())) {
flatFlags |= kHasEffects_FlatFlag;
}
#ifdef SK_BUILD_FOR_ANDROID
if (this->getPaintOptionsAndroid() != SkPaintOptionsAndroid()) {
flatFlags |= kHasNonDefaultPaintOptionsAndroid_FlatFlag;
}
#endif
SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
uint32_t* ptr = buffer.reserve(kPODPaintSize);
@ -2165,11 +2126,6 @@ void SkPaint::flatten(SkWriteBuffer& buffer) const {
buffer.writeBool(false);
}
}
#ifdef SK_BUILD_FOR_ANDROID
if (flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
this->getPaintOptionsAndroid().flatten(buffer);
}
#endif
}
void SkPaint::unflatten(SkReadBuffer& buffer) {
@ -2228,15 +2184,12 @@ void SkPaint::unflatten(SkReadBuffer& buffer) {
this->setImageFilter(NULL);
}
#ifdef SK_BUILD_FOR_ANDROID
this->setPaintOptionsAndroid(SkPaintOptionsAndroid());
#endif
if (flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
SkPaintOptionsAndroid options;
options.unflatten(buffer);
#ifdef SK_BUILD_FOR_ANDROID
this->setPaintOptionsAndroid(options);
#endif
if (buffer.isVersionLT(SkReadBuffer::kRemoveAndroidPaintOpts_Version) &&
flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
SkString tag;
buffer.readUInt();
buffer.readString(&tag);
buffer.readBool();
}
}
@ -2695,9 +2648,6 @@ void SkPaint::FlatteningTraits::Flatten(SkWriteBuffer& buffer, const SkPaint& pa
#undef F
if (dirty & kTypeface_DirtyBit) buffer.writeTypeface(paint.getTypeface());
if (dirty & kAnnotation_DirtyBit) paint.getAnnotation()->writeToBuffer(buffer);
#ifdef SK_BUILD_FOR_ANDROID
if (dirty & kPaintOptionsAndroid_DirtyBit) paint.getPaintOptionsAndroid().flatten(buffer);
#endif
}
void SkPaint::FlatteningTraits::Unflatten(SkReadBuffer& buffer, SkPaint* paint) {
@ -2732,12 +2682,5 @@ void SkPaint::FlatteningTraits::Unflatten(SkReadBuffer& buffer, SkPaint* paint)
if (dirty & kAnnotation_DirtyBit) {
paint->setAnnotation(SkAnnotation::Create(buffer))->unref();
}
#ifdef SK_BUILD_FOR_ANDROID
if (dirty & kPaintOptionsAndroid_DirtyBit) {
SkPaintOptionsAndroid options;
options.unflatten(buffer);
paint->setPaintOptionsAndroid(options);
}
#endif
SkASSERT(dirty == paint->fDirtyBits);
}

43
src/core/SkPaintOptionsAndroid.cpp
View File

@ -1,43 +0,0 @@
/*
* Copyright 2012 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkPaintOptionsAndroid.h"
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
#include "SkTDict.h"
#include "SkThread.h"
#include <cstring>
SkLanguage SkLanguage::getParent() const {
SkASSERT(!fTag.isEmpty());
const char* tag = fTag.c_str();
// strip off the rightmost "-.*"
const char* parentTagEnd = strrchr(tag, '-');
if (parentTagEnd == NULL) {
return SkLanguage();
}
size_t parentTagLen = parentTagEnd - tag;
return SkLanguage(tag, parentTagLen);
}
void SkPaintOptionsAndroid::flatten(SkWriteBuffer& buffer) const {
buffer.writeUInt(fFontVariant);
buffer.writeString(fLanguage.getTag().c_str());
// to maintain picture compatibility for the old fUseFontFallbacks variable
buffer.writeBool(false);
}
void SkPaintOptionsAndroid::unflatten(SkReadBuffer& buffer) {
fFontVariant = (FontVariant)buffer.readUInt();
SkString tag;
buffer.readString(&tag);
fLanguage = SkLanguage(tag);
// to maintain picture compatibility for the old fUseFontFallbacks variable
buffer.readBool();
}

13
src/core/SkScalerContext.cpp
View File

@ -23,10 +23,6 @@
#include "SkStroke.h"
#include "SkThread.h"
#ifdef SK_BUILD_FOR_ANDROID
#include "SkTypeface_android.h"
#endif
#define ComputeBWRowBytes(width) (((unsigned)(width) + 7) >> 3)
void SkGlyph::toMask(SkMask* mask) const {
@ -111,15 +107,6 @@ SkScalerContext::SkScalerContext(SkTypeface* typeface, const SkDescriptor* desc)
desc->findEntry(kPathEffect_SkDescriptorTag, NULL),
desc->findEntry(kMaskFilter_SkDescriptorTag, NULL));
#endif
#ifdef SK_BUILD_FOR_ANDROID
uint32_t len;
const void* data = desc->findEntry(kAndroidOpts_SkDescriptorTag, &len);
if (data) {
SkReadBuffer buffer(data, len);
fPaintOptionsAndroid.unflatten(buffer);
SkASSERT(buffer.offset() == buffer.size());
}
#endif
}
SkScalerContext::~SkScalerContext() {

11
src/core/SkScalerContext.h
View File

@ -14,10 +14,6 @@
#include "SkPaint.h"
#include "SkTypeface.h"
#ifdef SK_BUILD_FOR_ANDROID
#include "SkPaintOptionsAndroid.h"
#endif
struct SkGlyph;
class SkDescriptor;
class SkMaskFilter;
@ -262,10 +258,6 @@ private:
// never null
SkAutoTUnref<SkTypeface> fTypeface;
#ifdef SK_BUILD_FOR_ANDROID
SkPaintOptionsAndroid fPaintOptionsAndroid;
#endif
// optional object, which may be null
SkPathEffect* fPathEffect;
SkMaskFilter* fMaskFilter;
@ -297,9 +289,6 @@ private:
#define kPathEffect_SkDescriptorTag SkSetFourByteTag('p', 't', 'h', 'e')
#define kMaskFilter_SkDescriptorTag SkSetFourByteTag('m', 's', 'k', 'f')
#define kRasterizer_SkDescriptorTag SkSetFourByteTag('r', 'a', 's', 't')
#ifdef SK_BUILD_FOR_ANDROID
#define kAndroidOpts_SkDescriptorTag SkSetFourByteTag('a', 'n', 'd', 'r')
#endif
///////////////////////////////////////////////////////////////////////////////

48
src/ports/SkFontConfigParser_android.cpp
View File

@ -109,9 +109,9 @@ void familyElementHandler(FontFamily* family, const char** attributes) {
} else if (nameLen == 7 && !strncmp("variant", name, nameLen)) {
// Value should be either elegant or compact.
if (valueLen == 7 && !strncmp("elegant", value, valueLen)) {
family->fVariant = SkPaintOptionsAndroid::kElegant_Variant;
family->fVariant = kElegant_FontVariant;
} else if (valueLen == 7 && !strncmp("compact", value, valueLen)) {
family->fVariant = SkPaintOptionsAndroid::kCompact_Variant;
family->fVariant = kCompact_FontVariant;
}
}
}
@ -122,13 +122,6 @@ void fontFileNameHandler(void* data, const char* s, int len) {
familyData->currentFontInfo->fFileName.set(s, len);
}
void familyElementEndHandler(FontFamily* family) {
for (int i = 0; i < family->fFonts.count(); i++) {
family->fFonts[i].fPaintOptions.setLanguage(family->fLanguage);
family->fFonts[i].fPaintOptions.setFontVariant(family->fVariant);
}
}
void fontElementHandler(XML_Parser* parser, FontFileInfo* file, const char** attributes) {
// A <font> should have weight (integer) and style (normal, italic) attributes.
// NOTE: we ignore the style.
@ -278,7 +271,6 @@ void endElementHandler(void* data, const char* tag) {
if (len == 9 && strncmp(tag, "familyset", len) == 0) {
familysetElementEndHandler(familyData);
} else if (len == 6 && strncmp(tag, "family", len) == 0) {
familyElementEndHandler(familyData->currentFamily);
*familyData->families.append() = familyData->currentFamily;
familyData->currentFamily = NULL;
} else if (len == 4 && !strncmp(tag, "font", len)) {
@ -332,14 +324,27 @@ static void fontFileElementHandler(FamilyData* familyData, const char** attribut
size_t nameLength = strlen(attributeName);
size_t valueLength = strlen(attributeValue);
if (nameLength == 7 && strncmp(attributeName, "variant", nameLength) == 0) {
const FontVariant prevVariant = familyData->currentFamily->fVariant;
if (valueLength == 7 && strncmp(attributeValue, "elegant", valueLength) == 0) {
newFileInfo.fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kElegant_Variant);
familyData->currentFamily->fVariant = kElegant_FontVariant;
} else if (valueLength == 7 &&
strncmp(attributeValue, "compact", valueLength) == 0) {
newFileInfo.fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kCompact_Variant);
familyData->currentFamily->fVariant = kCompact_FontVariant;
}
if (familyData->currentFamily->fFonts.count() > 1 &&
familyData->currentFamily->fVariant != prevVariant) {
SkDebugf("Every font file within a family must have identical variants");
sk_throw();
}
} else if (nameLength == 4 && strncmp(attributeName, "lang", nameLength) == 0) {
newFileInfo.fPaintOptions.setLanguage(attributeValue);
SkLanguage prevLang = familyData->currentFamily->fLanguage;
familyData->currentFamily->fLanguage = SkLanguage(attributeValue);
if (familyData->currentFamily->fFonts.count() > 1 &&
familyData->currentFamily->fLanguage != prevLang) {
SkDebugf("Every font file within a family must have identical languages");
sk_throw();
}
} else if (nameLength == 5 && strncmp(attributeName, "index", nameLength) == 0) {
int value;
if (parseNonNegativeInteger(attributeValue, &value)) {
@ -514,9 +519,7 @@ static void getFallbackFontFamiliesForLocale(SkTDArray<FontFamily*> &fallbackFon
for (int i = 0; i < langSpecificFonts.count(); ++i) {
FontFamily* family = langSpecificFonts[i];
for (int j = 0; j < family->fFonts.count(); ++j) {
family->fFonts[j].fPaintOptions.setLanguage(locale);
}
family->fLanguage = SkLanguage(locale);
*fallbackFonts.append() = family;
}
}
@ -594,3 +597,16 @@ void SkFontConfigParser::GetTestFontFamilies(SkTDArray<FontFamily*> &fontFamilie
*fontFamilies.append() = fallbackFonts[i];
}
}
SkLanguage SkLanguage::getParent() const {
SkASSERT(!fTag.isEmpty());
const char* tag = fTag.c_str();
// strip off the rightmost "-.*"
const char* parentTagEnd = strrchr(tag, '-');
if (parentTagEnd == NULL) {
return SkLanguage();
}
size_t parentTagLen = parentTagEnd - tag;
return SkLanguage(tag, parentTagLen);
}

56
src/ports/SkFontConfigParser_android.h
View File

@ -8,18 +8,62 @@
#ifndef SKFONTCONFIGPARSER_ANDROID_H_
#define SKFONTCONFIGPARSER_ANDROID_H_
#include "SkTypes.h"
#include "SkPaintOptionsAndroid.h"
#include "SkString.h"
#include "SkTDArray.h"
/** \class SkLanguage
The SkLanguage class represents a human written language, and is used by
text draw operations to determine which glyph to draw when drawing
characters with variants (ie Han-derived characters).
*/
class SkLanguage {
public:
SkLanguage() { }
SkLanguage(const SkString& tag) : fTag(tag) { }
SkLanguage(const char* tag) : fTag(tag) { }
SkLanguage(const char* tag, size_t len) : fTag(tag, len) { }
SkLanguage(const SkLanguage& b) : fTag(b.fTag) { }
/** Gets a BCP 47 language identifier for this SkLanguage.
@return a BCP 47 language identifier representing this language
*/
const SkString& getTag() const { return fTag; }
/** Performs BCP 47 fallback to return an SkLanguage one step more general.
@return an SkLanguage one step more general
*/
SkLanguage getParent() const;
bool operator==(const SkLanguage& b) const {
return fTag == b.fTag;
}
bool operator!=(const SkLanguage& b) const {
return fTag != b.fTag;
}
SkLanguage& operator=(const SkLanguage& b) {
fTag = b.fTag;
return *this;
}
private:
//! BCP 47 language identifier
SkString fTag;
};
enum FontVariants {
kDefault_FontVariant = 0x01,
kCompact_FontVariant = 0x02,
kElegant_FontVariant = 0x04,
kLast_FontVariant = kElegant_FontVariant,
};
typedef uint32_t FontVariant;
struct FontFileInfo {
FontFileInfo() : fIndex(0), fWeight(0) { }
SkString fFileName;
int fIndex;
SkPaintOptionsAndroid fPaintOptions;
int fWeight;
};
@ -32,14 +76,14 @@ struct FontFileInfo {
*/
struct FontFamily {
FontFamily()
: fVariant(SkPaintOptionsAndroid::kDefault_Variant)
: fVariant(kDefault_FontVariant)
, fOrder(-1)
, fIsFallbackFont(false) { }
SkTArray<SkString> fNames;
SkTArray<FontFileInfo> fFonts;
SkLanguage fLanguage;
SkPaintOptionsAndroid::FontVariant fVariant;
FontVariant fVariant;
int fOrder; // internal to SkFontConfigParser
bool fIsFallbackFont;
};

15
src/ports/SkFontMgr_android.cpp
View File

@ -67,7 +67,7 @@ public:
bool isFixedPitch,
const SkString familyName,
const SkLanguage& lang,
uint32_t variantStyle)
FontVariant variantStyle)
: INHERITED(index, style, isFixedPitch, familyName)
, fPathName(pathName)
, fLang(lang)
@ -88,7 +88,7 @@ public:
const SkString fPathName;
const SkLanguage fLang;
const uint32_t fVariantStyle;
const FontVariant fVariantStyle;
typedef SkTypeface_Android INHERITED;
};
@ -163,11 +163,10 @@ public:
continue;
}
const SkLanguage& lang = fontFile.fPaintOptions.getLanguage();
uint32_t variant = fontFile.fPaintOptions.getFontVariant();
if (SkPaintOptionsAndroid::kDefault_Variant == variant) {
variant = SkPaintOptionsAndroid::kCompact_Variant |
SkPaintOptionsAndroid::kElegant_Variant;
const SkLanguage& lang = family.fLanguage;
uint32_t variant = family.fVariant;
if (kDefault_FontVariant == variant) {
variant = kCompact_FontVariant | kElegant_FontVariant;
}
// The first specified family name overrides the family name found in the font.
@ -353,7 +352,7 @@ protected:
// TODO: add 'is_elegant' and 'is_compact' bits to 'style' request.
// For compatibility, try 'elegant' fonts first in fallback.
uint32_t variantMask = SkPaintOptionsAndroid::kElegant_Variant;
uint32_t variantMask = kElegant_FontVariant;
// The first time match anything in the mask, second time anything not in the mask.
for (bool maskMatches = true; maskMatches != false; maskMatches = false) {

75
tests/AndroidPaintTest.cpp
View File

@ -1,75 +0,0 @@
// SkPaints only have an SkPaintOptionsAndroid if SK_BUILD_FOR_ANDROID is true.
#ifdef SK_BUILD_FOR_ANDROID
#include "SkReadBuffer.h"
#include "SkWriteBuffer.h"
#include "SkPaint.h"
#include "SkPaintOptionsAndroid.h"
#include "Test.h"
static size_t Reconstruct(const SkPaint& src, SkPaint* dst) {
SkWriteBuffer writer;
src.flatten(writer);
const size_t size = writer.bytesWritten();
SkAutoMalloc bytes(size);
writer.writeToMemory(bytes.get());
SkReadBuffer reader(bytes.get(), size);
dst->unflatten(reader);
return size;
}
DEF_TEST(AndroidOptionsSerialization, reporter) {
// We want to make sure that Android's paint options survive a flatten/unflatten round trip.
// These are all non-default options.
SkPaintOptionsAndroid options;
options.setLanguage("ja-JP");
options.setFontVariant(SkPaintOptionsAndroid::kElegant_Variant);
SkPaint paint;
paint.setPaintOptionsAndroid(options);
SkPaint reconstructed;
Reconstruct(paint, &reconstructed);
REPORTER_ASSERT(reporter, options == reconstructed.getPaintOptionsAndroid());
}
DEF_TEST(AndroidOptionsSerializationReverse, reporter) {
// Opposite test of above: make sure the serialized default values of a paint overwrite
// non-default values on the paint we're unflattening into.
const SkPaint defaultOptions;
SkPaintOptionsAndroid options;
options.setLanguage("ja-JP");
options.setFontVariant(SkPaintOptionsAndroid::kElegant_Variant);
SkPaint nonDefaultOptions;
nonDefaultOptions.setPaintOptionsAndroid(options);
Reconstruct(defaultOptions, &nonDefaultOptions);
REPORTER_ASSERT(reporter,
defaultOptions.getPaintOptionsAndroid() ==
nonDefaultOptions.getPaintOptionsAndroid());
}
DEF_TEST(AndroidOptionsSize, reporter) {
// A paint with default android options should serialize to something smaller than
// a paint with non-default android options.
SkPaint defaultOptions;
SkPaintOptionsAndroid options;
options.setLanguage("ja-JP");
SkPaint nonDefaultOptions;
nonDefaultOptions.setPaintOptionsAndroid(options);
SkPaint dummy;
REPORTER_ASSERT(reporter,
Reconstruct(defaultOptions, &dummy) < Reconstruct(nonDefaultOptions, &dummy));
}
#endif // SK_BUILD_FOR_ANDROID