The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/fonts/SkGScalerContext.cpp
gfx/skia/trunk/src/fonts/SkGScalerContext.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:e38b05dabe3d |
|---|---|
| 1 /* | |
| 2 * Copyright 2013 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 #include "SkGScalerContext.h" | |
| 9 #include "SkGlyph.h" | |
| 10 #include "SkPath.h" | |
| 11 #include "SkCanvas.h" | |
| 12 | |
| 13 class SkGScalerContext : public SkScalerContext { | |
| 14 public: | |
| 15 SkGScalerContext(SkGTypeface*, const SkDescriptor*); | |
| 16 virtual ~SkGScalerContext(); | |
| 17 | |
| 18 protected: | |
| 19 virtual unsigned generateGlyphCount() SK_OVERRIDE; | |
| 20 virtual uint16_t generateCharToGlyph(SkUnichar) SK_OVERRIDE; | |
| 21 virtual void generateAdvance(SkGlyph*) SK_OVERRIDE; | |
| 22 virtual void generateMetrics(SkGlyph*) SK_OVERRIDE; | |
| 23 virtual void generateImage(const SkGlyph&) SK_OVERRIDE; | |
| 24 virtual void generatePath(const SkGlyph&, SkPath*) SK_OVERRIDE; | |
| 25 virtual void generateFontMetrics(SkPaint::FontMetrics* mX, | |
| 26 SkPaint::FontMetrics* mY) SK_OVERRIDE; | |
| 27 | |
| 28 private: | |
| 29 SkGTypeface* fFace; | |
| 30 SkScalerContext* fProxy; | |
| 31 SkMatrix fMatrix; | |
| 32 }; | |
| 33 | |
| 34 #define STD_SIZE 1 | |
| 35 | |
| 36 #include "SkDescriptor.h" | |
| 37 | |
| 38 SkGScalerContext::SkGScalerContext(SkGTypeface* face, const SkDescriptor* desc) | |
| 39 : SkScalerContext(face, desc) | |
| 40 , fFace(face) | |
| 41 { | |
| 42 | |
| 43 size_t descSize = SkDescriptor::ComputeOverhead(1) + sizeof(SkScalerContext::Rec); | |
| 44 SkAutoDescriptor ad(descSize); | |
| 45 SkDescriptor* newDesc = ad.getDesc(); | |
| 46 | |
| 47 newDesc->init(); | |
| 48 void* entry = newDesc->addEntry(kRec_SkDescriptorTag, | |
| 49 sizeof(SkScalerContext::Rec), &fRec); | |
| 50 { | |
| 51 SkScalerContext::Rec* rec = (SkScalerContext::Rec*)entry; | |
| 52 rec->fTextSize = STD_SIZE; | |
| 53 rec->fPreScaleX = SK_Scalar1; | |
| 54 rec->fPreSkewX = 0; | |
| 55 rec->fPost2x2[0][0] = rec->fPost2x2[1][1] = SK_Scalar1; | |
| 56 rec->fPost2x2[1][0] = rec->fPost2x2[0][1] = 0; | |
| 57 } | |
| 58 SkASSERT(descSize == newDesc->getLength()); | |
| 59 newDesc->computeChecksum(); | |
| 60 | |
| 61 fProxy = face->proxy()->createScalerContext(newDesc); | |
| 62 | |
| 63 fRec.getSingleMatrix(&fMatrix); | |
| 64 fMatrix.preScale(SK_Scalar1 / STD_SIZE, SK_Scalar1 / STD_SIZE); | |
| 65 } | |
| 66 | |
| 67 SkGScalerContext::~SkGScalerContext() { | |
| 68 SkDELETE(fProxy); | |
| 69 } | |
| 70 | |
| 71 unsigned SkGScalerContext::generateGlyphCount() { | |
| 72 return fProxy->getGlyphCount(); | |
| 73 } | |
| 74 | |
| 75 uint16_t SkGScalerContext::generateCharToGlyph(SkUnichar uni) { | |
| 76 return fProxy->charToGlyphID(uni); | |
| 77 } | |
| 78 | |
| 79 void SkGScalerContext::generateAdvance(SkGlyph* glyph) { | |
| 80 fProxy->getAdvance(glyph); | |
| 81 | |
| 82 SkVector advance; | |
| 83 fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX), | |
| 84 SkFixedToScalar(glyph->fAdvanceY), &advance); | |
| 85 glyph->fAdvanceX = SkScalarToFixed(advance.fX); | |
| 86 glyph->fAdvanceY = SkScalarToFixed(advance.fY); | |
| 87 } | |
| 88 | |
| 89 void SkGScalerContext::generateMetrics(SkGlyph* glyph) { | |
| 90 fProxy->getMetrics(glyph); | |
| 91 | |
| 92 SkVector advance; | |
| 93 fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX), | |
| 94 SkFixedToScalar(glyph->fAdvanceY), &advance); | |
| 95 glyph->fAdvanceX = SkScalarToFixed(advance.fX); | |
| 96 glyph->fAdvanceY = SkScalarToFixed(advance.fY); | |
| 97 | |
| 98 SkPath path; | |
| 99 fProxy->getPath(*glyph, &path); | |
| 100 path.transform(fMatrix); | |
| 101 | |
| 102 SkRect storage; | |
| 103 const SkPaint& paint = fFace->paint(); | |
| 104 const SkRect& newBounds = paint.doComputeFastBounds(path.getBounds(), | |
| 105 &storage, | |
| 106 SkPaint::kFill_Style); | |
| 107 SkIRect ibounds; | |
| 108 newBounds.roundOut(&ibounds); | |
| 109 glyph->fLeft = ibounds.fLeft; | |
| 110 glyph->fTop = ibounds.fTop; | |
| 111 glyph->fWidth = ibounds.width(); | |
| 112 glyph->fHeight = ibounds.height(); | |
| 113 glyph->fMaskFormat = SkMask::kARGB32_Format; | |
| 114 } | |
| 115 | |
| 116 void SkGScalerContext::generateImage(const SkGlyph& glyph) { | |
| 117 if (SkMask::kARGB32_Format == glyph.fMaskFormat) { | |
| 118 SkPath path; | |
| 119 fProxy->getPath(glyph, &path); | |
| 120 | |
| 121 SkBitmap bm; | |
| 122 bm.setConfig(SkBitmap::kARGB_8888_Config, glyph.fWidth, glyph.fHeight, | |
| 123 glyph.rowBytes()); | |
| 124 bm.setPixels(glyph.fImage); | |
| 125 bm.eraseColor(0); | |
| 126 | |
| 127 SkCanvas canvas(bm); | |
| 128 canvas.translate(-SkIntToScalar(glyph.fLeft), | |
| 129 -SkIntToScalar(glyph.fTop)); | |
| 130 canvas.concat(fMatrix); | |
| 131 canvas.drawPath(path, fFace->paint()); | |
| 132 } else { | |
| 133 fProxy->getImage(glyph); | |
| 134 } | |
| 135 } | |
| 136 | |
| 137 void SkGScalerContext::generatePath(const SkGlyph& glyph, SkPath* path) { | |
| 138 fProxy->getPath(glyph, path); | |
| 139 path->transform(fMatrix); | |
| 140 } | |
| 141 | |
| 142 void SkGScalerContext::generateFontMetrics(SkPaint::FontMetrics*, | |
| 143 SkPaint::FontMetrics* metrics) { | |
| 144 fProxy->getFontMetrics(metrics); | |
| 145 if (metrics) { | |
| 146 SkScalar scale = fMatrix.getScaleY(); | |
| 147 metrics->fTop = SkScalarMul(metrics->fTop, scale); | |
| 148 metrics->fAscent = SkScalarMul(metrics->fAscent, scale); | |
| 149 metrics->fDescent = SkScalarMul(metrics->fDescent, scale); | |
| 150 metrics->fBottom = SkScalarMul(metrics->fBottom, scale); | |
| 151 metrics->fLeading = SkScalarMul(metrics->fLeading, scale); | |
| 152 metrics->fAvgCharWidth = SkScalarMul(metrics->fAvgCharWidth, scale); | |
| 153 metrics->fXMin = SkScalarMul(metrics->fXMin, scale); | |
| 154 metrics->fXMax = SkScalarMul(metrics->fXMax, scale); | |
| 155 metrics->fXHeight = SkScalarMul(metrics->fXHeight, scale); | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 /////////////////////////////////////////////////////////////////////////////// | |
| 160 | |
| 161 #include "SkTypefaceCache.h" | |
| 162 | |
| 163 SkGTypeface::SkGTypeface(SkTypeface* proxy, const SkPaint& paint) | |
| 164 : SkTypeface(proxy->style(), SkTypefaceCache::NewFontID(), false) | |
| 165 , fProxy(SkRef(proxy)) | |
| 166 , fPaint(paint) {} | |
| 167 | |
| 168 SkGTypeface::~SkGTypeface() { | |
| 169 fProxy->unref(); | |
| 170 } | |
| 171 | |
| 172 SkScalerContext* SkGTypeface::onCreateScalerContext( | |
| 173 const SkDescriptor* desc) const { | |
| 174 return SkNEW_ARGS(SkGScalerContext, (const_cast<SkGTypeface*>(this), desc)); | |
| 175 } | |
| 176 | |
| 177 void SkGTypeface::onFilterRec(SkScalerContextRec* rec) const { | |
| 178 fProxy->filterRec(rec); | |
| 179 rec->setHinting(SkPaint::kNo_Hinting); | |
| 180 rec->fMaskFormat = SkMask::kARGB32_Format; | |
| 181 } | |
| 182 | |
| 183 SkAdvancedTypefaceMetrics* SkGTypeface::onGetAdvancedTypefaceMetrics( | |
| 184 SkAdvancedTypefaceMetrics::PerGlyphInfo info, | |
| 185 const uint32_t* glyphIDs, | |
| 186 uint32_t glyphIDsCount) const { | |
| 187 return fProxy->getAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount); | |
| 188 } | |
| 189 | |
| 190 SkStream* SkGTypeface::onOpenStream(int* ttcIndex) const { | |
| 191 return fProxy->openStream(ttcIndex); | |
| 192 } | |
| 193 | |
| 194 void SkGTypeface::onGetFontDescriptor(SkFontDescriptor* desc, | |
| 195 bool* isLocal) const { | |
| 196 fProxy->getFontDescriptor(desc, isLocal); | |
| 197 } | |
| 198 | |
| 199 int SkGTypeface::onCharsToGlyphs(const void* chars, Encoding encoding, | |
| 200 uint16_t glyphs[], int glyphCount) const { | |
| 201 return fProxy->charsToGlyphs(chars, encoding, glyphs, glyphCount); | |
| 202 } | |
| 203 | |
| 204 int SkGTypeface::onCountGlyphs() const { | |
| 205 return fProxy->countGlyphs(); | |
| 206 } | |
| 207 | |
| 208 int SkGTypeface::onGetUPEM() const { | |
| 209 return fProxy->getUnitsPerEm(); | |
| 210 } | |
| 211 | |
| 212 SkTypeface::LocalizedStrings* SkGTypeface::onCreateFamilyNameIterator() const { | |
| 213 return fProxy->createFamilyNameIterator(); | |
| 214 } | |
| 215 | |
| 216 int SkGTypeface::onGetTableTags(SkFontTableTag tags[]) const { | |
| 217 return fProxy->getTableTags(tags); | |
| 218 } | |
| 219 | |
| 220 size_t SkGTypeface::onGetTableData(SkFontTableTag tag, size_t offset, | |
| 221 size_t length, void* data) const { | |
| 222 return fProxy->getTableData(tag, offset, length, data); | |
| 223 } | |
| 224 | |
| 225 /////////////////////////////////////////////////////////////////////////////// | |
| 226 | |
| 227 #if 0 | |
| 228 // under construction -- defining a font purely in terms of skia primitives | |
| 229 // ala an SVG-font. | |
| 230 class SkGFont : public SkRefCnt { | |
| 231 public: | |
| 232 virtual ~SkGFont(); | |
| 233 | |
| 234 int unicharToGlyph(SkUnichar) const; | |
| 235 | |
| 236 int countGlyphs() const { return fCount; } | |
| 237 | |
| 238 float getAdvance(int index) const { | |
| 239 SkASSERT((unsigned)index < (unsigned)fCount); | |
| 240 return fGlyphs[index].fAdvance; | |
| 241 } | |
| 242 | |
| 243 const SkPath& getPath(int index) const { | |
| 244 SkASSERT((unsigned)index < (unsigned)fCount); | |
| 245 return fGlyphs[index].fPath; | |
| 246 } | |
| 247 | |
| 248 private: | |
| 249 struct Glyph { | |
| 250 SkUnichar fUni; | |
| 251 float fAdvance; | |
| 252 SkPath fPath; | |
| 253 }; | |
| 254 int fCount; | |
| 255 Glyph* fGlyphs; | |
| 256 | |
| 257 friend class SkGFontBuilder; | |
| 258 SkGFont(int count, Glyph* array); | |
| 259 }; | |
| 260 | |
| 261 class SkGFontBuilder { | |
| 262 public: | |
| 263 | |
| 264 }; | |
| 265 #endif |
