Apply SVG styles paint-order, stroke-linejoin, and stroke-linecap on DOM text

third_party/WebKit/Source/core/style/SVGComputedStyle.h

 /*
     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005 Rob Buis <buis@kde.org>
     Copyright (C) 2005, 2006 Apple Computer, Inc.
     Copyright (C) Research In Motion Limited 2010. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 47 matching lines @@
   bool operator==(const SVGComputedStyle&) const;
   bool operator!=(const SVGComputedStyle& o) const { return !(*this == o); }
 
   // Initial values for all the properties
   static EAlignmentBaseline initialAlignmentBaseline() { return AB_AUTO; }
   static EDominantBaseline initialDominantBaseline() { return DB_AUTO; }
   static EBaselineShift initialBaselineShift() { return BS_LENGTH; }
   static Length initialBaselineShiftValue() { return Length(Fixed); }
   static EVectorEffect initialVectorEffect() { return VE_NONE; }
   static EBufferedRendering initialBufferedRendering() { return BR_AUTO; }
-  static LineCap initialCapStyle() { return ButtCap; }
   static WindRule initialClipRule() { return RULE_NONZERO; }
   static EColorInterpolation initialColorInterpolation() { return CI_SRGB; }
   static EColorInterpolation initialColorInterpolationFilters() {
     return CI_LINEARRGB;
   }
   static EColorRendering initialColorRendering() { return CR_AUTO; }
   static WindRule initialFillRule() { return RULE_NONZERO; }
-  static LineJoin initialJoinStyle() { return MiterJoin; }
   static EShapeRendering initialShapeRendering() { return SR_AUTO; }
   static ETextAnchor initialTextAnchor() { return TA_START; }
   static float initialFillOpacity() { return 1; }
   static SVGPaintType initialFillPaintType() { return SVG_PAINTTYPE_RGBCOLOR; }
   static Color initialFillPaintColor() { return Color::black; }
   static String initialFillPaintUri() { return String(); }
   static float initialStrokeOpacity() { return 1; }
   static SVGPaintType initialStrokePaintType() { return SVG_PAINTTYPE_NONE; }
   static Color initialStrokePaintColor() { return Color(); }
   static String initialStrokePaintUri() { return String(); }
   static PassRefPtr<SVGDashArray> initialStrokeDashArray();
   static Length initialStrokeDashOffset() { return Length(Fixed); }
   static float initialStrokeMiterLimit() { return 4; }
-  static UnzoomedLength initialStrokeWidth() {
-    return UnzoomedLength(Length(1, Fixed));
-  }
   static float initialStopOpacity() { return 1; }
   static Color initialStopColor() { return Color(0, 0, 0); }
   static float initialFloodOpacity() { return 1; }
   static Color initialFloodColor() { return Color(0, 0, 0); }
   static Color initialLightingColor() { return Color(255, 255, 255); }
   static const AtomicString& initialMaskerResource() { return nullAtom; }
   static const AtomicString& initialMarkerStartResource() { return nullAtom; }
   static const AtomicString& initialMarkerMidResource() { return nullAtom; }
   static const AtomicString& initialMarkerEndResource() { return nullAtom; }
   static EMaskType initialMaskType() { return MT_LUMINANCE; }
-  static EPaintOrder initialPaintOrder() { return PaintOrderNormal; }
   static StylePath* initialD() { return nullptr; }
   static Length initialCx() { return Length(Fixed); }
   static Length initialCy() { return Length(Fixed); }
   static Length initialX() { return Length(Fixed); }
   static Length initialY() { return Length(Fixed); }
   static Length initialR() { return Length(Fixed); }
   static Length initialRx() { return Length(Auto); }
   static Length initialRy() { return Length(Auto); }
 
   // SVG CSS Property setters
   void setAlignmentBaseline(EAlignmentBaseline val) {
     svg_noninherited_flags.f.alignmentBaseline = val;
   }
   void setDominantBaseline(EDominantBaseline val) {
     svg_inherited_flags.dominantBaseline = val;
   }
   void setBaselineShift(EBaselineShift val) {
     svg_noninherited_flags.f.baselineShift = val;
   }
   void setVectorEffect(EVectorEffect val) {
     svg_noninherited_flags.f.vectorEffect = val;
   }
   void setBufferedRendering(EBufferedRendering val) {
     svg_noninherited_flags.f.bufferedRendering = val;
   }
-  void setCapStyle(LineCap val) { svg_inherited_flags.capStyle = val; }
   void setClipRule(WindRule val) { svg_inherited_flags.clipRule = val; }
   void setColorInterpolation(EColorInterpolation val) {
     svg_inherited_flags.colorInterpolation = val;
   }
   void setColorInterpolationFilters(EColorInterpolation val) {
     svg_inherited_flags.colorInterpolationFilters = val;
   }
   void setColorRendering(EColorRendering val) {
     svg_inherited_flags.colorRendering = val;
   }
   void setFillRule(WindRule val) { svg_inherited_flags.fillRule = val; }
-  void setJoinStyle(LineJoin val) { svg_inherited_flags.joinStyle = val; }
   void setShapeRendering(EShapeRendering val) {
     svg_inherited_flags.shapeRendering = val;
   }
   void setTextAnchor(ETextAnchor val) { svg_inherited_flags.textAnchor = val; }
   void setMaskType(EMaskType val) { svg_noninherited_flags.f.maskType = val; }
-  void setPaintOrder(EPaintOrder val) {
-    svg_inherited_flags.paintOrder = (int)val;
-  }
   void setD(PassRefPtr<StylePath> d) {
     if (!(geometry->d == d))
       geometry.access()->d = d;
   }
   void setCx(const Length& obj) {
     if (!(geometry->cx == obj))
       geometry.access()->cx = obj;
   }
   void setCy(const Length& obj) {
     if (!(geometry->cy == obj))
@@ skipping 78 matching lines @@
   void setStrokeDashArray(PassRefPtr<SVGDashArray> dashArray) {
     if (*stroke->dashArray != *dashArray)
       stroke.access()->dashArray = dashArray;
   }
 
   void setStrokeMiterLimit(float obj) {
     if (!(stroke->miterLimit == obj))
       stroke.access()->miterLimit = obj;
   }
 
-  void setStrokeWidth(const UnzoomedLength& strokeWidth) {
-    if (!(stroke->width == strokeWidth))
-      stroke.access()->width = strokeWidth;
-  }
-
   void setStrokeDashOffset(const Length& dashOffset) {
     if (!(stroke->dashOffset == dashOffset))
       stroke.access()->dashOffset = dashOffset;
   }
 
   void setStopOpacity(float obj) {
     if (!(stops->opacity == obj))
       stops.access()->opacity = obj;
   }
 
@@ skipping 53 matching lines @@
   }
   EBaselineShift baselineShift() const {
     return (EBaselineShift)svg_noninherited_flags.f.baselineShift;
   }
   EVectorEffect vectorEffect() const {
     return (EVectorEffect)svg_noninherited_flags.f.vectorEffect;
   }
   EBufferedRendering bufferedRendering() const {
     return (EBufferedRendering)svg_noninherited_flags.f.bufferedRendering;
   }
-  LineCap capStyle() const { return (LineCap)svg_inherited_flags.capStyle; }
   WindRule clipRule() const { return (WindRule)svg_inherited_flags.clipRule; }
   EColorInterpolation colorInterpolation() const {
     return (EColorInterpolation)svg_inherited_flags.colorInterpolation;
   }
   EColorInterpolation colorInterpolationFilters() const {
     return (EColorInterpolation)svg_inherited_flags.colorInterpolationFilters;
   }
   EColorRendering colorRendering() const {
     return (EColorRendering)svg_inherited_flags.colorRendering;
   }
   WindRule fillRule() const { return (WindRule)svg_inherited_flags.fillRule; }
-  LineJoin joinStyle() const { return (LineJoin)svg_inherited_flags.joinStyle; }
   EShapeRendering shapeRendering() const {
     return (EShapeRendering)svg_inherited_flags.shapeRendering;
   }
   ETextAnchor textAnchor() const {
     return (ETextAnchor)svg_inherited_flags.textAnchor;
   }
   float fillOpacity() const { return fill->opacity; }
   const SVGPaintType& fillPaintType() const { return fill->paintType; }
   const Color& fillPaintColor() const { return fill->paintColor; }
   const String& fillPaintUri() const { return fill->paintUri; }
   float strokeOpacity() const { return stroke->opacity; }
   const SVGPaintType& strokePaintType() const { return stroke->paintType; }
   const Color& strokePaintColor() const { return stroke->paintColor; }
   const String& strokePaintUri() const { return stroke->paintUri; }
   SVGDashArray* strokeDashArray() const { return stroke->dashArray.get(); }
   float strokeMiterLimit() const { return stroke->miterLimit; }
-  const UnzoomedLength& strokeWidth() const { return stroke->width; }
   const Length& strokeDashOffset() const { return stroke->dashOffset; }
   float stopOpacity() const { return stops->opacity; }
   const Color& stopColor() const { return stops->color; }
   float floodOpacity() const { return misc->floodOpacity; }
   const Color& floodColor() const { return misc->floodColor; }
   const Color& lightingColor() const { return misc->lightingColor; }
   const Length& baselineShiftValue() const { return misc->baselineShiftValue; }
   StylePath* d() const { return geometry->d.get(); }
   const Length& cx() const { return geometry->cx; }
   const Length& cy() const { return geometry->cy; }
   const Length& x() const { return geometry->x; }
   const Length& y() const { return geometry->y; }
   const Length& r() const { return geometry->r; }
   const Length& rx() const { return geometry->rx; }
   const Length& ry() const { return geometry->ry; }
   const AtomicString& maskerResource() const { return resources->masker; }
   const AtomicString& markerStartResource() const {
     return inheritedResources->markerStart;
   }
   const AtomicString& markerMidResource() const {
     return inheritedResources->markerMid;
   }
   const AtomicString& markerEndResource() const {
     return inheritedResources->markerEnd;
   }
   EMaskType maskType() const {
     return (EMaskType)svg_noninherited_flags.f.maskType;
   }
-  EPaintOrder paintOrder() const {
-    return (EPaintOrder)svg_inherited_flags.paintOrder;
-  }
-  EPaintOrderType paintOrderType(unsigned index) const;
-
   const SVGPaintType& visitedLinkFillPaintType() const {
     return fill->visitedLinkPaintType;
   }
   const Color& visitedLinkFillPaintColor() const {
     return fill->visitedLinkPaintColor;
   }
   const String& visitedLinkFillPaintUri() const {
     return fill->visitedLinkPaintUri;
   }
   const SVGPaintType& visitedLinkStrokePaintType() const {
@@ skipping 20 matching lines @@
            visitedLinkStrokePaintType() == SVG_PAINTTYPE_URI_CURRENTCOLOR;
   }
 
   // convenience
   bool hasMasker() const { return !maskerResource().isEmpty(); }
   bool hasMarkers() const {
     return !markerStartResource().isEmpty() || !markerMidResource().isEmpty() ||
            !markerEndResource().isEmpty();
   }
   bool hasStroke() const { return strokePaintType() != SVG_PAINTTYPE_NONE; }
-  bool hasVisibleStroke() const {
-    return hasStroke() && !strokeWidth().isZero();
-  }
-  bool hasSquareCapStyle() const { return capStyle() == SquareCap; }
-  bool hasMiterJoinStyle() const { return joinStyle() == MiterJoin; }
   bool hasFill() const { return fillPaintType() != SVG_PAINTTYPE_NONE; }
 
  protected:
   // inherit
   struct InheritedFlags {
     bool operator==(const InheritedFlags& other) const {
       return (colorRendering == other.colorRendering) &&
              (shapeRendering == other.shapeRendering) &&
              (clipRule == other.clipRule) && (fillRule == other.fillRule) &&
-             (capStyle == other.capStyle) && (joinStyle == other.joinStyle) &&
              (textAnchor == other.textAnchor) &&
              (colorInterpolation == other.colorInterpolation) &&
              (colorInterpolationFilters == other.colorInterpolationFilters) &&
-             (paintOrder == other.paintOrder) &&
              (dominantBaseline == other.dominantBaseline);
     }
 
     bool operator!=(const InheritedFlags& other) const {
       return !(*this == other);
     }
 
     unsigned colorRendering : 2;             // EColorRendering
     unsigned shapeRendering : 2;             // EShapeRendering
     unsigned clipRule : 1;                   // WindRule
     unsigned fillRule : 1;                   // WindRule
-    unsigned capStyle : 2;                   // LineCap
-    unsigned joinStyle : 2;                  // LineJoin
     unsigned textAnchor : 2;                 // ETextAnchor
     unsigned colorInterpolation : 2;         // EColorInterpolation
     unsigned colorInterpolationFilters : 2;  // EColorInterpolation_
-    unsigned paintOrder : 3;                 // EPaintOrder
     unsigned dominantBaseline : 4;           // EDominantBaseline
   } svg_inherited_flags;
 
   // don't inherit
   struct NonInheritedFlags {
     // 32 bit non-inherited, don't add to the struct, or the operator will
     // break.
     bool operator==(const NonInheritedFlags& other) const {
       return niflags == other.niflags;
     }
@@ skipping 35 matching lines @@
 
   bool diffNeedsLayoutAndPaintInvalidation(const SVGComputedStyle* other) const;
   bool diffNeedsPaintInvalidation(const SVGComputedStyle* other) const;
 
   void setBitDefaults() {
     svg_inherited_flags.clipRule = initialClipRule();
     svg_inherited_flags.colorRendering = initialColorRendering();
     svg_inherited_flags.fillRule = initialFillRule();
     svg_inherited_flags.shapeRendering = initialShapeRendering();
     svg_inherited_flags.textAnchor = initialTextAnchor();
-    svg_inherited_flags.capStyle = initialCapStyle();
-    svg_inherited_flags.joinStyle = initialJoinStyle();
     svg_inherited_flags.colorInterpolation = initialColorInterpolation();
     svg_inherited_flags.colorInterpolationFilters =
         initialColorInterpolationFilters();
-    svg_inherited_flags.paintOrder = initialPaintOrder();
     svg_inherited_flags.dominantBaseline = initialDominantBaseline();
 
     svg_noninherited_flags.niflags = 0;
     svg_noninherited_flags.f.alignmentBaseline = initialAlignmentBaseline();
     svg_noninherited_flags.f.baselineShift = initialBaselineShift();
     svg_noninherited_flags.f.vectorEffect = initialVectorEffect();
     svg_noninherited_flags.f.bufferedRendering = initialBufferedRendering();
     svg_noninherited_flags.f.maskType = initialMaskType();
   }
 };
 
 }  // namespace blink
 
 #endif  // SVGComputedStyle_h