1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/skia/patches/0005-Bug-736276-Add-a-new-SkFontHost-that-takes-a-cairo_s.patch Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,472 @@
1.4 +From: George Wright <george@mozilla.com>
1.5 +Date: Wed, 1 Aug 2012 16:43:15 -0400
1.6 +Subject: Bug 736276 - Add a new SkFontHost that takes a cairo_scaled_font_t r=karl
1.7 +
1.8 +
1.9 +diff --git a/gfx/skia/Makefile.in b/gfx/skia/Makefile.in
1.10 +index 5ebbd2e..7c8cdbf 100644
1.11 +--- a/gfx/skia/Makefile.in
1.12 ++++ b/gfx/skia/Makefile.in
1.13 +@@ -60,15 +60,15 @@ VPATH += \
1.14 + $(NULL)
1.15 +
1.16 + ifeq (android,$(MOZ_WIDGET_TOOLKIT))
1.17 +-OS_CXXFLAGS += $(CAIRO_FT_CFLAGS)
1.18 ++OS_CXXFLAGS += $(MOZ_CAIRO_CFLAGS) $(CAIRO_FT_CFLAGS)
1.19 + endif
1.20 +
1.21 + ifeq (gtk2,$(MOZ_WIDGET_TOOLKIT))
1.22 +-OS_CXXFLAGS += $(MOZ_PANGO_CFLAGS)
1.23 ++OS_CXXFLAGS += $(MOZ_CAIRO_CFLAGS) $(MOZ_PANGO_CFLAGS) $(CAIRO_FT_CFLAGS)
1.24 + endif
1.25 +
1.26 + ifeq (qt,$(MOZ_WIDGET_TOOLKIT))
1.27 +-OS_CXXFLAGS += $(MOZ_PANGO_CFLAGS)
1.28 ++OS_CXXFLAGS += $(MOZ_CAIRO_CFLAGS) $(MOZ_PANGO_CFLAGS) $(CAIRO_FT_CFLAGS)
1.29 + ifeq (Linux,$(OS_TARGET))
1.30 + DEFINES += -DSK_USE_POSIX_THREADS=1
1.31 + endif
1.32 +diff --git a/gfx/skia/include/ports/SkTypeface_cairo.h b/gfx/skia/include/ports/SkTypeface_cairo.h
1.33 +new file mode 100644
1.34 +index 0000000..7e44f04
1.35 +--- /dev/null
1.36 ++++ b/gfx/skia/include/ports/SkTypeface_cairo.h
1.37 +@@ -0,0 +1,11 @@
1.38 ++#ifndef SkTypeface_cairo_DEFINED
1.39 ++#define SkTypeface_cairo_DEFINED
1.40 ++
1.41 ++#include <cairo.h>
1.42 ++
1.43 ++#include "SkTypeface.h"
1.44 ++
1.45 ++SK_API extern SkTypeface* SkCreateTypefaceFromCairoFont(cairo_font_face_t* fontFace, SkTypeface::Style style, bool isFixedWidth);
1.46 ++
1.47 ++#endif
1.48 ++
1.49 +diff --git a/gfx/skia/moz.build b/gfx/skia/moz.build
1.50 +index 9ceba59..66efd52 100644
1.51 +--- a/gfx/skia/moz.build
1.52 ++++ b/gfx/skia/moz.build
1.53 +@@ -171,10 +171,12 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
1.54 + 'SkTime_win.cpp',
1.55 + ]
1.56 + elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gtk2':
1.57 ++ EXPORTS.skia += [
1.58 ++ 'include/ports/SkTypeface_cairo.h',
1.59 ++ ]
1.60 + CPP_SOURCES += [
1.61 +- 'SkFontHost_FreeType.cpp',
1.62 ++ 'SkFontHost_cairo.cpp',
1.63 + 'SkFontHost_FreeType_common.cpp',
1.64 +- 'SkFontHost_linux.cpp',
1.65 + 'SkThread_pthread.cpp',
1.66 + 'SkThreadUtils_pthread.cpp',
1.67 + 'SkThreadUtils_pthread_linux.cpp',
1.68 +@@ -183,14 +185,15 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gtk2':
1.69 + ]
1.70 + elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'qt':
1.71 + CPP_SOURCES += [
1.72 +- 'SkFontHost_FreeType.cpp',
1.73 ++ 'SkFontHost_cairo.cpp',
1.74 + 'SkFontHost_FreeType_common.cpp',
1.75 + 'SkOSFile.cpp',
1.76 + ]
1.77 + if CONFIG['OS_TARGET'] == 'Linux':
1.78 ++ EXPORTS.skia += [
1.79 ++ 'include/ports/SkTypeface_cairo.h',
1.80 ++ ]
1.81 + CPP_SOURCES += [
1.82 +- 'SkFontHost_linux.cpp',
1.83 +- 'SkFontHost_tables.cpp',
1.84 + 'SkThread_pthread.cpp',
1.85 + 'SkThreadUtils_pthread.cpp',
1.86 + 'SkThreadUtils_pthread_linux.cpp',
1.87 +@@ -204,11 +207,13 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
1.88 + # Separate 'if' from above, since the else below applies to all != 'android'
1.89 + # toolkits.
1.90 + if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'android':
1.91 ++ EXPORTS.skia += [
1.92 ++ 'include/ports/SkTypeface_cairo.h',
1.93 ++ ]
1.94 + CPP_SOURCES += [
1.95 + 'ashmem.cpp',
1.96 + 'SkDebug_android.cpp',
1.97 +- 'SkFontHost_android_old.cpp',
1.98 +- 'SkFontHost_FreeType.cpp',
1.99 ++ 'SkFontHost_cairo.cpp',
1.100 + 'SkFontHost_FreeType_common.cpp',
1.101 + 'SkImageRef_ashmem.cpp',
1.102 + 'SkTime_Unix.cpp',
1.103 +diff --git a/gfx/skia/src/ports/SkFontHost_cairo.cpp b/gfx/skia/src/ports/SkFontHost_cairo.cpp
1.104 +new file mode 100644
1.105 +index 0000000..bb5b778
1.106 +--- /dev/null
1.107 ++++ b/gfx/skia/src/ports/SkFontHost_cairo.cpp
1.108 +@@ -0,0 +1,364 @@
1.109 ++
1.110 ++/*
1.111 ++ * Copyright 2012 Mozilla Foundation
1.112 ++ *
1.113 ++ * Use of this source code is governed by a BSD-style license that can be
1.114 ++ * found in the LICENSE file.
1.115 ++ */
1.116 ++
1.117 ++#include "cairo.h"
1.118 ++#include "cairo-ft.h"
1.119 ++
1.120 ++#include "SkFontHost_FreeType_common.h"
1.121 ++
1.122 ++#include "SkAdvancedTypefaceMetrics.h"
1.123 ++#include "SkFontHost.h"
1.124 ++#include "SkPath.h"
1.125 ++#include "SkScalerContext.h"
1.126 ++#include "SkTypefaceCache.h"
1.127 ++
1.128 ++#include <ft2build.h>
1.129 ++#include FT_FREETYPE_H
1.130 ++
1.131 ++static cairo_user_data_key_t kSkTypefaceKey;
1.132 ++
1.133 ++class SkScalerContext_CairoFT : public SkScalerContext_FreeType_Base {
1.134 ++public:
1.135 ++ SkScalerContext_CairoFT(SkTypeface* typeface, const SkDescriptor* desc);
1.136 ++ virtual ~SkScalerContext_CairoFT();
1.137 ++
1.138 ++protected:
1.139 ++ virtual unsigned generateGlyphCount() SK_OVERRIDE;
1.140 ++ virtual uint16_t generateCharToGlyph(SkUnichar uniChar) SK_OVERRIDE;
1.141 ++ virtual void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
1.142 ++ virtual void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
1.143 ++ virtual void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
1.144 ++ virtual void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
1.145 ++ virtual void generateFontMetrics(SkPaint::FontMetrics* mx,
1.146 ++ SkPaint::FontMetrics* my) SK_OVERRIDE;
1.147 ++ virtual SkUnichar generateGlyphToChar(uint16_t glyph) SK_OVERRIDE;
1.148 ++private:
1.149 ++ cairo_scaled_font_t* fScaledFont;
1.150 ++ uint32_t fLoadGlyphFlags;
1.151 ++};
1.152 ++
1.153 ++class CairoLockedFTFace {
1.154 ++public:
1.155 ++ CairoLockedFTFace(cairo_scaled_font_t* scaledFont)
1.156 ++ : fScaledFont(scaledFont)
1.157 ++ , fFace(cairo_ft_scaled_font_lock_face(scaledFont))
1.158 ++ {}
1.159 ++
1.160 ++ ~CairoLockedFTFace()
1.161 ++ {
1.162 ++ cairo_ft_scaled_font_unlock_face(fScaledFont);
1.163 ++ }
1.164 ++
1.165 ++ FT_Face getFace()
1.166 ++ {
1.167 ++ return fFace;
1.168 ++ }
1.169 ++
1.170 ++private:
1.171 ++ cairo_scaled_font_t* fScaledFont;
1.172 ++ FT_Face fFace;
1.173 ++};
1.174 ++
1.175 ++class SkCairoFTTypeface : public SkTypeface {
1.176 ++public:
1.177 ++ static SkTypeface* CreateTypeface(cairo_font_face_t* fontFace, SkTypeface::Style style, bool isFixedWidth) {
1.178 ++ SkASSERT(fontFace != NULL);
1.179 ++ SkASSERT(cairo_font_face_get_type(fontFace) == CAIRO_FONT_TYPE_FT);
1.180 ++
1.181 ++ SkFontID newId = SkTypefaceCache::NewFontID();
1.182 ++
1.183 ++ return SkNEW_ARGS(SkCairoFTTypeface, (fontFace, style, newId, isFixedWidth));
1.184 ++ }
1.185 ++
1.186 ++ cairo_font_face_t* getFontFace() {
1.187 ++ return fFontFace;
1.188 ++ }
1.189 ++
1.190 ++ virtual SkStream* onOpenStream(int*) const SK_OVERRIDE { return NULL; }
1.191 ++
1.192 ++ virtual SkAdvancedTypefaceMetrics*
1.193 ++ onGetAdvancedTypefaceMetrics(SkAdvancedTypefaceMetrics::PerGlyphInfo,
1.194 ++ const uint32_t*, uint32_t) const SK_OVERRIDE
1.195 ++ {
1.196 ++ SkDEBUGCODE(SkDebugf("SkCairoFTTypeface::onGetAdvancedTypefaceMetrics unimplemented\n"));
1.197 ++ return NULL;
1.198 ++ }
1.199 ++
1.200 ++ virtual SkScalerContext* onCreateScalerContext(const SkDescriptor* desc) const SK_OVERRIDE
1.201 ++ {
1.202 ++ return SkNEW_ARGS(SkScalerContext_CairoFT, (const_cast<SkCairoFTTypeface*>(this), desc));
1.203 ++ }
1.204 ++
1.205 ++ virtual void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE
1.206 ++ {
1.207 ++ SkDEBUGCODE(SkDebugf("SkCairoFTTypeface::onFilterRec unimplemented\n"));
1.208 ++ }
1.209 ++
1.210 ++ virtual void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE
1.211 ++ {
1.212 ++ SkDEBUGCODE(SkDebugf("SkCairoFTTypeface::onGetFontDescriptor unimplemented\n"));
1.213 ++ }
1.214 ++
1.215 ++
1.216 ++private:
1.217 ++
1.218 ++ SkCairoFTTypeface(cairo_font_face_t* fontFace, SkTypeface::Style style, SkFontID id, bool isFixedWidth)
1.219 ++ : SkTypeface(style, id, isFixedWidth)
1.220 ++ , fFontFace(fontFace)
1.221 ++ {
1.222 ++ cairo_font_face_set_user_data(fFontFace, &kSkTypefaceKey, this, NULL);
1.223 ++ cairo_font_face_reference(fFontFace);
1.224 ++ }
1.225 ++
1.226 ++ ~SkCairoFTTypeface()
1.227 ++ {
1.228 ++ cairo_font_face_set_user_data(fFontFace, &kSkTypefaceKey, NULL, NULL);
1.229 ++ cairo_font_face_destroy(fFontFace);
1.230 ++ }
1.231 ++
1.232 ++ cairo_font_face_t* fFontFace;
1.233 ++};
1.234 ++
1.235 ++SkTypeface* SkCreateTypefaceFromCairoFont(cairo_font_face_t* fontFace, SkTypeface::Style style, bool isFixedWidth)
1.236 ++{
1.237 ++ SkTypeface* typeface = reinterpret_cast<SkTypeface*>(cairo_font_face_get_user_data(fontFace, &kSkTypefaceKey));
1.238 ++
1.239 ++ if (typeface) {
1.240 ++ typeface->ref();
1.241 ++ } else {
1.242 ++ typeface = SkCairoFTTypeface::CreateTypeface(fontFace, style, isFixedWidth);
1.243 ++ SkTypefaceCache::Add(typeface, style);
1.244 ++ }
1.245 ++
1.246 ++ return typeface;
1.247 ++}
1.248 ++
1.249 ++SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
1.250 ++ const char famillyName[],
1.251 ++ SkTypeface::Style style)
1.252 ++{
1.253 ++ SkDEBUGFAIL("SkFontHost::FindTypeface unimplemented");
1.254 ++ return NULL;
1.255 ++}
1.256 ++
1.257 ++SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream*)
1.258 ++{
1.259 ++ SkDEBUGFAIL("SkFontHost::CreateTypeface unimplemented");
1.260 ++ return NULL;
1.261 ++}
1.262 ++
1.263 ++SkTypeface* SkFontHost::CreateTypefaceFromFile(char const*)
1.264 ++{
1.265 ++ SkDEBUGFAIL("SkFontHost::CreateTypefaceFromFile unimplemented");
1.266 ++ return NULL;
1.267 ++}
1.268 ++
1.269 ++///////////////////////////////////////////////////////////////////////////////
1.270 ++
1.271 ++static bool isLCD(const SkScalerContext::Rec& rec) {
1.272 ++ switch (rec.fMaskFormat) {
1.273 ++ case SkMask::kLCD16_Format:
1.274 ++ case SkMask::kLCD32_Format:
1.275 ++ return true;
1.276 ++ default:
1.277 ++ return false;
1.278 ++ }
1.279 ++}
1.280 ++
1.281 ++///////////////////////////////////////////////////////////////////////////////
1.282 ++SkScalerContext_CairoFT::SkScalerContext_CairoFT(SkTypeface* typeface, const SkDescriptor* desc)
1.283 ++ : SkScalerContext_FreeType_Base(typeface, desc)
1.284 ++{
1.285 ++ SkMatrix matrix;
1.286 ++ fRec.getSingleMatrix(&matrix);
1.287 ++
1.288 ++ cairo_font_face_t* fontFace = static_cast<SkCairoFTTypeface*>(typeface)->getFontFace();
1.289 ++
1.290 ++ cairo_matrix_t fontMatrix, ctMatrix;
1.291 ++ cairo_matrix_init(&fontMatrix, matrix.getScaleX(), matrix.getSkewY(), matrix.getSkewX(), matrix.getScaleY(), 0.0, 0.0);
1.292 ++ cairo_matrix_init_scale(&ctMatrix, 1.0, 1.0);
1.293 ++
1.294 ++ // We need to ensure that the font options match for hinting, as generateMetrics()
1.295 ++ // uses the fScaledFont which uses these font options
1.296 ++ cairo_font_options_t *fontOptions = cairo_font_options_create();
1.297 ++
1.298 ++ FT_Int32 loadFlags = FT_LOAD_DEFAULT;
1.299 ++
1.300 ++ if (SkMask::kBW_Format == fRec.fMaskFormat) {
1.301 ++ // See http://code.google.com/p/chromium/issues/detail?id=43252#c24
1.302 ++ loadFlags = FT_LOAD_TARGET_MONO;
1.303 ++ if (fRec.getHinting() == SkPaint::kNo_Hinting) {
1.304 ++ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_NONE);
1.305 ++ loadFlags = FT_LOAD_NO_HINTING;
1.306 ++ }
1.307 ++ } else {
1.308 ++ switch (fRec.getHinting()) {
1.309 ++ case SkPaint::kNo_Hinting:
1.310 ++ loadFlags = FT_LOAD_NO_HINTING;
1.311 ++ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_NONE);
1.312 ++ break;
1.313 ++ case SkPaint::kSlight_Hinting:
1.314 ++ loadFlags = FT_LOAD_TARGET_LIGHT; // This implies FORCE_AUTOHINT
1.315 ++ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_SLIGHT);
1.316 ++ break;
1.317 ++ case SkPaint::kNormal_Hinting:
1.318 ++ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_MEDIUM);
1.319 ++ if (fRec.fFlags & SkScalerContext::kAutohinting_Flag) {
1.320 ++ loadFlags = FT_LOAD_FORCE_AUTOHINT;
1.321 ++ }
1.322 ++ break;
1.323 ++ case SkPaint::kFull_Hinting:
1.324 ++ cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_FULL);
1.325 ++ if (fRec.fFlags & SkScalerContext::kAutohinting_Flag) {
1.326 ++ loadFlags = FT_LOAD_FORCE_AUTOHINT;
1.327 ++ }
1.328 ++ if (isLCD(fRec)) {
1.329 ++ if (SkToBool(fRec.fFlags & SkScalerContext::kLCD_Vertical_Flag)) {
1.330 ++ loadFlags = FT_LOAD_TARGET_LCD_V;
1.331 ++ } else {
1.332 ++ loadFlags = FT_LOAD_TARGET_LCD;
1.333 ++ }
1.334 ++ }
1.335 ++ break;
1.336 ++ default:
1.337 ++ SkDebugf("---------- UNKNOWN hinting %d\n", fRec.getHinting());
1.338 ++ break;
1.339 ++ }
1.340 ++ }
1.341 ++
1.342 ++ fScaledFont = cairo_scaled_font_create(fontFace, &fontMatrix, &ctMatrix, fontOptions);
1.343 ++
1.344 ++ if ((fRec.fFlags & SkScalerContext::kEmbeddedBitmapText_Flag) == 0) {
1.345 ++ loadFlags |= FT_LOAD_NO_BITMAP;
1.346 ++ }
1.347 ++
1.348 ++ // Always using FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH to get correct
1.349 ++ // advances, as fontconfig and cairo do.
1.350 ++ // See http://code.google.com/p/skia/issues/detail?id=222.
1.351 ++ loadFlags |= FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
1.352 ++
1.353 ++ fLoadGlyphFlags = loadFlags;
1.354 ++}
1.355 ++
1.356 ++SkScalerContext_CairoFT::~SkScalerContext_CairoFT()
1.357 ++{
1.358 ++ cairo_scaled_font_destroy(fScaledFont);
1.359 ++}
1.360 ++
1.361 ++unsigned SkScalerContext_CairoFT::generateGlyphCount()
1.362 ++{
1.363 ++ CairoLockedFTFace faceLock(fScaledFont);
1.364 ++ return faceLock.getFace()->num_glyphs;
1.365 ++}
1.366 ++
1.367 ++uint16_t SkScalerContext_CairoFT::generateCharToGlyph(SkUnichar uniChar)
1.368 ++{
1.369 ++ CairoLockedFTFace faceLock(fScaledFont);
1.370 ++ return SkToU16(FT_Get_Char_Index(faceLock.getFace(), uniChar));
1.371 ++}
1.372 ++
1.373 ++void SkScalerContext_CairoFT::generateAdvance(SkGlyph* glyph)
1.374 ++{
1.375 ++ generateMetrics(glyph);
1.376 ++}
1.377 ++
1.378 ++void SkScalerContext_CairoFT::generateMetrics(SkGlyph* glyph)
1.379 ++{
1.380 ++ SkASSERT(fScaledFont != NULL);
1.381 ++ cairo_text_extents_t extents;
1.382 ++ cairo_glyph_t cairoGlyph = { glyph->getGlyphID(fBaseGlyphCount), 0.0, 0.0 };
1.383 ++ cairo_scaled_font_glyph_extents(fScaledFont, &cairoGlyph, 1, &extents);
1.384 ++
1.385 ++ glyph->fAdvanceX = SkDoubleToFixed(extents.x_advance);
1.386 ++ glyph->fAdvanceY = SkDoubleToFixed(extents.y_advance);
1.387 ++ glyph->fWidth = SkToU16(SkScalarCeil(extents.width));
1.388 ++ glyph->fHeight = SkToU16(SkScalarCeil(extents.height));
1.389 ++ glyph->fLeft = SkToS16(SkScalarCeil(extents.x_bearing));
1.390 ++ glyph->fTop = SkToS16(SkScalarCeil(extents.y_bearing));
1.391 ++ glyph->fLsbDelta = 0;
1.392 ++ glyph->fRsbDelta = 0;
1.393 ++}
1.394 ++
1.395 ++void SkScalerContext_CairoFT::generateImage(const SkGlyph& glyph)
1.396 ++{
1.397 ++ SkASSERT(fScaledFont != NULL);
1.398 ++ CairoLockedFTFace faceLock(fScaledFont);
1.399 ++ FT_Face face = faceLock.getFace();
1.400 ++
1.401 ++ FT_Error err = FT_Load_Glyph(face, glyph.getGlyphID(fBaseGlyphCount), fLoadGlyphFlags);
1.402 ++
1.403 ++ if (err != 0) {
1.404 ++ memset(glyph.fImage, 0, glyph.rowBytes() * glyph.fHeight);
1.405 ++ return;
1.406 ++ }
1.407 ++
1.408 ++ generateGlyphImage(face, glyph);
1.409 ++}
1.410 ++
1.411 ++void SkScalerContext_CairoFT::generatePath(const SkGlyph& glyph, SkPath* path)
1.412 ++{
1.413 ++ SkASSERT(fScaledFont != NULL);
1.414 ++ CairoLockedFTFace faceLock(fScaledFont);
1.415 ++ FT_Face face = faceLock.getFace();
1.416 ++
1.417 ++ SkASSERT(&glyph && path);
1.418 ++
1.419 ++ uint32_t flags = fLoadGlyphFlags;
1.420 ++ flags |= FT_LOAD_NO_BITMAP; // ignore embedded bitmaps so we're sure to get the outline
1.421 ++ flags &= ~FT_LOAD_RENDER; // don't scan convert (we just want the outline)
1.422 ++
1.423 ++ FT_Error err = FT_Load_Glyph(face, glyph.getGlyphID(fBaseGlyphCount), flags);
1.424 ++
1.425 ++ if (err != 0) {
1.426 ++ path->reset();
1.427 ++ return;
1.428 ++ }
1.429 ++
1.430 ++ generateGlyphPath(face, path);
1.431 ++}
1.432 ++
1.433 ++void SkScalerContext_CairoFT::generateFontMetrics(SkPaint::FontMetrics* mx,
1.434 ++ SkPaint::FontMetrics* my)
1.435 ++{
1.436 ++ SkDEBUGCODE(SkDebugf("SkScalerContext_CairoFT::generateFontMetrics unimplemented\n"));
1.437 ++}
1.438 ++
1.439 ++SkUnichar SkScalerContext_CairoFT::generateGlyphToChar(uint16_t glyph)
1.440 ++{
1.441 ++ SkASSERT(fScaledFont != NULL);
1.442 ++ CairoLockedFTFace faceLock(fScaledFont);
1.443 ++ FT_Face face = faceLock.getFace();
1.444 ++
1.445 ++ FT_UInt glyphIndex;
1.446 ++ SkUnichar charCode = FT_Get_First_Char(face, &glyphIndex);
1.447 ++ while (glyphIndex != 0) {
1.448 ++ if (glyphIndex == glyph) {
1.449 ++ return charCode;
1.450 ++ }
1.451 ++ charCode = FT_Get_Next_Char(face, charCode, &glyphIndex);
1.452 ++ }
1.453 ++
1.454 ++ return 0;
1.455 ++}
1.456 ++
1.457 ++#ifdef SK_BUILD_FOR_ANDROID
1.458 ++SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID,
1.459 ++ SkFontID origFontID) {
1.460 ++ return NULL;
1.461 ++}
1.462 ++#endif
1.463 ++
1.464 ++///////////////////////////////////////////////////////////////////////////////
1.465 ++
1.466 ++#include "SkFontMgr.h"
1.467 ++
1.468 ++SkFontMgr* SkFontMgr::Factory() {
1.469 ++ // todo
1.470 ++ return NULL;
1.471 ++}
1.472 ++
1.473 +--
1.474 +1.7.11.7
1.475 +
