Home | History | Annotate | Download | only in core 
      1 /* libs/graphics/sgl/SkPaint.cpp
      2 **
      3 ** Copyright 2006, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 #include "SkPaint.h"
     19 #include "SkColorFilter.h"
     20 #include "SkDrawLooper.h"
     21 #include "SkFontHost.h"
     22 #include "SkMaskFilter.h"
     23 #include "SkPathEffect.h"
     24 #include "SkRasterizer.h"
     25 #include "SkShader.h"
     26 #include "SkScalar.h"
     27 #include "SkScalerContext.h"
     28 #include "SkStroke.h"
     29 #include "SkTextFormatParams.h"
     30 #include "SkTypeface.h"
     31 #include "SkXfermode.h"
     32 #include "SkAutoKern.h"
     33 
     34 #define SK_DefaultTextSize      SkIntToScalar(12)
     35 
     36 #define SK_DefaultFlags         0   //(kNativeHintsText_Flag)
     37 
     38 #ifdef ANDROID
     39 #define GEN_ID_INC                  fGenerationID++
     40 #define GEN_ID_INC_EVAL(expression) if (expression) { fGenerationID++; }
     41 #else
     42 #define GEN_ID_INC
     43 #define GEN_ID_INC_EVAL(expression)
     44 #endif
     45 
     46 SkPaint::SkPaint() {
     47     // since we may have padding, we zero everything so that our memcmp() call
     48     // in operator== will work correctly.
     49     // with this, we can skip 0 and null individual initializations
     50     sk_bzero(this, sizeof(*this));
     51 
     52 #if 0   // not needed with the bzero call above
     53     fTypeface   = NULL;
     54     fTextSkewX  = 0;
     55     fPathEffect  = NULL;
     56     fShader      = NULL;
     57     fXfermode    = NULL;
     58     fMaskFilter  = NULL;
     59     fColorFilter = NULL;
     60     fRasterizer  = NULL;
     61     fLooper      = NULL;
     62     fWidth      = 0;
     63 #endif
     64 
     65     fTextSize   = SK_DefaultTextSize;
     66     fTextScaleX = SK_Scalar1;
     67     fColor      = SK_ColorBLACK;
     68     fMiterLimit = SK_DefaultMiterLimit;
     69     fFlags      = SK_DefaultFlags;
     70     fCapType    = kDefault_Cap;
     71     fJoinType   = kDefault_Join;
     72     fTextAlign  = kLeft_Align;
     73     fStyle      = kFill_Style;
     74     fTextEncoding = kUTF8_TextEncoding;
     75     fHinting    = kNormal_Hinting;
     76 #ifdef ANDROID
     77     fGenerationID = 0;
     78 #endif
     79 }
     80 
     81 SkPaint::SkPaint(const SkPaint& src) {
     82     memcpy(this, &src, sizeof(src));
     83 
     84     SkSafeRef(fTypeface);
     85     SkSafeRef(fPathEffect);
     86     SkSafeRef(fShader);
     87     SkSafeRef(fXfermode);
     88     SkSafeRef(fMaskFilter);
     89     SkSafeRef(fColorFilter);
     90     SkSafeRef(fRasterizer);
     91     SkSafeRef(fLooper);
     92 }
     93 
     94 SkPaint::~SkPaint() {
     95     SkSafeUnref(fTypeface);
     96     SkSafeUnref(fPathEffect);
     97     SkSafeUnref(fShader);
     98     SkSafeUnref(fXfermode);
     99     SkSafeUnref(fMaskFilter);
    100     SkSafeUnref(fColorFilter);
    101     SkSafeUnref(fRasterizer);
    102     SkSafeUnref(fLooper);
    103 }
    104 
    105 SkPaint& SkPaint::operator=(const SkPaint& src) {
    106     SkASSERT(&src);
    107 
    108     SkSafeRef(src.fTypeface);
    109     SkSafeRef(src.fPathEffect);
    110     SkSafeRef(src.fShader);
    111     SkSafeRef(src.fXfermode);
    112     SkSafeRef(src.fMaskFilter);
    113     SkSafeRef(src.fColorFilter);
    114     SkSafeRef(src.fRasterizer);
    115     SkSafeRef(src.fLooper);
    116 
    117     SkSafeUnref(fTypeface);
    118     SkSafeUnref(fPathEffect);
    119     SkSafeUnref(fShader);
    120     SkSafeUnref(fXfermode);
    121     SkSafeUnref(fMaskFilter);
    122     SkSafeUnref(fColorFilter);
    123     SkSafeUnref(fRasterizer);
    124     SkSafeUnref(fLooper);
    125 
    126 #ifdef ANDROID
    127     uint32_t oldGenerationID = fGenerationID;
    128 #endif
    129     memcpy(this, &src, sizeof(src));
    130 #ifdef ANDROID
    131     fGenerationID = oldGenerationID + 1;
    132 #endif
    133 
    134     return *this;
    135 }
    136 
    137 int operator==(const SkPaint& a, const SkPaint& b) {
    138     return memcmp(&a, &b, sizeof(a)) == 0;
    139 }
    140 
    141 void SkPaint::reset() {
    142     SkPaint init;
    143 
    144 #ifdef ANDROID
    145     uint32_t oldGenerationID = fGenerationID;
    146 #endif
    147     *this = init;
    148 #ifdef ANDROID
    149     fGenerationID = oldGenerationID + 1;
    150 #endif
    151 }
    152 
    153 #ifdef ANDROID
    154 uint32_t SkPaint::getGenerationID() const {
    155     return fGenerationID;
    156 }
    157 #endif
    158 
    159 void SkPaint::setHinting(Hinting hintingLevel) {
    160     GEN_ID_INC_EVAL((unsigned) hintingLevel != fHinting);
    161     fHinting = hintingLevel;
    162 }
    163 
    164 void SkPaint::setFlags(uint32_t flags) {
    165     GEN_ID_INC_EVAL(fFlags != flags);
    166     fFlags = flags;
    167 }
    168 
    169 void SkPaint::setAntiAlias(bool doAA) {
    170     GEN_ID_INC_EVAL(doAA != isAntiAlias());
    171     this->setFlags(SkSetClearMask(fFlags, doAA, kAntiAlias_Flag));
    172 }
    173 
    174 void SkPaint::setDither(bool doDither) {
    175     GEN_ID_INC_EVAL(doDither != isDither());
    176     this->setFlags(SkSetClearMask(fFlags, doDither, kDither_Flag));
    177 }
    178 
    179 void SkPaint::setSubpixelText(bool doSubpixel) {
    180     GEN_ID_INC_EVAL(doSubpixel != isSubpixelText());
    181     this->setFlags(SkSetClearMask(fFlags, doSubpixel, kSubpixelText_Flag));
    182 }
    183 
    184 void SkPaint::setLCDRenderText(bool doLCDRender) {
    185     GEN_ID_INC_EVAL(doLCDRender != isLCDRenderText());
    186     this->setFlags(SkSetClearMask(fFlags, doLCDRender, kLCDRenderText_Flag));
    187 }
    188 
    189 void SkPaint::setEmbeddedBitmapText(bool doEmbeddedBitmapText) {
    190     GEN_ID_INC_EVAL(doEmbeddedBitmapText != isEmbeddedBitmapText());
    191     this->setFlags(SkSetClearMask(fFlags, doEmbeddedBitmapText, kEmbeddedBitmapText_Flag));
    192 }
    193 
    194 void SkPaint::setAutohinted(bool useAutohinter) {
    195     GEN_ID_INC_EVAL(useAutohinter != isAutohinted());
    196     this->setFlags(SkSetClearMask(fFlags, useAutohinter, kAutoHinting_Flag));
    197 }
    198 
    199 void SkPaint::setLinearText(bool doLinearText) {
    200     GEN_ID_INC_EVAL(doLinearText != isLinearText());
    201     this->setFlags(SkSetClearMask(fFlags, doLinearText, kLinearText_Flag));
    202 }
    203 
    204 void SkPaint::setUnderlineText(bool doUnderline) {
    205     GEN_ID_INC_EVAL(doUnderline != isUnderlineText());
    206     this->setFlags(SkSetClearMask(fFlags, doUnderline, kUnderlineText_Flag));
    207 }
    208 
    209 void SkPaint::setStrikeThruText(bool doStrikeThru) {
    210     GEN_ID_INC_EVAL(doStrikeThru != isStrikeThruText());
    211     this->setFlags(SkSetClearMask(fFlags, doStrikeThru, kStrikeThruText_Flag));
    212 }
    213 
    214 void SkPaint::setFakeBoldText(bool doFakeBold) {
    215     GEN_ID_INC_EVAL(doFakeBold != isFakeBoldText());
    216     this->setFlags(SkSetClearMask(fFlags, doFakeBold, kFakeBoldText_Flag));
    217 }
    218 
    219 void SkPaint::setDevKernText(bool doDevKern) {
    220     GEN_ID_INC_EVAL(doDevKern != isDevKernText());
    221     this->setFlags(SkSetClearMask(fFlags, doDevKern, kDevKernText_Flag));
    222 }
    223 
    224 void SkPaint::setFilterBitmap(bool doFilter) {
    225     GEN_ID_INC_EVAL(doFilter != isFilterBitmap());
    226     this->setFlags(SkSetClearMask(fFlags, doFilter, kFilterBitmap_Flag));
    227 }
    228 
    229 void SkPaint::setStyle(Style style) {
    230     if ((unsigned)style < kStyleCount) {
    231         GEN_ID_INC_EVAL((unsigned)style != fStyle);
    232         fStyle = style;
    233     } else {
    234         SkDEBUGCODE(SkDebugf("SkPaint::setStyle(%d) out of range\n", style);)
    235     }
    236 }
    237 
    238 void SkPaint::setColor(SkColor color) {
    239     GEN_ID_INC_EVAL(color != fColor);
    240     fColor = color;
    241 }
    242 
    243 void SkPaint::setAlpha(U8CPU a) {
    244     this->setColor(SkColorSetARGB(a, SkColorGetR(fColor),
    245                                   SkColorGetG(fColor), SkColorGetB(fColor)));
    246 }
    247 
    248 void SkPaint::setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
    249     this->setColor(SkColorSetARGB(a, r, g, b));
    250 }
    251 
    252 void SkPaint::setStrokeWidth(SkScalar width) {
    253     if (width >= 0) {
    254         GEN_ID_INC_EVAL(width != fWidth);
    255         fWidth = width;
    256     } else {
    257         SkDEBUGCODE(SkDebugf("SkPaint::setStrokeWidth() called with negative value\n");)
    258     }
    259 }
    260 
    261 void SkPaint::setStrokeMiter(SkScalar limit) {
    262     if (limit >= 0) {
    263         GEN_ID_INC_EVAL(limit != fMiterLimit);
    264         fMiterLimit = limit;
    265     } else {
    266         SkDEBUGCODE(SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");)
    267     }
    268 }
    269 
    270 void SkPaint::setStrokeCap(Cap ct) {
    271     if ((unsigned)ct < kCapCount) {
    272         GEN_ID_INC_EVAL((unsigned)ct != fCapType);
    273         fCapType = SkToU8(ct);
    274     } else {
    275         SkDEBUGCODE(SkDebugf("SkPaint::setStrokeCap(%d) out of range\n", ct);)
    276     }
    277 }
    278 
    279 void SkPaint::setStrokeJoin(Join jt) {
    280     if ((unsigned)jt < kJoinCount) {
    281         GEN_ID_INC_EVAL((unsigned)jt != fJoinType);
    282         fJoinType = SkToU8(jt);
    283     } else {
    284         SkDEBUGCODE(SkDebugf("SkPaint::setStrokeJoin(%d) out of range\n", jt);)
    285     }
    286 }
    287 
    288 ///////////////////////////////////////////////////////////////////////////////
    289 
    290 void SkPaint::setTextAlign(Align align) {
    291     if ((unsigned)align < kAlignCount) {
    292         GEN_ID_INC_EVAL((unsigned)align != fTextAlign);
    293         fTextAlign = SkToU8(align);
    294     } else {
    295         SkDEBUGCODE(SkDebugf("SkPaint::setTextAlign(%d) out of range\n", align);)
    296     }
    297 }
    298 
    299 void SkPaint::setTextSize(SkScalar ts) {
    300     if (ts > 0) {
    301         GEN_ID_INC_EVAL(ts != fTextSize);
    302         fTextSize = ts;
    303     } else {
    304         SkDEBUGCODE(SkDebugf("SkPaint::setTextSize() called with negative value\n");)
    305     }
    306 }
    307 
    308 void SkPaint::setTextScaleX(SkScalar scaleX) {
    309     GEN_ID_INC_EVAL(scaleX != fTextScaleX);
    310     fTextScaleX = scaleX;
    311 }
    312 
    313 void SkPaint::setTextSkewX(SkScalar skewX) {
    314     GEN_ID_INC_EVAL(skewX != fTextSkewX);
    315     fTextSkewX = skewX;
    316 }
    317 
    318 void SkPaint::setTextEncoding(TextEncoding encoding) {
    319     if ((unsigned)encoding <= kGlyphID_TextEncoding) {
    320         GEN_ID_INC_EVAL((unsigned)encoding != fTextEncoding);
    321         fTextEncoding = encoding;
    322     } else {
    323         SkDEBUGCODE(SkDebugf("SkPaint::setTextEncoding(%d) out of range\n", encoding);)
    324     }
    325 }
    326 
    327 ///////////////////////////////////////////////////////////////////////////////
    328 
    329 SkTypeface* SkPaint::setTypeface(SkTypeface* font) {
    330     SkRefCnt_SafeAssign(fTypeface, font);
    331     GEN_ID_INC;
    332     return font;
    333 }
    334 
    335 SkRasterizer* SkPaint::setRasterizer(SkRasterizer* r) {
    336     SkRefCnt_SafeAssign(fRasterizer, r);
    337     GEN_ID_INC;
    338     return r;
    339 }
    340 
    341 SkDrawLooper* SkPaint::setLooper(SkDrawLooper* looper) {
    342     SkRefCnt_SafeAssign(fLooper, looper);
    343     GEN_ID_INC;
    344     return looper;
    345 }
    346 
    347 ///////////////////////////////////////////////////////////////////////////////
    348 
    349 #include "SkGlyphCache.h"
    350 #include "SkUtils.h"
    351 
    352 static void DetachDescProc(const SkDescriptor* desc, void* context) {
    353     *((SkGlyphCache**)context) = SkGlyphCache::DetachCache(desc);
    354 }
    355 
    356 #ifdef ANDROID
    357 const SkGlyph& SkPaint::getUnicharMetrics(SkUnichar text) {
    358     SkGlyphCache* cache;
    359     descriptorProc(NULL, DetachDescProc, &cache, true);
    360 
    361     const SkGlyph& glyph = cache->getUnicharMetrics(text);
    362 
    363     SkGlyphCache::AttachCache(cache);
    364     return glyph;
    365 }
    366 
    367 const SkGlyph& SkPaint::getGlyphMetrics(uint16_t glyphId) {
    368     SkGlyphCache* cache;
    369     descriptorProc(NULL, DetachDescProc, &cache, true);
    370 
    371     const SkGlyph& glyph = cache->getGlyphIDMetrics(glyphId);
    372 
    373     SkGlyphCache::AttachCache(cache);
    374     return glyph;
    375 }
    376 
    377 const void* SkPaint::findImage(const SkGlyph& glyph) {
    378     // See ::detachCache()
    379     SkGlyphCache* cache;
    380     descriptorProc(NULL, DetachDescProc, &cache, true);
    381 
    382     const void* image = cache->findImage(glyph);
    383 
    384     SkGlyphCache::AttachCache(cache);
    385     return image;
    386 }
    387 #endif
    388 
    389 int SkPaint::textToGlyphs(const void* textData, size_t byteLength,
    390                           uint16_t glyphs[]) const {
    391     if (byteLength == 0) {
    392         return 0;
    393     }
    394 
    395     SkASSERT(textData != NULL);
    396 
    397     if (NULL == glyphs) {
    398         switch (this->getTextEncoding()) {
    399         case kUTF8_TextEncoding:
    400             return SkUTF8_CountUnichars((const char*)textData, byteLength);
    401         case kUTF16_TextEncoding:
    402             return SkUTF16_CountUnichars((const uint16_t*)textData,
    403                                          byteLength >> 1);
    404         case kGlyphID_TextEncoding:
    405             return byteLength >> 1;
    406         default:
    407             SkASSERT(!"unknown text encoding");
    408         }
    409         return 0;
    410     }
    411 
    412     // if we get here, we have a valid glyphs[] array, so time to fill it in
    413 
    414     // handle this encoding before the setup for the glyphcache
    415     if (this->getTextEncoding() == kGlyphID_TextEncoding) {
    416         // we want to ignore the low bit of byteLength
    417         memcpy(glyphs, textData, byteLength >> 1 << 1);
    418         return byteLength >> 1;
    419     }
    420 
    421     SkAutoGlyphCache autoCache(*this, NULL);
    422     SkGlyphCache*    cache = autoCache.getCache();
    423 
    424     const char* text = (const char*)textData;
    425     const char* stop = text + byteLength;
    426     uint16_t*   gptr = glyphs;
    427 
    428     switch (this->getTextEncoding()) {
    429         case SkPaint::kUTF8_TextEncoding:
    430             while (text < stop) {
    431                 *gptr++ = cache->unicharToGlyph(SkUTF8_NextUnichar(&text));
    432             }
    433             break;
    434         case SkPaint::kUTF16_TextEncoding: {
    435             const uint16_t* text16 = (const uint16_t*)text;
    436             const uint16_t* stop16 = (const uint16_t*)stop;
    437             while (text16 < stop16) {
    438                 *gptr++ = cache->unicharToGlyph(SkUTF16_NextUnichar(&text16));
    439             }
    440             break;
    441         }
    442         default:
    443             SkASSERT(!"unknown text encoding");
    444     }
    445     return gptr - glyphs;
    446 }
    447 
    448 bool SkPaint::containsText(const void* textData, size_t byteLength) const {
    449     if (0 == byteLength) {
    450         return true;
    451     }
    452 
    453     SkASSERT(textData != NULL);
    454 
    455     // handle this encoding before the setup for the glyphcache
    456     if (this->getTextEncoding() == kGlyphID_TextEncoding) {
    457         const uint16_t* glyphID = static_cast<const uint16_t*>(textData);
    458         size_t count = byteLength >> 1;
    459         for (size_t i = 0; i < count; i++) {
    460             if (0 == glyphID[i]) {
    461                 return false;
    462             }
    463         }
    464         return true;
    465     }
    466 
    467     SkAutoGlyphCache autoCache(*this, NULL);
    468     SkGlyphCache*    cache = autoCache.getCache();
    469 
    470     switch (this->getTextEncoding()) {
    471         case SkPaint::kUTF8_TextEncoding: {
    472             const char* text = static_cast<const char*>(textData);
    473             const char* stop = text + byteLength;
    474             while (text < stop) {
    475                 if (0 == cache->unicharToGlyph(SkUTF8_NextUnichar(&text))) {
    476                     return false;
    477                 }
    478             }
    479             break;
    480         }
    481         case SkPaint::kUTF16_TextEncoding: {
    482             const uint16_t* text = static_cast<const uint16_t*>(textData);
    483             const uint16_t* stop = text + (byteLength >> 1);
    484             while (text < stop) {
    485                 if (0 == cache->unicharToGlyph(SkUTF16_NextUnichar(&text))) {
    486                     return false;
    487                 }
    488             }
    489             break;
    490         }
    491         default:
    492             SkASSERT(!"unknown text encoding");
    493             return false;
    494     }
    495     return true;
    496 }
    497 
    498 void SkPaint::glyphsToUnichars(const uint16_t glyphs[], int count,
    499                                SkUnichar textData[]) const {
    500     if (count <= 0) {
    501         return;
    502     }
    503 
    504     SkASSERT(glyphs != NULL);
    505     SkASSERT(textData != NULL);
    506 
    507     SkAutoGlyphCache autoCache(*this, NULL);
    508     SkGlyphCache*    cache = autoCache.getCache();
    509 
    510     for (int index = 0; index < count; index++) {
    511         textData[index] = cache->glyphToUnichar(glyphs[index]);
    512     }
    513 }
    514 
    515 ///////////////////////////////////////////////////////////////////////////////
    516 
    517 static const SkGlyph& sk_getMetrics_utf8_next(SkGlyphCache* cache,
    518                                               const char** text) {
    519     SkASSERT(cache != NULL);
    520     SkASSERT(text != NULL);
    521 
    522     return cache->getUnicharMetrics(SkUTF8_NextUnichar(text));
    523 }
    524 
    525 static const SkGlyph& sk_getMetrics_utf8_prev(SkGlyphCache* cache,
    526                                               const char** text) {
    527     SkASSERT(cache != NULL);
    528     SkASSERT(text != NULL);
    529 
    530     return cache->getUnicharMetrics(SkUTF8_PrevUnichar(text));
    531 }
    532 
    533 static const SkGlyph& sk_getMetrics_utf16_next(SkGlyphCache* cache,
    534                                                const char** text) {
    535     SkASSERT(cache != NULL);
    536     SkASSERT(text != NULL);
    537 
    538     return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text));
    539 }
    540 
    541 static const SkGlyph& sk_getMetrics_utf16_prev(SkGlyphCache* cache,
    542                                                const char** text) {
    543     SkASSERT(cache != NULL);
    544     SkASSERT(text != NULL);
    545 
    546     return cache->getUnicharMetrics(SkUTF16_PrevUnichar((const uint16_t**)text));
    547 }
    548 
    549 static const SkGlyph& sk_getMetrics_glyph_next(SkGlyphCache* cache,
    550                                                const char** text) {
    551     SkASSERT(cache != NULL);
    552     SkASSERT(text != NULL);
    553 
    554     const uint16_t* ptr = *(const uint16_t**)text;
    555     unsigned glyphID = *ptr;
    556     ptr += 1;
    557     *text = (const char*)ptr;
    558     return cache->getGlyphIDMetrics(glyphID);
    559 }
    560 
    561 static const SkGlyph& sk_getMetrics_glyph_prev(SkGlyphCache* cache,
    562                                                const char** text) {
    563     SkASSERT(cache != NULL);
    564     SkASSERT(text != NULL);
    565 
    566     const uint16_t* ptr = *(const uint16_t**)text;
    567     ptr -= 1;
    568     unsigned glyphID = *ptr;
    569     *text = (const char*)ptr;
    570     return cache->getGlyphIDMetrics(glyphID);
    571 }
    572 
    573 static const SkGlyph& sk_getAdvance_utf8_next(SkGlyphCache* cache,
    574                                               const char** text) {
    575     SkASSERT(cache != NULL);
    576     SkASSERT(text != NULL);
    577 
    578     return cache->getUnicharAdvance(SkUTF8_NextUnichar(text));
    579 }
    580 
    581 static const SkGlyph& sk_getAdvance_utf8_prev(SkGlyphCache* cache,
    582                                               const char** text) {
    583     SkASSERT(cache != NULL);
    584     SkASSERT(text != NULL);
    585 
    586     return cache->getUnicharAdvance(SkUTF8_PrevUnichar(text));
    587 }
    588 
    589 static const SkGlyph& sk_getAdvance_utf16_next(SkGlyphCache* cache,
    590                                                const char** text) {
    591     SkASSERT(cache != NULL);
    592     SkASSERT(text != NULL);
    593 
    594     return cache->getUnicharAdvance(SkUTF16_NextUnichar((const uint16_t**)text));
    595 }
    596 
    597 static const SkGlyph& sk_getAdvance_utf16_prev(SkGlyphCache* cache,
    598                                                const char** text) {
    599     SkASSERT(cache != NULL);
    600     SkASSERT(text != NULL);
    601 
    602     return cache->getUnicharAdvance(SkUTF16_PrevUnichar((const uint16_t**)text));
    603 }
    604 
    605 static const SkGlyph& sk_getAdvance_glyph_next(SkGlyphCache* cache,
    606                                                const char** text) {
    607     SkASSERT(cache != NULL);
    608     SkASSERT(text != NULL);
    609 
    610     const uint16_t* ptr = *(const uint16_t**)text;
    611     unsigned glyphID = *ptr;
    612     ptr += 1;
    613     *text = (const char*)ptr;
    614     return cache->getGlyphIDAdvance(glyphID);
    615 }
    616 
    617 static const SkGlyph& sk_getAdvance_glyph_prev(SkGlyphCache* cache,
    618                                                const char** text) {
    619     SkASSERT(cache != NULL);
    620     SkASSERT(text != NULL);
    621 
    622     const uint16_t* ptr = *(const uint16_t**)text;
    623     ptr -= 1;
    624     unsigned glyphID = *ptr;
    625     *text = (const char*)ptr;
    626     return cache->getGlyphIDAdvance(glyphID);
    627 }
    628 
    629 SkMeasureCacheProc SkPaint::getMeasureCacheProc(TextBufferDirection tbd,
    630                                                 bool needFullMetrics) const {
    631     static const SkMeasureCacheProc gMeasureCacheProcs[] = {
    632         sk_getMetrics_utf8_next,
    633         sk_getMetrics_utf16_next,
    634         sk_getMetrics_glyph_next,
    635 
    636         sk_getMetrics_utf8_prev,
    637         sk_getMetrics_utf16_prev,
    638         sk_getMetrics_glyph_prev,
    639 
    640         sk_getAdvance_utf8_next,
    641         sk_getAdvance_utf16_next,
    642         sk_getAdvance_glyph_next,
    643 
    644         sk_getAdvance_utf8_prev,
    645         sk_getAdvance_utf16_prev,
    646         sk_getAdvance_glyph_prev
    647     };
    648 
    649     unsigned index = this->getTextEncoding();
    650 
    651     if (kBackward_TextBufferDirection == tbd) {
    652         index += 3;
    653     }
    654     if (!needFullMetrics && !this->isDevKernText()) {
    655         index += 6;
    656     }
    657 
    658     SkASSERT(index < SK_ARRAY_COUNT(gMeasureCacheProcs));
    659     return gMeasureCacheProcs[index];
    660 }
    661 
    662 ///////////////////////////////////////////////////////////////////////////////
    663 
    664 static const SkGlyph& sk_getMetrics_utf8_00(SkGlyphCache* cache,
    665                                         const char** text, SkFixed, SkFixed) {
    666     SkASSERT(cache != NULL);
    667     SkASSERT(text != NULL);
    668 
    669     return cache->getUnicharMetrics(SkUTF8_NextUnichar(text));
    670 }
    671 
    672 static const SkGlyph& sk_getMetrics_utf8_xy(SkGlyphCache* cache,
    673                                     const char** text, SkFixed x, SkFixed y) {
    674     SkASSERT(cache != NULL);
    675     SkASSERT(text != NULL);
    676 
    677     return cache->getUnicharMetrics(SkUTF8_NextUnichar(text), x, y);
    678 }
    679 
    680 static const SkGlyph& sk_getMetrics_utf16_00(SkGlyphCache* cache,
    681                                         const char** text, SkFixed, SkFixed) {
    682     SkASSERT(cache != NULL);
    683     SkASSERT(text != NULL);
    684 
    685     return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text));
    686 }
    687 
    688 static const SkGlyph& sk_getMetrics_utf16_xy(SkGlyphCache* cache,
    689                                      const char** text, SkFixed x, SkFixed y) {
    690     SkASSERT(cache != NULL);
    691     SkASSERT(text != NULL);
    692 
    693     return cache->getUnicharMetrics(SkUTF16_NextUnichar((const uint16_t**)text),
    694                                     x, y);
    695 }
    696 
    697 static const SkGlyph& sk_getMetrics_glyph_00(SkGlyphCache* cache,
    698                                          const char** text, SkFixed, SkFixed) {
    699     SkASSERT(cache != NULL);
    700     SkASSERT(text != NULL);
    701 
    702     const uint16_t* ptr = *(const uint16_t**)text;
    703     unsigned glyphID = *ptr;
    704     ptr += 1;
    705     *text = (const char*)ptr;
    706     return cache->getGlyphIDMetrics(glyphID);
    707 }
    708 
    709 static const SkGlyph& sk_getMetrics_glyph_xy(SkGlyphCache* cache,
    710                                      const char** text, SkFixed x, SkFixed y) {
    711     SkASSERT(cache != NULL);
    712     SkASSERT(text != NULL);
    713 
    714     const uint16_t* ptr = *(const uint16_t**)text;
    715     unsigned glyphID = *ptr;
    716     ptr += 1;
    717     *text = (const char*)ptr;
    718     return cache->getGlyphIDMetrics(glyphID, x, y);
    719 }
    720 
    721 SkDrawCacheProc SkPaint::getDrawCacheProc() const {
    722     static const SkDrawCacheProc gDrawCacheProcs[] = {
    723         sk_getMetrics_utf8_00,
    724         sk_getMetrics_utf16_00,
    725         sk_getMetrics_glyph_00,
    726 
    727         sk_getMetrics_utf8_xy,
    728         sk_getMetrics_utf16_xy,
    729         sk_getMetrics_glyph_xy
    730     };
    731 
    732     unsigned index = this->getTextEncoding();
    733     if (fFlags & kSubpixelText_Flag) {
    734         index += 3;
    735     }
    736 
    737     SkASSERT(index < SK_ARRAY_COUNT(gDrawCacheProcs));
    738     return gDrawCacheProcs[index];
    739 }
    740 
    741 ///////////////////////////////////////////////////////////////////////////////
    742 
    743 class SkAutoRestorePaintTextSizeAndFrame {
    744 public:
    745     SkAutoRestorePaintTextSizeAndFrame(const SkPaint* paint)
    746             : fPaint((SkPaint*)paint) {
    747         fTextSize = paint->getTextSize();
    748         fStyle = paint->getStyle();
    749         fPaint->setStyle(SkPaint::kFill_Style);
    750     }
    751 
    752     ~SkAutoRestorePaintTextSizeAndFrame() {
    753         fPaint->setStyle(fStyle);
    754         fPaint->setTextSize(fTextSize);
    755     }
    756 
    757 private:
    758     SkPaint*        fPaint;
    759     SkScalar        fTextSize;
    760     SkPaint::Style  fStyle;
    761 };
    762 
    763 static void set_bounds(const SkGlyph& g, SkRect* bounds) {
    764     bounds->set(SkIntToScalar(g.fLeft),
    765                 SkIntToScalar(g.fTop),
    766                 SkIntToScalar(g.fLeft + g.fWidth),
    767                 SkIntToScalar(g.fTop + g.fHeight));
    768 }
    769 
    770 // 64bits wide, with a 16bit bias. Useful when accumulating lots of 16.16 so
    771 // we don't overflow along the way
    772 typedef int64_t Sk48Dot16;
    773 
    774 #ifdef SK_SCALAR_IS_FLOAT
    775     static inline float Sk48Dot16ToScalar(Sk48Dot16 x) {
    776         return (float) (x * 1.5258789e-5);   // x * (1 / 65536.0f)
    777     }
    778 #else
    779     static inline SkFixed Sk48Dot16ToScalar(Sk48Dot16 x) {
    780         // just return the low 32bits
    781         return static_cast<SkFixed>(x);
    782     }
    783 #endif
    784 
    785 static void join_bounds(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dx) {
    786     SkScalar sx = Sk48Dot16ToScalar(dx);
    787     bounds->join(SkIntToScalar(g.fLeft) + sx,
    788                  SkIntToScalar(g.fTop),
    789                  SkIntToScalar(g.fLeft + g.fWidth) + sx,
    790                  SkIntToScalar(g.fTop + g.fHeight));
    791 }
    792 
    793 SkScalar SkPaint::measure_text(SkGlyphCache* cache,
    794                                const char* text, size_t byteLength,
    795                                int* count, SkRect* bounds) const {
    796     SkASSERT(count);
    797     if (byteLength == 0) {
    798         *count = 0;
    799         if (bounds) {
    800             bounds->setEmpty();
    801         }
    802         return 0;
    803     }
    804 
    805     SkMeasureCacheProc glyphCacheProc;
    806     glyphCacheProc = this->getMeasureCacheProc(kForward_TextBufferDirection,
    807                                                NULL != bounds);
    808 
    809     int         n = 1;
    810     const char* stop = (const char*)text + byteLength;
    811     const SkGlyph* g = &glyphCacheProc(cache, &text);
    812     // our accumulated fixed-point advances might overflow 16.16, so we use
    813     // a 48.16 (64bit) accumulator, and then convert that to scalar at the
    814     // very end.
    815     Sk48Dot16 x = g->fAdvanceX;
    816 
    817     SkAutoKern  autokern;
    818 
    819     if (NULL == bounds) {
    820         if (this->isDevKernText()) {
    821             int rsb;
    822             for (; text < stop; n++) {
    823                 rsb = g->fRsbDelta;
    824                 g = &glyphCacheProc(cache, &text);
    825                 x += SkAutoKern_AdjustF(rsb, g->fLsbDelta) + g->fAdvanceX;
    826             }
    827         } else {
    828             for (; text < stop; n++) {
    829                 x += glyphCacheProc(cache, &text).fAdvanceX;
    830             }
    831         }
    832     } else {
    833         set_bounds(*g, bounds);
    834         if (this->isDevKernText()) {
    835             int rsb;
    836             for (; text < stop; n++) {
    837                 rsb = g->fRsbDelta;
    838                 g = &glyphCacheProc(cache, &text);
    839                 x += SkAutoKern_AdjustF(rsb, g->fLsbDelta);
    840                 join_bounds(*g, bounds, x);
    841                 x += g->fAdvanceX;
    842             }
    843         } else {
    844             for (; text < stop; n++) {
    845                 g = &glyphCacheProc(cache, &text);
    846                 join_bounds(*g, bounds, x);
    847                 x += g->fAdvanceX;
    848             }
    849         }
    850     }
    851     SkASSERT(text == stop);
    852 
    853     *count = n;
    854     return Sk48Dot16ToScalar(x);
    855 }
    856 
    857 SkScalar SkPaint::measureText(const void* textData, size_t length,
    858                               SkRect* bounds, SkScalar zoom) const {
    859     const char* text = (const char*)textData;
    860     SkASSERT(text != NULL || length == 0);
    861 
    862     SkScalar                            scale = 0;
    863     SkAutoRestorePaintTextSizeAndFrame  restore(this);
    864 
    865     if (this->isLinearText()) {
    866         scale = fTextSize / kCanonicalTextSizeForPaths;
    867         // this gets restored by restore
    868         ((SkPaint*)this)->setTextSize(SkIntToScalar(kCanonicalTextSizeForPaths));
    869     }
    870 
    871     SkMatrix zoomMatrix, *zoomPtr = NULL;
    872     if (zoom) {
    873         zoomMatrix.setScale(zoom, zoom);
    874         zoomPtr = &zoomMatrix;
    875     }
    876 
    877     SkAutoGlyphCache    autoCache(*this, zoomPtr);
    878     SkGlyphCache*       cache = autoCache.getCache();
    879 
    880     SkScalar width = 0;
    881 
    882     if (length > 0) {
    883         int tempCount;
    884 
    885         width = this->measure_text(cache, text, length, &tempCount, bounds);
    886         if (scale) {
    887             width = SkScalarMul(width, scale);
    888             if (bounds) {
    889                 bounds->fLeft = SkScalarMul(bounds->fLeft, scale);
    890                 bounds->fTop = SkScalarMul(bounds->fTop, scale);
    891                 bounds->fRight = SkScalarMul(bounds->fRight, scale);
    892                 bounds->fBottom = SkScalarMul(bounds->fBottom, scale);
    893             }
    894         }
    895     }
    896     return width;
    897 }
    898 
    899 typedef bool (*SkTextBufferPred)(const char* text, const char* stop);
    900 
    901 static bool forward_textBufferPred(const char* text, const char* stop) {
    902     return text < stop;
    903 }
    904 
    905 static bool backward_textBufferPred(const char* text, const char* stop) {
    906     return text > stop;
    907 }
    908 
    909 static SkTextBufferPred chooseTextBufferPred(SkPaint::TextBufferDirection tbd,
    910                                              const char** text, size_t length,
    911                                              const char** stop) {
    912     if (SkPaint::kForward_TextBufferDirection == tbd) {
    913         *stop = *text + length;
    914         return forward_textBufferPred;
    915     } else {
    916         // text should point to the end of the buffer, and stop to the beginning
    917         *stop = *text;
    918         *text += length;
    919         return backward_textBufferPred;
    920     }
    921 }
    922 
    923 size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
    924                           SkScalar* measuredWidth,
    925                           TextBufferDirection tbd) const {
    926     if (0 == length || 0 >= maxWidth) {
    927         if (measuredWidth) {
    928             *measuredWidth = 0;
    929         }
    930         return 0;
    931     }
    932 
    933     SkASSERT(textD != NULL);
    934     const char* text = (const char*)textD;
    935 
    936     SkScalar                            scale = 0;
    937     SkAutoRestorePaintTextSizeAndFrame  restore(this);
    938 
    939     if (this->isLinearText()) {
    940         scale = fTextSize / kCanonicalTextSizeForPaths;
    941         maxWidth = SkScalarMulDiv(maxWidth, kCanonicalTextSizeForPaths, fTextSize);
    942         // this gets restored by restore
    943         ((SkPaint*)this)->setTextSize(SkIntToScalar(kCanonicalTextSizeForPaths));
    944     }
    945 
    946     SkAutoGlyphCache    autoCache(*this, NULL);
    947     SkGlyphCache*       cache = autoCache.getCache();
    948 
    949     SkMeasureCacheProc glyphCacheProc = this->getMeasureCacheProc(tbd, false);
    950     const char*      stop;
    951     SkTextBufferPred pred = chooseTextBufferPred(tbd, &text, length, &stop);
    952     // use 64bits for our accumulator, to avoid overflowing 16.16
    953     Sk48Dot16        max = SkScalarToFixed(maxWidth);
    954     Sk48Dot16        width = 0;
    955 
    956     SkAutoKern  autokern;
    957 
    958     if (this->isDevKernText()) {
    959         int rsb = 0;
    960         while (pred(text, stop)) {
    961             const char* curr = text;
    962             const SkGlyph& g = glyphCacheProc(cache, &text);
    963             SkFixed x = SkAutoKern_AdjustF(rsb, g.fLsbDelta) + g.fAdvanceX;
    964             if ((width += x) > max) {
    965                 width -= x;
    966                 text = curr;
    967                 break;
    968             }
    969             rsb = g.fRsbDelta;
    970         }
    971     } else {
    972         while (pred(text, stop)) {
    973             const char* curr = text;
    974             SkFixed x = glyphCacheProc(cache, &text).fAdvanceX;
    975             if ((width += x) > max) {
    976                 width -= x;
    977                 text = curr;
    978                 break;
    979             }
    980         }
    981     }
    982 
    983     if (measuredWidth) {
    984         SkScalar scalarWidth = Sk48Dot16ToScalar(width);
    985         if (scale) {
    986             scalarWidth = SkScalarMul(scalarWidth, scale);
    987         }
    988         *measuredWidth = scalarWidth;
    989     }
    990 
    991     // return the number of bytes measured
    992     return (kForward_TextBufferDirection == tbd) ?
    993                 text - stop + length : stop - text + length;
    994 }
    995 
    996 ///////////////////////////////////////////////////////////////////////////////
    997 
    998 static bool FontMetricsCacheProc(const SkGlyphCache* cache, void* context) {
    999     *(SkPaint::FontMetrics*)context = cache->getFontMetricsY();
   1000     return false;   // don't detach the cache
   1001 }
   1002 
   1003 static void FontMetricsDescProc(const SkDescriptor* desc, void* context) {
   1004     SkGlyphCache::VisitCache(desc, FontMetricsCacheProc, context);
   1005 }
   1006 
   1007 SkScalar SkPaint::getFontMetrics(FontMetrics* metrics, SkScalar zoom) const {
   1008     SkScalar                            scale = 0;
   1009     SkAutoRestorePaintTextSizeAndFrame  restore(this);
   1010 
   1011     if (this->isLinearText()) {
   1012         scale = fTextSize / kCanonicalTextSizeForPaths;
   1013         // this gets restored by restore
   1014         ((SkPaint*)this)->setTextSize(SkIntToScalar(kCanonicalTextSizeForPaths));
   1015     }
   1016 
   1017     SkMatrix zoomMatrix, *zoomPtr = NULL;
   1018     if (zoom) {
   1019         zoomMatrix.setScale(zoom, zoom);
   1020         zoomPtr = &zoomMatrix;
   1021     }
   1022 
   1023 #if 0
   1024     SkAutoGlyphCache    autoCache(*this, zoomPtr);
   1025     SkGlyphCache*       cache = autoCache.getCache();
   1026     const FontMetrics&  my = cache->getFontMetricsY();
   1027 #endif
   1028     FontMetrics storage;
   1029     if (NULL == metrics) {
   1030         metrics = &storage;
   1031     }
   1032 
   1033     this->descriptorProc(zoomPtr, FontMetricsDescProc, metrics);
   1034 
   1035     if (scale) {
   1036         metrics->fTop = SkScalarMul(metrics->fTop, scale);
   1037         metrics->fAscent = SkScalarMul(metrics->fAscent, scale);
   1038         metrics->fDescent = SkScalarMul(metrics->fDescent, scale);
   1039         metrics->fBottom = SkScalarMul(metrics->fBottom, scale);
   1040         metrics->fLeading = SkScalarMul(metrics->fLeading, scale);
   1041     }
   1042     return metrics->fDescent - metrics->fAscent + metrics->fLeading;
   1043 }
   1044 
   1045 ///////////////////////////////////////////////////////////////////////////////
   1046 
   1047 static void set_bounds(const SkGlyph& g, SkRect* bounds, SkScalar scale) {
   1048     bounds->set(g.fLeft * scale,
   1049                 g.fTop * scale,
   1050                 (g.fLeft + g.fWidth) * scale,
   1051                 (g.fTop + g.fHeight) * scale);
   1052 }
   1053 
   1054 int SkPaint::getTextWidths(const void* textData, size_t byteLength,
   1055                            SkScalar widths[], SkRect bounds[]) const {
   1056     if (0 == byteLength) {
   1057         return 0;
   1058     }
   1059 
   1060     SkASSERT(NULL != textData);
   1061 
   1062     if (NULL == widths && NULL == bounds) {
   1063         return this->countText(textData, byteLength);
   1064     }
   1065 
   1066     SkAutoRestorePaintTextSizeAndFrame  restore(this);
   1067     SkScalar                            scale = 0;
   1068 
   1069     if (this->isLinearText()) {
   1070         scale = fTextSize / kCanonicalTextSizeForPaths;
   1071         // this gets restored by restore
   1072         ((SkPaint*)this)->setTextSize(SkIntToScalar(kCanonicalTextSizeForPaths));
   1073     }
   1074 
   1075     SkAutoGlyphCache    autoCache(*this, NULL);
   1076     SkGlyphCache*       cache = autoCache.getCache();
   1077     SkMeasureCacheProc  glyphCacheProc;
   1078     glyphCacheProc = this->getMeasureCacheProc(kForward_TextBufferDirection,
   1079                                                NULL != bounds);
   1080 
   1081     const char* text = (const char*)textData;
   1082     const char* stop = text + byteLength;
   1083     int         count = 0;
   1084 
   1085     if (this->isDevKernText()) {
   1086         // we adjust the widths returned here through auto-kerning
   1087         SkAutoKern  autokern;
   1088         SkFixed     prevWidth = 0;
   1089 
   1090         if (scale) {
   1091             while (text < stop) {
   1092                 const SkGlyph& g = glyphCacheProc(cache, &text);
   1093                 if (widths) {
   1094                     SkFixed  adjust = autokern.adjust(g);
   1095 
   1096                     if (count > 0) {
   1097                         SkScalar w = SkFixedToScalar(prevWidth + adjust);
   1098                         *widths++ = SkScalarMul(w, scale);
   1099                     }
   1100                     prevWidth = g.fAdvanceX;
   1101                 }
   1102                 if (bounds) {
   1103                     set_bounds(g, bounds++, scale);
   1104                 }
   1105                 ++count;
   1106             }
   1107             if (count > 0 && widths) {
   1108                 *widths = SkScalarMul(SkFixedToScalar(prevWidth), scale);
   1109             }
   1110         } else {
   1111             while (text < stop) {
   1112                 const SkGlyph& g = glyphCacheProc(cache, &text);
   1113                 if (widths) {
   1114                     SkFixed  adjust = autokern.adjust(g);
   1115 
   1116                     if (count > 0) {
   1117                         *widths++ = SkFixedToScalar(prevWidth + adjust);
   1118                     }
   1119                     prevWidth = g.fAdvanceX;
   1120                 }
   1121                 if (bounds) {
   1122                     set_bounds(g, bounds++);
   1123                 }
   1124                 ++count;
   1125             }
   1126             if (count > 0 && widths) {
   1127                 *widths = SkFixedToScalar(prevWidth);
   1128             }
   1129         }
   1130     } else {    // no devkern
   1131         if (scale) {
   1132             while (text < stop) {
   1133                 const SkGlyph& g = glyphCacheProc(cache, &text);
   1134                 if (widths) {
   1135                     *widths++ = SkScalarMul(SkFixedToScalar(g.fAdvanceX),
   1136                                             scale);
   1137                 }
   1138                 if (bounds) {
   1139                     set_bounds(g, bounds++, scale);
   1140                 }
   1141                 ++count;
   1142             }
   1143         } else {
   1144             while (text < stop) {
   1145                 const SkGlyph& g = glyphCacheProc(cache, &text);
   1146                 if (widths) {
   1147                     *widths++ = SkFixedToScalar(g.fAdvanceX);
   1148                 }
   1149                 if (bounds) {
   1150                     set_bounds(g, bounds++);
   1151                 }
   1152                 ++count;
   1153             }
   1154         }
   1155     }
   1156 
   1157     SkASSERT(text == stop);
   1158     return count;
   1159 }
   1160 
   1161 ///////////////////////////////////////////////////////////////////////////////
   1162 
   1163 #include "SkDraw.h"
   1164 
   1165 void SkPaint::getTextPath(const void* textData, size_t length,
   1166                           SkScalar x, SkScalar y, SkPath* path) const {
   1167     SkASSERT(length == 0 || textData != NULL);
   1168 
   1169     const char* text = (const char*)textData;
   1170     if (text == NULL || length == 0 || path == NULL) {
   1171         return;
   1172     }
   1173 
   1174     SkTextToPathIter    iter(text, length, *this, false, true);
   1175     SkMatrix            matrix;
   1176     SkScalar            prevXPos = 0;
   1177 
   1178     matrix.setScale(iter.getPathScale(), iter.getPathScale());
   1179     matrix.postTranslate(x, y);
   1180     path->reset();
   1181 
   1182     SkScalar        xpos;
   1183     const SkPath*   iterPath;
   1184     while ((iterPath = iter.next(&xpos)) != NULL) {
   1185         matrix.postTranslate(xpos - prevXPos, 0);
   1186         path->addPath(*iterPath, matrix);
   1187         prevXPos = xpos;
   1188     }
   1189 }
   1190 
   1191 static void add_flattenable(SkDescriptor* desc, uint32_t tag,
   1192                             SkFlattenableWriteBuffer* buffer) {
   1193     buffer->flatten(desc->addEntry(tag, buffer->size(), NULL));
   1194 }
   1195 
   1196 static SkMask::Format computeMaskFormat(const SkPaint& paint) {
   1197     uint32_t flags = paint.getFlags();
   1198 
   1199     // Antialiasing being disabled trumps all other settings.
   1200     if (!(flags & SkPaint::kAntiAlias_Flag)) {
   1201         return SkMask::kBW_Format;
   1202     }
   1203 
   1204 #if defined(SK_SUPPORT_LCDTEXT)
   1205     if (flags & SkPaint::kLCDRenderText_Flag) {
   1206         return SkFontHost::GetSubpixelOrientation() == SkFontHost::kHorizontal_LCDOrientation ?
   1207                    SkMask::kHorizontalLCD_Format : SkMask::kVerticalLCD_Format;
   1208     }
   1209 #else
   1210     if (flags & SkPaint::kLCDRenderText_Flag) {
   1211         return SkMask::kLCD16_Format;
   1212     }
   1213 #endif
   1214 
   1215     return SkMask::kA8_Format;
   1216 }
   1217 
   1218 // if linear-text is on, then we force hinting to be off (since that's sort of
   1219 // the point of linear-text.
   1220 static SkPaint::Hinting computeHinting(const SkPaint& paint) {
   1221     SkPaint::Hinting h = paint.getHinting();
   1222     if (paint.isLinearText()) {
   1223         h = SkPaint::kNo_Hinting;
   1224     }
   1225     return h;
   1226 }
   1227 
   1228 /*
   1229  *  Return the scalar with only limited fractional precision. Used to consolidate matrices
   1230  *  that vary only slightly when we create our key into the font cache, since the font scaler
   1231  *  typically returns the same looking resuts for tiny changes in the matrix.
   1232  */
   1233 static SkScalar sk_relax(SkScalar x) {
   1234 #ifdef SK_SCALAR_IS_FLOAT
   1235     int n = sk_float_round2int(x * 1024);
   1236     return n / 1024.0f;
   1237 #else
   1238     // round to the nearest 10 fractional bits
   1239     return (x + (1 << 5)) & ~(1024 - 1);
   1240 #endif
   1241 }
   1242 
   1243 void SkScalerContext::MakeRec(const SkPaint& paint,
   1244                               const SkMatrix* deviceMatrix, Rec* rec) {
   1245     SkASSERT(deviceMatrix == NULL || !deviceMatrix->hasPerspective());
   1246 
   1247     rec->fOrigFontID = SkTypeface::UniqueID(paint.getTypeface());
   1248     rec->fFontID = rec->fOrigFontID;
   1249     rec->fTextSize = paint.getTextSize();
   1250     rec->fPreScaleX = paint.getTextScaleX();
   1251     rec->fPreSkewX  = paint.getTextSkewX();
   1252 
   1253     if (deviceMatrix) {
   1254         rec->fPost2x2[0][0] = sk_relax(deviceMatrix->getScaleX());
   1255         rec->fPost2x2[0][1] = sk_relax(deviceMatrix->getSkewX());
   1256         rec->fPost2x2[1][0] = sk_relax(deviceMatrix->getSkewY());
   1257         rec->fPost2x2[1][1] = sk_relax(deviceMatrix->getScaleY());
   1258     } else {
   1259         rec->fPost2x2[0][0] = rec->fPost2x2[1][1] = SK_Scalar1;
   1260         rec->fPost2x2[0][1] = rec->fPost2x2[1][0] = 0;
   1261     }
   1262 
   1263     SkPaint::Style  style = paint.getStyle();
   1264     SkScalar        strokeWidth = paint.getStrokeWidth();
   1265 
   1266     unsigned flags = SkFontHost::ComputeGammaFlag(paint);
   1267 
   1268     if (paint.isFakeBoldText()) {
   1269 #ifdef SK_USE_FREETYPE_EMBOLDEN
   1270         flags |= SkScalerContext::kEmbolden_Flag;
   1271 #else
   1272         SkScalar fakeBoldScale = SkScalarInterpFunc(paint.getTextSize(),
   1273                                                     kStdFakeBoldInterpKeys,
   1274                                                     kStdFakeBoldInterpValues,
   1275                                                     kStdFakeBoldInterpLength);
   1276         SkScalar extra = SkScalarMul(paint.getTextSize(), fakeBoldScale);
   1277 
   1278         if (style == SkPaint::kFill_Style) {
   1279             style = SkPaint::kStrokeAndFill_Style;
   1280             strokeWidth = extra;    // ignore paint's strokeWidth if it was "fill"
   1281         } else {
   1282             strokeWidth += extra;
   1283         }
   1284 #endif
   1285     }
   1286 
   1287     if (paint.isDevKernText()) {
   1288         flags |= SkScalerContext::kDevKernText_Flag;
   1289     }
   1290 
   1291     if (style != SkPaint::kFill_Style && strokeWidth > 0) {
   1292         rec->fFrameWidth = strokeWidth;
   1293         rec->fMiterLimit = paint.getStrokeMiter();
   1294         rec->fStrokeJoin = SkToU8(paint.getStrokeJoin());
   1295 
   1296         if (style == SkPaint::kStrokeAndFill_Style) {
   1297             flags |= SkScalerContext::kFrameAndFill_Flag;
   1298         }
   1299     } else {
   1300         rec->fFrameWidth = 0;
   1301         rec->fMiterLimit = 0;
   1302         rec->fStrokeJoin = 0;
   1303     }
   1304 
   1305     rec->fMaskFormat = SkToU8(computeMaskFormat(paint));
   1306 
   1307     if (SkMask::kLCD16_Format == rec->fMaskFormat) {
   1308         SkFontHost::LCDOrder order = SkFontHost::GetSubpixelOrder();
   1309         SkFontHost::LCDOrientation orient = SkFontHost::GetSubpixelOrientation();
   1310         if (SkFontHost::kNONE_LCDOrder == order) {
   1311             // eeek, can't support LCD
   1312             rec->fMaskFormat = SkMask::kA8_Format;
   1313         } else {
   1314             if (SkFontHost::kVertical_LCDOrientation == orient) {
   1315                 flags |= SkScalerContext::kLCD_Vertical_Flag;
   1316             }
   1317             if (SkFontHost::kBGR_LCDOrder == order) {
   1318                 flags |= SkScalerContext::kLCD_BGROrder_Flag;
   1319             }
   1320         }
   1321     }
   1322 
   1323     if (paint.isEmbeddedBitmapText()) {
   1324         flags |= SkScalerContext::kEmbeddedBitmapText_Flag;
   1325     }
   1326     if (paint.isSubpixelText()) {
   1327         flags |= SkScalerContext::kSubpixelPositioning_Flag;
   1328     }
   1329     if (paint.isAutohinted()) {
   1330         flags |= SkScalerContext::kAutohinting_Flag;
   1331     }
   1332     rec->fFlags = SkToU16(flags);
   1333 
   1334     // setHinting modifies fFlags, so do this last
   1335     rec->setHinting(computeHinting(paint));
   1336 
   1337     /*  Allow the fonthost to modify our rec before we use it as a key into the
   1338         cache. This way if we're asking for something that they will ignore,
   1339         they can modify our rec up front, so we don't create duplicate cache
   1340         entries.
   1341      */
   1342     SkFontHost::FilterRec(rec);
   1343 }
   1344 
   1345 #define MIN_SIZE_FOR_EFFECT_BUFFER  1024
   1346 
   1347 #ifdef SK_DEBUG
   1348     #define TEST_DESC
   1349 #endif
   1350 
   1351 void SkPaint::descriptorProc(const SkMatrix* deviceMatrix,
   1352                              void (*proc)(const SkDescriptor*, void*),
   1353                              void* context, bool ignoreGamma) const {
   1354     SkScalerContext::Rec    rec;
   1355 
   1356     SkScalerContext::MakeRec(*this, deviceMatrix, &rec);
   1357     if (ignoreGamma) {
   1358         rec.fFlags &= ~(SkScalerContext::kGammaForBlack_Flag |
   1359                 SkScalerContext::kGammaForWhite_Flag);
   1360     }
   1361 
   1362     size_t          descSize = sizeof(rec);
   1363     int             entryCount = 1;
   1364     SkPathEffect*   pe = this->getPathEffect();
   1365     SkMaskFilter*   mf = this->getMaskFilter();
   1366     SkRasterizer*   ra = this->getRasterizer();
   1367 
   1368     SkFlattenableWriteBuffer    peBuffer(MIN_SIZE_FOR_EFFECT_BUFFER);
   1369     SkFlattenableWriteBuffer    mfBuffer(MIN_SIZE_FOR_EFFECT_BUFFER);
   1370     SkFlattenableWriteBuffer    raBuffer(MIN_SIZE_FOR_EFFECT_BUFFER);
   1371 
   1372     if (pe) {
   1373         peBuffer.writeFlattenable(pe);
   1374         descSize += peBuffer.size();
   1375         entryCount += 1;
   1376         rec.fMaskFormat = SkMask::kA8_Format;   // force antialiasing when we do the scan conversion
   1377         // seems like we could support kLCD as well at this point...
   1378     }
   1379     if (mf) {
   1380         mfBuffer.writeFlattenable(mf);
   1381         descSize += mfBuffer.size();
   1382         entryCount += 1;
   1383         rec.fMaskFormat = SkMask::kA8_Format;   // force antialiasing with maskfilters
   1384     }
   1385     if (ra) {
   1386         raBuffer.writeFlattenable(ra);
   1387         descSize += raBuffer.size();
   1388         entryCount += 1;
   1389         rec.fMaskFormat = SkMask::kA8_Format;   // force antialiasing when we do the scan conversion
   1390     }
   1391     descSize += SkDescriptor::ComputeOverhead(entryCount);
   1392 
   1393     SkAutoDescriptor    ad(descSize);
   1394     SkDescriptor*       desc = ad.getDesc();
   1395 
   1396     desc->init();
   1397     desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
   1398 
   1399     if (pe) {
   1400         add_flattenable(desc, kPathEffect_SkDescriptorTag, &peBuffer);
   1401     }
   1402     if (mf) {
   1403         add_flattenable(desc, kMaskFilter_SkDescriptorTag, &mfBuffer);
   1404     }
   1405     if (ra) {
   1406         add_flattenable(desc, kRasterizer_SkDescriptorTag, &raBuffer);
   1407     }
   1408 
   1409     SkASSERT(descSize == desc->getLength());
   1410     desc->computeChecksum();
   1411 
   1412 #ifdef TEST_DESC
   1413     {
   1414         // Check that we completely write the bytes in desc (our key), and that
   1415         // there are no uninitialized bytes. If there were, then we would get
   1416         // false-misses (or worse, false-hits) in our fontcache.
   1417         //
   1418         // We do this buy filling 2 others, one with 0s and the other with 1s
   1419         // and create those, and then check that all 3 are identical.
   1420         SkAutoDescriptor    ad1(descSize);
   1421         SkAutoDescriptor    ad2(descSize);
   1422         SkDescriptor*       desc1 = ad1.getDesc();
   1423         SkDescriptor*       desc2 = ad2.getDesc();
   1424 
   1425         memset(desc1, 0x00, descSize);
   1426         memset(desc2, 0xFF, descSize);
   1427 
   1428         desc1->init();
   1429         desc2->init();
   1430         desc1->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
   1431         desc2->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
   1432 
   1433         if (pe) {
   1434             add_flattenable(desc1, kPathEffect_SkDescriptorTag, &peBuffer);
   1435             add_flattenable(desc2, kPathEffect_SkDescriptorTag, &peBuffer);
   1436         }
   1437         if (mf) {
   1438             add_flattenable(desc1, kMaskFilter_SkDescriptorTag, &mfBuffer);
   1439             add_flattenable(desc2, kMaskFilter_SkDescriptorTag, &mfBuffer);
   1440         }
   1441         if (ra) {
   1442             add_flattenable(desc1, kRasterizer_SkDescriptorTag, &raBuffer);
   1443             add_flattenable(desc2, kRasterizer_SkDescriptorTag, &raBuffer);
   1444         }
   1445 
   1446         SkASSERT(descSize == desc1->getLength());
   1447         SkASSERT(descSize == desc2->getLength());
   1448         desc1->computeChecksum();
   1449         desc2->computeChecksum();
   1450         SkASSERT(!memcmp(desc, desc1, descSize));
   1451         SkASSERT(!memcmp(desc, desc2, descSize));
   1452     }
   1453 #endif
   1454 
   1455     proc(desc, context);
   1456 }
   1457 
   1458 SkGlyphCache* SkPaint::detachCache(const SkMatrix* deviceMatrix) const {
   1459     SkGlyphCache* cache;
   1460     this->descriptorProc(deviceMatrix, DetachDescProc, &cache);
   1461     return cache;
   1462 }
   1463 
   1464 ///////////////////////////////////////////////////////////////////////////////
   1465 
   1466 #include "SkStream.h"
   1467 
   1468 static uintptr_t asint(const void* p) {
   1469     return reinterpret_cast<uintptr_t>(p);
   1470 }
   1471 
   1472 union Scalar32 {
   1473     SkScalar    fScalar;
   1474     uint32_t    f32;
   1475 };
   1476 
   1477 static uint32_t* write_scalar(uint32_t* ptr, SkScalar value) {
   1478     SkASSERT(sizeof(SkScalar) == sizeof(uint32_t));
   1479     Scalar32 tmp;
   1480     tmp.fScalar = value;
   1481     *ptr = tmp.f32;
   1482     return ptr + 1;
   1483 }
   1484 
   1485 static SkScalar read_scalar(const uint32_t*& ptr) {
   1486     SkASSERT(sizeof(SkScalar) == sizeof(uint32_t));
   1487     Scalar32 tmp;
   1488     tmp.f32 = *ptr++;
   1489     return tmp.fScalar;
   1490 }
   1491 
   1492 static uint32_t pack_4(unsigned a, unsigned b, unsigned c, unsigned d) {
   1493     SkASSERT(a == (uint8_t)a);
   1494     SkASSERT(b == (uint8_t)b);
   1495     SkASSERT(c == (uint8_t)c);
   1496     SkASSERT(d == (uint8_t)d);
   1497     return (a << 24) | (b << 16) | (c << 8) | d;
   1498 }
   1499 
   1500 enum FlatFlags {
   1501     kHasTypeface_FlatFlag   = 0x01,
   1502     kHasEffects_FlatFlag    = 0x02
   1503 };
   1504 
   1505 // The size of a flat paint's POD fields
   1506 static const uint32_t kPODPaintSize =   5 * sizeof(SkScalar) +
   1507                                         1 * sizeof(SkColor) +
   1508                                         1 * sizeof(uint16_t) +
   1509                                         6 * sizeof(uint8_t);
   1510 
   1511 /*  To save space/time, we analyze the paint, and write a truncated version of
   1512     it if there are not tricky elements like shaders, etc.
   1513  */
   1514 void SkPaint::flatten(SkFlattenableWriteBuffer& buffer) const {
   1515     uint8_t flatFlags = 0;
   1516     if (this->getTypeface()) {
   1517         flatFlags |= kHasTypeface_FlatFlag;
   1518     }
   1519     if (asint(this->getPathEffect()) |
   1520         asint(this->getShader()) |
   1521         asint(this->getXfermode()) |
   1522         asint(this->getMaskFilter()) |
   1523         asint(this->getColorFilter()) |
   1524         asint(this->getRasterizer()) |
   1525         asint(this->getLooper())) {
   1526         flatFlags |= kHasEffects_FlatFlag;
   1527     }
   1528 
   1529     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
   1530     uint32_t* ptr = buffer.reserve(kPODPaintSize);
   1531 
   1532     ptr = write_scalar(ptr, this->getTextSize());
   1533     ptr = write_scalar(ptr, this->getTextScaleX());
   1534     ptr = write_scalar(ptr, this->getTextSkewX());
   1535     ptr = write_scalar(ptr, this->getStrokeWidth());
   1536     ptr = write_scalar(ptr, this->getStrokeMiter());
   1537     *ptr++ = this->getColor();
   1538     *ptr++ = (this->getFlags() << 16) | (this->getTextAlign() << 8) | flatFlags;
   1539     *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
   1540                     this->getStyle(), this->getTextEncoding());
   1541 
   1542     // now we're done with ptr and the (pre)reserved space. If we need to write
   1543     // additional fields, use the buffer directly
   1544     if (flatFlags & kHasTypeface_FlatFlag) {
   1545         buffer.writeTypeface(this->getTypeface());
   1546     }
   1547     if (flatFlags & kHasEffects_FlatFlag) {
   1548         buffer.writeFlattenable(this->getPathEffect());
   1549         buffer.writeFlattenable(this->getShader());
   1550         buffer.writeFlattenable(this->getXfermode());
   1551         buffer.writeFlattenable(this->getMaskFilter());
   1552         buffer.writeFlattenable(this->getColorFilter());
   1553         buffer.writeFlattenable(this->getRasterizer());
   1554         buffer.writeFlattenable(this->getLooper());
   1555     }
   1556 }
   1557 
   1558 void SkPaint::unflatten(SkFlattenableReadBuffer& buffer) {
   1559     SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
   1560     const void* podData = buffer.skip(kPODPaintSize);
   1561     const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
   1562 
   1563     // the order we read must match the order we wrote in flatten()
   1564     this->setTextSize(read_scalar(pod));
   1565     this->setTextScaleX(read_scalar(pod));
   1566     this->setTextSkewX(read_scalar(pod));
   1567     this->setStrokeWidth(read_scalar(pod));
   1568     this->setStrokeMiter(read_scalar(pod));
   1569     this->setColor(*pod++);
   1570 
   1571     uint32_t tmp = *pod++;
   1572     this->setFlags(tmp >> 16);
   1573     this->setTextAlign(static_cast<Align>((tmp >> 8) & 0xFF));
   1574     uint8_t flatFlags = tmp & 0xFF;
   1575 
   1576     tmp = *pod++;
   1577     this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
   1578     this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
   1579     this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
   1580     this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
   1581 
   1582     if (flatFlags & kHasTypeface_FlatFlag) {
   1583         this->setTypeface(buffer.readTypeface());
   1584     } else {
   1585         this->setTypeface(NULL);
   1586     }
   1587 
   1588     if (flatFlags & kHasEffects_FlatFlag) {
   1589         SkSafeUnref(this->setPathEffect((SkPathEffect*) buffer.readFlattenable()));
   1590         SkSafeUnref(this->setShader((SkShader*) buffer.readFlattenable()));
   1591         SkSafeUnref(this->setXfermode((SkXfermode*) buffer.readFlattenable()));
   1592         SkSafeUnref(this->setMaskFilter((SkMaskFilter*) buffer.readFlattenable()));
   1593         SkSafeUnref(this->setColorFilter((SkColorFilter*) buffer.readFlattenable()));
   1594         SkSafeUnref(this->setRasterizer((SkRasterizer*) buffer.readFlattenable()));
   1595         SkSafeUnref(this->setLooper((SkDrawLooper*) buffer.readFlattenable()));
   1596     } else {
   1597         this->setPathEffect(NULL);
   1598         this->setShader(NULL);
   1599         this->setXfermode(NULL);
   1600         this->setMaskFilter(NULL);
   1601         this->setColorFilter(NULL);
   1602         this->setRasterizer(NULL);
   1603         this->setLooper(NULL);
   1604     }
   1605 }
   1606 
   1607 ///////////////////////////////////////////////////////////////////////////////
   1608 
   1609 SkShader* SkPaint::setShader(SkShader* shader) {
   1610     GEN_ID_INC_EVAL(shader != fShader);
   1611     SkRefCnt_SafeAssign(fShader, shader);
   1612     return shader;
   1613 }
   1614 
   1615 SkColorFilter* SkPaint::setColorFilter(SkColorFilter* filter) {
   1616     GEN_ID_INC_EVAL(filter != fColorFilter);
   1617     SkRefCnt_SafeAssign(fColorFilter, filter);
   1618     return filter;
   1619 }
   1620 
   1621 SkXfermode* SkPaint::setXfermode(SkXfermode* mode) {
   1622     GEN_ID_INC_EVAL(mode != fXfermode);
   1623     SkRefCnt_SafeAssign(fXfermode, mode);
   1624     return mode;
   1625 }
   1626 
   1627 SkXfermode* SkPaint::setXfermodeMode(SkXfermode::Mode mode) {
   1628     SkSafeUnref(fXfermode);
   1629     fXfermode = SkXfermode::Create(mode);
   1630     GEN_ID_INC;
   1631     return fXfermode;
   1632 }
   1633 
   1634 SkPathEffect* SkPaint::setPathEffect(SkPathEffect* effect) {
   1635     GEN_ID_INC_EVAL(effect != fPathEffect);
   1636     SkRefCnt_SafeAssign(fPathEffect, effect);
   1637     return effect;
   1638 }
   1639 
   1640 SkMaskFilter* SkPaint::setMaskFilter(SkMaskFilter* filter) {
   1641     GEN_ID_INC_EVAL(filter != fMaskFilter);
   1642     SkRefCnt_SafeAssign(fMaskFilter, filter);
   1643     return filter;
   1644 }
   1645 
   1646 ///////////////////////////////////////////////////////////////////////////////
   1647 
   1648 bool SkPaint::getFillPath(const SkPath& src, SkPath* dst) const {
   1649     SkPath          effectPath, strokePath;
   1650     const SkPath*   path = &src;
   1651 
   1652     SkScalar width = this->getStrokeWidth();
   1653 
   1654     switch (this->getStyle()) {
   1655         case SkPaint::kFill_Style:
   1656             width = -1; // mark it as no-stroke
   1657             break;
   1658         case SkPaint::kStrokeAndFill_Style:
   1659             if (width == 0) {
   1660                 width = -1; // mark it as no-stroke
   1661             }
   1662             break;
   1663         case SkPaint::kStroke_Style:
   1664             break;
   1665         default:
   1666             SkASSERT(!"unknown paint style");
   1667     }
   1668 
   1669     if (this->getPathEffect()) {
   1670         // lie to the pathEffect if our style is strokeandfill, so that it treats us as just fill
   1671         if (this->getStyle() == SkPaint::kStrokeAndFill_Style) {
   1672             width = -1; // mark it as no-stroke
   1673         }
   1674 
   1675         if (this->getPathEffect()->filterPath(&effectPath, src, &width)) {
   1676             path = &effectPath;
   1677         }
   1678 
   1679         // restore the width if we earlier had to lie, and if we're still set to no-stroke
   1680         // note: if we're now stroke (width >= 0), then the pathEffect asked for that change
   1681         // and we want to respect that (i.e. don't overwrite their setting for width)
   1682         if (this->getStyle() == SkPaint::kStrokeAndFill_Style && width < 0) {
   1683             width = this->getStrokeWidth();
   1684             if (width == 0) {
   1685                 width = -1;
   1686             }
   1687         }
   1688     }
   1689 
   1690     if (width > 0 && !path->isEmpty()) {
   1691         SkStroke stroker(*this, width);
   1692         stroker.strokePath(*path, &strokePath);
   1693         path = &strokePath;
   1694     }
   1695 
   1696     if (path == &src) {
   1697         *dst = src;
   1698     } else {
   1699         SkASSERT(path == &effectPath || path == &strokePath);
   1700         dst->swap(*(SkPath*)path);
   1701     }
   1702 
   1703     return width != 0;  // return true if we're filled, or false if we're hairline (width == 0)
   1704 }
   1705 
   1706 const SkRect& SkPaint::computeStrokeFastBounds(const SkRect& src,
   1707                                                SkRect* storage) const {
   1708     SkASSERT(storage);
   1709     SkASSERT(this->getStyle() != SkPaint::kFill_Style);
   1710 
   1711     // since we're stroked, outset the rect by the radius (and join type)
   1712     SkScalar radius = SkScalarHalf(this->getStrokeWidth());
   1713     if (0 == radius) {  // hairline
   1714         radius = SK_Scalar1;
   1715     } else if (this->getStrokeJoin() == SkPaint::kMiter_Join) {
   1716         SkScalar scale = this->getStrokeMiter();
   1717         if (scale > SK_Scalar1) {
   1718             radius = SkScalarMul(radius, scale);
   1719         }
   1720     }
   1721     storage->set(src.fLeft - radius, src.fTop - radius,
   1722                  src.fRight + radius, src.fBottom + radius);
   1723     return *storage;
   1724 }
   1725 
   1726 ///////////////////////////////////////////////////////////////////////////////
   1727 
   1728 static bool has_thick_frame(const SkPaint& paint) {
   1729     return  paint.getStrokeWidth() > 0 &&
   1730             paint.getStyle() != SkPaint::kFill_Style;
   1731 }
   1732 
   1733 SkTextToPathIter::SkTextToPathIter( const char text[], size_t length,
   1734                                     const SkPaint& paint,
   1735                                     bool applyStrokeAndPathEffects,
   1736                                     bool forceLinearTextOn) : fPaint(paint) {
   1737     fGlyphCacheProc = paint.getMeasureCacheProc(SkPaint::kForward_TextBufferDirection,
   1738                                                 true);
   1739 
   1740     if (forceLinearTextOn) {
   1741         fPaint.setLinearText(true);
   1742     }
   1743     fPaint.setMaskFilter(NULL);   // don't want this affecting our path-cache lookup
   1744 
   1745     if (fPaint.getPathEffect() == NULL && !has_thick_frame(fPaint)) {
   1746         applyStrokeAndPathEffects = false;
   1747     }
   1748 
   1749     // can't use our canonical size if we need to apply patheffects/strokes
   1750     if (fPaint.isLinearText() && !applyStrokeAndPathEffects) {
   1751         fPaint.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
   1752         fScale = paint.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
   1753     } else {
   1754         fScale = SK_Scalar1;
   1755     }
   1756 
   1757     if (!applyStrokeAndPathEffects) {
   1758         fPaint.setStyle(SkPaint::kFill_Style);
   1759         fPaint.setPathEffect(NULL);
   1760     }
   1761 
   1762     fCache = fPaint.detachCache(NULL);
   1763 
   1764     SkPaint::Style  style = SkPaint::kFill_Style;
   1765     SkPathEffect*   pe = NULL;
   1766 
   1767     if (!applyStrokeAndPathEffects) {
   1768         style = paint.getStyle();   // restore
   1769         pe = paint.getPathEffect();     // restore
   1770     }
   1771     fPaint.setStyle(style);
   1772     fPaint.setPathEffect(pe);
   1773     fPaint.setMaskFilter(paint.getMaskFilter());    // restore
   1774 
   1775     // now compute fXOffset if needed
   1776 
   1777     SkScalar xOffset = 0;
   1778     if (paint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
   1779         int      count;
   1780         SkScalar width = SkScalarMul(fPaint.measure_text(fCache, text, length,
   1781                                                          &count, NULL), fScale);
   1782         if (paint.getTextAlign() == SkPaint::kCenter_Align) {
   1783             width = SkScalarHalf(width);
   1784         }
   1785         xOffset = -width;
   1786     }
   1787     fXPos = xOffset;
   1788     fPrevAdvance = 0;
   1789 
   1790     fText = text;
   1791     fStop = text + length;
   1792 }
   1793 
   1794 SkTextToPathIter::~SkTextToPathIter() {
   1795     SkGlyphCache::AttachCache(fCache);
   1796 }
   1797 
   1798 const SkPath* SkTextToPathIter::next(SkScalar* xpos) {
   1799     while (fText < fStop) {
   1800         const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
   1801 
   1802         fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
   1803         fPrevAdvance = glyph.fAdvanceX;   // + fPaint.getTextTracking();
   1804 
   1805         if (glyph.fWidth) {
   1806             if (xpos) {
   1807                 *xpos = fXPos;
   1808             }
   1809             return fCache->findPath(glyph);
   1810         }
   1811     }
   1812     return NULL;
   1813 }
   1814