[SVGDom] Initial linear gradient support

experimental/svg/model/SkSVGRenderContext.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 "SkSVGAttribute.h"
+#include "SkSVGNode.h"
 #include "SkSVGRenderContext.h"
 #include "SkSVGTypes.h"
 
 namespace {
 
 SkScalar length_size_for_type(const SkSize& viewport, SkSVGLengthContext::LengthType t) {
     switch (t) {
     case SkSVGLengthContext::LengthType::kHorizontal:
         return viewport.width();
     case SkSVGLengthContext::LengthType::kVertical:
@@ skipping 71 matching lines @@
     case SkSVGLineJoin::Type::kRound:
         return SkPaint::kRound_Join;
     case SkSVGLineJoin::Type::kBevel:
         return SkPaint::kBevel_Join;
     default:
         SkASSERT(false);
         return SkPaint::kMiter_Join;
     }
 }
 
-void applySvgPaint(const SkSVGPaint& svgPaint, SkPaint* p) {
+void applySvgPaint(const SkSVGRenderContext& ctx, const SkSVGPaint& svgPaint, SkPaint* p) {
     switch (svgPaint.type()) {
     case SkSVGPaint::Type::kColor:
         p->setColor(SkColorSetA(svgPaint.color(), p->getAlpha()));
         break;
+    case SkSVGPaint::Type::kIRI: {
+        const auto* node = ctx.findNodeById(svgPaint.iri());
+        if (!node || !node->asPaint(ctx, p)) {
+            p->setColor(SK_ColorTRANSPARENT);
+        }
+        break;
+    }
     case SkSVGPaint::Type::kCurrentColor:
         SkDebugf("unimplemented 'currentColor' paint type");
         // Fall through.
     case SkSVGPaint::Type::kNone:
         // Fall through.
     case SkSVGPaint::Type::kInherit:
         break;
     }
 }
 
 inline uint8_t opacity_to_alpha(SkScalar o) {
     return SkTo<uint8_t>(SkScalarRoundToInt(o * 255));
 }
 
 // Commit the selected attribute to the paint cache.
 template <SkSVGAttribute>
 void commitToPaint(const SkSVGPresentationAttributes&,
-                   const SkSVGLengthContext&,
+                   const SkSVGRenderContext&,
                    SkSVGPresentationContext*);
 
 template <>
 void commitToPaint<SkSVGAttribute::kFill>(const SkSVGPresentationAttributes& attrs,
-                                          const SkSVGLengthContext&,
+                                          const SkSVGRenderContext& ctx,
                                           SkSVGPresentationContext* pctx) {
-    applySvgPaint(*attrs.fFill.get(), &pctx->fFillPaint);
+    applySvgPaint(ctx, *attrs.fFill.get(), &pctx->fFillPaint);
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kStroke>(const SkSVGPresentationAttributes& attrs,
-                                            const SkSVGLengthContext&,
+                                            const SkSVGRenderContext& ctx,
                                             SkSVGPresentationContext* pctx) {
-    applySvgPaint(*attrs.fStroke.get(), &pctx->fStrokePaint);
+    applySvgPaint(ctx, *attrs.fStroke.get(), &pctx->fStrokePaint);
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kFillOpacity>(const SkSVGPresentationAttributes& attrs,
-                                                 const SkSVGLengthContext&,
+                                                 const SkSVGRenderContext&,
                                                  SkSVGPresentationContext* pctx) {
     pctx->fFillPaint.setAlpha(opacity_to_alpha(*attrs.fFillOpacity.get()));
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kStrokeLineCap>(const SkSVGPresentationAttributes& attrs,
-                                                   const SkSVGLengthContext&,
+                                                   const SkSVGRenderContext&,
                                                    SkSVGPresentationContext* pctx) {
     const auto& cap = *attrs.fStrokeLineCap.get();
     if (cap.type() != SkSVGLineCap::Type::kInherit) {
         pctx->fStrokePaint.setStrokeCap(toSkCap(cap));
     }
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kStrokeLineJoin>(const SkSVGPresentationAttributes& attrs,
-                                                    const SkSVGLengthContext&,
+                                                    const SkSVGRenderContext&,
                                                     SkSVGPresentationContext* pctx) {
     const auto& join = *attrs.fStrokeLineJoin.get();
     if (join.type() != SkSVGLineJoin::Type::kInherit) {
         pctx->fStrokePaint.setStrokeJoin(toSkJoin(join));
     }
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kStrokeOpacity>(const SkSVGPresentationAttributes& attrs,
-                                                   const SkSVGLengthContext&,
+                                                   const SkSVGRenderContext&,
                                                    SkSVGPresentationContext* pctx) {
     pctx->fStrokePaint.setAlpha(opacity_to_alpha(*attrs.fStrokeOpacity.get()));
 }
 
 template <>
 void commitToPaint<SkSVGAttribute::kStrokeWidth>(const SkSVGPresentationAttributes& attrs,
-                                                 const SkSVGLengthContext& lctx,
+                                                 const SkSVGRenderContext& ctx,
                                                  SkSVGPresentationContext* pctx) {
-    auto strokeWidth = lctx.resolve(*attrs.fStrokeWidth.get(),
-                                    SkSVGLengthContext::LengthType::kOther);
+    auto strokeWidth = ctx.lengthContext().resolve(*attrs.fStrokeWidth.get(),
+                                                   SkSVGLengthContext::LengthType::kOther);
     pctx->fStrokePaint.setStrokeWidth(strokeWidth);
 }
 
 } // anonymous ns
 
 SkSVGPresentationContext::SkSVGPresentationContext()
     : fInherited(SkSVGPresentationAttributes::MakeInitial()) {
 
     fFillPaint.setStyle(SkPaint::kFill_Style);
     fStrokePaint.setStyle(SkPaint::kStroke_Style);
 
     // TODO: drive AA off presentation attrs also (shape-rendering?)
     fFillPaint.setAntiAlias(true);
     fStrokePaint.setAntiAlias(true);
 
     // Commit initial values to the paint cache.
-    SkSVGLengthContext dummy(SkSize::Make(0, 0));
+    SkCanvas dummyCanvas(0, 0);

[robertphillips, 2016/09/12 19:31:52]

overlength line ?

[f(malita), 2016/09/12 19:52:09]

Done.

+    SkSVGRenderContext dummy(&dummyCanvas, SkSVGIDMapper(), SkSVGLengthContext(SkSize::Make(0, 0)), *this);
+
     commitToPaint<SkSVGAttribute::kFill>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kFillOpacity>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kStroke>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kStrokeLineCap>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kStrokeLineJoin>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kStrokeOpacity>(fInherited, dummy, this);
     commitToPaint<SkSVGAttribute::kStrokeWidth>(fInherited, dummy, this);
 }
 
 SkSVGRenderContext::SkSVGRenderContext(SkCanvas* canvas,
+                                       const SkSVGIDMapper& mapper,
                                        const SkSVGLengthContext& lctx,
                                        const SkSVGPresentationContext& pctx)
-    : fLengthContext(lctx)
+    : fIDMapper(mapper)
+    , fLengthContext(lctx)
     , fPresentationContext(pctx)
     , fCanvas(canvas)
     , fCanvasSaveCount(canvas->getSaveCount()) {}
 
 SkSVGRenderContext::SkSVGRenderContext(const SkSVGRenderContext& other)
     : SkSVGRenderContext(other.fCanvas,
+                         other.fIDMapper,
                          *other.fLengthContext,
                          *other.fPresentationContext) {}
 
 SkSVGRenderContext::~SkSVGRenderContext() {
     fCanvas->restoreToCount(fCanvasSaveCount);
 }
 
+const SkSVGNode* SkSVGRenderContext::findNodeById(const SkString& id) const {
+    const auto* v = fIDMapper.find(id);
+    return v ? v->get() : nullptr;
+}
+
 void SkSVGRenderContext::applyPresentationAttributes(const SkSVGPresentationAttributes& attrs) {
 
 #define ApplyLazyInheritedAttribute(ATTR)                                               \
     do {                                                                                \
         /* All attributes should be defined on the inherited context. */                \
         SkASSERT(fPresentationContext->fInherited.f ## ATTR.isValid());                 \
         const auto* value = attrs.f ## ATTR.getMaybeNull();                             \
         if (value && *value != *fPresentationContext->fInherited.f ## ATTR.get()) {     \
             /* Update the local attribute value */                                      \
             fPresentationContext.writable()->fInherited.f ## ATTR.set(*value);          \
             /* Update the cached paints */                                              \
-            commitToPaint<SkSVGAttribute::k ## ATTR>(attrs, *fLengthContext,            \
+            commitToPaint<SkSVGAttribute::k ## ATTR>(attrs, *this,    \
                                                      fPresentationContext.writable());  \
         }                                                                               \
     } while (false)
 
     ApplyLazyInheritedAttribute(Fill);
     ApplyLazyInheritedAttribute(FillOpacity);
     ApplyLazyInheritedAttribute(Stroke);
     ApplyLazyInheritedAttribute(StrokeLineCap);
     ApplyLazyInheritedAttribute(StrokeLineJoin);
     ApplyLazyInheritedAttribute(StrokeOpacity);
@@ skipping 13 matching lines @@
 
 const SkPaint* SkSVGRenderContext::fillPaint() const {
     const SkSVGPaint::Type paintType = fPresentationContext->fInherited.fFill.get()->type();
     return paintType != SkSVGPaint::Type::kNone ? &fPresentationContext->fFillPaint : nullptr;
 }
 
 const SkPaint* SkSVGRenderContext::strokePaint() const {
     const SkSVGPaint::Type paintType = fPresentationContext->fInherited.fStroke.get()->type();
     return paintType != SkSVGPaint::Type::kNone ? &fPresentationContext->fStrokePaint : nullptr;
 }