OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> | 2 * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> |
3 * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org> | 3 * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org> |
4 * Copyright (C) Research In Motion Limited 2010. All rights reserved. | 4 * Copyright (C) Research In Motion Limited 2010. All rights reserved. |
5 * | 5 * |
6 * This library is free software; you can redistribute it and/or | 6 * This library is free software; you can redistribute it and/or |
7 * modify it under the terms of the GNU Library General Public | 7 * modify it under the terms of the GNU Library General Public |
8 * License as published by the Free Software Foundation; either | 8 * License as published by the Free Software Foundation; either |
9 * version 2 of the License, or (at your option) any later version. | 9 * version 2 of the License, or (at your option) any later version. |
10 * | 10 * |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
110 return point.release(); | 110 return point.release(); |
111 } | 111 } |
112 | 112 |
113 float SVGAngle::value() const | 113 float SVGAngle::value() const |
114 { | 114 { |
115 switch (m_unitType) { | 115 switch (m_unitType) { |
116 case SVG_ANGLETYPE_GRAD: | 116 case SVG_ANGLETYPE_GRAD: |
117 return grad2deg(m_valueInSpecifiedUnits); | 117 return grad2deg(m_valueInSpecifiedUnits); |
118 case SVG_ANGLETYPE_RAD: | 118 case SVG_ANGLETYPE_RAD: |
119 return rad2deg(m_valueInSpecifiedUnits); | 119 return rad2deg(m_valueInSpecifiedUnits); |
120 case SVG_ANGLETYPE_TURN: | |
121 return turn2deg(m_valueInSpecifiedUnits); | |
120 case SVG_ANGLETYPE_UNSPECIFIED: | 122 case SVG_ANGLETYPE_UNSPECIFIED: |
121 case SVG_ANGLETYPE_UNKNOWN: | 123 case SVG_ANGLETYPE_UNKNOWN: |
122 case SVG_ANGLETYPE_DEG: | 124 case SVG_ANGLETYPE_DEG: |
123 return m_valueInSpecifiedUnits; | 125 return m_valueInSpecifiedUnits; |
124 } | 126 } |
125 | 127 |
126 ASSERT_NOT_REACHED(); | 128 ASSERT_NOT_REACHED(); |
127 return 0; | 129 return 0; |
128 } | 130 } |
129 | 131 |
130 void SVGAngle::setValue(float value) | 132 void SVGAngle::setValue(float value) |
131 { | 133 { |
132 switch (m_unitType) { | 134 switch (m_unitType) { |
133 case SVG_ANGLETYPE_GRAD: | 135 case SVG_ANGLETYPE_GRAD: |
134 m_valueInSpecifiedUnits = deg2grad(value); | 136 m_valueInSpecifiedUnits = deg2grad(value); |
135 break; | 137 break; |
136 case SVG_ANGLETYPE_RAD: | 138 case SVG_ANGLETYPE_RAD: |
137 m_valueInSpecifiedUnits = deg2rad(value); | 139 m_valueInSpecifiedUnits = deg2rad(value); |
138 break; | 140 break; |
141 case SVG_ANGLETYPE_TURN: | |
142 m_valueInSpecifiedUnits = deg2turn(value); | |
143 break; | |
139 case SVG_ANGLETYPE_UNSPECIFIED: | 144 case SVG_ANGLETYPE_UNSPECIFIED: |
140 case SVG_ANGLETYPE_UNKNOWN: | 145 case SVG_ANGLETYPE_UNKNOWN: |
141 case SVG_ANGLETYPE_DEG: | 146 case SVG_ANGLETYPE_DEG: |
142 m_valueInSpecifiedUnits = value; | 147 m_valueInSpecifiedUnits = value; |
143 break; | 148 break; |
144 } | 149 } |
145 m_orientType->setEnumValue(SVGMarkerOrientAngle); | 150 m_orientType->setEnumValue(SVGMarkerOrientAngle); |
146 } | 151 } |
147 | 152 |
148 template<typename CharType> | 153 template<typename CharType> |
(...skipping 25 matching lines...) Expand all Loading... | |
174 | 179 |
175 // If the unit contains three characters, but is not deg or rad, then it's u nknown. | 180 // If the unit contains three characters, but is not deg or rad, then it's u nknown. |
176 ++ptr; | 181 ++ptr; |
177 if (ptr == end) | 182 if (ptr == end) |
178 return SVGAngle::SVG_ANGLETYPE_UNKNOWN; | 183 return SVGAngle::SVG_ANGLETYPE_UNKNOWN; |
179 | 184 |
180 const CharType fourthChar = *ptr; | 185 const CharType fourthChar = *ptr; |
181 | 186 |
182 if (firstChar == 'g' && secondChar == 'r' && thirdChar == 'a' && fourthChar == 'd') | 187 if (firstChar == 'g' && secondChar == 'r' && thirdChar == 'a' && fourthChar == 'd') |
183 return SVGAngle::SVG_ANGLETYPE_GRAD; | 188 return SVGAngle::SVG_ANGLETYPE_GRAD; |
189 if (firstChar == 't' && secondChar == 'u' && thirdChar == 'r' && fourthChar == 'n') | |
190 return SVGAngle::SVG_ANGLETYPE_TURN; | |
184 | 191 |
185 return SVGAngle::SVG_ANGLETYPE_UNKNOWN; | 192 return SVGAngle::SVG_ANGLETYPE_UNKNOWN; |
186 } | 193 } |
187 | 194 |
188 String SVGAngle::valueAsString() const | 195 String SVGAngle::valueAsString() const |
189 { | 196 { |
190 switch (m_unitType) { | 197 switch (m_unitType) { |
191 case SVG_ANGLETYPE_DEG: { | 198 case SVG_ANGLETYPE_DEG: { |
192 DEFINE_STATIC_LOCAL(String, degString, ("deg")); | 199 DEFINE_STATIC_LOCAL(String, degString, ("deg")); |
193 return String::number(m_valueInSpecifiedUnits) + degString; | 200 return String::number(m_valueInSpecifiedUnits) + degString; |
194 } | 201 } |
195 case SVG_ANGLETYPE_RAD: { | 202 case SVG_ANGLETYPE_RAD: { |
196 DEFINE_STATIC_LOCAL(String, radString, ("rad")); | 203 DEFINE_STATIC_LOCAL(String, radString, ("rad")); |
197 return String::number(m_valueInSpecifiedUnits) + radString; | 204 return String::number(m_valueInSpecifiedUnits) + radString; |
198 } | 205 } |
199 case SVG_ANGLETYPE_GRAD: { | 206 case SVG_ANGLETYPE_GRAD: { |
200 DEFINE_STATIC_LOCAL(String, gradString, ("grad")); | 207 DEFINE_STATIC_LOCAL(String, gradString, ("grad")); |
201 return String::number(m_valueInSpecifiedUnits) + gradString; | 208 return String::number(m_valueInSpecifiedUnits) + gradString; |
202 } | 209 } |
210 case SVG_ANGLETYPE_TURN: { | |
211 DEFINE_STATIC_LOCAL(String, turnString, ("turn")); | |
212 return String::number(m_valueInSpecifiedUnits) + turnString; | |
213 } | |
203 case SVG_ANGLETYPE_UNSPECIFIED: | 214 case SVG_ANGLETYPE_UNSPECIFIED: |
204 case SVG_ANGLETYPE_UNKNOWN: | 215 case SVG_ANGLETYPE_UNKNOWN: |
205 return String::number(m_valueInSpecifiedUnits); | 216 return String::number(m_valueInSpecifiedUnits); |
206 } | 217 } |
207 | 218 |
208 ASSERT_NOT_REACHED(); | 219 ASSERT_NOT_REACHED(); |
209 return String(); | 220 return String(); |
210 } | 221 } |
211 | 222 |
212 template<typename CharType> | 223 template<typename CharType> |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
264 { | 275 { |
265 if (m_unitType == SVG_ANGLETYPE_UNKNOWN) { | 276 if (m_unitType == SVG_ANGLETYPE_UNKNOWN) { |
266 exceptionState.throwDOMException(NotSupportedError, "Cannot convert from unknown or invalid units."); | 277 exceptionState.throwDOMException(NotSupportedError, "Cannot convert from unknown or invalid units."); |
267 return; | 278 return; |
268 } | 279 } |
269 | 280 |
270 if (unitType == m_unitType) | 281 if (unitType == m_unitType) |
271 return; | 282 return; |
272 | 283 |
273 switch (m_unitType) { | 284 switch (m_unitType) { |
285 case SVG_ANGLETYPE_TURN: | |
286 switch (unitType) { | |
287 case SVG_ANGLETYPE_GRAD: | |
288 m_valueInSpecifiedUnits = turn2grad(m_valueInSpecifiedUnits); | |
289 break; | |
290 case SVG_ANGLETYPE_UNSPECIFIED: | |
291 case SVG_ANGLETYPE_DEG: | |
292 m_valueInSpecifiedUnits = turn2deg(m_valueInSpecifiedUnits); | |
293 break; | |
294 case SVG_ANGLETYPE_RAD: | |
295 m_valueInSpecifiedUnits = deg2rad(turn2deg(m_valueInSpecifiedUnits)) ; | |
296 break; | |
297 case SVG_ANGLETYPE_TURN: | |
298 break; | |
299 case SVG_ANGLETYPE_UNKNOWN: | |
300 ASSERT_NOT_REACHED(); | |
301 break; | |
302 } | |
303 break; | |
274 case SVG_ANGLETYPE_RAD: | 304 case SVG_ANGLETYPE_RAD: |
275 switch (unitType) { | 305 switch (unitType) { |
276 case SVG_ANGLETYPE_GRAD: | 306 case SVG_ANGLETYPE_GRAD: |
277 m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits); | 307 m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits); |
278 break; | 308 break; |
279 case SVG_ANGLETYPE_UNSPECIFIED: | 309 case SVG_ANGLETYPE_UNSPECIFIED: |
280 case SVG_ANGLETYPE_DEG: | 310 case SVG_ANGLETYPE_DEG: |
281 m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits); | 311 m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits); |
282 break; | 312 break; |
313 case SVG_ANGLETYPE_TURN: | |
314 m_valueInSpecifiedUnits = deg2turn(rad2deg(m_valueInSpecifiedUnits)) ; | |
315 break; | |
283 case SVG_ANGLETYPE_RAD: | 316 case SVG_ANGLETYPE_RAD: |
317 break; | |
284 case SVG_ANGLETYPE_UNKNOWN: | 318 case SVG_ANGLETYPE_UNKNOWN: |
285 ASSERT_NOT_REACHED(); | 319 ASSERT_NOT_REACHED(); |
286 break; | 320 break; |
287 } | 321 } |
288 break; | 322 break; |
289 case SVG_ANGLETYPE_GRAD: | 323 case SVG_ANGLETYPE_GRAD: |
290 switch (unitType) { | 324 switch (unitType) { |
291 case SVG_ANGLETYPE_RAD: | 325 case SVG_ANGLETYPE_RAD: |
292 m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits); | 326 m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits); |
293 break; | 327 break; |
294 case SVG_ANGLETYPE_UNSPECIFIED: | 328 case SVG_ANGLETYPE_UNSPECIFIED: |
295 case SVG_ANGLETYPE_DEG: | 329 case SVG_ANGLETYPE_DEG: |
296 m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits); | 330 m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits); |
297 break; | 331 break; |
332 case SVG_ANGLETYPE_TURN: | |
333 m_valueInSpecifiedUnits = grad2turn(m_valueInSpecifiedUnits); | |
334 break; | |
298 case SVG_ANGLETYPE_GRAD: | 335 case SVG_ANGLETYPE_GRAD: |
336 break; | |
299 case SVG_ANGLETYPE_UNKNOWN: | 337 case SVG_ANGLETYPE_UNKNOWN: |
300 ASSERT_NOT_REACHED(); | 338 ASSERT_NOT_REACHED(); |
301 break; | 339 break; |
302 } | 340 } |
303 break; | 341 break; |
304 case SVG_ANGLETYPE_UNSPECIFIED: | 342 case SVG_ANGLETYPE_UNSPECIFIED: |
305 // Spec: For angles, a unitless value is treated the same as if degrees were specified. | 343 // Spec: For angles, a unitless value is treated the same as if degrees were specified. |
306 case SVG_ANGLETYPE_DEG: | 344 case SVG_ANGLETYPE_DEG: |
307 switch (unitType) { | 345 switch (unitType) { |
308 case SVG_ANGLETYPE_RAD: | 346 case SVG_ANGLETYPE_RAD: |
309 m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits); | 347 m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits); |
310 break; | 348 break; |
311 case SVG_ANGLETYPE_GRAD: | 349 case SVG_ANGLETYPE_GRAD: |
312 m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits); | 350 m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits); |
313 break; | 351 break; |
352 case SVG_ANGLETYPE_TURN: | |
353 m_valueInSpecifiedUnits = deg2turn(m_valueInSpecifiedUnits); | |
354 break; | |
314 case SVG_ANGLETYPE_UNSPECIFIED: | 355 case SVG_ANGLETYPE_UNSPECIFIED: |
315 break; | 356 break; |
316 case SVG_ANGLETYPE_DEG: | 357 case SVG_ANGLETYPE_DEG: |
358 break; | |
fs
2014/06/03 15:52:48
Nit: This should still be unreachable (due to the
Erik Dahlström (inactive)
2014/06/04 09:28:21
The other cases I agree with, but for this one (du
fs
2014/06/04 11:21:14
Ah, yes, this particular spot had a higher-level f
| |
317 case SVG_ANGLETYPE_UNKNOWN: | 359 case SVG_ANGLETYPE_UNKNOWN: |
318 ASSERT_NOT_REACHED(); | 360 ASSERT_NOT_REACHED(); |
319 break; | 361 break; |
320 } | 362 } |
321 break; | 363 break; |
322 case SVG_ANGLETYPE_UNKNOWN: | 364 case SVG_ANGLETYPE_UNKNOWN: |
323 ASSERT_NOT_REACHED(); | 365 ASSERT_NOT_REACHED(); |
324 break; | 366 break; |
325 } | 367 } |
326 | 368 |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
397 | 439 |
398 void SVGAngle::orientTypeChanged() | 440 void SVGAngle::orientTypeChanged() |
399 { | 441 { |
400 if (orientType()->enumValue() == SVGMarkerOrientAuto) { | 442 if (orientType()->enumValue() == SVGMarkerOrientAuto) { |
401 m_unitType = SVG_ANGLETYPE_UNSPECIFIED; | 443 m_unitType = SVG_ANGLETYPE_UNSPECIFIED; |
402 m_valueInSpecifiedUnits = 0; | 444 m_valueInSpecifiedUnits = 0; |
403 } | 445 } |
404 } | 446 } |
405 | 447 |
406 } | 448 } |
OLD | NEW |