1 /* 2 * Copyright 2010 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 "GrTextContext.h" 9 #include "GrContext.h" 10 #include "GrDrawTarget.h" 11 #include "GrFontScaler.h" 12 13 #include "SkAutoKern.h" 14 #include "SkDrawFilter.h" 15 #include "SkDrawProcs.h" 16 #include "SkGlyphCache.h" 17 #include "SkGpuDevice.h" 18 #include "SkTextBlob.h" 19 #include "SkTextMapStateProc.h" 20 #include "SkTextToPathIter.h" 21 22 GrTextContext::GrTextContext(GrContext* context, SkGpuDevice* gpuDevice, 23 const SkDeviceProperties& properties) 24 : fFallbackTextContext(NULL) 25 , fContext(context) 26 , fGpuDevice(gpuDevice) 27 , fDeviceProperties(properties) 28 , fDrawTarget(NULL) { 29 } 30 31 GrTextContext::~GrTextContext() { 32 SkDELETE(fFallbackTextContext); 33 } 34 35 void GrTextContext::init(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint, 36 const SkPaint& skPaint, const SkIRect& regionClipBounds) { 37 fClip = clip; 38 39 fRenderTarget.reset(SkRef(rt)); 40 41 fRegionClipBounds = regionClipBounds; 42 fClip.getConservativeBounds(fRenderTarget->width(), fRenderTarget->height(), &fClipRect); 43 44 fDrawTarget = fContext->getTextTarget(); 45 46 fPaint = grPaint; 47 fSkPaint = skPaint; 48 } 49 50 void GrTextContext::drawText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& paint, 51 const SkPaint& skPaint, const SkMatrix& viewMatrix, 52 const char text[], size_t byteLength, 53 SkScalar x, SkScalar y, const SkIRect& clipBounds) { 54 if (!fContext->getTextTarget()) { 55 return; 56 } 57 58 GrTextContext* textContext = this; 59 do { 60 if (textContext->canDraw(rt, clip, paint, skPaint, viewMatrix)) { 61 textContext->onDrawText(rt, clip, paint, skPaint, viewMatrix, text, byteLength, x, y, 62 clipBounds); 63 return; 64 } 65 textContext = textContext->fFallbackTextContext; 66 } while (textContext); 67 68 // fall back to drawing as a path 69 SkASSERT(fGpuDevice); 70 this->drawTextAsPath(skPaint, viewMatrix, text, byteLength, x, y, clipBounds); 71 } 72 73 void GrTextContext::drawPosText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& paint, 74 const SkPaint& skPaint, const SkMatrix& viewMatrix, 75 const char text[], size_t byteLength, 76 const SkScalar pos[], int scalarsPerPosition, 77 const SkPoint& offset, const SkIRect& clipBounds) { 78 if (!fContext->getTextTarget()) { 79 return; 80 } 81 82 GrTextContext* textContext = this; 83 do { 84 if (textContext->canDraw(rt, clip, paint, skPaint, viewMatrix)) { 85 textContext->onDrawPosText(rt, clip, paint, skPaint, viewMatrix, text, byteLength, pos, 86 scalarsPerPosition, offset, clipBounds); 87 return; 88 } 89 textContext = textContext->fFallbackTextContext; 90 } while (textContext); 91 92 // fall back to drawing as a path 93 SkASSERT(fGpuDevice); 94 this->drawPosTextAsPath(skPaint, viewMatrix, text, byteLength, pos, scalarsPerPosition, offset, 95 clipBounds); 96 } 97 98 void GrTextContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip, const SkPaint& skPaint, 99 const SkMatrix& viewMatrix, const SkTextBlob* blob, 100 SkScalar x, SkScalar y, 101 SkDrawFilter* drawFilter, const SkIRect& clipBounds) { 102 SkPaint runPaint = skPaint; 103 104 SkTextBlob::RunIterator it(blob); 105 for (;!it.done(); it.next()) { 106 size_t textLen = it.glyphCount() * sizeof(uint16_t); 107 const SkPoint& offset = it.offset(); 108 // applyFontToPaint() always overwrites the exact same attributes, 109 // so it is safe to not re-seed the paint for this reason. 110 it.applyFontToPaint(&runPaint); 111 112 if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) { 113 // A false return from filter() means we should abort the current draw. 114 runPaint = skPaint; 115 continue; 116 } 117 118 runPaint.setFlags(fGpuDevice->filterTextFlags(runPaint)); 119 120 GrPaint grPaint; 121 if (!SkPaint2GrPaint(fContext, fRenderTarget, runPaint, viewMatrix, true, &grPaint)) { 122 return; 123 } 124 125 switch (it.positioning()) { 126 case SkTextBlob::kDefault_Positioning: 127 this->drawText(rt, clip, grPaint, runPaint, viewMatrix, (const char *)it.glyphs(), 128 textLen, x + offset.x(), y + offset.y(), clipBounds); 129 break; 130 case SkTextBlob::kHorizontal_Positioning: 131 this->drawPosText(rt, clip, grPaint, runPaint, viewMatrix, (const char*)it.glyphs(), 132 textLen, it.pos(), 1, SkPoint::Make(x, y + offset.y()), clipBounds); 133 break; 134 case SkTextBlob::kFull_Positioning: 135 this->drawPosText(rt, clip, grPaint, runPaint, viewMatrix, (const char*)it.glyphs(), 136 textLen, it.pos(), 2, SkPoint::Make(x, y), clipBounds); 137 break; 138 default: 139 SkFAIL("unhandled positioning mode"); 140 } 141 142 if (drawFilter) { 143 // A draw filter may change the paint arbitrarily, so we must re-seed in this case. 144 runPaint = skPaint; 145 } 146 } 147 } 148 149 void GrTextContext::drawTextAsPath(const SkPaint& skPaint, const SkMatrix& viewMatrix, 150 const char text[], size_t byteLength, SkScalar x, SkScalar y, 151 const SkIRect& clipBounds) { 152 SkTextToPathIter iter(text, byteLength, skPaint, true); 153 154 SkMatrix matrix; 155 matrix.setScale(iter.getPathScale(), iter.getPathScale()); 156 matrix.postTranslate(x, y); 157 158 const SkPath* iterPath; 159 SkScalar xpos, prevXPos = 0; 160 161 while (iter.next(&iterPath, &xpos)) { 162 matrix.postTranslate(xpos - prevXPos, 0); 163 if (iterPath) { 164 const SkPaint& pnt = iter.getPaint(); 165 fGpuDevice->internalDrawPath(*iterPath, pnt, viewMatrix, &matrix, clipBounds, false); 166 } 167 prevXPos = xpos; 168 } 169 } 170 171 void GrTextContext::drawPosTextAsPath(const SkPaint& origPaint, const SkMatrix& viewMatrix, 172 const char text[], size_t byteLength, 173 const SkScalar pos[], int scalarsPerPosition, 174 const SkPoint& offset, const SkIRect& clipBounds) { 175 // setup our std paint, in hopes of getting hits in the cache 176 SkPaint paint(origPaint); 177 SkScalar matrixScale = paint.setupForAsPaths(); 178 179 SkMatrix matrix; 180 matrix.setScale(matrixScale, matrixScale); 181 182 // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache. 183 paint.setStyle(SkPaint::kFill_Style); 184 paint.setPathEffect(NULL); 185 186 SkDrawCacheProc glyphCacheProc = paint.getDrawCacheProc(); 187 SkAutoGlyphCache autoCache(paint, NULL, NULL); 188 SkGlyphCache* cache = autoCache.getCache(); 189 190 const char* stop = text + byteLength; 191 SkTextAlignProc alignProc(paint.getTextAlign()); 192 SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition); 193 194 // Now restore the original settings, so we "draw" with whatever style/stroking. 195 paint.setStyle(origPaint.getStyle()); 196 paint.setPathEffect(origPaint.getPathEffect()); 197 198 while (text < stop) { 199 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0); 200 if (glyph.fWidth) { 201 const SkPath* path = cache->findPath(glyph); 202 if (path) { 203 SkPoint tmsLoc; 204 tmsProc(pos, &tmsLoc); 205 SkPoint loc; 206 alignProc(tmsLoc, glyph, &loc); 207 208 matrix[SkMatrix::kMTransX] = loc.fX; 209 matrix[SkMatrix::kMTransY] = loc.fY; 210 fGpuDevice->internalDrawPath(*path, paint, viewMatrix, &matrix, clipBounds, false); 211 } 212 } 213 pos += scalarsPerPosition; 214 } 215 } 216 217 //*** change to output positions? 218 int GrTextContext::MeasureText(SkGlyphCache* cache, SkDrawCacheProc glyphCacheProc, 219 const char text[], size_t byteLength, SkVector* stopVector) { 220 SkFixed x = 0, y = 0; 221 const char* stop = text + byteLength; 222 223 SkAutoKern autokern; 224 225 int numGlyphs = 0; 226 while (text < stop) { 227 // don't need x, y here, since all subpixel variants will have the 228 // same advance 229 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0); 230 231 x += autokern.adjust(glyph) + glyph.fAdvanceX; 232 y += glyph.fAdvanceY; 233 ++numGlyphs; 234 } 235 stopVector->set(SkFixedToScalar(x), SkFixedToScalar(y)); 236 237 SkASSERT(text == stop); 238 239 return numGlyphs; 240 } 241 242 static void GlyphCacheAuxProc(void* data) { 243 GrFontScaler* scaler = (GrFontScaler*)data; 244 SkSafeUnref(scaler); 245 } 246 247 GrFontScaler* GrTextContext::GetGrFontScaler(SkGlyphCache* cache) { 248 void* auxData; 249 GrFontScaler* scaler = NULL; 250 251 if (cache->getAuxProcData(GlyphCacheAuxProc, &auxData)) { 252 scaler = (GrFontScaler*)auxData; 253 } 254 if (NULL == scaler) { 255 scaler = SkNEW_ARGS(GrFontScaler, (cache)); 256 cache->setAuxProc(GlyphCacheAuxProc, scaler); 257 } 258 259 return scaler; 260 } 261