[SkSVGDevice] drawTextOnPath() 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"
@@ skipping 39 matching lines @@
     "round", // kRound_Join
     "bevel"  // kBevel_Join
 };
 SK_COMPILE_ASSERT(SK_ARRAY_COUNT(join_map) == SkPaint::kJoinCount, missing_join_map_entry);
 
 static const char* svg_join(SkPaint::Join join) {
     SkASSERT(join < SK_ARRAY_COUNT(join_map));
     return join_map[join];
 }
 
+// Keep in sync with SkPaint::Align
+static const char* text_align_map[] = {
+    NULL,     // kLeft_Align (default)
+    "middle", // kCenter_Align
+    "end"     // kRight_Align
+};
+SK_COMPILE_ASSERT(SK_ARRAY_COUNT(text_align_map) == SkPaint::kAlignCount,
+                  missing_text_align_map_entry);
+static const char* svg_text_align(SkPaint::Align align) {
+    SkASSERT(align < SK_ARRAY_COUNT(text_align_map));
+    return text_align_map[align];
+}
+
+static SkString svg_transform(const SkMatrix& t) {
+    SkASSERT(!t.isIdentity());
+
+    SkString tstr;
+    switch (t.getType()) {
+    case SkMatrix::kPerspective_Mask:
+        SkDebugf("Can't handle perspective matrices.");
+        break;
+    case SkMatrix::kTranslate_Mask:
+        tstr.printf("translate(%g %g)", t.getTranslateX(), t.getTranslateY());
+        break;
+    case SkMatrix::kScale_Mask:
+        tstr.printf("scale(%g %g)", t.getScaleX(), t.getScaleY());
+        break;
+    default:
+        // http://www.w3.org/TR/SVG/coords.html#TransformMatrixDefined
+        //    | a c e |
+        //    | b d f |
+        //    | 0 0 1 |
+        tstr.printf("matrix(%g %g %g %g %g %g)",
+                    t.getScaleX(),     t.getSkewY(),
+                    t.getSkewX(),      t.getScaleY(),
+                    t.getTranslateX(), t.getTranslateY());
+        break;
+    }
+
+    return tstr;
+}
+
 static void append_escaped_unichar(SkUnichar c, SkString* text) {
     switch(c) {
     case '&':
         text->append("&amp;");
         break;
     case '"':
         text->append("&quot;");
         break;
     case '\'':
         text->append("&apos;");
@@ skipping 59 matching lines @@
     SkString fPaintServer;
     SkString fClip;
 };
 
 }
 
 // For now all this does is serve unique serial IDs, but it will eventually evolve to track
 // and deduplicate resources.
 class SkSVGDevice::ResourceBucket : ::SkNoncopyable {
 public:
-    ResourceBucket() : fGradientCount(0), fClipCount(0) {}
+    ResourceBucket() : fGradientCount(0), fClipCount(0), fPathCount(0) {}
 
     SkString addLinearGradient() {
         return SkStringPrintf("gradient_%d", fGradientCount++);
     }
 
     SkString addClip() {
         return SkStringPrintf("clip_%d", fClipCount++);
     }
 
+    SkString addPath() {
+        return SkStringPrintf("path_%d", fPathCount++);
+    }
+
 private:
     uint32_t fGradientCount;
     uint32_t fClipCount;
+    uint32_t fPathCount;
 };
 
 class SkSVGDevice::AutoElement : ::SkNoncopyable {
 public:
     AutoElement(const char name[], SkXMLWriter* writer)
         : fWriter(writer)
         , fResourceBucket(NULL) {
         fWriter->startElement(name);
     }
 
     AutoElement(const char name[], SkXMLWriter* writer, ResourceBucket* bucket,
                 const SkDraw& draw, const SkPaint& paint)
         : fWriter(writer)
         , fResourceBucket(bucket) {
 
         Resources res = this->addResources(draw, paint);
 
         fWriter->startElement(name);
 
         this->addPaint(paint, res);
-        this->addTransform(*draw.fMatrix);
+
+        if (!draw.fMatrix->isIdentity()) {
+            this->addAttribute("transform", svg_transform(*draw.fMatrix));
+        }
     }
 
     ~AutoElement() {
         fWriter->endElement();
     }
 
     void addAttribute(const char name[], const char val[]) {
         fWriter->addAttribute(name, val);
     }
 
     void addAttribute(const char name[], const SkString& val) {
         fWriter->addAttribute(name, val.c_str());
     }
 
     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.c_str());
     }
 
     void addRectAttributes(const SkRect&);
-    void addFontAttributes(const SkPaint&);
+    void addPathAttributes(const SkPath&);
+    void addTextAttributes(const SkPaint&);
 
 private:
     Resources addResources(const SkDraw& draw, const SkPaint& paint);
     void addClipResources(const SkDraw& draw, Resources* resources);
     void addShaderResources(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;
     ResourceBucket* fResourceBucket;
 };
 
 void SkSVGDevice::AutoElement::addPaint(const SkPaint& paint, const Resources& resources) {
     SkPaint::Style style = paint.getStyle();
     if (style == SkPaint::kFill_Style || style == SkPaint::kStrokeAndFill_Style) {
@@ skipping 36 matching lines @@
     } else {
         SkASSERT(style == SkPaint::kFill_Style);
         this->addAttribute("stroke", "none");
     }
 
     if (!resources.fClip.isEmpty()) {
         this->addAttribute("clip-path", resources.fClip);
     }
 }
 
-void SkSVGDevice::AutoElement::addTransform(const SkMatrix& t, const char name[]) {
-    if (t.isIdentity()) {
-        return;
-    }
-
-    SkString tstr;
-    switch (t.getType()) {
-    case SkMatrix::kPerspective_Mask:
-        SkDebugf("Can't handle perspective matrices.");
-        break;
-    case SkMatrix::kTranslate_Mask:
-        tstr.printf("translate(%g %g)",
-                     SkScalarToFloat(t.getTranslateX()),
-                     SkScalarToFloat(t.getTranslateY()));
-        break;
-    case SkMatrix::kScale_Mask:
-        tstr.printf("scale(%g %g)",
-                     SkScalarToFloat(t.getScaleX()),
-                     SkScalarToFloat(t.getScaleY()));
-        break;
-    default:
-        tstr.printf("matrix(%g %g %g %g %g %g)",
-                     SkScalarToFloat(t.getScaleX()), SkScalarToFloat(t.getSkewY()),
-                     SkScalarToFloat(t.getSkewX()), SkScalarToFloat(t.getScaleY()),
-                     SkScalarToFloat(t.getTranslateX()), SkScalarToFloat(t.getTranslateY()));
-        break;
-    }
-
-    fWriter->addAttribute(name, tstr.c_str());
-}
-
 Resources SkSVGDevice::AutoElement::addResources(const SkDraw& draw, const SkPaint& paint) {
     Resources resources(paint);
 
     // FIXME: this is a weak heuristic and we end up with LOTS of redundant clips.
     bool hasClip   = !draw.fClipStack->isWideOpen();
     bool hasShader = SkToBool(paint.getShader());
 
     if (hasClip || hasShader) {
         AutoElement defs("defs", fWriter);
 
@@ skipping 49 matching lines @@
         AutoElement clipPathElement("clipPath", fWriter);
         clipPathElement.addAttribute("id", clipID);
 
         SkRect clipRect = SkRect::MakeEmpty();
         if (clipPath.isEmpty() || clipPath.isRect(&clipRect)) {
             AutoElement rectElement("rect", fWriter);
             rectElement.addRectAttributes(clipRect);
             rectElement.addAttribute("clip-rule", clipRule);
         } else {
             AutoElement pathElement("path", fWriter);
-            SkString pathStr;
-            SkParsePath::ToSVGString(clipPath, &pathStr);
-            pathElement.addAttribute("d", pathStr.c_str());
+            pathElement.addPathAttributes(clipPath);
             pathElement.addAttribute("clip-rule", clipRule);
         }
     }
 
     resources->fClip.printf("url(#%s)", clipID.c_str());
 }
 
 SkString SkSVGDevice::AutoElement::addLinearGradientDef(const SkShader::GradientInfo& info,
                                                         const SkShader* shader) {
     SkASSERT(fResourceBucket);
     SkString id = fResourceBucket->addLinearGradient();
 
     {
         AutoElement gradient("linearGradient", fWriter);
 
         gradient.addAttribute("id", id);
         gradient.addAttribute("gradientUnits", "userSpaceOnUse");
         gradient.addAttribute("x1", info.fPoint[0].x());
         gradient.addAttribute("y1", info.fPoint[0].y());
         gradient.addAttribute("x2", info.fPoint[1].x());
         gradient.addAttribute("y2", info.fPoint[1].y());
-        gradient.addTransform(shader->getLocalMatrix(), "gradientTransform");
+
+        if (!shader->getLocalMatrix().isIdentity()) {
+            this->addAttribute("gradientTransform", svg_transform(shader->getLocalMatrix()));
+        }
 
         SkASSERT(info.fColorCount >= 2);
         for (int i = 0; i < info.fColorCount; ++i) {
             SkColor color = info.fColors[i];
             SkString colorStr(svg_color(color));
 
             {
                 AutoElement stop("stop", fWriter);
                 stop.addAttribute("offset", info.fColorOffsets[i]);
                 stop.addAttribute("stop-color", colorStr.c_str());
@@ skipping 14 matching lines @@
         this->addAttribute("x", rect.x());
     }
     if (rect.y() != 0) {
         this->addAttribute("y", rect.y());
     }
 
     this->addAttribute("width", rect.width());
     this->addAttribute("height", rect.height());
 }
 
-void SkSVGDevice::AutoElement::addFontAttributes(const SkPaint& paint) {
+void SkSVGDevice::AutoElement::addPathAttributes(const SkPath& path) {
+    SkString pathData;
+    SkParsePath::ToSVGString(path, &pathData);
+    this->addAttribute("d", pathData);
+}
+
+void SkSVGDevice::AutoElement::addTextAttributes(const SkPaint& paint) {
     this->addAttribute("font-size", paint.getTextSize());
 
     SkTypeface::Style style = paint.getTypeface()->style();
     if (style & SkTypeface::kItalic) {
         this->addAttribute("font-style", "italic");
     }
     if (style & SkTypeface::kBold) {
         this->addAttribute("font-weight", "bold");
     }
 
     SkAutoTUnref<const SkTypeface> tface(paint.getTypeface() ?
         SkRef(paint.getTypeface()) : SkTypeface::RefDefault(style));
     SkString familyName;
     tface->getFamilyName(&familyName);
     if (!familyName.isEmpty()) {
         this->addAttribute("font-family", familyName);
     }
+
+    if (const char* textAlign = svg_text_align(paint.getTextAlign())) {
+        this->addAttribute("text-anchor", textAlign);
+    }
 }
 
 SkBaseDevice* SkSVGDevice::Create(const SkISize& size, SkWStream* wstream) {
     if (!SkToBool(wstream)) {
         return NULL;
     }
 
     return SkNEW_ARGS(SkSVGDevice, (size, wstream));
 }
 
@@ skipping 51 matching lines @@
 }
 
 void SkSVGDevice::drawRRect(const SkDraw&, const SkRRect& rr, const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawRRect()\n");
 }
 
 void SkSVGDevice::drawPath(const SkDraw& draw, const SkPath& path, const SkPaint& paint,
                            const SkMatrix* prePathMatrix, bool pathIsMutable) {
     AutoElement elem("path", fWriter, fResourceBucket, draw, paint);
-
-    SkString pathStr;
-    SkParsePath::ToSVGString(path, &pathStr);
-    elem.addAttribute("d", pathStr.c_str());
+    elem.addPathAttributes(path);
 }
 
 void SkSVGDevice::drawBitmap(const SkDraw&, const SkBitmap& bitmap,
                              const SkMatrix& matrix, const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawBitmap()\n");
 }
 
 void SkSVGDevice::drawSprite(const SkDraw&, const SkBitmap& bitmap,
                              int x, int y, const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawSprite()\n");
 }
 
 void SkSVGDevice::drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect* srcOrNull,
                                  const SkRect& dst, const SkPaint& paint,
                                  SkCanvas::DrawBitmapRectFlags flags) {
     // todo
     SkDebugf("unsupported operation: drawBitmapRect()\n");
 }
 
 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);
-    elem.addFontAttributes(paint);
+    elem.addTextAttributes(paint);
     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) {
     SkASSERT(scalarsPerPos == 1 || scalarsPerPos == 2);
 
     AutoElement elem("text", fWriter, fResourceBucket, draw, paint);
-    elem.addFontAttributes(paint);
+    elem.addTextAttributes(paint);
 
     SkString xStr;
     SkString yStr;
     for (int i = 0; i < paint.countText(text, len); ++i) {
         xStr.appendf("%.8g, ", offset.x() + pos[i * scalarsPerPos]);
 
         if (scalarsPerPos == 2) {
             yStr.appendf("%.8g, ", offset.y() + pos[i * scalarsPerPos + 1]);
         }
     }
 
     if (scalarsPerPos != 2) {
         yStr.appendScalar(offset.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()\n");
+    SkString pathID = fResourceBucket->addPath();
+
+    {
+        AutoElement defs("defs", fWriter);
+        AutoElement pathElement("path", fWriter);
+        pathElement.addAttribute("id", pathID);
+        pathElement.addPathAttributes(path);
+
+    }
+
+    {
+        AutoElement textElement("text", fWriter);
+        textElement.addTextAttributes(paint);
+
+        if (matrix && !matrix->isIdentity()) {
+            textElement.addAttribute("transform", svg_transform(*matrix));
+        }
+
+        {
+            AutoElement textPathElement("textPath", fWriter);
+            textPathElement.addAttribute("xlink:href", SkStringPrintf("#%s", pathID.c_str()));
+
+            if (paint.getTextAlign() != SkPaint::kLeft_Align) {
+                SkASSERT(paint.getTextAlign() == SkPaint::kCenter_Align ||
+                         paint.getTextAlign() == SkPaint::kRight_Align);
+                textPathElement.addAttribute("startOffset",
+                    paint.getTextAlign() == SkPaint::kCenter_Align ? "50%" : "100%");
+            }
+
+            textPathElement.addText(svg_text(text, len, paint));
+        }
+    }
 }
 
 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()\n");
 }
 
 void SkSVGDevice::drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                              const SkPaint&) {
     // todo
     SkDebugf("unsupported operation: drawDevice()\n");
 }