gfx/skia/trunk/src/fonts/SkGScalerContext.cpp@129ffea94266
gfx/skia/trunk/src/fonts/SkGScalerContext.cpp
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
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 */
8 #include "SkGScalerContext.h"
9 #include "SkGlyph.h"
10 #include "SkPath.h"
11 #include "SkCanvas.h"
13 class SkGScalerContext : public SkScalerContext {
14 public:
15 SkGScalerContext(SkGTypeface*, const SkDescriptor*);
16 virtual ~SkGScalerContext();
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;
28 private:
29 SkGTypeface* fFace;
30 SkScalerContext* fProxy;
31 SkMatrix fMatrix;
32 };
34 #define STD_SIZE 1
36 #include "SkDescriptor.h"
38 SkGScalerContext::SkGScalerContext(SkGTypeface* face, const SkDescriptor* desc)
39 : SkScalerContext(face, desc)
40 , fFace(face)
41 {
43 size_t descSize = SkDescriptor::ComputeOverhead(1) + sizeof(SkScalerContext::Rec);
44 SkAutoDescriptor ad(descSize);
45 SkDescriptor* newDesc = ad.getDesc();
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();
61 fProxy = face->proxy()->createScalerContext(newDesc);
63 fRec.getSingleMatrix(&fMatrix);
64 fMatrix.preScale(SK_Scalar1 / STD_SIZE, SK_Scalar1 / STD_SIZE);
65 }
67 SkGScalerContext::~SkGScalerContext() {
68 SkDELETE(fProxy);
69 }
71 unsigned SkGScalerContext::generateGlyphCount() {
72 return fProxy->getGlyphCount();
73 }
75 uint16_t SkGScalerContext::generateCharToGlyph(SkUnichar uni) {
76 return fProxy->charToGlyphID(uni);
77 }
79 void SkGScalerContext::generateAdvance(SkGlyph* glyph) {
80 fProxy->getAdvance(glyph);
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 }
89 void SkGScalerContext::generateMetrics(SkGlyph* glyph) {
90 fProxy->getMetrics(glyph);
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);
98 SkPath path;
99 fProxy->getPath(*glyph, &path);
100 path.transform(fMatrix);
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 }
116 void SkGScalerContext::generateImage(const SkGlyph& glyph) {
117 if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
118 SkPath path;
119 fProxy->getPath(glyph, &path);
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);
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 }
137 void SkGScalerContext::generatePath(const SkGlyph& glyph, SkPath* path) {
138 fProxy->getPath(glyph, path);
139 path->transform(fMatrix);
140 }
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 }
159 ///////////////////////////////////////////////////////////////////////////////
161 #include "SkTypefaceCache.h"
163 SkGTypeface::SkGTypeface(SkTypeface* proxy, const SkPaint& paint)
164 : SkTypeface(proxy->style(), SkTypefaceCache::NewFontID(), false)
165 , fProxy(SkRef(proxy))
166 , fPaint(paint) {}
168 SkGTypeface::~SkGTypeface() {
169 fProxy->unref();
170 }
172 SkScalerContext* SkGTypeface::onCreateScalerContext(
173 const SkDescriptor* desc) const {
174 return SkNEW_ARGS(SkGScalerContext, (const_cast<SkGTypeface*>(this), desc));
175 }
177 void SkGTypeface::onFilterRec(SkScalerContextRec* rec) const {
178 fProxy->filterRec(rec);
179 rec->setHinting(SkPaint::kNo_Hinting);
180 rec->fMaskFormat = SkMask::kARGB32_Format;
181 }
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 }
190 SkStream* SkGTypeface::onOpenStream(int* ttcIndex) const {
191 return fProxy->openStream(ttcIndex);
192 }
194 void SkGTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
195 bool* isLocal) const {
196 fProxy->getFontDescriptor(desc, isLocal);
197 }
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 }
204 int SkGTypeface::onCountGlyphs() const {
205 return fProxy->countGlyphs();
206 }
208 int SkGTypeface::onGetUPEM() const {
209 return fProxy->getUnitsPerEm();
210 }
212 SkTypeface::LocalizedStrings* SkGTypeface::onCreateFamilyNameIterator() const {
213 return fProxy->createFamilyNameIterator();
214 }
216 int SkGTypeface::onGetTableTags(SkFontTableTag tags[]) const {
217 return fProxy->getTableTags(tags);
218 }
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 }
225 ///////////////////////////////////////////////////////////////////////////////
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();
234 int unicharToGlyph(SkUnichar) const;
236 int countGlyphs() const { return fCount; }
238 float getAdvance(int index) const {
239 SkASSERT((unsigned)index < (unsigned)fCount);
240 return fGlyphs[index].fAdvance;
241 }
243 const SkPath& getPath(int index) const {
244 SkASSERT((unsigned)index < (unsigned)fCount);
245 return fGlyphs[index].fPath;
246 }
248 private:
249 struct Glyph {
250 SkUnichar fUni;
251 float fAdvance;
252 SkPath fPath;
253 };
254 int fCount;
255 Glyph* fGlyphs;
257 friend class SkGFontBuilder;
258 SkGFont(int count, Glyph* array);
259 };
261 class SkGFontBuilder {
262 public:
264 };
265 #endif
