[SVGDom] Add more presentation attributes.

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 "SkSVGDOM.h"
 #include "SkSVGG.h"
 #include "SkSVGNode.h"
 #include "SkSVGPath.h"
 #include "SkSVGRect.h"
 #include "SkSVGRenderContext.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) {
-    SkSVGColorType color;
+    SkSVGPaint paint;
     SkSVGAttributeParser parser(stringValue);
-    if (!parser.parseColor(&color)) {
-        return false;
+    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;
     }
 
-    node->setAttribute(attr, SkSVGColorValue(color));
+    node->setAttribute(attr, SkSVGPaintValue(paint));
     return true;
 }
 
 bool SetPathDataAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                           const char* stringValue) {
     SkPath path;
     if (!SkParsePath::FromSVGString(stringValue, &path)) {
         return false;
     }
 
@@ skipping 18 matching lines @@
     SkSVGLength length;
     SkSVGAttributeParser parser(stringValue);
     if (!parser.parseLength(&length)) {
         return false;
     }
 
     node->setAttribute(attr, SkSVGLengthValue(length));
     return true;
 }
 
+bool SetNumberAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                        const char* stringValue) {
+    SkSVGNumberType number;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseNumber(&number)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGNumberValue(number));
+    return true;
+}
+
 bool SetViewBoxAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                          const char* stringValue) {
     SkSVGViewBoxType viewBox;
     SkSVGAttributeParser parser(stringValue);
     if (!parser.parseViewBox(&viewBox)) {
         return false;
     }
 
     node->setAttribute(attr, SkSVGViewBoxValue(viewBox));
     return true;
 }
 
+bool SetLineCapAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                         const char* stringValue) {
+    SkSVGLineCap lineCap;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseLineCap(&lineCap)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGLineCapValue(lineCap));
+    return true;
+}
+
+bool SetLineJoinAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                          const char* stringValue) {
+    SkSVGLineJoin lineJoin;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseLineJoin(&lineJoin)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGLineJoinValue(lineJoin));
+    return true;
+}
+
 SkString TrimmedString(const char* first, const char* last) {
     SkASSERT(first);
     SkASSERT(last);
     SkASSERT(first <= last);
 
     while (first <= last && *first <= ' ') { first++; }
     while (first <= last && *last  <= ' ') { last--; }
 
     SkASSERT(last - first + 1 >= 0);
     return SkString(first, SkTo<size_t>(last - first + 1));
@@ skipping 58 matching lines @@
     const char* fKey;
     const T     fValue;
 };
 
 struct AttrParseInfo {
     SkSVGAttribute fAttr;
     bool (*fSetter)(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr, const char* stringValue);
 };
 
 SortedDictionaryEntry<AttrParseInfo> gAttributeParseInfo[] = {
-    { "d"        , { SkSVGAttribute::kD        , SetPathDataAttribute  }},
-    { "fill"     , { SkSVGAttribute::kFill     , SetPaintAttribute     }},
-    { "height"   , { SkSVGAttribute::kHeight   , SetLengthAttribute    }},
-    { "rx"       , { SkSVGAttribute::kRx       , SetLengthAttribute    }},
-    { "ry"       , { SkSVGAttribute::kRy       , SetLengthAttribute    }},
-    { "stroke"   , { SkSVGAttribute::kStroke   , SetPaintAttribute     }},
-    { "style"    , { SkSVGAttribute::kUnknown  , SetStyleAttributes    }},
-    { "transform", { SkSVGAttribute::kTransform, SetTransformAttribute }},
-    { "viewBox"  , { SkSVGAttribute::kViewBox  , SetViewBoxAttribute   }},
-    { "width"    , { SkSVGAttribute::kWidth    , SetLengthAttribute    }},
-    { "x"        , { SkSVGAttribute::kX        , SetLengthAttribute    }},
-    { "y"        , { SkSVGAttribute::kY        , SetLengthAttribute    }},
+    { "d"              , { SkSVGAttribute::kD             , SetPathDataAttribute  }},
+    { "fill"           , { SkSVGAttribute::kFill          , SetPaintAttribute     }},
+    { "fill-opacity"   , { SkSVGAttribute::kFillOpacity   , SetNumberAttribute    }},
+    { "height"         , { SkSVGAttribute::kHeight        , SetLengthAttribute    }},
+    { "rx"             , { SkSVGAttribute::kRx            , SetLengthAttribute    }},
+    { "ry"             , { SkSVGAttribute::kRy            , SetLengthAttribute    }},
+    { "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    }},
+    { "y"              , { SkSVGAttribute::kY             , SetLengthAttribute    }},
 };
 
 SortedDictionaryEntry<sk_sp<SkSVGNode>(*)()> gTagFactories[] = {
     { "g"   , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();    }},
     { "path", []() -> sk_sp<SkSVGNode> { return SkSVGPath::Make(); }},
     { "rect", []() -> sk_sp<SkSVGNode> { return SkSVGRect::Make(); }},
     { "svg" , []() -> sk_sp<SkSVGNode> { return SkSVGSVG::Make();  }},
 };
 
 struct ConstructionContext {
@@ skipping 102 matching lines @@
                                SkSVGLengthContext(fContainerSize),
                                SkSVGPresentationContext());
         fRoot->render(ctx);
     }
 }
 
 void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
     // TODO: inval
     fContainerSize = containerSize;
 }