[SkSVGDevice] Initial clipping 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 "SkPathOps.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;
+    return SkStringPrintf("rgb(%u,%u,%u)",
+                          SkColorGetR(color),
+                          SkColorGetG(color),
+                          SkColorGetB(color));
 }
 
 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("&");
@@ skipping 56 matching lines @@
     }
 
     return svgText;
 }
 
 struct Resources {
     Resources(const SkPaint& paint)
         : fPaintServer(svg_color(paint.getColor())) {}
 
     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) {}
+    ResourceBucket() : fGradientCount(0), fClipCount(0) {}
 
     SkString addLinearGradient() {
-        SkString id;
-        id.printf("gradient_%d", fGradientCount++);
-        return id;
+        return SkStringPrintf("gradient_%d", fGradientCount++);
+    }
+
+    SkString addClip() {
+        return SkStringPrintf("clip_%d", fClipCount++);
     }
 
 private:
     uint32_t fGradientCount;
+    uint32_t fClipCount;
 };
 
 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(paint);
+        Resources res = this->addResources(draw, paint);
 
         fWriter->startElement(name);
 
         this->addPaint(paint, res);
         this->addTransform(*draw.fMatrix);
     }
 
     ~AutoElement() {
         fWriter->endElement();
     }
@@ skipping 11 matching lines @@
     }
 
     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&);
 
 private:
-    Resources addResources(const SkPaint& paint);
-    void addResourceDefs(const SkPaint& paint, Resources* resources);
+    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) {
         this->addAttribute("fill", resources.fPaintServer);
     } else {
         this->addAttribute("fill", "none");
     }
 
     if (style == SkPaint::kStroke_Style || style == SkPaint::kStrokeAndFill_Style) {
         this->addAttribute("stroke", resources.fPaintServer);
         this->addAttribute("stroke-width", paint.getStrokeWidth());
     } else {
         this->addAttribute("stroke", "none");
     }
 
     if (SK_AlphaOPAQUE != SkColorGetA(paint.getColor())) {
         this->addAttribute("opacity", svg_opacity(paint.getColor()));
     }
+
+    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:
@@ skipping 13 matching lines @@
         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 SkPaint& paint) {
+Resources SkSVGDevice::AutoElement::addResources(const SkDraw& draw, const SkPaint& paint) {
     Resources resources(paint);
-    this->addResourceDefs(paint, &resources);
+
+    // 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);
+
+        if (hasClip) {
+            this->addClipResources(draw, &resources);
+        }
+
+        if (hasShader) {
+            this->addShaderResources(paint, &resources);
+        }
+    }
+
     return resources;
 }
 
-void SkSVGDevice::AutoElement::addResourceDefs(const SkPaint& paint, Resources* resources) {
+void SkSVGDevice::AutoElement::addShaderResources(const SkPaint& paint, Resources* resources) {
     const SkShader* shader = paint.getShader();
-    if (!SkToBool(shader)) {
-        // TODO: clip support
-        return;
-    }
+    SkASSERT(SkToBool(shader));
 
     SkShader::GradientInfo grInfo;
     grInfo.fColorCount = 0;
     if (SkShader::kLinear_GradientType != shader->asAGradient(&grInfo)) {
         // TODO: non-linear gradient support
         SkDebugf("unsupported shader type\n");
         return;
     }
 
+    SkAutoSTArray<16, SkColor>  grColors(grInfo.fColorCount);
+    SkAutoSTArray<16, SkScalar> grOffsets(grInfo.fColorCount);
+    grInfo.fColors = grColors.get();
+    grInfo.fColorOffsets = grOffsets.get();
+
+    // One more call to get the actual colors/offsets.
+    shader->asAGradient(&grInfo);
+    SkASSERT(grInfo.fColorCount <= grColors.count());
+    SkASSERT(grInfo.fColorCount <= grOffsets.count());
+
+    resources->fPaintServer.printf("url(#%s)", addLinearGradientDef(grInfo, shader).c_str());
+}
+
+void SkSVGDevice::AutoElement::addClipResources(const SkDraw& draw, Resources* resources) {
+    SkASSERT(!draw.fClipStack->isWideOpen());
+
+    SkPath clipPath;
+    (void) draw.fClipStack->asPath(&clipPath);
+
+    SkString clipID = fResourceBucket->addClip();
+    const char* clipRule = clipPath.getFillType() == SkPath::kEvenOdd_FillType ?
+                           "evenodd" : "nonzero";
     {
-        AutoElement defs("defs", fWriter);
+        // clipPath is in device space, but since we're only pushing transform attributes
+        // to the leaf nodes, so are all our elements => SVG userSpaceOnUse == device space.
+        AutoElement clipPathElement("clipPath", fWriter);
+        clipPathElement.addAttribute("id", clipID);
 
-        SkAutoSTArray<16, SkColor>  grColors(grInfo.fColorCount);
-        SkAutoSTArray<16, SkScalar> grOffsets(grInfo.fColorCount);
-        grInfo.fColors = grColors.get();
-        grInfo.fColorOffsets = grOffsets.get();
+        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.addAttribute("clip-rule", clipRule);
+        }
+    }
 
-        // One more call to get the actual colors/offsets.
-        shader->asAGradient(&grInfo);
-        SkASSERT(grInfo.fColorCount <= grColors.count());
-        SkASSERT(grInfo.fColorCount <= grOffsets.count());
-
-        resources->fPaintServer.printf("url(#%s)", addLinearGradientDef(grInfo, shader).c_str());
-    }
+    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);
 
@@ skipping 18 matching lines @@
                 if (SK_AlphaOPAQUE != SkColorGetA(color)) {
                     stop.addAttribute("stop-opacity", svg_opacity(color));
                 }
             }
         }
     }
 
     return id;
 }
 
+void SkSVGDevice::AutoElement::addRectAttributes(const SkRect& rect) {
+    // x, y default to 0
+    if (rect.x() != 0) {
+        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) {
     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");
     }
@@ skipping 38 matching lines @@
 SkImageInfo SkSVGDevice::imageInfo() const {
     return fLegacyBitmap.info();
 }
 
 const SkBitmap& SkSVGDevice::onAccessBitmap() {
     return fLegacyBitmap;
 }
 
 void SkSVGDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     AutoElement rect("rect", fWriter, fResourceBucket, draw, paint);
-    rect.addAttribute("x", 0);
-    rect.addAttribute("y", 0);
-    rect.addAttribute("width", this->width());
-    rect.addAttribute("height", this->height());
+    rect.addRectAttributes(SkRect::MakeWH(SkIntToScalar(this->width()),
+                                          SkIntToScalar(this->height())));
 }
 
 void SkSVGDevice::drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
                              const SkPoint[], const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawPoints()\n");
 }
 
 void SkSVGDevice::drawRect(const SkDraw& draw, const SkRect& r, const SkPaint& paint) {
     AutoElement rect("rect", fWriter, fResourceBucket, draw, paint);
-    rect.addAttribute("x", r.fLeft);
-    rect.addAttribute("y", r.fTop);
-    rect.addAttribute("width", r.width());
-    rect.addAttribute("height", r.height());
+    rect.addRectAttributes(r);
 }
 
 void SkSVGDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
     AutoElement ellipse("ellipse", fWriter, fResourceBucket, draw, paint);
     ellipse.addAttribute("cx", oval.centerX());
     ellipse.addAttribute("cy", oval.centerY());
     ellipse.addAttribute("rx", oval.width() / 2);
     ellipse.addAttribute("ry", oval.height() / 2);
 }
 
@@ skipping 79 matching lines @@
                                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");
 }