[SVGDom/experimental] Initial SVGLength 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 "SkParse.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 {
 
-SkColor ParseColor(const char* str) {
-    // FIXME: real parser
-    if (*str++ != '#') {
-        return SK_ColorBLACK;
-    }
-
-    uint32_t v;
-    const char* consumed = SkParse::FindHex(str, &v);
-
-    switch(consumed - str) {
-    case 6:
-        // matched '#xxxxxx'
-        break;
-    case 3:
-        // matched '#xxx;
-        v = ((v << 12) & 0x00f00000) |
-            ((v <<  8) & 0x000ff000) |
-            ((v <<  4) & 0x00000ff0) |
-            ((v <<  0) & 0x0000000f);
-        break;
-    default:
-        // failed
-        v = 0;
-        break;
-    }
-
-    return v | 0xff000000;
-}
-
 const char* ParseScalarPair(const char* str, SkScalar v[2]) {
     str = SkParse::FindScalar(str, v);
     if (str) {
         const char* second = SkParse::FindScalar(str, v + 1);
         if (!second) {
             v[1] = v[0];
         } else {
             str = second;
         }
     }
@@ skipping 29 matching lines @@
         if (str) {
             m.setRotate(value);
         }
     }
 
     return m;
 }
 
 bool SetPaintAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                        const char* stringValue) {
-    node->setAttribute(attr, SkSVGColorValue(ParseColor(stringValue)));
+    SkSVGColor color;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseColor(&color)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGColorValue(color));
     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;
 }
 
 bool SetTransformAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                            const char* stringValue) {
     node->setAttribute(attr, SkSVGTransformValue(ParseTransform(stringValue)));
     return true;
 }
 
+bool SetLengthAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                        const char* stringValue) {
+    SkSVGLength length;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parseLength(&length)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGLengthValue(length));
+    return true;
+}
+
 // Breaks a "foo: bar; baz: ..." string into key:value pairs.
 class StyleIterator {
 public:
     StyleIterator(const char* str) : fPos(str) { }
 
     std::tuple<SkString, SkString> next() {
         SkString name, value;
 
         if (fPos) {
             const char* sep = this->nextSeparator();
@@ skipping 46 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     }},
-    { "stroke",    { SkSVGAttribute::kStroke,    SetPaintAttribute     }},
-    { "style",     { SkSVGAttribute::kUnknown,   SetStyleAttributes    }},
+    { "d"        , { SkSVGAttribute::kD        , SetPathDataAttribute  }},
+    { "fill"     , { SkSVGAttribute::kFill     , SetPaintAttribute     }},
+    { "height"   , { SkSVGAttribute::kHeight   , SetLengthAttribute    }},
+    { "stroke"   , { SkSVGAttribute::kStroke   , SetPaintAttribute     }},
+    { "style"    , { SkSVGAttribute::kUnknown  , SetStyleAttributes    }},
     { "transform", { SkSVGAttribute::kTransform, SetTransformAttribute }},
+    { "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 {
     ConstructionContext() : fParent(nullptr) { }
     ConstructionContext(const ConstructionContext& other, const sk_sp<SkSVGNode>& newParent)
         : fParent(newParent.get()) { }
 
     const SkSVGNode* fParent;
 };
@@ skipping 79 matching lines @@
     SkDOM xmlDom;
     if (!xmlDom.build(svgStream)) {
         return nullptr;
     }
 
     return MakeFromDOM(xmlDom, containerSize);
 }
 
 void SkSVGDOM::render(SkCanvas* canvas) const {
     if (fRoot) {
-        fRoot->render(canvas);
+        SkSVGRenderContext ctx(fContainerSize);
+        fRoot->render(canvas, ctx);
     }
 }
 
 void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
     // TODO: inval
     fContainerSize = containerSize;
 }