Added JSON support for TextBlob

tools/json/SkJSONRenderer.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkJSONRenderer.h"
 
 #include "SkBlurMaskFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkJSONCanvas.h"
 #include "SkJSONCPP.h"
 #include "SkPath.h"
+#include "SkTextBlob.h"
+#include "SkTypeface.h"
 #include "SkValidatingReadBuffer.h"
 
 namespace SkJSONRenderer {
 
 class Renderer {
 public:
     void getPaint(Json::Value& paint, SkPaint* result);
 
     void getRect(Json::Value& rect, SkRect* result);
 
@@ skipping 28 matching lines @@
     void processOval(Json::Value& command, SkCanvas* target);
 
     void processPath(Json::Value& command, SkCanvas* target);
 
     void processText(Json::Value& command, SkCanvas* target);
 
     void processPosText(Json::Value& command, SkCanvas* target);
 
     void processTextOnPath(Json::Value& command, SkCanvas* target);
 
+    void processTextBlob(Json::Value& command, SkCanvas* target);
+
     void processPoints(Json::Value& command, SkCanvas* target);
 
     void processImage(Json::Value& command, SkCanvas* target);
 
     void processImageRect(Json::Value& command, SkCanvas* target);
 
     void processBitmap(Json::Value& command, SkCanvas* target);
 
     void processBitmapRect(Json::Value& command, SkCanvas* target);
 
@@ skipping 42 matching lines @@
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXT)) {
         this->processText(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_POSTEXT)) {
         this->processPosText(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXTONPATH)) {
         this->processTextOnPath(command, target);
     }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXTBLOB)) {
+        this->processTextBlob(command, target);
+    }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_POINTS)) {
         this->processPoints(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGE)) {
         this->processImage(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGERECT)) {
         this->processImageRect(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_BITMAP)) {
@@ skipping 162 matching lines @@
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_MASKFILTER)) {
         Json::Value jsonMaskFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_MASKFILTER];
         SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter);
         if (maskFilter != nullptr) {
             target->setMaskFilter(maskFilter);
             maskFilter->unref();
         }
     }
 }
 
+static void apply_paint_colorfilter(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_COLORFILTER)) {
+        Json::Value jsonColorFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_COLORFILTER];
+        SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter);
+        if (colorFilter != nullptr) {
+            target->setColorFilter(colorFilter);
+            colorFilter->unref();
+        }
+    }
+}
+
 static void apply_paint_xfermode(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_XFERMODE)) {
         Json::Value jsonXfermode = jsonPaint[SKJSONCANVAS_ATTRIBUTE_XFERMODE];
         SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode);
         if (xfermode != nullptr) {
             target->setXfermode(xfermode);
             xfermode->unref();
         }
     }
 }
@@ skipping 147 matching lines @@
     }
 }
 
 static void apply_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX)) {
         float textSkewX = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
         target->setTextSkewX(textSkewX);
     }
 }
 
+static void apply_paint_typeface(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TYPEFACE)) {
+        Json::Value jsonTypeface = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TYPEFACE];
+        Json::Value bytes = jsonTypeface[SKJSONCANVAS_ATTRIBUTE_BYTES];
+        void* data;
+        Json::ArrayIndex length = decode_data(bytes, &data);
+        SkMemoryStream buffer(data, length);
+        SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
+        free(data);
+        target->setTypeface(typeface);
+    }
+}
+
 void Renderer::getPaint(Json::Value& paint, SkPaint* result) {
     apply_paint_color(paint, result);
     apply_paint_shader(paint, result);
     apply_paint_patheffect(paint, result);
     apply_paint_maskfilter(paint, result);
+    apply_paint_colorfilter(paint, result);
     apply_paint_xfermode(paint, result);
     apply_paint_imagefilter(paint, result);
     apply_paint_style(paint, result);
     apply_paint_strokewidth(paint, result);
     apply_paint_strokemiter(paint, result);
     apply_paint_cap(paint, result);
     apply_paint_antialias(paint, result);
     apply_paint_blur(paint, result);
     apply_paint_dashing(paint, result);
     apply_paint_textalign(paint, result);
     apply_paint_textsize(paint, result);
     apply_paint_textscalex(paint, result);
     apply_paint_textskewx(paint, result);
+    apply_paint_typeface(paint, result);
 }
 
 void Renderer::getRect(Json::Value& rect, SkRect* result) {
     result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
 }
 
 void Renderer::getRRect(Json::Value& rrect, SkRRect* result) {
     SkVector radii[4] = {
                             { rrect[1][0].asFloat(), rrect[1][1].asFloat() }, 
                             { rrect[2][0].asFloat(), rrect[2][1].asFloat() }, 
@@ skipping 208 matching lines @@
         matrixPtr = &matrix;
     }
     else {
         matrixPtr = nullptr;
     }
     SkPaint paint;
     this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
     target->drawTextOnPath(text, strlen(text), path, matrixPtr, paint);
 }
 
+void Renderer::processTextBlob(Json::Value& command, SkCanvas* target) {
+    SkTextBlobBuilder builder;
+    Json::Value runs = command[SKJSONCANVAS_ATTRIBUTE_RUNS];
+    for (Json::ArrayIndex i = 0 ; i < runs.size(); i++) {
+        Json::Value run = runs[i];
+        SkPaint font;
+        font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+        this->getPaint(run[SKJSONCANVAS_ATTRIBUTE_FONT], &font);
+        Json::Value glyphs = run[SKJSONCANVAS_ATTRIBUTE_GLYPHS];
+        int count = glyphs.size();
+        Json::Value coords = run[SKJSONCANVAS_ATTRIBUTE_COORDS];
+        SkScalar x = coords[0].asFloat();
+        SkScalar y = coords[1].asFloat();
+        if (run.isMember(SKJSONCANVAS_ATTRIBUTE_POSITIONS)) {
+            Json::Value positions = run[SKJSONCANVAS_ATTRIBUTE_POSITIONS];
+            if (positions.size() > 0 && positions[0].isNumeric()) {
+                SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPosH(font, count, y);
+                for (int j = 0; j < count; j++) {
+                    buffer.glyphs[j] = glyphs[j].asUInt();
+                    buffer.pos[j] = positions[j].asFloat();
+                }
+            }
+            else {
+                SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPos(font, count);
+                for (int j = 0; j < count; j++) {
+                    buffer.glyphs[j] = glyphs[j].asUInt();
+                    buffer.pos[j * 2] = positions[j][0].asFloat();
+                    buffer.pos[j * 2 + 1] = positions[j][1].asFloat();
+                }
+            }
+        }
+        else {
+            SkTextBlobBuilder::RunBuffer buffer = builder.allocRun(font, count, x, y);
+            for (int j = 0; j < count; j++) {
+                buffer.glyphs[j] = glyphs[j].asUInt();
+            }
+        }
+    }
+    SkScalar x = command[SKJSONCANVAS_ATTRIBUTE_X].asFloat();
+    SkScalar y = command[SKJSONCANVAS_ATTRIBUTE_Y].asFloat();
+    SkPaint paint;
+    this->getPaint(command[SKJSONCANVAS_ATTRIBUTE_PAINT], &paint);
+    target->drawTextBlob(builder.build(), x, y, paint);
+}
+
 void Renderer::processPoints(Json::Value& command, SkCanvas* target) {
     SkCanvas::PointMode mode;
     const char* jsonMode = command[SKJSONCANVAS_ATTRIBUTE_MODE].asCString();
     if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_POINTS)) {
         mode = SkCanvas::kPoints_PointMode;
     }
     else if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_LINES)) {
         mode = SkCanvas::kLines_PointMode;
     }
     else if (!strcmp(jsonMode, SKJSONCANVAS_POINTMODE_POLYGON)) {
@@ skipping 155 matching lines @@
             renderer.processCommand(commands[i], target);
         }
     }
     else {
         SkDebugf(json);
         SkFAIL("json parse failure");
     }
 }
 
 } // namespace