[ 'skia_os == "android" and skia_arch_type == "arm" and armv7 == 1', {
# The code in SkUtilsArm.cpp can be used on an ARM-based Linux system, not only Android.
'sources': [
+ '../src/core/SkPaintOptionsAndroid.cpp',
'../src/core/SkUtilsArm.cpp',
'../src/core/SkUtilsArm.h',
],
#include "SkColor.h"
#include "SkDrawLooper.h"
#include "SkXfermode.h"
+#ifdef SK_BUILD_FOR_ANDROID
+#include "SkPaintOptionsAndroid.h"
+#endif
class SkAnnotation;
class SkAutoGlyphCache;
/** Returns the base glyph count for the strike associated with this paint
*/
unsigned getBaseGlyphCount(SkUnichar text) const;
+
+ 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
friend class SkTextToPathIter;
#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;
--- /dev/null
+
+/*
+ * 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
+
+#ifdef SK_BUILD_FOR_ANDROID
+
+#include "SkString.h"
+#include "SkTypes.h"
+
+class SkFlattenableReadBuffer;
+class SkFlattenableWriteBuffer;
+
+struct SkLanguageInfo {
+ SkLanguageInfo(const char* tag) : fTag(tag) { }
+ SkString fTag; //! BCP 47 language identifier
+};
+
+/** \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() : fInfo(getInfo("")) { }
+ SkLanguage(const char* tag) : fInfo(getInfo(tag)) { }
+ SkLanguage(const SkLanguage& b) : fInfo(b.fInfo) { }
+
+ /** Gets a BCP 47 language identifier for this SkLanguage.
+ @return a BCP 47 language identifier representing this language
+ */
+ const SkString& getTag() const { return fInfo->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 fInfo == b.fInfo;
+ }
+ bool operator!=(const SkLanguage& b) const {
+ return fInfo != b.fInfo;
+ }
+ bool operator<(const SkLanguage& b) const {
+ return fInfo < b.fInfo;
+ }
+ bool operator>(const SkLanguage& b) const {
+ return fInfo > b.fInfo;
+ }
+ SkLanguage& operator=(const SkLanguage& b) {
+ fInfo = b.fInfo;
+ return *this;
+ }
+
+private:
+ const SkLanguageInfo* fInfo;
+
+ static const SkLanguageInfo* getInfo(const char* tag);
+};
+
+class SkPaintOptionsAndroid {
+public:
+ SkPaintOptionsAndroid() {
+ fFontVariant = kDefault_Variant;
+ }
+
+ /** 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, // Currently setting yourself to Default gives you Compact Variant
+ kCompact_Variant,
+ kElegant_Variant,
+ 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;
+ }
+
+ void flatten(SkFlattenableWriteBuffer&) const;
+ void unflatten(SkFlattenableReadBuffer&);
+
+private:
+ SkLanguage fLanguage;
+ FontVariant fFontVariant;
+};
+
+#endif // #ifdef SK_BUILD_FOR_ANDROID
+#endif // #ifndef SkPaintOptionsAndroid_DEFINED
#ifndef SkTypeface_android_DEFINED
#define SkTypeface_android_DEFINED
+#ifdef SK_BUILD_FOR_ANDROID
+
#include "SkTypeface.h"
/**
* get the 3rd can still inspect the original, and try to match its
* stylistic attributes.
*/
-SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID, SkFontID origFontID);
+SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
+ const SkPaintOptionsAndroid& options);
-#endif
+#endif // #ifdef SK_BUILD_FOR_ANDROID
+#endif // #ifndef SkTypeface_android_DEFINED
void SkPaint::setGenerationID(uint32_t generationID) {
fGenerationID = generationID;
}
-#endif
-#ifdef SK_BUILD_FOR_ANDROID
unsigned SkPaint::getBaseGlyphCount(SkUnichar text) const {
SkAutoGlyphCache autoCache(*this, NULL, NULL);
SkGlyphCache* cache = autoCache.getCache();
return cache->getBaseGlyphCount(text);
}
+
+void SkPaint::setPaintOptionsAndroid(const SkPaintOptionsAndroid& options) {
+ if(!memcmp(&fPaintOptionsAndroid, &options, sizeof(SkPaintOptionsAndroid))) {
+ fPaintOptionsAndroid = options;
+ GEN_ID_INC;
+ }
+}
#endif
void SkPaint::setHinting(Hinting hintingLevel) {
rec.fMaskFormat = SkMask::kA8_Format; // force antialiasing when we do the scan conversion
}
+#ifdef SK_BUILD_FOR_ANDROID
+ SkOrderedWriteBuffer androidBuffer(128);
+ fPaintOptionsAndroid.flatten(androidBuffer);
+ descSize += androidBuffer.size();
+ entryCount += 1;
+#endif
+
///////////////////////////////////////////////////////////////////////////
// Now that we're done tweaking the rec, call the PostMakeRec cleanup
SkScalerContext::PostMakeRec(*this, &rec);
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);
}
--- /dev/null
+
+/*
+ * 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.
+ */
+
+#ifdef SK_BUILD_FOR_ANDROID
+
+#include "SkPaintOptionsAndroid.h"
+#include "SkFlattenableBuffers.h"
+#include "SkTDict.h"
+#include "SkThread.h"
+#include <cstring>
+
+SkLanguage SkLanguage::getParent() const {
+ SkASSERT(fInfo != NULL);
+ const char* tag = fInfo->fTag.c_str();
+ SkASSERT(tag != NULL);
+
+ // strip off the rightmost "-.*"
+ char* parentTagEnd = strrchr(tag, '-');
+ if (parentTagEnd == NULL) {
+ return SkLanguage("");
+ }
+ size_t parentTagLen = parentTagEnd - tag;
+ char parentTag[parentTagLen + 1];
+ strncpy(parentTag, tag, parentTagLen);
+ parentTag[parentTagLen] = '\0';
+ return SkLanguage(parentTag);
+}
+
+SK_DECLARE_STATIC_MUTEX(gGetInfoMutex);
+const SkLanguageInfo* SkLanguage::getInfo(const char* tag) {
+ SkAutoMutexAcquire lock(gGetInfoMutex);
+
+ static const size_t kDictSize = 128;
+ static SkTDict<SkLanguageInfo*> tagToInfo(kDictSize);
+
+ // try a lookup
+ SkLanguageInfo* info;
+ if (tagToInfo.find(tag, &info)) {
+ return info;
+ }
+
+ // no match - add this language
+ info = new SkLanguageInfo(tag);
+ tagToInfo.set(tag, info);
+ return info;
+}
+
+void SkPaintOptionsAndroid::flatten(SkFlattenableWriteBuffer& buffer) const {
+ buffer.writeUInt(fFontVariant);
+ buffer.writeString(fLanguage.getTag().c_str());
+}
+
+void SkPaintOptionsAndroid::unflatten(SkFlattenableReadBuffer& buffer) {
+ fFontVariant = (FontVariant)buffer.readUInt();
+ char* tag = buffer.readString();
+ fLanguage = SkLanguage(tag);
+ sk_free(tag);
+}
+
+#endif
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);
+ SkASSERT(data);
+ SkOrderedReadBuffer buffer(data, len);
+ fPaintOptionsAndroid.unflatten(buffer);
+ SkASSERT(buffer.offset() == buffer.size());
+#endif
}
SkScalerContext::~SkScalerContext() {
SkScalerContext* SkScalerContext::allocNextContext() const {
#ifdef SK_BUILD_FOR_ANDROID
SkTypeface* newFace = SkAndroidNextLogicalTypeface(fRec.fFontID,
- fRec.fOrigFontID);
+ fRec.fOrigFontID,
+ fPaintOptionsAndroid);
if (0 == newFace) {
return NULL;
}
#include "SkPaint.h"
#include "SkTypeface.h"
+#ifdef SK_BUILD_FOR_ANDROID
+ #include "SkPaintOptionsAndroid.h"
+#endif
+
struct SkGlyph;
class SkDescriptor;
class SkMaskFilter;
// never null
SkAutoTUnref<SkTypeface> fTypeface;
+#ifdef SK_BUILD_FOR_ANDROID
+ SkPaintOptionsAndroid fPaintOptionsAndroid;
+#endif
+
// optional object, which may be null
SkPathEffect* fPathEffect;
SkMaskFilter* fMaskFilter;
#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
///////////////////////////////////////////////////////////////////////////////
return tf;
}
-SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID,
- SkFontID origFontID) {
-#if defined(SK_BUILD_FOR_ANDROID) && !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
+SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
+ const SkPaintOptionsAndroid& options) {
+#if !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
// Skia does not support font fallback for ndk applications in order to
// enable clients such as WebKit to customize their font selection.
// Clients can use GetFallbackFamilyNameForChar() to get the fallback
// font for individual characters.
return NULL;
-#else
+#endif
SkAutoMutexAcquire ac(gFamilyHeadAndNameListMutex);
load_system_fonts();
// i.e. gFallbackFonts[0] != 0.
const SkTypeface* firstTypeface = find_from_uniqueID(list[0]);
return SkRef(find_typeface(firstTypeface, origTypeface->style()));
-#endif
}
///////////////////////////////////////////////////////////////////////////////
projects / platform / upstream / libSkiaSharp.git / commitdiff