OLD | NEW |
| (Empty) |
1 /* | |
2 Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org> | |
3 2004, 2005, 2010 Rob Buis <buis@kde.org> | |
4 Copyright (C) Research In Motion Limited 2010. All rights reserved. | |
5 | |
6 Based on khtml code by: | |
7 Copyright (C) 1999 Antti Koivisto (koivisto@kde.org) | |
8 Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org) | |
9 Copyright (C) 2002-2003 Dirk Mueller (mueller@kde.org) | |
10 Copyright (C) 2002 Apple Computer, Inc. | |
11 | |
12 This library is free software; you can redistribute it and/or | |
13 modify it under the terms of the GNU Library General Public | |
14 License as published by the Free Software Foundation; either | |
15 version 2 of the License, or (at your option) any later version. | |
16 | |
17 This library is distributed in the hope that it will be useful, | |
18 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 Library General Public License for more details. | |
21 | |
22 You should have received a copy of the GNU Library General Public License | |
23 along with this library; see the file COPYING.LIB. If not, write to | |
24 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
25 Boston, MA 02110-1301, USA. | |
26 */ | |
27 | |
28 #include "config.h" | |
29 | |
30 #include "core/layout/style/SVGLayoutStyle.h" | |
31 | |
32 namespace blink { | |
33 | |
34 SVGLayoutStyle::SVGLayoutStyle() | |
35 { | |
36 static SVGLayoutStyle* initialStyle = new SVGLayoutStyle(CreateInitial); | |
37 | |
38 fill = initialStyle->fill; | |
39 stroke = initialStyle->stroke; | |
40 stops = initialStyle->stops; | |
41 misc = initialStyle->misc; | |
42 inheritedResources = initialStyle->inheritedResources; | |
43 layout = initialStyle->layout; | |
44 resources = initialStyle->resources; | |
45 | |
46 setBitDefaults(); | |
47 } | |
48 | |
49 SVGLayoutStyle::SVGLayoutStyle(CreateInitialType) | |
50 { | |
51 setBitDefaults(); | |
52 | |
53 fill.init(); | |
54 stroke.init(); | |
55 stops.init(); | |
56 misc.init(); | |
57 inheritedResources.init(); | |
58 layout.init(); | |
59 resources.init(); | |
60 } | |
61 | |
62 SVGLayoutStyle::SVGLayoutStyle(const SVGLayoutStyle& other) | |
63 : RefCounted<SVGLayoutStyle>() | |
64 { | |
65 fill = other.fill; | |
66 stroke = other.stroke; | |
67 stops = other.stops; | |
68 misc = other.misc; | |
69 inheritedResources = other.inheritedResources; | |
70 layout = other.layout; | |
71 resources = other.resources; | |
72 | |
73 svg_inherited_flags = other.svg_inherited_flags; | |
74 svg_noninherited_flags = other.svg_noninherited_flags; | |
75 } | |
76 | |
77 SVGLayoutStyle::~SVGLayoutStyle() | |
78 { | |
79 } | |
80 | |
81 bool SVGLayoutStyle::operator==(const SVGLayoutStyle& other) const | |
82 { | |
83 return fill == other.fill | |
84 && stroke == other.stroke | |
85 && stops == other.stops | |
86 && misc == other.misc | |
87 && inheritedResources == other.inheritedResources | |
88 && layout == other.layout | |
89 && resources == other.resources | |
90 && svg_inherited_flags == other.svg_inherited_flags | |
91 && svg_noninherited_flags == other.svg_noninherited_flags; | |
92 } | |
93 | |
94 bool SVGLayoutStyle::inheritedNotEqual(const SVGLayoutStyle* other) const | |
95 { | |
96 return fill != other->fill | |
97 || stroke != other->stroke | |
98 || inheritedResources != other->inheritedResources | |
99 || svg_inherited_flags != other->svg_inherited_flags; | |
100 } | |
101 | |
102 void SVGLayoutStyle::inheritFrom(const SVGLayoutStyle* svgInheritParent) | |
103 { | |
104 if (!svgInheritParent) | |
105 return; | |
106 | |
107 fill = svgInheritParent->fill; | |
108 stroke = svgInheritParent->stroke; | |
109 inheritedResources = svgInheritParent->inheritedResources; | |
110 | |
111 svg_inherited_flags = svgInheritParent->svg_inherited_flags; | |
112 } | |
113 | |
114 void SVGLayoutStyle::copyNonInheritedFromCached(const SVGLayoutStyle* other) | |
115 { | |
116 svg_noninherited_flags = other->svg_noninherited_flags; | |
117 stops = other->stops; | |
118 misc = other->misc; | |
119 layout = other->layout; | |
120 resources = other->resources; | |
121 } | |
122 | |
123 PassRefPtr<SVGDashArray> SVGLayoutStyle::initialStrokeDashArray() | |
124 { | |
125 DEFINE_STATIC_REF(SVGDashArray, initialDashArray, SVGDashArray::create()); | |
126 return initialDashArray; | |
127 } | |
128 | |
129 StyleDifference SVGLayoutStyle::diff(const SVGLayoutStyle* other) const | |
130 { | |
131 StyleDifference styleDifference; | |
132 | |
133 if (diffNeedsLayoutAndPaintInvalidation(other)) { | |
134 styleDifference.setNeedsFullLayout(); | |
135 styleDifference.setNeedsPaintInvalidationObject(); | |
136 } else if (diffNeedsPaintInvalidation(other)) { | |
137 styleDifference.setNeedsPaintInvalidationObject(); | |
138 } | |
139 | |
140 return styleDifference; | |
141 } | |
142 | |
143 bool SVGLayoutStyle::diffNeedsLayoutAndPaintInvalidation(const SVGLayoutStyle* o
ther) const | |
144 { | |
145 // If resources change, we need a relayout, as the presence of resources inf
luences the paint invalidation rect. | |
146 if (resources != other->resources) | |
147 return true; | |
148 | |
149 // If markers change, we need a relayout, as marker boundaries are cached in
LayoutSVGPath. | |
150 if (inheritedResources != other->inheritedResources) | |
151 return true; | |
152 | |
153 // All text related properties influence layout. | |
154 if (svg_inherited_flags._textAnchor != other->svg_inherited_flags._textAncho
r | |
155 || svg_inherited_flags._writingMode != other->svg_inherited_flags._writi
ngMode | |
156 || svg_inherited_flags._glyphOrientationHorizontal != other->svg_inherit
ed_flags._glyphOrientationHorizontal | |
157 || svg_inherited_flags._glyphOrientationVertical != other->svg_inherited
_flags._glyphOrientationVertical | |
158 || svg_noninherited_flags.f._alignmentBaseline != other->svg_noninherite
d_flags.f._alignmentBaseline | |
159 || svg_noninherited_flags.f._dominantBaseline != other->svg_noninherited
_flags.f._dominantBaseline | |
160 || svg_noninherited_flags.f._baselineShift != other->svg_noninherited_fl
ags.f._baselineShift) | |
161 return true; | |
162 | |
163 // Text related properties influence layout. | |
164 if (misc->baselineShiftValue != other->misc->baselineShiftValue) | |
165 return true; | |
166 | |
167 // These properties affect the cached stroke bounding box rects. | |
168 if (svg_inherited_flags._capStyle != other->svg_inherited_flags._capStyle | |
169 || svg_inherited_flags._joinStyle != other->svg_inherited_flags._joinSty
le) | |
170 return true; | |
171 | |
172 // vector-effect changes require a re-layout. | |
173 if (svg_noninherited_flags.f._vectorEffect != other->svg_noninherited_flags.
f._vectorEffect) | |
174 return true; | |
175 | |
176 // Some stroke properties, requires relayouts, as the cached stroke boundari
es need to be recalculated. | |
177 if (stroke.get() != other->stroke.get()) { | |
178 if (stroke->width != other->stroke->width | |
179 || stroke->paintType != other->stroke->paintType | |
180 || stroke->paintColor != other->stroke->paintColor | |
181 || stroke->paintUri != other->stroke->paintUri | |
182 || stroke->miterLimit != other->stroke->miterLimit | |
183 || *stroke->dashArray != *other->stroke->dashArray | |
184 || stroke->dashOffset != other->stroke->dashOffset | |
185 || stroke->visitedLinkPaintColor != other->stroke->visitedLinkPaintC
olor | |
186 || stroke->visitedLinkPaintUri != other->stroke->visitedLinkPaintUri | |
187 || stroke->visitedLinkPaintType != other->stroke->visitedLinkPaintTy
pe) | |
188 return true; | |
189 } | |
190 | |
191 // The x, y, rx and ry properties require a re-layout. | |
192 if (layout.get() != other->layout.get()) { | |
193 if (layout->x != other->layout->x | |
194 || layout->y != other->layout->y | |
195 || layout->r != other->layout->r | |
196 || layout->rx != other->layout->rx | |
197 || layout->ry != other->layout->ry | |
198 || layout->cx != other->layout->cx | |
199 || layout->cy != other->layout->cy) | |
200 return true; | |
201 } | |
202 | |
203 return false; | |
204 } | |
205 | |
206 bool SVGLayoutStyle::diffNeedsPaintInvalidation(const SVGLayoutStyle* other) con
st | |
207 { | |
208 if (stroke->opacity != other->stroke->opacity) | |
209 return true; | |
210 | |
211 // Painting related properties only need paint invalidation. | |
212 if (misc.get() != other->misc.get()) { | |
213 if (misc->floodColor != other->misc->floodColor | |
214 || misc->floodOpacity != other->misc->floodOpacity | |
215 || misc->lightingColor != other->misc->lightingColor) | |
216 return true; | |
217 } | |
218 | |
219 // If fill changes, we just need to issue paint invalidations. Fill boundari
es are not influenced by this, only by the Path, that LayoutSVGPath contains. | |
220 if (fill.get() != other->fill.get()) { | |
221 if (fill->paintType != other->fill->paintType | |
222 || fill->paintColor != other->fill->paintColor | |
223 || fill->paintUri != other->fill->paintUri | |
224 || fill->opacity != other->fill->opacity) | |
225 return true; | |
226 } | |
227 | |
228 // If gradient stops change, we just need to issue paint invalidations. Styl
e updates are already handled through LayoutSVGGradientSTop. | |
229 if (stops != other->stops) | |
230 return true; | |
231 | |
232 // Changes of these flags only cause paint invalidations. | |
233 if (svg_inherited_flags._colorRendering != other->svg_inherited_flags._color
Rendering | |
234 || svg_inherited_flags._shapeRendering != other->svg_inherited_flags._sh
apeRendering | |
235 || svg_inherited_flags._clipRule != other->svg_inherited_flags._clipRule | |
236 || svg_inherited_flags._fillRule != other->svg_inherited_flags._fillRule | |
237 || svg_inherited_flags._colorInterpolation != other->svg_inherited_flags
._colorInterpolation | |
238 || svg_inherited_flags._colorInterpolationFilters != other->svg_inherite
d_flags._colorInterpolationFilters | |
239 || svg_inherited_flags._paintOrder != other->svg_inherited_flags._paintO
rder) | |
240 return true; | |
241 | |
242 if (svg_noninherited_flags.f.bufferedRendering != other->svg_noninherited_fl
ags.f.bufferedRendering) | |
243 return true; | |
244 | |
245 if (svg_noninherited_flags.f.maskType != other->svg_noninherited_flags.f.mas
kType) | |
246 return true; | |
247 | |
248 return false; | |
249 } | |
250 | |
251 EPaintOrderType SVGLayoutStyle::paintOrderType(unsigned index) const | |
252 { | |
253 ASSERT(index < ((1 << kPaintOrderBitwidth)-1)); | |
254 unsigned pt = (paintOrder() >> (kPaintOrderBitwidth*index)) & ((1u << kPaint
OrderBitwidth) - 1); | |
255 return (EPaintOrderType)pt; | |
256 } | |
257 | |
258 } | |
OLD | NEW |