[SVGDom] Initial linear gradient support

experimental/svg/model/SkSVGDOM.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 "SkCanvas.h"
 #include "SkDOM.h"
 #include "SkParsePath.h"
 #include "SkString.h"
 #include "SkSVGAttributeParser.h"
 #include "SkSVGCircle.h"
+#include "SkSVGDefs.h"
 #include "SkSVGDOM.h"
 #include "SkSVGEllipse.h"
 #include "SkSVGG.h"
 #include "SkSVGLine.h"
+#include "SkSVGLinearGradient.h"
 #include "SkSVGNode.h"
 #include "SkSVGPath.h"
 #include "SkSVGPoly.h"
 #include "SkSVGRect.h"
 #include "SkSVGRenderContext.h"
+#include "SkSVGStop.h"
 #include "SkSVGSVG.h"
 #include "SkSVGTypes.h"
 #include "SkSVGValue.h"
 #include "SkTSearch.h"
 
 namespace {
 
 bool SetPaintAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                        const char* stringValue) {
     SkSVGPaint paint;
     SkSVGAttributeParser parser(stringValue);
     if (!parser.parsePaint(&paint)) {
-        // Until we have paint server support, failing here will cause default/all-black rendering.
-        // It's better to just not draw for now.
-        paint = SkSVGPaint(SkSVGPaint::Type::kNone);
-
-        // return false;
+        return false;
     }
 
     node->setAttribute(attr, SkSVGPaintValue(paint));
     return true;
 }
 
+bool SetColorAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                       const char* stringValue) {
+    SkSVGColorType color;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseColor(&color)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGColorValue(color));
+    return true;
+}
+
+bool SetIRIAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                      const char* stringValue) {
+    SkSVGStringType iri;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseIRI(&iri)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGStringValue(iri));
+    return true;
+}
+
 bool SetPathDataAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                           const char* stringValue) {
     SkPath path;
     if (!SkParsePath::FromSVGString(stringValue, &path)) {
         return false;
     }
 
     node->setAttribute(attr, SkSVGPathValue(path));
     return true;
 }
@@ skipping 159 matching lines @@
     bool (*fSetter)(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr, const char* stringValue);
 };
 
 SortedDictionaryEntry<AttrParseInfo> gAttributeParseInfo[] = {
     { "cx"             , { SkSVGAttribute::kCx            , SetLengthAttribute    }},
     { "cy"             , { SkSVGAttribute::kCy            , SetLengthAttribute    }},
     { "d"              , { SkSVGAttribute::kD             , SetPathDataAttribute  }},
     { "fill"           , { SkSVGAttribute::kFill          , SetPaintAttribute     }},
     { "fill-opacity"   , { SkSVGAttribute::kFillOpacity   , SetNumberAttribute    }},
     { "height"         , { SkSVGAttribute::kHeight        , SetLengthAttribute    }},
+    { "offset"         , { SkSVGAttribute::kOffset        , SetLengthAttribute    }},
     { "opacity"        , { SkSVGAttribute::kOpacity       , SetNumberAttribute    }},
     { "points"         , { SkSVGAttribute::kPoints        , SetPointsAttribute    }},
     { "r"              , { SkSVGAttribute::kR             , SetLengthAttribute    }},
     { "rx"             , { SkSVGAttribute::kRx            , SetLengthAttribute    }},
     { "ry"             , { SkSVGAttribute::kRy            , SetLengthAttribute    }},
+    { "stop-color"     , { SkSVGAttribute::kStopColor     , SetColorAttribute     }},
+    { "stop-opacity"   , { SkSVGAttribute::kStopOpacity   , SetNumberAttribute    }},
     { "stroke"         , { SkSVGAttribute::kStroke        , SetPaintAttribute     }},
     { "stroke-linecap" , { SkSVGAttribute::kStrokeLineCap , SetLineCapAttribute   }},
     { "stroke-linejoin", { SkSVGAttribute::kStrokeLineJoin, SetLineJoinAttribute  }},
     { "stroke-opacity" , { SkSVGAttribute::kStrokeOpacity , SetNumberAttribute    }},
     { "stroke-width"   , { SkSVGAttribute::kStrokeWidth   , SetLengthAttribute    }},
     { "style"          , { SkSVGAttribute::kUnknown       , SetStyleAttributes    }},
     { "transform"      , { SkSVGAttribute::kTransform     , SetTransformAttribute }},
     { "viewBox"        , { SkSVGAttribute::kViewBox       , SetViewBoxAttribute   }},
     { "width"          , { SkSVGAttribute::kWidth         , SetLengthAttribute    }},
     { "x"              , { SkSVGAttribute::kX             , SetLengthAttribute    }},
     { "x1"             , { SkSVGAttribute::kX1            , SetLengthAttribute    }},
     { "x2"             , { SkSVGAttribute::kX2            , SetLengthAttribute    }},
+    { "xlink:href"     , { SkSVGAttribute::kHref          , SetIRIAttribute       }},
     { "y"              , { SkSVGAttribute::kY             , SetLengthAttribute    }},
     { "y1"             , { SkSVGAttribute::kY1            , SetLengthAttribute    }},
     { "y2"             , { SkSVGAttribute::kY2            , SetLengthAttribute    }},
 };
 
 SortedDictionaryEntry<sk_sp<SkSVGNode>(*)()> gTagFactories[] = {
-    { "circle"  , []() -> sk_sp<SkSVGNode> { return SkSVGCircle::Make();       }},
-    { "ellipse" , []() -> sk_sp<SkSVGNode> { return SkSVGEllipse::Make();      }},
-    { "g"       , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();            }},
-    { "line"    , []() -> sk_sp<SkSVGNode> { return SkSVGLine::Make();         }},
-    { "path"    , []() -> sk_sp<SkSVGNode> { return SkSVGPath::Make();         }},
-    { "polygon" , []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolygon();  }},
-    { "polyline", []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolyline(); }},
-    { "rect"    , []() -> sk_sp<SkSVGNode> { return SkSVGRect::Make();         }},
-    { "svg"     , []() -> sk_sp<SkSVGNode> { return SkSVGSVG::Make();          }},
+    { "circle"        , []() -> sk_sp<SkSVGNode> { return SkSVGCircle::Make();         }},
+    { "defs"          , []() -> sk_sp<SkSVGNode> { return SkSVGDefs::Make();           }},
+    { "ellipse"       , []() -> sk_sp<SkSVGNode> { return SkSVGEllipse::Make();        }},
+    { "g"             , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();              }},
+    { "line"          , []() -> sk_sp<SkSVGNode> { return SkSVGLine::Make();           }},
+    { "linearGradient", []() -> sk_sp<SkSVGNode> { return SkSVGLinearGradient::Make(); }},
+    { "path"          , []() -> sk_sp<SkSVGNode> { return SkSVGPath::Make();           }},
+    { "polygon"       , []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolygon();    }},
+    { "polyline"      , []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolyline();   }},
+    { "rect"          , []() -> sk_sp<SkSVGNode> { return SkSVGRect::Make();           }},
+    { "stop"          , []() -> sk_sp<SkSVGNode> { return SkSVGStop::Make();           }},
+    { "svg"           , []() -> sk_sp<SkSVGNode> { return SkSVGSVG::Make();            }},
 };
 
 struct ConstructionContext {
-    ConstructionContext() : fParent(nullptr) { }
+    ConstructionContext(SkSVGIDMapper* mapper) : fParent(nullptr), fIDMapper(mapper) {}
     ConstructionContext(const ConstructionContext& other, const sk_sp<SkSVGNode>& newParent)
-        : fParent(newParent.get()) { }
+        : fParent(newParent.get()), fIDMapper(other.fIDMapper) {}
 
     const SkSVGNode* fParent;
+    SkSVGIDMapper*   fIDMapper;
 };
 
 void set_string_attribute(const sk_sp<SkSVGNode>& node, const char* name, const char* value) {
     const int attrIndex = SkStrSearch(&gAttributeParseInfo[0].fKey,
                                       SkTo<int>(SK_ARRAY_COUNT(gAttributeParseInfo)),
                                       name, sizeof(gAttributeParseInfo[0]));
     if (attrIndex < 0) {
 #if defined(SK_VERBOSE_SVG_PARSING)
         SkDebugf("unhandled attribute: %s\n", name);
 #endif
         return;
     }
 
     SkASSERT(SkTo<size_t>(attrIndex) < SK_ARRAY_COUNT(gAttributeParseInfo));
     const auto& attrInfo = gAttributeParseInfo[attrIndex].fValue;
     if (!attrInfo.fSetter(node, attrInfo.fAttr, value)) {
 #if defined(SK_VERBOSE_SVG_PARSING)
         SkDebugf("could not parse attribute: '%s=\"%s\"'\n", name, value);
 #endif
     }
 }
 
 void parse_node_attributes(const SkDOM& xmlDom, const SkDOM::Node* xmlNode,
-                           const sk_sp<SkSVGNode>& svgNode) {
+                           const sk_sp<SkSVGNode>& svgNode, SkSVGIDMapper* mapper) {
     const char* name, *value;
     SkDOM::AttrIter attrIter(xmlDom, xmlNode);
     while ((name = attrIter.next(&value))) {
+        // We're handling id attributes out of band for now.
+        if (!strcmp(name, "id")) {
+            mapper->set(SkString(value), svgNode);
+            continue;
+        }
         set_string_attribute(svgNode, name, value);
     }
 }
 
 sk_sp<SkSVGNode> construct_svg_node(const SkDOM& dom, const ConstructionContext& ctx,
                                     const SkDOM::Node* xmlNode) {
     const char* elem = dom.getName(xmlNode);
     const SkDOM::Type elemType = dom.getType(xmlNode);
 
     if (elemType == SkDOM::kText_Type) {
         SkASSERT(dom.countChildren(xmlNode) == 0);
         // TODO: text handling
         return nullptr;
     }
 
     SkASSERT(elemType == SkDOM::kElement_Type);
 
     const int tagIndex = SkStrSearch(&gTagFactories[0].fKey,
                                      SkTo<int>(SK_ARRAY_COUNT(gTagFactories)),
                                      elem, sizeof(gTagFactories[0]));
     if (tagIndex < 0) {
 #if defined(SK_VERBOSE_SVG_PARSING)
         SkDebugf("unhandled element: <%s>\n", elem);
 #endif
         return nullptr;
     }
 
     SkASSERT(SkTo<size_t>(tagIndex) < SK_ARRAY_COUNT(gTagFactories));
     sk_sp<SkSVGNode> node = gTagFactories[tagIndex].fValue();
-    parse_node_attributes(dom, xmlNode, node);
+    parse_node_attributes(dom, xmlNode, node, ctx.fIDMapper);
 
     ConstructionContext localCtx(ctx, node);
     for (auto* child = dom.getFirstChild(xmlNode, nullptr); child;
          child = dom.getNextSibling(child)) {
         sk_sp<SkSVGNode> childNode = construct_svg_node(dom, localCtx, child);
         if (childNode) {
             node->appendChild(std::move(childNode));
         }
     }
 
     return node;
 }
 
 } // anonymous namespace
 
 SkSVGDOM::SkSVGDOM(const SkSize& containerSize)
     : fContainerSize(containerSize) {
 }
 
 sk_sp<SkSVGDOM> SkSVGDOM::MakeFromDOM(const SkDOM& xmlDom, const SkSize& containerSize) {
     sk_sp<SkSVGDOM> dom = sk_make_sp<SkSVGDOM>(containerSize);
 
-    ConstructionContext ctx;
+    ConstructionContext ctx(&dom->fIDMapper);
     dom->fRoot = construct_svg_node(xmlDom, ctx, xmlDom.getRootNode());
 
     return dom;
 }
 
 sk_sp<SkSVGDOM> SkSVGDOM::MakeFromStream(SkStream& svgStream, const SkSize& containerSize) {
     SkDOM xmlDom;
     if (!xmlDom.build(svgStream)) {
         return nullptr;
     }
 
     return MakeFromDOM(xmlDom, containerSize);
 }
 
 void SkSVGDOM::render(SkCanvas* canvas) const {
     if (fRoot) {
         SkSVGRenderContext ctx(canvas,
+                               fIDMapper,
                                SkSVGLengthContext(fContainerSize),
                                SkSVGPresentationContext());
         fRoot->render(ctx);
     }
 }
 
 void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
     // TODO: inval
     fContainerSize = containerSize;
 }
 
 void SkSVGDOM::setRoot(sk_sp<SkSVGNode> root) {
     fRoot = std::move(root);
 }