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 = deg2grad(turn2deg(m_valueInSpecifiedUnits) ); | |
pdr.
2014/06/02 13:56:49
Is this just m_valueInSpecifiedUnits * 400? Could
Erik Dahlström (inactive)
2014/06/03 15:30:29
Done.
| |
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 case SVG_ANGLETYPE_UNKNOWN: | |
299 ASSERT_NOT_REACHED(); | |
300 break; | |
301 } | |
302 break; | |
274 case SVG_ANGLETYPE_RAD: | 303 case SVG_ANGLETYPE_RAD: |
275 switch (unitType) { | 304 switch (unitType) { |
276 case SVG_ANGLETYPE_GRAD: | 305 case SVG_ANGLETYPE_GRAD: |
277 m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits); | 306 m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits); |
278 break; | 307 break; |
279 case SVG_ANGLETYPE_UNSPECIFIED: | 308 case SVG_ANGLETYPE_UNSPECIFIED: |
280 case SVG_ANGLETYPE_DEG: | 309 case SVG_ANGLETYPE_DEG: |
281 m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits); | 310 m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits); |
282 break; | 311 break; |
312 case SVG_ANGLETYPE_TURN: | |
313 m_valueInSpecifiedUnits = deg2turn(rad2deg(m_valueInSpecifiedUnits)) ; | |
314 break; | |
283 case SVG_ANGLETYPE_RAD: | 315 case SVG_ANGLETYPE_RAD: |
284 case SVG_ANGLETYPE_UNKNOWN: | 316 case SVG_ANGLETYPE_UNKNOWN: |
285 ASSERT_NOT_REACHED(); | 317 ASSERT_NOT_REACHED(); |
286 break; | 318 break; |
287 } | 319 } |
288 break; | 320 break; |
289 case SVG_ANGLETYPE_GRAD: | 321 case SVG_ANGLETYPE_GRAD: |
290 switch (unitType) { | 322 switch (unitType) { |
291 case SVG_ANGLETYPE_RAD: | 323 case SVG_ANGLETYPE_RAD: |
292 m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits); | 324 m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits); |
293 break; | 325 break; |
294 case SVG_ANGLETYPE_UNSPECIFIED: | 326 case SVG_ANGLETYPE_UNSPECIFIED: |
295 case SVG_ANGLETYPE_DEG: | 327 case SVG_ANGLETYPE_DEG: |
296 m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits); | 328 m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits); |
297 break; | 329 break; |
330 case SVG_ANGLETYPE_TURN: | |
331 m_valueInSpecifiedUnits = deg2turn(grad2deg(m_valueInSpecifiedUnits) ); | |
332 break; | |
298 case SVG_ANGLETYPE_GRAD: | 333 case SVG_ANGLETYPE_GRAD: |
299 case SVG_ANGLETYPE_UNKNOWN: | 334 case SVG_ANGLETYPE_UNKNOWN: |
300 ASSERT_NOT_REACHED(); | 335 ASSERT_NOT_REACHED(); |
301 break; | 336 break; |
302 } | 337 } |
303 break; | 338 break; |
304 case SVG_ANGLETYPE_UNSPECIFIED: | 339 case SVG_ANGLETYPE_UNSPECIFIED: |
305 // Spec: For angles, a unitless value is treated the same as if degrees were specified. | 340 // Spec: For angles, a unitless value is treated the same as if degrees were specified. |
306 case SVG_ANGLETYPE_DEG: | 341 case SVG_ANGLETYPE_DEG: |
307 switch (unitType) { | 342 switch (unitType) { |
308 case SVG_ANGLETYPE_RAD: | 343 case SVG_ANGLETYPE_RAD: |
309 m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits); | 344 m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits); |
310 break; | 345 break; |
311 case SVG_ANGLETYPE_GRAD: | 346 case SVG_ANGLETYPE_GRAD: |
312 m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits); | 347 m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits); |
313 break; | 348 break; |
349 case SVG_ANGLETYPE_TURN: | |
350 m_valueInSpecifiedUnits = deg2turn(m_valueInSpecifiedUnits); | |
351 break; | |
314 case SVG_ANGLETYPE_UNSPECIFIED: | 352 case SVG_ANGLETYPE_UNSPECIFIED: |
315 break; | 353 break; |
316 case SVG_ANGLETYPE_DEG: | 354 case SVG_ANGLETYPE_DEG: |
317 case SVG_ANGLETYPE_UNKNOWN: | 355 case SVG_ANGLETYPE_UNKNOWN: |
318 ASSERT_NOT_REACHED(); | 356 ASSERT_NOT_REACHED(); |
319 break; | 357 break; |
320 } | 358 } |
321 break; | 359 break; |
322 case SVG_ANGLETYPE_UNKNOWN: | 360 case SVG_ANGLETYPE_UNKNOWN: |
323 ASSERT_NOT_REACHED(); | 361 ASSERT_NOT_REACHED(); |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
397 | 435 |
398 void SVGAngle::orientTypeChanged() | 436 void SVGAngle::orientTypeChanged() |
399 { | 437 { |
400 if (orientType()->enumValue() == SVGMarkerOrientAuto) { | 438 if (orientType()->enumValue() == SVGMarkerOrientAuto) { |
401 m_unitType = SVG_ANGLETYPE_UNSPECIFIED; | 439 m_unitType = SVG_ANGLETYPE_UNSPECIFIED; |
402 m_valueInSpecifiedUnits = 0; | 440 m_valueInSpecifiedUnits = 0; |
403 } | 441 } |
404 } | 442 } |
405 | 443 |
406 } | 444 } |
OLD | NEW |