Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(3205)

Unified Diff: experimental/svg/model/SkSVGDOM.cpp

Issue 2164193002: Initial SVG model (Closed) Base URL: https://chromium.googlesource.com/skia.git@master
Patch Set: warning fix Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « experimental/svg/model/SkSVGDOM.h ('k') | experimental/svg/model/SkSVGG.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: experimental/svg/model/SkSVGDOM.cpp
diff --git a/experimental/svg/model/SkSVGDOM.cpp b/experimental/svg/model/SkSVGDOM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f782c3a96368d51bddb1e407732ae17205d9aaf
--- /dev/null
+++ b/experimental/svg/model/SkSVGDOM.cpp
@@ -0,0 +1,244 @@
+/*
+ * 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 "SkSVGDOM.h"
+#include "SkSVGG.h"
+#include "SkSVGNode.h"
+#include "SkSVGPath.h"
+#include "SkSVGSVG.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;
+ }
+ }
+
+ return str;
+}
+
+SkMatrix ParseTransform(const char* str) {
+ SkMatrix m = SkMatrix::I();
+
+ // FIXME: real parser
+ if (!strncmp(str, "matrix(", 7)) {
+ SkScalar values[6];
+ str = SkParse::FindScalars(str + 7, values, 6);
+ if (str) {
+ m.setAffine(values);
+ }
+ } else if (!strncmp(str, "scale(", 6)) {
+ SkScalar values[2];
+ str = ParseScalarPair(str + 6, values);
+ if (str) {
+ m.setScale(values[0], values[1]);
+ }
+ } else if (!strncmp(str, "translate(", 10)) {
+ SkScalar values[2];
+ str = ParseScalarPair(str + 10, values);
+ if (str) {
+ m.setTranslate(values[0], values[1]);
+ }
+ } else if (!strncmp(str, "rotate(", 7)) {
+ SkScalar value;
+ str = SkParse::FindScalar(str + 7, &value);
+ 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)));
+ 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;
+}
+
+template<typename T>
+struct SortedDictionaryEntry {
+ 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::d, SetPathDataAttribute }},
+ { "fill", { SkSVGAttribute::fill, SetPaintAttribute }},
+ { "stroke", { SkSVGAttribute::stroke, SetPaintAttribute }},
+ { "transform", { SkSVGAttribute::transform, SetTransformAttribute }},
+};
+
+SortedDictionaryEntry<sk_sp<SkSVGNode>(*)()> gTagFactories[] = {
+ { "g" , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make(); }},
+ { "path", []() -> sk_sp<SkSVGNode> { return SkSVGPath::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;
+};
+
+void parse_node_attributes(const SkDOM& xmlDom, const SkDOM::Node* xmlNode,
+ const sk_sp<SkSVGNode>& svgNode) {
+ const char* name, *value;
+ SkDOM::AttrIter attrIter(xmlDom, xmlNode);
+ while ((name = attrIter.next(&value))) {
+ const int attrIndex = SkStrSearch(&gAttributeParseInfo[0].fKey,
+ SkTo<int>(SK_ARRAY_COUNT(gAttributeParseInfo)),
+ name, sizeof(gAttributeParseInfo[0]));
+ if (attrIndex < 0) {
+ SkDebugf("unhandled attribute: %s\n", name);
+ continue;
+ }
+
+ SkASSERT(SkTo<size_t>(attrIndex) < SK_ARRAY_COUNT(gAttributeParseInfo));
+ const auto& attrInfo = gAttributeParseInfo[attrIndex].fValue;
+ if (!attrInfo.fSetter(svgNode, attrInfo.fAttr, value)) {
+ SkDebugf("could not parse attribute: '%s=\"%s\"'\n", 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) {
+ SkDebugf("unhandled element: <%s>\n", elem);
+ return nullptr;
+ }
+
+ SkASSERT(SkTo<size_t>(tagIndex) < SK_ARRAY_COUNT(gTagFactories));
+ sk_sp<SkSVGNode> node = gTagFactories[tagIndex].fValue();
+ parse_node_attributes(dom, xmlNode, node);
+
+ 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;
+ 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) {
+ fRoot->render(canvas);
+ }
+}
+
+void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
+ // TODO: inval
+ fContainerSize = containerSize;
+}
« no previous file with comments | « experimental/svg/model/SkSVGDOM.h ('k') | experimental/svg/model/SkSVGG.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698