[SkSVGDevice] Initial text support

experimental/svg/SkSVGDevice.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSVGDevice.h"
 
 #include "SkBitmap.h"
 #include "SkDraw.h"
 #include "SkPaint.h"
 #include "SkParsePath.h"
 #include "SkShader.h"
 #include "SkStream.h"
+#include "SkTypeface.h"
+#include "SkUtils.h"
 #include "SkXMLWriter.h"
 
 namespace {
 
 static SkString svg_color(SkColor color) {
     SkString colorStr;
     colorStr.printf("rgb(%u,%u,%u)",
                      SkColorGetR(color),
                      SkColorGetG(color),
                      SkColorGetB(color));
     return colorStr;
 }
 
 static SkScalar svg_opacity(SkColor color) {
     return SkIntToScalar(SkColorGetA(color)) / SK_AlphaOPAQUE;
 }
 
+static void append_escaped_unichar(SkUnichar c, SkString* text) {
+    switch(c) {
+    case '&':
+        text->append("&");
+        break;
+    case '"':
+        text->append(""");
+        break;
+    case '\'':
+        text->append("'");
+        break;
+    case '<':
+        text->append("&lt;");
+        break;
+    case '>':
+        text->append("&gt;");
+        break;
+    default:
+        text->appendUnichar(c);
+        break;
+    }
+}
+
+static SkString svg_text(const void* text, size_t byteLen, const SkPaint& paint) {
+    SkString svgText;
+    int count = paint.countText(text, byteLen);
+

[mtklein, 2015/02/03 20:51:08]

Worth asserting byteLen alignment for each of these cases (2 byte, 1 byte, 2
byte, 4 byte) ?

[f(malita), 2015/02/03 22:51:25]

We can probably be even more opinionated and assert that byteLen == the exact
number of bytes consumed. Done.

+    switch(paint.getTextEncoding()) {
+    case SkPaint::kGlyphID_TextEncoding: {
+        SkAutoSTArray<64, SkUnichar> unichars(count);
+        paint.glyphsToUnichars((const uint16_t*)text, count, unichars.get());
+        for (int i = 0; i < count; ++i) {
+            append_escaped_unichar(unichars[i], &svgText);
+        }
+    } break;
+    case SkPaint::kUTF8_TextEncoding: {
+        const char* c8 = reinterpret_cast<const char*>(text);
+        for (int i = 0; i < count; ++i) {
+            append_escaped_unichar(SkUTF8_NextUnichar(&c8), &svgText);
+        }
+    } break;
+    case SkPaint::kUTF16_TextEncoding: {
+        const uint16_t* c16 = reinterpret_cast<const uint16_t*>(text);
+        for (int i = 0; i < count; ++i) {
+            append_escaped_unichar(SkUTF16_NextUnichar(&c16), &svgText);
+        }
+    } break;
+    case SkPaint::kUTF32_TextEncoding: {
+        const uint32_t* c32 = reinterpret_cast<const uint32_t*>(text);
+        for (int i = 0; i < count; ++i) {
+            append_escaped_unichar(c32[i], &svgText);
+        }
+    } break;
+    default:
+        SkFAIL("unknown text encoding");
+    }
+
+    return svgText;
+}
+
 struct Resources {
     Resources(const SkPaint& paint)
         : fPaintServer(svg_color(paint.getColor())) {}
 
     SkString fPaintServer;
 };
 
 }
 
 // For now all this does is serve unique serial IDs, but it will eventually evolve to track
@@ skipping 46 matching lines @@
     }
 
     void addAttribute(const char name[], int32_t val) {
         fWriter->addS32Attribute(name, val);
     }
 
     void addAttribute(const char name[], SkScalar val) {
         fWriter->addScalarAttribute(name, val);
     }
 
+    void addText(const SkString& text) {
+        fWriter->addText(text);
+    }
+
 private:
     Resources addResources(const SkPaint& paint);
     void addResourceDefs(const SkPaint& paint, Resources* resources);
 
     void addPaint(const SkPaint& paint, const Resources& resources);
     void addTransform(const SkMatrix& transform, const char name[] = "transform");
 
     SkString addLinearGradientDef(const SkShader::GradientInfo& info, const SkShader* shader);
 
     SkXMLWriter*    fWriter;
@@ skipping 217 matching lines @@
     SkDebugf("unsupported operation: drawSprite()");
 }
 
 void SkSVGDevice::drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect* srcOrNull,
                                  const SkRect& dst, const SkPaint& paint,
                                  SkCanvas::DrawBitmapRectFlags flags) {
     // todo
     SkDebugf("unsupported operation: drawBitmapRect()");
 }
 
-void SkSVGDevice::drawText(const SkDraw&, const void* text, size_t len,
-                           SkScalar x, SkScalar y, const SkPaint& paint) {
-    // todo
-    SkDebugf("unsupported operation: drawText()");
+void SkSVGDevice::AddFontAttributes(const SkPaint& paint, AutoElement* elem) {

[mtklein, 2015/02/03 20:51:08]

void AutoElement::addFontAttributes(const SkPaint&)? 

Or even do it as part of the AutoElement constructor?  I guess you want it to be
a separate call so that it's only done for text-y draws?

[f(malita), 2015/02/03 22:51:25]

Done.
Yeah, this is only needed for drawText*.

+    elem->addAttribute("font-size", paint.getTextSize());
+
+    SkTypeface::Style style = paint.getTypeface()->style();
+    if (style & SkTypeface::kItalic) {
+        elem->addAttribute("font-style", "italic");
+    }
+    if (style & SkTypeface::kBold) {
+        elem->addAttribute("font-weight", "bold");
+    }
+
+    SkAutoTUnref<const SkTypeface> tface(paint.getTypeface() ?
+        SkRef(paint.getTypeface()) : SkTypeface::RefDefault(style));
+    SkString familyName;
+    tface->getFamilyName(&familyName);
+    if (!familyName.isEmpty()) {
+        elem->addAttribute("font-family", familyName);
+    }
 }
 
-void SkSVGDevice::drawPosText(const SkDraw&, const void* text, size_t len,const SkScalar pos[],
-                              int scalarsPerPos, const SkPoint& offset, const SkPaint& paint) {
-    // todo
-    SkDebugf("unsupported operation: drawPosText()");
+void SkSVGDevice::drawText(const SkDraw& draw, const void* text, size_t len,
+                           SkScalar x, SkScalar y, const SkPaint& paint) {
+    AutoElement elem("text", fWriter, fResourceBucket, draw, paint);
+    AddFontAttributes(paint, &elem);
+    elem.addAttribute("x", x);
+    elem.addAttribute("y", y);
+    elem.addText(svg_text(text, len, paint));
+}
+
+void SkSVGDevice::drawPosText(const SkDraw& draw, const void* text, size_t len,
+                              const SkScalar pos[], int scalarsPerPos, const SkPoint& offset,
+                              const SkPaint& paint) {
+    AutoElement elem("text", fWriter, fResourceBucket, draw, paint);
+    AddFontAttributes(paint, &elem);
+
+    SkString xStr;
+    SkString yStr;
+    for (int i = 0; i < paint.countText(text, len); ++i) {
+        SkScalar x = offset.x() + pos[i * scalarsPerPos];

[mtklein, 2015/02/03 20:51:08]

Are offset.x() and offset.y() "dx" and "dy"?  If so, seems like you can have SVG
do the deltas from offset for you.

[f(malita), 2015/02/03 22:51:25]

The syntactic rules are quirky though and this would require either a) dx/dy to
be a list matching the number of glyphs or b) nest the glyphs in a <tspan> while
dx/dy is applied to the parent <text>.

Since the output is quite verbose already, I think we should avoid this.

+        SkScalar y = offset.y() + (scalarsPerPos > 1 ? pos[i * scalarsPerPos + 1] : 0);

[mtklein, 2015/02/03 20:51:08]

When scalarsPerPos == 1, can we just use a single y value, or do we have to have
matching x and y pairs?

[f(malita), 2015/02/03 22:51:25]

Yeah, I think that will work. Done.

+
+        if (i > 0) {
+            xStr.append(", ");
+            yStr.append(", ");
+        }
+        xStr.appendScalar(x);
+        yStr.appendScalar(y);
+    }
+
+    elem.addAttribute("x", xStr);
+    elem.addAttribute("y", yStr);
+    elem.addText(svg_text(text, len, paint));
 }
 
 void SkSVGDevice::drawTextOnPath(const SkDraw&, const void* text, size_t len, const SkPath& path,
                                  const SkMatrix* matrix, const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawTextOnPath()");
 }
 
 void SkSVGDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
                                const SkPoint verts[], const SkPoint texs[],
                                const SkColor colors[], SkXfermode* xmode,
                                const uint16_t indices[], int indexCount,
                                const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawVertices()");
 }
 
 void SkSVGDevice::drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                              const SkPaint&) {
     // todo
     SkDebugf("unsupported operation: drawDevice()");
 }