[CSS Parser] Unprefix -webkit-writing-mode
[WebKit-https.git] / Source / WebCore / rendering / style / SVGRenderStyle.h
1 /*
2     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
3                   2004, 2005 Rob Buis <buis@kde.org>
4     Copyright (C) 2005, 2006 Apple Inc.
5     Copyright (C) Research In Motion Limited 2010. All rights reserved.
6     Copyright (C) 2014 Adobe Systems Incorporated. All rights reserved.
7
8     This library is free software; you can redistribute it and/or
9     modify it under the terms of the GNU Library General Public
10     License as published by the Free Software Foundation; either
11     version 2 of the License, or (at your option) any later version.
12
13     This library is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     Library General Public License for more details.
17
18     You should have received a copy of the GNU Library General Public License
19     along with this library; see the file COPYING.LIB.  If not, write to
20     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21     Boston, MA 02110-1301, USA.
22 */
23
24 #ifndef SVGRenderStyle_h
25 #define SVGRenderStyle_h
26
27 #include "CSSValueList.h"
28 #include "DataRef.h"
29 #include "ExceptionCodePlaceholder.h"
30 #include "GraphicsTypes.h"
31 #include "Path.h"
32 #include "RenderStyleConstants.h"
33 #include "SVGPaint.h"
34 #include "SVGRenderStyleDefs.h"
35
36 namespace WebCore {
37
38 class FloatRect;
39 class IntRect;
40 class RenderObject;
41
42 class SVGRenderStyle : public RefCounted<SVGRenderStyle> {    
43 public:
44     static Ref<SVGRenderStyle> createDefaultStyle();
45     static Ref<SVGRenderStyle> create() { return adoptRef(*new SVGRenderStyle); }
46     Ref<SVGRenderStyle> copy() const;
47     ~SVGRenderStyle();
48
49     bool inheritedNotEqual(const SVGRenderStyle*) const;
50     void inheritFrom(const SVGRenderStyle*);
51     void copyNonInheritedFrom(const SVGRenderStyle*);
52
53     StyleDifference diff(const SVGRenderStyle*) const;
54
55     bool operator==(const SVGRenderStyle&) const;
56     bool operator!=(const SVGRenderStyle& o) const { return !(*this == o); }
57
58     // Initial values for all the properties
59     static EAlignmentBaseline initialAlignmentBaseline() { return AB_AUTO; }
60     static EDominantBaseline initialDominantBaseline() { return DB_AUTO; }
61     static EBaselineShift initialBaselineShift() { return BS_BASELINE; }
62     static EVectorEffect initialVectorEffect() { return VE_NONE; }
63     static EBufferedRendering initialBufferedRendering() { return BR_AUTO; }
64     static LineCap initialCapStyle() { return ButtCap; }
65     static WindRule initialClipRule() { return RULE_NONZERO; }
66     static EColorInterpolation initialColorInterpolation() { return CI_SRGB; }
67     static EColorInterpolation initialColorInterpolationFilters() { return CI_LINEARRGB; }
68     static EColorRendering initialColorRendering() { return CR_AUTO; }
69     static WindRule initialFillRule() { return RULE_NONZERO; }
70     static LineJoin initialJoinStyle() { return MiterJoin; }
71     static EShapeRendering initialShapeRendering() { return SR_AUTO; }
72     static ETextAnchor initialTextAnchor() { return TA_START; }
73     static EGlyphOrientation initialGlyphOrientationHorizontal() { return GO_0DEG; }
74     static EGlyphOrientation initialGlyphOrientationVertical() { return GO_AUTO; }
75     static float initialFillOpacity() { return 1; }
76     static SVGPaint::SVGPaintType initialFillPaintType() { return SVGPaint::SVG_PAINTTYPE_RGBCOLOR; }
77     static Color initialFillPaintColor() { return Color::black; }
78     static String initialFillPaintUri() { return String(); }
79     static float initialStrokeOpacity() { return 1; }
80     static SVGPaint::SVGPaintType initialStrokePaintType() { return SVGPaint::SVG_PAINTTYPE_NONE; }
81     static Color initialStrokePaintColor() { return Color(); }
82     static String initialStrokePaintUri() { return String(); }
83     static Vector<SVGLength> initialStrokeDashArray() { return Vector<SVGLength>(); }
84     static float initialStrokeMiterLimit() { return 4; }
85     static float initialStopOpacity() { return 1; }
86     static Color initialStopColor() { return Color(0, 0, 0); }
87     static float initialFloodOpacity() { return 1; }
88     static Color initialFloodColor() { return Color(0, 0, 0); }
89     static Color initialLightingColor() { return Color(255, 255, 255); }
90     static ShadowData* initialShadow() { return 0; }
91     static String initialClipperResource() { return String(); }
92     static String initialMaskerResource() { return String(); }
93     static String initialMarkerStartResource() { return String(); }
94     static String initialMarkerMidResource() { return String(); }
95     static String initialMarkerEndResource() { return String(); }
96     static EMaskType initialMaskType() { return MT_LUMINANCE; }
97     static PaintOrder initialPaintOrder() { return PaintOrderNormal; }
98
99     static SVGLength initialBaselineShiftValue()
100     {
101         SVGLength length;
102         length.newValueSpecifiedUnits(LengthTypeNumber, 0);
103         return length;
104     }
105
106     static SVGLength initialKerning()
107     {
108         SVGLength length;
109         length.newValueSpecifiedUnits(LengthTypeNumber, 0);
110         return length;
111     }
112
113     // SVG CSS Property setters
114     void setAlignmentBaseline(EAlignmentBaseline val) { svg_noninherited_flags.f._alignmentBaseline = val; }
115     void setDominantBaseline(EDominantBaseline val) { svg_noninherited_flags.f._dominantBaseline = val; }
116     void setBaselineShift(EBaselineShift val) { svg_noninherited_flags.f._baselineShift = val; }
117     void setVectorEffect(EVectorEffect val) { svg_noninherited_flags.f._vectorEffect = val; }
118     void setBufferedRendering(EBufferedRendering val) { svg_noninherited_flags.f.bufferedRendering = val; }
119     void setCapStyle(LineCap val) { svg_inherited_flags._capStyle = val; }
120     void setClipRule(WindRule val) { svg_inherited_flags._clipRule = val; }
121     void setColorInterpolation(EColorInterpolation val) { svg_inherited_flags._colorInterpolation = val; }
122     void setColorInterpolationFilters(EColorInterpolation val) { svg_inherited_flags._colorInterpolationFilters = val; }
123     void setColorRendering(EColorRendering val) { svg_inherited_flags._colorRendering = val; }
124     void setFillRule(WindRule val) { svg_inherited_flags._fillRule = val; }
125     void setJoinStyle(LineJoin val) { svg_inherited_flags._joinStyle = val; }
126     void setShapeRendering(EShapeRendering val) { svg_inherited_flags._shapeRendering = val; }
127     void setTextAnchor(ETextAnchor val) { svg_inherited_flags._textAnchor = val; }
128     void setGlyphOrientationHorizontal(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationHorizontal = val; }
129     void setGlyphOrientationVertical(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationVertical = val; }
130     void setMaskType(EMaskType val) { svg_noninherited_flags.f.maskType = val; }
131     void setPaintOrder(PaintOrder val) { svg_inherited_flags.paintOrder = val; }
132     void setCx(const Length& obj)
133     {
134         if (!(layout->cx == obj))
135             layout.access()->cx = obj;
136     }
137     void setCy(const Length& obj)
138     {
139         if (!(layout->cy == obj))
140             layout.access()->cy = obj;
141     }
142     void setR(const Length& obj)
143     {
144         if (!(layout->r == obj))
145             layout.access()->r = obj;
146     }
147     void setRx(const Length& obj)
148     {
149         if (!(layout->rx == obj))
150             layout.access()->rx = obj;
151     }
152     void setRy(const Length& obj)
153     {
154         if (!(layout->ry == obj))
155             layout.access()->ry = obj;
156     }
157     void setX(const Length& obj)
158     {
159         if (!(layout->x == obj))
160             layout.access()->x = obj;
161     }
162     void setY(const Length& obj)
163     {
164         if (!(layout->y == obj))
165             layout.access()->y = obj;
166     }
167
168     void setFillOpacity(float obj)
169     {
170         if (!(fill->opacity == obj))
171             fill.access()->opacity = obj;
172     }
173
174     void setFillPaint(SVGPaint::SVGPaintType type, const Color& color, const String& uri, bool applyToRegularStyle = true, bool applyToVisitedLinkStyle = false)
175     {
176         if (applyToRegularStyle) {
177             if (!(fill->paintType == type))
178                 fill.access()->paintType = type;
179             if (!(fill->paintColor == color))
180                 fill.access()->paintColor = color;
181             if (!(fill->paintUri == uri))
182                 fill.access()->paintUri = uri;
183         }
184         if (applyToVisitedLinkStyle) {
185             if (!(fill->visitedLinkPaintType == type))
186                 fill.access()->visitedLinkPaintType = type;
187             if (!(fill->visitedLinkPaintColor == color))
188                 fill.access()->visitedLinkPaintColor = color;
189             if (!(fill->visitedLinkPaintUri == uri))
190                 fill.access()->visitedLinkPaintUri = uri;
191         }
192     }
193
194     void setStrokeOpacity(float obj)
195     {
196         if (!(stroke->opacity == obj))
197             stroke.access()->opacity = obj;
198     }
199
200     void setStrokePaint(SVGPaint::SVGPaintType type, const Color& color, const String& uri, bool applyToRegularStyle = true, bool applyToVisitedLinkStyle = false)
201     {
202         if (applyToRegularStyle) {
203             if (!(stroke->paintType == type))
204                 stroke.access()->paintType = type;
205             if (!(stroke->paintColor == color))
206                 stroke.access()->paintColor = color;
207             if (!(stroke->paintUri == uri))
208                 stroke.access()->paintUri = uri;
209         }
210         if (applyToVisitedLinkStyle) {
211             if (!(stroke->visitedLinkPaintType == type))
212                 stroke.access()->visitedLinkPaintType = type;
213             if (!(stroke->visitedLinkPaintColor == color))
214                 stroke.access()->visitedLinkPaintColor = color;
215             if (!(stroke->visitedLinkPaintUri == uri))
216                 stroke.access()->visitedLinkPaintUri = uri;
217         }
218     }
219
220     void setStrokeDashArray(const Vector<SVGLength>& obj)
221     {
222         if (!(stroke->dashArray == obj))
223             stroke.access()->dashArray = obj;
224     }
225
226     void setStrokeMiterLimit(float obj)
227     {
228         if (!(stroke->miterLimit == obj))
229             stroke.access()->miterLimit = obj;
230     }
231
232     void setStrokeWidth(const Length& obj)
233     {
234         if (!(stroke->width == obj))
235             stroke.access()->width = obj;
236     }
237
238     void setStrokeDashOffset(const Length& obj)
239     {
240         if (!(stroke->dashOffset == obj))
241             stroke.access()->dashOffset = obj;
242     }
243
244     void setKerning(const SVGLength& obj)
245     {
246         if (!(text->kerning == obj))
247             text.access()->kerning = obj;
248     }
249
250     void setStopOpacity(float obj)
251     {
252         if (!(stops->opacity == obj))
253             stops.access()->opacity = obj;
254     }
255
256     void setStopColor(const Color& obj)
257     {
258         if (!(stops->color == obj))
259             stops.access()->color = obj;
260     }
261
262     void setFloodOpacity(float obj)
263     {
264         if (!(misc->floodOpacity == obj))
265             misc.access()->floodOpacity = obj;
266     }
267
268     void setFloodColor(const Color& obj)
269     {
270         if (!(misc->floodColor == obj))
271             misc.access()->floodColor = obj;
272     }
273
274     void setLightingColor(const Color& obj)
275     {
276         if (!(misc->lightingColor == obj))
277             misc.access()->lightingColor = obj;
278     }
279
280     void setBaselineShiftValue(const SVGLength& obj)
281     {
282         if (!(misc->baselineShiftValue == obj))
283             misc.access()->baselineShiftValue = obj;
284     }
285
286     void setShadow(std::unique_ptr<ShadowData> obj) { shadowSVG.access()->shadow = WTFMove(obj); }
287
288     // Setters for non-inherited resources
289     void setClipperResource(const String& obj)
290     {
291         if (!(resources->clipper == obj))
292             resources.access()->clipper = obj;
293     }
294
295     void setMaskerResource(const String& obj)
296     {
297         if (!(resources->masker == obj))
298             resources.access()->masker = obj;
299     }
300
301     // Setters for inherited resources
302     void setMarkerStartResource(const String& obj)
303     {
304         if (!(inheritedResources->markerStart == obj))
305             inheritedResources.access()->markerStart = obj;
306     }
307
308     void setMarkerMidResource(const String& obj)
309     {
310         if (!(inheritedResources->markerMid == obj))
311             inheritedResources.access()->markerMid = obj;
312     }
313
314     void setMarkerEndResource(const String& obj)
315     {
316         if (!(inheritedResources->markerEnd == obj))
317             inheritedResources.access()->markerEnd = obj;
318     }
319
320     // Read accessors for all the properties
321     EAlignmentBaseline alignmentBaseline() const { return (EAlignmentBaseline) svg_noninherited_flags.f._alignmentBaseline; }
322     EDominantBaseline dominantBaseline() const { return (EDominantBaseline) svg_noninherited_flags.f._dominantBaseline; }
323     EBaselineShift baselineShift() const { return (EBaselineShift) svg_noninherited_flags.f._baselineShift; }
324     EVectorEffect vectorEffect() const { return (EVectorEffect) svg_noninherited_flags.f._vectorEffect; }
325     EBufferedRendering bufferedRendering() const { return (EBufferedRendering) svg_noninherited_flags.f.bufferedRendering; }
326     LineCap capStyle() const { return (LineCap) svg_inherited_flags._capStyle; }
327     WindRule clipRule() const { return (WindRule) svg_inherited_flags._clipRule; }
328     EColorInterpolation colorInterpolation() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolation; }
329     EColorInterpolation colorInterpolationFilters() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolationFilters; }
330     EColorRendering colorRendering() const { return (EColorRendering) svg_inherited_flags._colorRendering; }
331     WindRule fillRule() const { return (WindRule) svg_inherited_flags._fillRule; }
332     LineJoin joinStyle() const { return (LineJoin) svg_inherited_flags._joinStyle; }
333     EShapeRendering shapeRendering() const { return (EShapeRendering) svg_inherited_flags._shapeRendering; }
334     ETextAnchor textAnchor() const { return (ETextAnchor) svg_inherited_flags._textAnchor; }
335     EGlyphOrientation glyphOrientationHorizontal() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationHorizontal; }
336     EGlyphOrientation glyphOrientationVertical() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationVertical; }
337     float fillOpacity() const { return fill->opacity; }
338     const SVGPaint::SVGPaintType& fillPaintType() const { return fill->paintType; }
339     const Color& fillPaintColor() const { return fill->paintColor; }
340     const String& fillPaintUri() const { return fill->paintUri; }    
341     float strokeOpacity() const { return stroke->opacity; }
342     const SVGPaint::SVGPaintType& strokePaintType() const { return stroke->paintType; }
343     const Color& strokePaintColor() const { return stroke->paintColor; }
344     const String& strokePaintUri() const { return stroke->paintUri; }
345     Vector<SVGLength> strokeDashArray() const { return stroke->dashArray; }
346     float strokeMiterLimit() const { return stroke->miterLimit; }
347     const Length& strokeWidth() const { return stroke->width; }
348     const Length& strokeDashOffset() const { return stroke->dashOffset; }
349     SVGLength kerning() const { return text->kerning; }
350     float stopOpacity() const { return stops->opacity; }
351     const Color& stopColor() const { return stops->color; }
352     float floodOpacity() const { return misc->floodOpacity; }
353     const Color& floodColor() const { return misc->floodColor; }
354     const Color& lightingColor() const { return misc->lightingColor; }
355     SVGLength baselineShiftValue() const { return misc->baselineShiftValue; }
356     ShadowData* shadow() const { return shadowSVG->shadow.get(); }
357     const Length& cx() const { return layout->cx; }
358     const Length& cy() const { return layout->cy; }
359     const Length& r() const { return layout->r; }
360     const Length& rx() const { return layout->rx; }
361     const Length& ry() const { return layout->ry; }
362     const Length& x() const { return layout->x; }
363     const Length& y() const { return layout->y; }
364     String clipperResource() const { return resources->clipper; }
365     String maskerResource() const { return resources->masker; }
366     String markerStartResource() const { return inheritedResources->markerStart; }
367     String markerMidResource() const { return inheritedResources->markerMid; }
368     String markerEndResource() const { return inheritedResources->markerEnd; }
369     EMaskType maskType() const { return (EMaskType) svg_noninherited_flags.f.maskType; }
370     PaintOrder paintOrder() const { return (PaintOrder) svg_inherited_flags.paintOrder; }
371     Vector<PaintType, 3> paintTypesForPaintOrder() const;
372
373     const SVGPaint::SVGPaintType& visitedLinkFillPaintType() const { return fill->visitedLinkPaintType; }
374     const Color& visitedLinkFillPaintColor() const { return fill->visitedLinkPaintColor; }
375     const String& visitedLinkFillPaintUri() const { return fill->visitedLinkPaintUri; }
376     const SVGPaint::SVGPaintType& visitedLinkStrokePaintType() const { return stroke->visitedLinkPaintType; }
377     const Color& visitedLinkStrokePaintColor() const { return stroke->visitedLinkPaintColor; }
378     const String& visitedLinkStrokePaintUri() const { return stroke->visitedLinkPaintUri; }
379
380     // convenience
381     bool hasClipper() const { return !clipperResource().isEmpty(); }
382     bool hasMasker() const { return !maskerResource().isEmpty(); }
383     bool hasMarkers() const { return !markerStartResource().isEmpty() || !markerMidResource().isEmpty() || !markerEndResource().isEmpty(); }
384     bool hasStroke() const { return strokePaintType() != SVGPaint::SVG_PAINTTYPE_NONE; }
385     bool hasVisibleStroke() const { return hasStroke() && !strokeWidth().isZero(); }
386     bool hasFill() const { return fillPaintType() != SVGPaint::SVG_PAINTTYPE_NONE; }
387     bool isolatesBlending() const { return hasMasker() || shadow(); }
388
389 protected:
390     // inherit
391     struct InheritedFlags {
392         bool operator==(const InheritedFlags& other) const
393         {
394             return (_colorRendering == other._colorRendering)
395                 && (_shapeRendering == other._shapeRendering)
396                 && (_clipRule == other._clipRule)
397                 && (_fillRule == other._fillRule)
398                 && (_capStyle == other._capStyle)
399                 && (_joinStyle == other._joinStyle)
400                 && (_textAnchor == other._textAnchor)
401                 && (_colorInterpolation == other._colorInterpolation)
402                 && (_colorInterpolationFilters == other._colorInterpolationFilters)
403                 && (_glyphOrientationHorizontal == other._glyphOrientationHorizontal)
404                 && (_glyphOrientationVertical == other._glyphOrientationVertical)
405                 && (paintOrder == other.paintOrder);
406         }
407
408         bool operator!=(const InheritedFlags& other) const
409         {
410             return !(*this == other);
411         }
412
413         unsigned _colorRendering : 2; // EColorRendering
414         unsigned _shapeRendering : 2; // EShapeRendering 
415         unsigned _clipRule : 1; // WindRule
416         unsigned _fillRule : 1; // WindRule
417         unsigned _capStyle : 2; // LineCap
418         unsigned _joinStyle : 2; // LineJoin
419         unsigned _textAnchor : 2; // ETextAnchor
420         unsigned _colorInterpolation : 2; // EColorInterpolation
421         unsigned _colorInterpolationFilters : 2; // EColorInterpolation
422         unsigned _glyphOrientationHorizontal : 3; // EGlyphOrientation
423         unsigned _glyphOrientationVertical : 3; // EGlyphOrientation
424         unsigned paintOrder : 3; // PaintOrder
425     } svg_inherited_flags;
426
427     // don't inherit
428     struct NonInheritedFlags {
429         // 32 bit non-inherited, don't add to the struct, or the operator will break.
430         bool operator==(const NonInheritedFlags &other) const { return _niflags == other._niflags; }
431         bool operator!=(const NonInheritedFlags &other) const { return _niflags != other._niflags; }
432
433         union {
434             struct {
435                 unsigned _alignmentBaseline : 4; // EAlignmentBaseline 
436                 unsigned _dominantBaseline : 4; // EDominantBaseline
437                 unsigned _baselineShift : 2; // EBaselineShift
438                 unsigned _vectorEffect: 1; // EVectorEffect
439                 unsigned bufferedRendering: 2; // EBufferedRendering
440                 unsigned maskType: 1; // EMaskType
441                 // 18 bits unused
442             } f;
443             uint32_t _niflags;
444         };
445     } svg_noninherited_flags;
446
447     // inherited attributes
448     DataRef<StyleFillData> fill;
449     DataRef<StyleStrokeData> stroke;
450     DataRef<StyleTextData> text;
451     DataRef<StyleInheritedResourceData> inheritedResources;
452
453     // non-inherited attributes
454     DataRef<StyleStopData> stops;
455     DataRef<StyleMiscData> misc;
456     DataRef<StyleShadowSVGData> shadowSVG;
457     DataRef<StyleLayoutData> layout;
458     DataRef<StyleResourceData> resources;
459
460 private:
461     enum CreateDefaultType { CreateDefault };
462         
463     SVGRenderStyle();
464     SVGRenderStyle(const SVGRenderStyle&);
465     SVGRenderStyle(CreateDefaultType); // Used to create the default style.
466
467     void setBitDefaults()
468     {
469         svg_inherited_flags._clipRule = initialClipRule();
470         svg_inherited_flags._colorRendering = initialColorRendering();
471         svg_inherited_flags._fillRule = initialFillRule();
472         svg_inherited_flags._shapeRendering = initialShapeRendering();
473         svg_inherited_flags._textAnchor = initialTextAnchor();
474         svg_inherited_flags._capStyle = initialCapStyle();
475         svg_inherited_flags._joinStyle = initialJoinStyle();
476         svg_inherited_flags._colorInterpolation = initialColorInterpolation();
477         svg_inherited_flags._colorInterpolationFilters = initialColorInterpolationFilters();
478         svg_inherited_flags._glyphOrientationHorizontal = initialGlyphOrientationHorizontal();
479         svg_inherited_flags._glyphOrientationVertical = initialGlyphOrientationVertical();
480         svg_inherited_flags.paintOrder = initialPaintOrder();
481
482         svg_noninherited_flags._niflags = 0;
483         svg_noninherited_flags.f._alignmentBaseline = initialAlignmentBaseline();
484         svg_noninherited_flags.f._dominantBaseline = initialDominantBaseline();
485         svg_noninherited_flags.f._baselineShift = initialBaselineShift();
486         svg_noninherited_flags.f._vectorEffect = initialVectorEffect();
487         svg_noninherited_flags.f.bufferedRendering = initialBufferedRendering();
488         svg_noninherited_flags.f.maskType = initialMaskType();
489     }
490 };
491
492 } // namespace WebCore
493
494 #endif // SVGRenderStyle_h