SkTextBlob

src/core/SkPicturePlayback.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkPatchUtils.h"
 #include "SkPictureData.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkPictureStateTree.h"
 #include "SkReader32.h"
+#include "SkTextBlob.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
 /*
  * Read the next op code and chunk size from 'reader'. The returned size
  * is the entire size of the chunk (including the opcode). Thus, the
  * offset just prior to calling ReadOpAndSize + 'size' is the offset
  * to the next chunk's op code. This also means that the size of a chunk
  * with no arguments (just an opcode) will be 4.
  */
@@ skipping 410 matching lines @@
         } break;
         case DRAW_TEXT_ON_PATH: {
             const SkPaint& paint = *fPictureData->getPaint(reader);
             TextContainer text;
             get_text(reader, &text);
             const SkPath& path = fPictureData->getPath(reader);
             SkMatrix matrix;
             reader->readMatrix(&matrix);
             canvas->drawTextOnPath(text.text(), text.length(), path, &matrix, paint);
         } break;
+        case DRAW_TEXT_BLOB: {
+            const SkPaint& paint = *fPictureData->getPaint(reader);
+            uint32_t chunkCount = reader->readInt();
+            const SkPoint& offset = reader->skipT<SkPoint>();
+
+            SkTextBlobBuilder blobBuilder;
+            for (unsigned i = 0; i < chunkCount; ++i) {
+                uint32_t glyphCount = reader->readInt();
+                const SkPaint& glyphPaint = *fPictureData->getPaint(reader);
+                unsigned scalarsPerPos = reader->readInt();
+                const SkRect* boundsPtr = get_rect_ptr(reader);
+                const uint16_t* glyphs = (uint16_t*)reader->skip(
+                    SkAlign4(glyphCount * sizeof(uint16_t)));
+                const SkTextChunk* chunk;
+                if (scalarsPerPos > 0) {
+                    const SkScalar* pos = (const SkScalar*)reader->skip(
+                        SkAlign4(glyphCount * sizeof(SkScalar) * scalarsPerPos));
+                    if (1 == scalarsPerPos) {
+                        chunk = SkTextChunk::Create(glyphs, glyphCount, pos, glyphPaint, boundsPtr);
+                    } else {
+                        SkASSERT(2 == scalarsPerPos);
+                        chunk = SkTextChunk::Create(glyphs, glyphCount, (const SkPoint*)pos,
+                                                    glyphPaint, boundsPtr);
+                    }
+
+                } else {
+                    chunk = SkTextChunk::Create(glyphs, glyphCount, glyphPaint, boundsPtr);
+                }
+
+                blobBuilder.addChunk(chunk);
+            }
+
+            SkAutoTUnref<const SkTextBlob> blob(blobBuilder.build());
+            canvas->drawTextBlob(blob, offset, paint);
+        } break;
         case DRAW_VERTICES: {
             SkAutoTUnref<SkXfermode> xfer;
             const SkPaint& paint = *fPictureData->getPaint(reader);
             DrawVertexFlags flags = (DrawVertexFlags)reader->readInt();
             SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readInt();
             int vCount = reader->readInt();
             const SkPoint* verts = (const SkPoint*)reader->skip(vCount * sizeof(SkPoint));
             const SkPoint* texs = NULL;
             const SkColor* colors = NULL;
             const uint16_t* indices = NULL;
@@ skipping 55 matching lines @@
         case TRANSLATE: {
             SkScalar dx = reader->readScalar();
             SkScalar dy = reader->readScalar();
             canvas->translate(dx, dy);
         } break;
         default:
             SkASSERT(0);
     }
 }