1 /**
2 * Phoebe DOM Implementation.
3 *
4 * This is a C++ approximation of the W3C DOM model, which follows
5 * fairly closely the specifications in the various .idl files, copies of
6 * which are provided for reference. Most important is this one:
7 *
8 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
9 *
10 * Authors:
11 * Bob Jamison
12 *
13 * Copyright(C) 2005-2008 Bob Jamison
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or(at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
28 *
29 * =======================================================================
30 * NOTES
31 *
32 * This API follows:
33 * http://www.w3.org/TR/SVG11/svgdom.html
34 *
35 * This file defines the main SVG-DOM Node types. Other non-Node types are
36 * defined in svgtypes.h.
37 *
38 */
40 #include "svg.h"
42 #include <math.h>
45 namespace org
46 {
47 namespace w3c
48 {
49 namespace dom
50 {
51 namespace svg
52 {
56 //########################################################################
57 //########################################################################
58 //########################################################################
59 //# I N T E R F A C E S
60 //########################################################################
61 //########################################################################
62 //########################################################################
66 /*#########################################################################
67 ## SVGMatrix
68 #########################################################################*/
70 /**
71 *
72 */
73 double SVGMatrix::getA()
74 {
75 return a;
76 }
78 /**
79 *
80 */
81 void SVGMatrix::setA(double val) throw (DOMException)
82 {
83 a = val;
84 }
86 /**
87 *
88 */
89 double SVGMatrix::getB()
90 {
91 return b;
92 }
94 /**
95 *
96 */
97 void SVGMatrix::setB(double val) throw (DOMException)
98 {
99 b = val;
100 }
102 /**
103 *
104 */
105 double SVGMatrix::getC()
106 {
107 return c;
108 }
110 /**
111 *
112 */
113 void SVGMatrix::setC(double val) throw (DOMException)
114 {
115 c = val;
116 }
118 /**
119 *
120 */
121 double SVGMatrix::getD()
122 {
123 return d;
124 }
126 /**
127 *
128 */
129 void SVGMatrix::setD(double val) throw (DOMException)
130 {
131 d = val;
132 }
134 /**
135 *
136 */
137 double SVGMatrix::getE()
138 {
139 return e;
140 }
142 /**
143 *
144 */
145 void SVGMatrix::setE(double val) throw (DOMException)
146 {
147 e = val;
148 }
150 /**
151 *
152 */
153 double SVGMatrix::getF()
154 {
155 return f;
156 }
158 /**
159 *
160 */
161 void SVGMatrix::setF(double val) throw (DOMException)
162 {
163 f = val;
164 }
167 /**
168 * Return the result of postmultiplying this matrix with another.
169 */
170 SVGMatrix SVGMatrix::multiply(const SVGMatrix &other)
171 {
172 SVGMatrix result;
173 result.a = a * other.a + c * other.b;
174 result.b = b * other.a + d * other.b;
175 result.c = a * other.c + c * other.d;
176 result.d = b * other.c + d * other.d;
177 result.e = a * other.e + c * other.f + e;
178 result.f = b * other.e + d * other.f + f;
179 return result;
180 }
182 /**
183 * Calculate the inverse of this matrix
184 *
185 */
186 SVGMatrix SVGMatrix::inverse() throw (SVGException)
187 {
188 /*###########################################
189 The determinant of a 3x3 matrix E
190 (let's use our own notation for a bit)
192 A B C
193 D E F
194 G H I
195 is
196 AEI - AFH - BDI + BFG + CDH - CEG
198 Since in our affine transforms, G and H==0 and I==1,
199 this reduces to:
200 AE - BD
201 In SVG's naming scheme, that is: a * d - c * b . SIMPLE!
203 In a similar method of attack, SVG's adjunct matrix is:
205 d -c cf-ed
206 -b a eb-af
207 0 0 ad-cb
209 To get the inverse matrix, we divide the adjunct matrix by
210 the determinant. Notice that (ad-cb)/(ad-cb)==1. Very cool.
211 So what we end up with is this:
213 a = d/(ad-cb) c = -c/(ad-cb) e = (cf-ed)/(ad-cb)
214 b = -b/(ad-cb) d = a/(ad-cb) f = (eb-af)/(ad-cb)
216 (Since this would be in all SVG-DOM implementations,
217 somebody needed to document this! ^^)
218 #############################################*/
220 SVGMatrix result;
221 double determinant = a * d - c * b;
222 if (determinant < 1.0e-18)//invertible?
223 {
224 result.identity();//cop out
225 return result;
226 }
228 double idet = 1.0 / determinant;
229 result.a = d * idet;
230 result.b = -b * idet;
231 result.c = -c * idet;
232 result.d = a * idet;
233 result.e = (c*f - e*d) * idet;
234 result.f = (e*b - a*f) * idet;
235 return result;
236 }
238 /**
239 * Equivalent to multiplying by:
240 * | 1 0 x |
241 * | 0 1 y |
242 * | 0 0 1 |
243 *
244 */
245 SVGMatrix SVGMatrix::translate(double x, double y)
246 {
247 SVGMatrix result;
248 result.a = a;
249 result.b = b;
250 result.c = c;
251 result.d = d;
252 result.e = a * x + c * y + e;
253 result.f = b * x + d * y + f;
254 return result;
255 }
257 /**
258 * Equivalent to multiplying by:
259 * | scale 0 0 |
260 * | 0 scale 0 |
261 * | 0 0 1 |
262 *
263 */
264 :SVGMatrix SVGMatrix:scale(double scale)
265 {
266 SVGMatrix result;
267 result.a = a * scale;
268 result.b = b * scale;
269 result.c = c * scale;
270 result.d = d * scale;
271 result.e = e;
272 result.f = f;
273 return result;
274 }
276 /**
277 * Equivalent to multiplying by:
278 * | scaleX 0 0 |
279 * | 0 scaleY 0 |
280 * | 0 0 1 |
281 *
282 */
283 SVGMatrix SVGMatrix::scaleNonUniform(double scaleX,
284 double scaleY)
285 {
286 SVGMatrix result;
287 result.a = a * scaleX;
288 result.b = b * scaleX;
289 result.c = c * scaleY;
290 result.d = d * scaleY;
291 result.e = e;
292 result.f = f;
293 return result;
294 }
296 /**
297 * Equivalent to multiplying by:
298 * | cos(a) -sin(a) 0 |
299 * | sin(a) cos(a) 0 |
300 * | 0 0 1 |
301 *
302 */
303 SVGMatrix SVGMatrix::rotate (double angle)
304 {
305 double sina = sin(angle);
306 double msina = -sina;
307 double cosa = cos(angle);
308 SVGMatrix result;
309 result.a = a * cosa + c * sina;
310 result.b = b * cosa + d + sina;
311 result.c = a * msina + c * cosa;
312 result.d = b * msina + d * cosa;
313 result.e = e;
314 result.f = f;
315 return result;
316 }
318 /**
319 * Equivalent to multiplying by:
320 * | cos(a) -sin(a) 0 |
321 * | sin(a) cos(a) 0 |
322 * | 0 0 1 |
323 * In this case, angle 'a' is computed as the artangent
324 * of the slope y/x . It is negative if the slope is negative.
325 */
326 SVGMatrix SVGMatrix::rotateFromVector(double x, double y)
327 throw (SVGException)
328 {
329 double angle = atan(y / x);
330 if (y < 0.0)
331 angle = -angle;
332 SVGMatrix result;
333 double sina = sin(angle);
334 double msina = -sina;
335 double cosa = cos(angle);
336 result.a = a * cosa + c * sina;
337 result.b = b * cosa + d + sina;
338 result.c = a * msina + c * cosa;
339 result.d = b * msina + d * cosa;
340 result.e = e;
341 result.f = f;
342 return result;
343 }
345 /**
346 * Equivalent to multiplying by:
347 * | -1 0 0 |
348 * | 0 1 0 |
349 * | 0 0 1 |
350 *
351 */
352 SVGMatrix SVGMatrix::flipX()
353 {
354 SVGMatrix result;
355 result.a = -a;
356 result.b = -b;
357 result.c = c;
358 result.d = d;
359 result.e = e;
360 result.f = f;
361 return result;
362 }
364 /**
365 * Equivalent to multiplying by:
366 * | 1 0 0 |
367 * | 0 -1 0 |
368 * | 0 0 1 |
369 *
370 */
371 SVGMatrix SVGMatrix::flipY()
372 {
373 SVGMatrix result;
374 result.a = a;
375 result.b = b;
376 result.c = -c;
377 result.d = -d;
378 result.e = e;
379 result.f = f;
380 return result;
381 }
383 /**
384 * | 1 tan(a) 0 |
385 * | 0 1 0 |
386 * | 0 0 1 |
387 *
388 */
389 SVGMatrix SVGMatrix::skewX(double angle)
390 {
391 double tana = tan(angle);
392 SVGMatrix result;
393 result.a = a;
394 result.b = b;
395 result.c = a * tana + c;
396 result.d = b * tana + d;
397 result.e = e;
398 result.f = f;
399 return result;
400 }
402 /**
403 * Equivalent to multiplying by:
404 * | 1 0 0 |
405 * | tan(a) 1 0 |
406 * | 0 0 1 |
407 *
408 */
409 SVGMatrix::SVGMatrix SVGMatrix::skewY(double angle)
410 {
411 double tana = tan(angle);
412 SVGMatrix result;
413 result.a = a + c * tana;
414 result.b = b + d * tana;
415 result.c = c;
416 result.d = d;
417 result.e = e;
418 result.f = f;
419 return result;
420 }
424 //##################
425 //# Non-API methods
426 //##################
428 /**
429 *
430 */
431 SVGMatrix::SVGMatrix()
432 {
433 identity();
434 }
436 /**
437 *
438 */
439 SVGMatrix::SVGMatrix(double aArg, double bArg, double cArg,
440 double dArg, double eArg, double fArg)
441 {
442 a = aArg; b = bArg; c = cArg;
443 d = dArg; e = eArg; f = fArg;
444 }
446 /**
447 * Copy constructor
448 */
449 SVGMatrix::SVGMatrix(const SVGMatrix &other)
450 {
451 a = other.a;
452 b = other.b;
453 c = other.c;
454 d = other.d;
455 e = other.e;
456 f = other.f;
457 }
461 /**
462 *
463 */
464 SVGMatrix::~SVGMatrix()
465 {
466 }
468 /*
469 * Set to the identity matrix
470 */
471 void SVGMatrix::identity()
472 {
473 a = 1.0;
474 b = 0.0;
475 c = 0.0;
476 d = 1.0;
477 e = 0.0;
478 f = 0.0;
479 }
482 /*#########################################################################
483 ## SVGTransform
484 #########################################################################*/
486 /**
487 *
488 */
489 unsigned short SVGTransform::getType()
490 {
491 return type;
492 }
495 /**
496 *
497 */
498 SVGMatrix SVGTransform::getMatrix()
499 {
500 return matrix;
501 }
503 /**
504 *
505 */
506 double SVGTransform::getAngle()
507 {
508 return angle;
509 }
512 /**
513 *
514 */
515 void SVGTransform::setMatrix(const SVGMatrix &matrixArg)
516 {
517 type = SVG_TRANSFORM_MATRIX;
518 matrix = matrixArg;
519 }
521 /**
522 *
523 */
524 void SVGTransform::setTranslate(double tx, double ty)
525 {
526 type = SVG_TRANSFORM_TRANSLATE;
527 matrix.setA(1.0);
528 matrix.setB(0.0);
529 matrix.setC(0.0);
530 matrix.setD(1.0);
531 matrix.setE(tx);
532 matrix.setF(ty);
533 }
535 /**
536 *
537 */
538 void SVGTransform::setScale(double sx, double sy)
539 {
540 type = SVG_TRANSFORM_SCALE;
541 matrix.setA(sx);
542 matrix.setB(0.0);
543 matrix.setC(0.0);
544 matrix.setD(sy);
545 matrix.setE(0.0);
546 matrix.setF(0.0);
547 }
549 /**
550 *
551 */
552 void SVGTransform::setRotate(double angleArg, double cx, double cy)
553 {
554 angle = angleArg;
555 setTranslate(cx, cy);
556 type = SVG_TRANSFORM_ROTATE;
557 matrix.rotate(angle);
558 }
560 /**
561 *
562 */
563 void SVGTransform::setSkewX(double angleArg)
564 {
565 angle = angleArg;
566 type = SVG_TRANSFORM_SKEWX;
567 matrix.identity();
568 matrix.skewX(angle);
569 }
571 /**
572 *
573 */
574 void SVGTransform::setSkewY(double angleArg)
575 {
576 angle = angleArg;
577 type = SVG_TRANSFORM_SKEWY;
578 matrix.identity();
579 matrix.skewY(angle);
580 }
583 //##################
584 //# Non-API methods
585 //##################
587 /**
588 *
589 */
590 SVGTransform::SVGTransform()
591 {
592 type = SVG_TRANSFORM_UNKNOWN;
593 angle = 0.0;
594 }
596 /**
597 *
598 */
599 SVGTransform::SVGTransform(const SVGTransform &other)
600 {
601 type = other.type;
602 angle = other.angle;
603 matrix = other.matrix;
604 }
606 /**
607 *
608 */
609 ~SVGTransform::SVGTransform()
610 {
611 }
615 /*#########################################################################
616 ## SVGNumber
617 #########################################################################*/
619 /**
620 *
621 */
622 double SVGNumber::getValue()
623 {
624 return value;
625 }
627 /**
628 *
629 */
630 void SVGNumber::setValue(double val) throw (DOMException)
631 {
632 value = val;
633 }
636 //##################
637 //# Non-API methods
638 //##################
640 /**
641 *
642 */
643 SVGNumber::SVGNumber()
644 {
645 value = 0.0;
646 }
648 /**
649 *
650 */
651 SVGNumber::SVGNumber(const SVGNumber &other)
652 {
653 value = other.value;
654 }
656 /**
657 *
658 */
659 SVGNumber::~SVGNumber()
660 {
661 }
665 /*#########################################################################
666 ## SVGLength
667 #########################################################################*/
670 /**
671 *
672 */
673 unsigned short SVGLength::getUnitType()
674 {
675 return unitType;
676 }
678 /**
679 *
680 */
681 double SVGLength::getValue()
682 {
683 return value;
684 }
686 /**
687 *
688 */
689 void SVGLength::setValue(double val) throw (DOMException)
690 {
691 value = val;
692 }
694 /**
695 *
696 */
697 double SVGLength::getValueInSpecifiedUnits()
698 {
699 double result = 0.0;
700 //fill this in
701 return result;
702 }
704 /**
705 *
706 */
707 void SVGLength::setValueInSpecifiedUnits(double /*val*/)
708 throw (DOMException)
709 {
710 //fill this in
711 }
713 /**
714 *
715 */
716 DOMString SVGLength::getValueAsString()
717 {
718 DOMString ret;
719 char buf[32];
720 snprintf(buf, 31, "%f", value);
721 ret.append(buf);
722 return ret;
723 }
725 /**
726 *
727 */
728 void SVGLength::setValueAsString(const DOMString& /*val*/)
729 throw (DOMException)
730 {
731 }
734 /**
735 *
736 */
737 void SVGLength::newValueSpecifiedUnits (unsigned short /*unitType*/, double /*val*/)
738 {
739 }
741 /**
742 *
743 */
744 void SVGLength::convertToSpecifiedUnits (unsigned short /*unitType*/)
745 {
746 }
750 //##################
751 //# Non-API methods
752 //##################
754 /**
755 *
756 */
757 SVGLength::SVGLength()
758 {
759 unitType = SVG_LENGTHTYPE_UNKNOWN;
760 value = 0.0;
761 }
764 /**
765 *
766 */
767 SVGLength::SVGLength(const SVGLength &other)
768 {
769 unitType = other.unitType;
770 value = other.value;
771 }
773 /**
774 *
775 */
776 SVGLength::~SVGLength()
777 {
778 }
783 /*#########################################################################
784 ## SVGAngle
785 #########################################################################*/
787 /**
788 *
789 */
790 unsigned short SVGAngle::getUnitType()
791 {
792 return unitType;
793 }
795 /**
796 *
797 */
798 double SVGAngle::getValue()
799 {
800 return value;
801 }
803 /**
804 *
805 */
806 void SVGAngle::setValue(double val) throw (DOMException)
807 {
808 value = val;
809 }
811 /**
812 *
813 */
814 double SVGAngle::getValueInSpecifiedUnits()
815 {
816 double result = 0.0;
817 //convert here
818 return result;
819 }
821 /**
822 *
823 */
824 void SVGAngle::setValueInSpecifiedUnits(double /*val*/)
825 throw (DOMException)
826 {
827 //do conversion
828 }
830 /**
831 *
832 */
833 DOMString SVGAngle::getValueAsString()
834 {
835 DOMString result;
836 char buf[32];
837 snprintf(buf, 31, "%f", value);
838 result.append(buf);
839 return result;
840 }
842 /**
843 *
844 */
845 void SVGAngle::setValueAsString(const DOMString &/*val*/)
846 throw (DOMException)
847 {
848 //convert here
849 }
852 /**
853 *
854 */
855 void SVGAngle::newValueSpecifiedUnits (unsigned short /*unitType*/,
856 double /*valueInSpecifiedUnits*/)
857 {
858 //convert here
859 }
861 /**
862 *
863 */
864 void SVGAngle::convertToSpecifiedUnits (unsigned short /*unitType*/)
865 {
866 //convert here
867 }
871 //##################
872 //# Non-API methods
873 //##################
875 /**
876 *
877 */
878 SVGAngle::SVGAngle()
879 {
880 unitType = SVG_ANGLETYPE_UNKNOWN;
881 value = 0.0;
882 }
884 /**
885 *
886 */
887 SVGAngle::SVGAngle(const SVGAngle &other)
888 {
889 unitType = other.unitType;
890 value = other.value;
891 }
893 /**
894 *
895 */
896 SVGAngle::~SVGAngle()
897 {
898 }
903 /*#########################################################################
904 ## SVGICCColor
905 #########################################################################*/
908 /**
909 *
910 */
911 DOMString SVGICCColor::getColorProfile()
912 {
913 return colorProfile;
914 }
916 /**
917 *
918 */
919 void SVGICCColor::setColorProfile(const DOMString &val) throw (DOMException)
920 {
921 colorProfile = val;
922 }
924 /**
925 *
926 */
927 SVGNumberList &SVGICCColor::getColors()
928 {
929 return colors;
930 }
934 //##################
935 //# Non-API methods
936 //##################
938 /**
939 *
940 */
941 SVGICCColor::SVGICCColor()
942 {
943 }
945 /**
946 *
947 */
948 SVGICCColor::SVGICCColor(const SVGICCColor &other)
949 {
950 colorProfile = other.colorProfile;
951 colors = other.colors;
952 }
954 /**
955 *
956 */
957 SVGICCColor::~SVGICCColor()
958 {
959 }
963 /*#########################################################################
964 ## SVGColor
965 #########################################################################*/
969 /**
970 *
971 */
972 unsigned short SVGColor::getColorType()
973 {
974 return colorType;
975 }
977 /**
978 *
979 */
980 css::RGBColor SVGColor::getRgbColor()
981 {
982 css::RGBColor col;
983 return col;
984 }
986 /**
987 *
988 */
989 SVGICCColor SVGColor::getIccColor()
990 {
991 SVGICCColor col;
992 return col;
993 }
996 /**
997 *
998 */
999 void SVGColor::setRGBColor(const DOMString& /*rgbColor*/)
1000 throw (SVGException)
1001 {
1002 }
1004 /**
1005 *
1006 */
1007 void SVGColor::setRGBColorICCColor(const DOMString& /*rgbColor*/,
1008 const DOMString& /*iccColor*/)
1009 throw (SVGException)
1010 {
1011 }
1013 /**
1014 *
1015 */
1016 void SVGColor::setColor (unsigned short /*colorType*/,
1017 const DOMString& /*rgbColor*/,
1018 const DOMString& /*iccColor*/)
1019 throw (SVGException)
1020 {
1021 }
1025 //##################
1026 //# Non-API methods
1027 //##################
1029 /**
1030 *
1031 */
1032 SVGColor::SVGColor()
1033 {
1034 colorType = SVG_COLORTYPE_UNKNOWN;
1035 }
1037 /**
1038 *
1039 */
1040 SVGColor::SVGColor(const SVGColor &other) : css::CSSValue(other)
1041 {
1042 colorType = other.colorType;
1043 }
1045 /**
1046 *
1047 */
1048 SVGColor::~SVGColor()
1049 {
1050 }
1054 /*#########################################################################
1055 ## SVGRect
1056 #########################################################################*/
1059 /**
1060 *
1061 */
1062 double SVGRect::getX()
1063 {
1064 return x;
1065 }
1067 /**
1068 *
1069 */
1070 void SVGRect::setX(double val) throw (DOMException)
1071 {
1072 x = val;
1073 }
1075 /**
1076 *
1077 */
1078 double SVGRect::getY()
1079 {
1080 return y;
1081 }
1083 /**
1084 *
1085 */
1086 void SVGRect::setY(double val) throw (DOMException)
1087 {
1088 y = val;
1089 }
1091 /**
1092 *
1093 */
1094 double SVGRect::getWidth()
1095 {
1096 return width;
1097 }
1099 /**
1100 *
1101 */
1102 void SVGRect::setWidth(double val) throw (DOMException)
1103 {
1104 width = val;
1105 }
1107 /**
1108 *
1109 */
1110 double SVGRect::getHeight()
1111 {
1112 return height;
1113 }
1115 /**
1116 *
1117 */
1118 void SVGRect::setHeight(double val) throw (DOMException)
1119 {
1120 height = val;
1121 }
1124 //##################
1125 //# Non-API methods
1126 //##################
1128 /**
1129 *
1130 */
1131 SVGRect::SVGRect()
1132 {
1133 x = y = width = height = 0.0;
1134 }
1136 /**
1137 *
1138 */
1139 SVGRect::SVGRect(const SVGRect &other)
1140 {
1141 x = other.x;
1142 y = other.y;
1143 width = other.width;
1144 height = other.height;
1145 }
1147 /**
1148 *
1149 */
1150 SVGRect::~SVGRect()
1151 {
1152 }
1156 /*#########################################################################
1157 ## SVGPoint
1158 #########################################################################*/
1161 /**
1162 *
1163 */
1164 double SVGPoint::getX()
1165 {
1166 return x;
1167 }
1169 /**
1170 *
1171 */
1172 void SVGPoint::setX(double val) throw (DOMException)
1173 {
1174 x = val;
1175 }
1177 /**
1178 *
1179 */
1180 double SVGPoint::getY()
1181 {
1182 return y;
1183 }
1185 /**
1186 *
1187 */
1188 void SVGPoint::setY(double val) throw (DOMException)
1189 {
1190 y = val;
1191 }
1193 /**
1194 *
1195 */
1196 SVGPoint SVGPoint::matrixTransform(const SVGMatrix &/*matrix*/)
1197 {
1198 SVGPoint point;
1199 return point;
1200 }
1204 //##################
1205 //# Non-API methods
1206 //##################
1208 /**
1209 *
1210 */
1211 SVGPoint::SVGPoint()
1212 {
1213 x = y = 0;
1214 }
1216 /**
1217 *
1218 */
1219 SVGPoint::SVGPoint(const SVGPoint &other)
1220 {
1221 x = other.x;
1222 y = other.y;
1223 }
1225 /**
1226 *
1227 */
1228 SVGPoint::~SVGPoint()
1229 {
1230 }
1233 /*#########################################################################
1234 ## SVGUnitTypes
1235 #########################################################################*/
1237 /**
1238 *
1239 */
1240 SVGUnitTypes::SVGUnitTypes()
1241 {
1242 }
1246 /**
1247 *
1248 */
1249 SVGUnitTypes::~SVGUnitTypes()
1250 {
1251 }
1254 /*#########################################################################
1255 ## SVGStylable
1256 #########################################################################*/
1259 /**
1260 *
1261 */
1262 SVGAnimatedString SVGStylable::getClassName()
1263 {
1264 return className;
1265 }
1267 /**
1268 *
1269 */
1270 css::CSSStyleDeclaration SVGStylable::getStyle()
1271 {
1272 return style;
1273 }
1276 /**
1277 *
1278 */
1279 css::CSSValue SVGStylable::getPresentationAttribute(const DOMString& /*name*/)
1280 {
1281 css::CSSValue val;
1282 //perform a lookup
1283 return val;
1284 }
1287 //##################
1288 //# Non-API methods
1289 //##################
1291 /**
1292 *
1293 */
1294 SVGStylable::SVGStylable()
1295 {
1296 }
1298 /**
1299 *
1300 */
1301 SVGStylable::SVGStylable(const SVGStylable &other)
1302 {
1303 className = other.className;
1304 style = other.style;
1305 }
1307 /**
1308 *
1309 */
1310 SVGStylable::~SVGStylable()
1311 {
1312 }
1317 /*#########################################################################
1318 ## SVGLocatable
1319 #########################################################################*/
1322 /**
1323 *
1324 */
1325 SVGElementPtr SVGLocatable::getNearestViewportElement()
1326 {
1327 SVGElementPtr result;
1328 return result;
1329 }
1331 /**
1332 *
1333 */
1334 SVGElementPtr SVGLocatable::getFarthestViewportElement()
1335 {
1336 SVGElementPtr result;
1337 return result;
1338 }
1340 /**
1341 *
1342 */
1343 SVGRect SVGLocatable::getBBox ()
1344 {
1345 return bbox;
1346 }
1348 /**
1349 *
1350 */
1351 SVGMatrix SVGLocatable::getCTM ()
1352 {
1353 return ctm;
1354 }
1356 /**
1357 *
1358 */
1359 SVGMatrix SVGLocatable::getScreenCTM ()
1360 {
1361 return screenCtm;
1362 }
1364 /**
1365 *
1366 */
1367 SVGMatrix SVGLocatable::getTransformToElement (const SVGElement &/*element*/)
1368 throw (SVGException)
1369 {
1370 SVGMatrix result;
1371 //do calculations
1372 return result;
1373 }
1377 //##################
1378 //# Non-API methods
1379 //##################
1381 /**
1382 *
1383 */
1384 SVGLocatable::SVGLocatable()
1385 {
1386 }
1388 /**
1389 *
1390 */
1391 SVGLocatable::SVGLocatable(const SVGLocatable &/*other*/)
1392 {
1393 }
1395 /**
1396 *
1397 */
1398 SVGLocatable::~SVGLocatable()
1399 {
1400 }
1403 /*#########################################################################
1404 ## SVGTransformable
1405 #########################################################################*/
1408 /**
1409 *
1410 */
1411 SVGAnimatedTransformList &SVGTransformable::getTransform()
1412 {
1413 return transforms;
1414 }
1418 //##################
1419 //# Non-API methods
1420 //##################
1422 /**
1423 *
1424 */
1425 SVGTransformable::SVGTransformable() {}
1427 /**
1428 *
1429 */
1430 SVGTransformable::SVGTransformable(const SVGTransformable &other) : SVGLocatable(other)
1431 {
1432 transforms = other.transforms;
1433 }
1435 /**
1436 *
1437 */
1438 SVGTransformable::~SVGTransformable()
1439 {
1440 }
1448 /*#########################################################################
1449 ## SVGTests
1450 #########################################################################*/
1453 /**
1454 *
1455 */
1456 SVGStringList &SVGTests::getRequiredFeatures()
1457 {
1458 return requiredFeatures;
1459 }
1461 /**
1462 *
1463 */
1464 SVGStringList &SVGTests::getRequiredExtensions()
1465 {
1466 return requiredExtensions;
1467 }
1469 /**
1470 *
1471 */
1472 SVGStringList &SVGTests::getSystemLanguage()
1473 {
1474 return systemLanguage;
1475 }
1478 /**
1479 *
1480 */
1481 bool SVGTests::hasExtension (const DOMString& /*extension*/)
1482 {
1483 return false;
1484 }
1488 //##################
1489 //# Non-API methods
1490 //##################
1492 /**
1493 *
1494 */
1495 SVGTests::SVGTests()
1496 {
1497 }
1499 /**
1500 *
1501 */
1502 SVGTests::SVGTests(const SVGTests &other)
1503 {
1504 requiredFeatures = other.requiredFeatures;
1505 requiredExtensions = other.requiredExtensions;
1506 systemLanguage = other.systemLanguage;
1507 }
1509 /**
1510 *
1511 */
1512 SVGTests::~SVGTests()
1513 {
1514 }
1518 /*#########################################################################
1519 ## SVGLangSpace
1520 #########################################################################*/
1523 /**
1524 *
1525 */
1526 DOMString SVGLangSpace::getXmllang()
1527 {
1528 return xmlLang;
1529 }
1531 /**
1532 *
1533 */
1534 void SVGLangSpace::setXmllang(const DOMString &val) throw (DOMException)
1535 {
1536 xmlLang = val;
1537 }
1539 /**
1540 *
1541 */
1542 DOMString SVGLangSpace::getXmlspace()
1543 {
1544 return xmlSpace;
1545 }
1547 /**
1548 *
1549 */
1550 void SVGLangSpace::setXmlspace(const DOMString &val)
1551 throw (DOMException)
1552 {
1553 xmlSpace = val;
1554 }
1558 //##################
1559 //# Non-API methods
1560 //##################
1562 /**
1563 *
1564 */
1565 SVGLangSpace::SVGLangSpace()
1566 {
1567 }
1569 /**
1570 *
1571 */
1572 SVGLangSpace::SVGLangSpace(const SVGLangSpace &other)
1573 {
1574 xmlLang = other.xmlLang;
1575 xmlSpace = other.xmlSpace;
1576 }
1578 /**
1579 *
1580 */
1581 SVGLangSpace::~SVGLangSpace()
1582 {
1583 }
1587 /*#########################################################################
1588 ## SVGExternalResourcesRequired
1589 #########################################################################*/
1591 /**
1592 *
1593 */
1594 SVGAnimatedBoolean SVGExternalResourcesRequired::getExternalResourcesRequired()
1595 {
1596 return required;
1597 }
1601 //##################
1602 //# Non-API methods
1603 //##################
1605 /**
1606 *
1607 */
1608 SVGExternalResourcesRequired::SVGExternalResourcesRequired()
1609 {
1610 }
1613 /**
1614 *
1615 */
1616 SVGExternalResourcesRequired::SVGExternalResourcesRequired(
1617 const SVGExternalResourcesRequired &other)
1618 {
1619 required = other.required;
1620 }
1622 /**
1623 *
1624 */
1625 SVGExternalResourcesRequired::~SVGExternalResourcesRequired() {}
1628 /*#########################################################################
1629 ## SVGPreserveAspectRatio
1630 #########################################################################*/
1632 /**
1633 *
1634 */
1635 unsigned short SVGPreserveAspectRatio::getAlign()
1636 {
1637 return align;
1638 }
1640 /**
1641 *
1642 */
1643 void SVGPreserveAspectRatio::setAlign(unsigned short val) throw (DOMException)
1644 {
1645 align = val;
1646 }
1648 /**
1649 *
1650 */
1651 unsigned short SVGPreserveAspectRatio::getMeetOrSlice()
1652 {
1653 return meetOrSlice;
1654 }
1656 /**
1657 *
1658 */
1659 void SVGPreserveAspectRatio::setMeetOrSlice(unsigned short val) throw (DOMException)
1660 {
1661 meetOrSlice = val;
1662 }
1666 //##################
1667 //# Non-API methods
1668 //##################
1670 /**
1671 *
1672 */
1673 SVGPreserveAspectRatio::SVGPreserveAspectRatio()
1674 {
1675 align = SVG_PRESERVEASPECTRATIO_UNKNOWN;
1676 meetOrSlice = SVG_MEETORSLICE_UNKNOWN;
1677 }
1679 /**
1680 *
1681 */
1682 SVGPreserveAspectRatio::SVGPreserveAspectRatio(const SVGPreserveAspectRatio &other)
1683 {
1684 align = other.align;
1685 meetOrSlice = other.meetOrSlice;
1686 }
1688 /**
1689 *
1690 */
1691 SVGPreserveAspectRatio::~SVGPreserveAspectRatio()
1692 {
1693 }
1697 /*#########################################################################
1698 ## SVGFitToViewBox
1699 #########################################################################*/
1702 /**
1703 *
1704 */
1705 SVGAnimatedRect SVGFitToViewBox::getViewBox()
1706 {
1707 return viewBox;
1708 }
1710 /**
1711 *
1712 */
1713 SVGAnimatedPreserveAspectRatio SVGFitToViewBox::getPreserveAspectRatio()
1714 {
1715 return preserveAspectRatio;
1716 }
1720 //##################
1721 //# Non-API methods
1722 //##################
1724 /**
1725 *
1726 */
1727 SVGFitToViewBox::SVGFitToViewBox()
1728 {
1729 }
1731 /**
1732 *
1733 */
1735 SVGFitToViewBox::SVGFitToViewBox(const SVGFitToViewBox &other)
1736 {
1737 viewBox = other.viewBox;
1738 preserveAspectRatio = other.preserveAspectRatio;
1739 }
1741 /**
1742 *
1743 */
1744 SVGFitToViewBox::~SVGFitToViewBox()
1745 {
1746 }
1748 /*#########################################################################
1749 ## SVGZoomAndPan
1750 #########################################################################*/
1752 /**
1753 *
1754 */
1755 unsigned short SVGZoomAndPan::getZoomAndPan()
1756 {
1757 return zoomAndPan;
1758 }
1760 /**
1761 *
1762 */
1763 void SVGZoomAndPan::setZoomAndPan(unsigned short val) throw (DOMException)
1764 {
1765 zoomAndPan = val;
1766 }
1769 //##################
1770 //# Non-API methods
1771 //##################
1773 /**
1774 *
1775 */
1776 SVGZoomAndPan::SVGZoomAndPan()
1777 {
1778 zoomAndPan = SVG_ZOOMANDPAN_UNKNOWN;
1779 }
1781 /**
1782 *
1783 */
1784 SVGZoomAndPan::SVGZoomAndPan(const SVGZoomAndPan &other)
1785 {
1786 zoomAndPan = other.zoomAndPan;
1787 }
1789 /**
1790 *
1791 */
1792 SVGZoomAndPan::~SVGZoomAndPan()
1793 {
1794 }
1797 /*#########################################################################
1798 ## SVGViewSpec
1799 #########################################################################*/
1801 /**
1802 *
1803 */
1804 SVGTransformList SVGViewSpec::getTransform()
1805 {
1806 return transform;
1807 }
1809 /**
1810 *
1811 */
1812 SVGElementPtr SVGViewSpec::getViewTarget()
1813 {
1814 return viewTarget;
1815 }
1817 /**
1818 *
1819 */
1820 DOMString SVGViewSpec::getViewBoxString()
1821 {
1822 DOMString ret;
1823 return ret;
1824 }
1826 /**
1827 *
1828 */
1829 DOMString SVGViewSpec::getPreserveAspectRatioString()
1830 {
1831 DOMString ret;
1832 return ret;
1833 }
1835 /**
1836 *
1837 */
1838 DOMString SVGViewSpec::getTransformString()
1839 {
1840 DOMString ret;
1841 return ret;
1842 }
1844 /**
1845 *
1846 */
1847 DOMString SVGViewSpec::getViewTargetString()
1848 {
1849 DOMString ret;
1850 return ret;
1851 }
1855 //##################
1856 //# Non-API methods
1857 //##################
1859 /**
1860 *
1861 */
1862 SVGViewSpec::SVGViewSpec()
1863 {
1864 viewTarget = NULL;
1865 }
1867 /**
1868 *
1869 */
1870 SVGViewSpec::SVGViewSpec(const SVGViewSpec &other) : SVGZoomAndPan(other), SVGFitToViewBox(other)
1871 {
1872 viewTarget = other.viewTarget;
1873 transform = other.transform;
1874 }
1876 /**
1877 *
1878 */
1879 SVGViewSpec::~SVGViewSpec()
1880 {
1881 }
1885 /*#########################################################################
1886 ## SVGURIReference
1887 #########################################################################*/
1890 /**
1891 *
1892 */
1893 SVGAnimatedString SVGURIReference::getHref()
1894 {
1895 return href;
1896 }
1900 //##################
1901 //# Non-API methods
1902 //##################
1904 /**
1905 *
1906 */
1907 SVGURIReference::SVGURIReference()
1908 {
1909 }
1911 /**
1912 *
1913 */
1914 SVGURIReference::SVGURIReference(const SVGURIReference &other)
1915 {
1916 href = other.href;
1917 }
1919 /**
1920 *
1921 */
1922 SVGURIReference::~SVGURIReference()
1923 {
1924 }
1928 /*#########################################################################
1929 ## SVGCSSRule
1930 #########################################################################*/
1935 /*#########################################################################
1936 ## SVGRenderingIntent
1937 #########################################################################*/
1943 /*#########################################################################
1944 ## SVGPathSeg
1945 #########################################################################*/
1947 static const char *pathSegLetters[] =
1948 {
1949 '@', // PATHSEG_UNKNOWN,
1950 'z', // PATHSEG_CLOSEPATH
1951 'M', // PATHSEG_MOVETO_ABS
1952 'm', // PATHSEG_MOVETO_REL,
1953 'L', // PATHSEG_LINETO_ABS
1954 'l', // PATHSEG_LINETO_REL
1955 'C', // PATHSEG_CURVETO_CUBIC_ABS
1956 'c', // PATHSEG_CURVETO_CUBIC_REL
1957 'Q', // PATHSEG_CURVETO_QUADRATIC_ABS,
1958 'q', // PATHSEG_CURVETO_QUADRATIC_REL
1959 'A', // PATHSEG_ARC_ABS
1960 'a', // PATHSEG_ARC_REL,
1961 'H', // PATHSEG_LINETO_HORIZONTAL_ABS,
1962 'h', // PATHSEG_LINETO_HORIZONTAL_REL
1963 'V', // PATHSEG_LINETO_VERTICAL_ABS
1964 'v', // PATHSEG_LINETO_VERTICAL_REL
1965 'S', // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
1966 's', // PATHSEG_CURVETO_CUBIC_SMOOTH_REL
1967 'T', // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
1968 't' // PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
1969 };
1973 /**
1974 *
1975 */
1976 unsigned short getPathSegType()
1977 {
1978 return type;
1979 }
1981 /**
1982 *
1983 */
1984 DOMString getPathSegTypeAsLetter()
1985 {
1986 int typ = type;
1987 if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL)
1988 typ = PATHSEG_UNKNOWN;
1989 char const ch = pathSegLetters[typ];
1990 DOMString letter = ch;
1991 return letter;
1992 }
1995 /**
1996 *
1997 */
1998 unsigned short getPathSegType()
1999 {
2000 return type;
2001 }
2003 /**
2004 *
2005 */
2006 DOMString getPathSegTypeAsLetter()
2007 {
2008 int typ = type;
2009 if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL)
2010 typ = PATHSEG_UNKNOWN;
2011 char const *ch = pathSegLetters[typ];
2012 DOMString letter = ch;
2013 return letter;
2014 }
2016 /**
2017 * From the various subclasses
2018 */
2020 /**
2021 *
2022 */
2023 double SVGPathSeg::getX()
2024 {
2025 return x;
2026 }
2028 /**
2029 *
2030 */
2031 void SVGPathSeg::setX(double val) throw (DOMException)
2032 {
2033 x = val;
2034 }
2036 /**
2037 *
2038 */
2039 double SVGPathSeg::getX1()
2040 {
2041 return x;
2042 }
2044 /**
2045 *
2046 */
2047 void SVGPathSeg::setX1(double val) throw (DOMException)
2048 {
2049 x = val;
2050 }
2052 /**
2053 *
2054 */
2055 double SVGPathSeg::getX2()
2056 {
2057 return x;
2058 }
2060 /**
2061 *
2062 */
2063 void SVGPathSeg::setX2(double val) throw (DOMException)
2064 {
2065 x = val;
2066 }
2068 /**
2069 *
2070 */
2071 double SVGPathSeg::getY()
2072 {
2073 return y;
2074 }
2076 /**
2077 *
2078 */
2079 void SVGPathSeg::setY(double val) throw (DOMException)
2080 {
2081 y = val;
2082 }
2084 /**
2085 *
2086 */
2087 double SVGPathSeg::getY1()
2088 {
2089 return y;
2090 }
2092 /**
2093 *
2094 */
2095 void SVGPathSeg::setY1(double val) throw (DOMException)
2096 {
2097 y = val;
2098 }
2100 /**
2101 *
2102 */
2103 double SVGPathSeg::getY2()
2104 {
2105 return y;
2106 }
2108 /**
2109 *
2110 */
2111 void SVGPathSeg::setY2(double val) throw (DOMException)
2112 {
2113 y = val;
2114 }
2116 /**
2117 *
2118 */
2119 double SVGPathSeg::getR1()
2120 {
2121 return r1;
2122 }
2124 /**
2125 *
2126 */
2127 void SVGPathSeg::setR1(double val) throw (DOMException)
2128 {
2129 r1 = val;
2130 }
2132 /**
2133 *
2134 */
2135 double SVGPathSeg::getR2()
2136 {
2137 return r2;
2138 }
2140 /**
2141 *
2142 */
2143 void SVGPathSeg::setR2(double val) throw (DOMException)
2144 {
2145 r2 = val;
2146 }
2148 /**
2149 *
2150 */
2151 double SVGPathSeg::getAngle()
2152 {
2153 return angle;
2154 }
2156 /**
2157 *
2158 */
2159 void SVGPathSeg::setAngle(double val) throw (DOMException)
2160 {
2161 angle = val;
2162 }
2164 /**
2165 *
2166 */
2167 bool SVGPathSeg::getLargeArcFlag()
2168 {
2169 return largeArcFlag;
2170 }
2172 /**
2173 *
2174 */
2175 void SVGPathSeg::setLargeArcFlag(bool val) throw (DOMException)
2176 {
2177 largeArcFlag = val;
2178 }
2180 /**
2181 *
2182 */
2183 bool SVGPathSeg::getSweepFlag()
2184 {
2185 return sweepFlag;
2186 }
2188 /**
2189 *
2190 */
2191 void SVGPathSeg::setSweepFlag(bool val) throw (DOMException)
2192 {
2193 sweepFlag = val;
2194 }
2199 //##################
2200 //# Non-API methods
2201 //##################
2203 /**
2204 *
2205 */
2206 SVGPathSeg::SVGPathSeg()
2207 {
2208 init();
2209 }
2211 /**
2212 *
2213 */
2214 SVGPathSeg::SVGPathSeg(const SVGPathSeg &other)
2215 {
2216 assign(other);
2217 }
2219 /**
2220 *
2221 */
2222 SVGPathSeg &operator=(const SVGPathSeg &other)
2223 {
2224 assign(other);
2225 return *this;
2226 }
2228 /**
2229 *
2230 */
2231 void SVGPathSeg::init()
2232 {
2233 type = PATHSEG_UNKNOWN;
2234 x = y = x1 = y1 = x2 = y2 = 0.0;
2235 r1 = r2 = 0.0;
2236 angle = 0.0;
2237 largeArcFlag = false;
2238 sweepFlag = false;
2239 }
2241 /**
2242 *
2243 */
2244 void SVGPathSeg::assign(const SVGPathSeg &other)
2245 {
2246 type = other.type;
2247 x = other.x;
2248 y = other.y;
2249 x1 = other.x1;
2250 y1 = other.y1;
2251 x2 = other.x2;
2252 y2 = other.y2;
2253 r1 = other.r1;
2254 r2 = other.r2;
2255 angle = other.angle;
2256 largeArcFlag = other.largeArcFlag;
2257 sweepFlag = other.sweepFlag;
2258 }
2261 /**
2262 *
2263 */
2264 SVGPathSeg::~SVGPathSeg()
2265 {
2266 }
2271 /*#########################################################################
2272 ## SVGPaint
2273 #########################################################################*/
2276 /**
2277 *
2278 */
2279 unsigned short SVGPaint::getPaintType()
2280 { return paintType; }
2282 /**
2283 *
2284 */
2285 DOMString SVGPaint::getUri()
2286 { return uri; }
2288 /**
2289 *
2290 */
2291 void SVGPaint::setUri(const DOMString& uriArg)
2292 {
2293 uri = uriArg;
2294 }
2296 /**
2297 *
2298 */
2299 void SVGPaint::setPaint (unsigned short paintTypeArg,
2300 const DOMString& uriArg,
2301 const DOMString& /*rgbColor*/,
2302 const DOMString& /*iccColor*/)
2303 throw (SVGException)
2304 {
2305 paintType = paintTypeArg;
2306 uri = uriArg;
2307 //do something with rgbColor
2308 //do something with iccColor;
2309 }
2313 //##################
2314 //# Non-API methods
2315 //##################
2317 /**
2318 *
2319 */
2320 SVGPaint::SVGPaint()
2321 {
2322 uri = "";
2323 paintType = SVG_PAINTTYPE_UNKNOWN;
2324 }
2326 /**
2327 *
2328 */
2329 SVGPaint::SVGPaint(const SVGPaint &other) : css::CSSValue(other), SVGColor(other)
2330 {
2331 uri = "";
2332 paintType = SVG_PAINTTYPE_UNKNOWN;
2333 }
2335 /**
2336 *
2337 */
2338 SVGPaint::~SVGPaint() {}
2341 /*#########################################################################
2342 ## SVGColorProfileRule
2343 #########################################################################*/
2346 /**
2347 *
2348 */
2349 DOMString SVGColorProfileRule::getSrc()
2350 { return src; }
2352 /**
2353 *
2354 */
2355 void SVGColorProfileRule::setSrc(const DOMString &val) throw (DOMException)
2356 { src = val; }
2358 /**
2359 *
2360 */
2361 DOMString SVGColorProfileRule::getName()
2362 { return name; }
2364 /**
2365 *
2366 */
2367 void SVGColorProfileRule::setName(const DOMString &val) throw (DOMException)
2368 { name = val; }
2370 /**
2371 *
2372 */
2373 unsigned short SVGColorProfileRule::getRenderingIntent()
2374 { return renderingIntent; }
2376 /**
2377 *
2378 */
2379 void SVGColorProfileRule::setRenderingIntent(unsigned short val) throw (DOMException)
2380 { renderingIntent = val; }
2383 //##################
2384 //# Non-API methods
2385 //##################
2387 /**
2388 *
2389 */
2390 SVGColorProfileRule::SVGColorProfileRule()
2391 {
2392 }
2394 /**
2395 *
2396 */
2397 SVGColorProfileRule::SVGColorProfileRule(const SVGColorProfileRule &other)
2398 : SVGCSSRule(other), SVGRenderingIntent(other)
2399 {
2400 renderingIntent = other.renderingIntent;
2401 src = other.src;
2402 name = other.name;
2403 }
2405 /**
2406 *
2407 */
2408 SVGColorProfileRule::~SVGColorProfileRule()
2409 {
2410 }
2413 /*#########################################################################
2414 ## SVGFilterPrimitiveStandardAttributes
2415 #########################################################################*/
2417 /**
2418 *
2419 */
2420 SVGAnimatedLength SVGFilterPrimitiveStandardAttributes::getX()
2421 { return x; }
2423 /**
2424 *
2425 */
2426 SVGAnimatedLength SVGFilterPrimitiveStandardAttributes::getY()
2427 { return y; }
2429 /**
2430 *
2431 */
2432 SVGAnimatedLength SVGFilterPrimitiveStandardAttributes::getWidth()
2433 { return width; }
2435 /**
2436 *
2437 */
2438 SVGAnimatedLength SVGFilterPrimitiveStandardAttributes::getHeight()
2439 { return height; }
2441 /**
2442 *
2443 */
2444 SVGAnimatedString SVGFilterPrimitiveStandardAttributes::getResult()
2445 { return result; }
2449 //##################
2450 //# Non-API methods
2451 //##################
2454 /**
2455 *
2456 */
2457 SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes()
2458 {
2459 }
2461 /**
2462 *
2463 */
2464 SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(
2465 const SVGFilterPrimitiveStandardAttributes &other)
2466 : SVGStylable(other)
2467 {
2468 x = other.x;
2469 y = other.y;
2470 width = other.width;
2471 height = other.height;
2472 result = other.result;
2473 }
2475 /**
2476 *
2477 */
2478 SVGFilterPrimitiveStandardAttributes::~SVGFilterPrimitiveStandardAttributes()
2479 {
2480 }
2483 /*#########################################################################
2484 ## SVGEvent
2485 #########################################################################*/
2487 /**
2488 *
2489 */
2490 SVGEvent:SVGEvent()
2491 {
2492 }
2494 /**
2495 *
2496 */
2497 SVGEvent:SVGEvent(const SVGEvent &other) : events::Event(other)
2498 {
2499 }
2501 /**
2502 *
2503 */
2504 SVGEvent::~SVGEvent()
2505 {
2506 }
2509 /*#########################################################################
2510 ## SVGZoomEvent
2511 #########################################################################*/
2513 /**
2514 *
2515 */
2516 SVGRect SVGZoomEvent::getZoomRectScreen()
2517 {
2518 return zoomRectScreen;
2519 }
2521 /**
2522 *
2523 */
2524 double SVGZoomEvent::getPreviousScale()
2525 {
2526 return previousScale;
2527 }
2529 /**
2530 *
2531 */
2532 SVGPoint SVGZoomEvent::getPreviousTranslate()
2533 {
2534 return previousTranslate;
2535 }
2537 /**
2538 *
2539 */
2540 double SVGZoomEvent::getNewScale()
2541 {
2542 return newScale;
2543 }
2545 /**
2546 *
2547 */
2548 SVGPoint SVGZoomEvent::getNewTranslate()
2549 {
2550 return newTranslate;
2551 }
2555 //##################
2556 //# Non-API methods
2557 //##################
2559 /**
2560 *
2561 */
2562 SVGZoomEvent::SVGZoomEvent()
2563 {
2564 }
2566 /**
2567 *
2568 */
2569 SVGZoomEvent::SVGZoomEvent(const SVGZoomEvent &other) :
2570 events::Event(other), events::UIEvent(other)
2571 {
2572 zoomRectScreen = other.zoomRectScreen;
2573 previousScale = other.previousScale;
2574 previousTranslate = other.previousTranslate;
2575 newScale = other.newScale;
2576 newTranslate = other.newTranslate;
2577 }
2579 /**
2580 *
2581 */
2582 SVGZoomEvent::~SVGZoomEvent()
2583 {
2584 }
2587 /*#########################################################################
2588 ## SVGElementInstance
2589 #########################################################################*/
2592 /**
2593 *
2594 */
2595 SVGElementPtr SVGElementInstance::getCorrespondingElement()
2596 {
2597 return correspondingElement;
2598 }
2600 /**
2601 *
2602 */
2603 SVGUseElementPtr SVGElementInstance::getCorrespondingUseElement()
2604 {
2605 return correspondingUseElement;
2606 }
2608 /**
2609 *
2610 */
2611 SVGElementInstance SVGElementInstance::getParentNode()
2612 {
2613 SVGElementInstance ret;
2614 return ret;
2615 }
2617 /**
2618 * Since we are using stack types and this is a circular definition,
2619 * we will instead implement this as a global function below:
2620 * SVGElementInstanceList getChildNodes(const SVGElementInstance instance);
2621 */
2622 //SVGElementInstanceList getChildNodes();
2624 /**
2625 *
2626 */
2627 SVGElementInstance SVGElementInstance::getFirstChild()
2628 {
2629 SVGElementInstance ret;
2630 return ret;
2631 }
2633 /**
2634 *
2635 */
2636 SVGElementInstance SVGElementInstance::getLastChild()
2637 {
2638 SVGElementInstance ret;
2639 return ret;
2640 }
2642 /**
2643 *
2644 */
2645 SVGElementInstance SVGElementInstance::getPreviousSibling()
2646 {
2647 SVGElementInstance ret;
2648 return ret;
2649 }
2651 /**
2652 *
2653 */
2654 SVGElementInstance SVGElementInstance::getNextSibling()
2655 {
2656 SVGElementInstance ret;
2657 return ret;
2658 }
2661 //##################
2662 //# Non-API methods
2663 //##################
2665 /**
2666 *
2667 */
2668 SVGElementInstance::SVGElementInstance()
2669 {
2670 }
2672 /**
2673 *
2674 */
2675 SVGElementInstance::SVGElementInstance(const SVGElementInstance &other)
2676 : events::EventTarget(other)
2677 {
2678 }
2680 /**
2681 *
2682 */
2683 SVGElementInstance::~SVGElementInstance()
2684 {
2685 }
2688 /*#########################################################################
2689 ## SVGElementInstanceList
2690 #########################################################################*/
2692 /**
2693 *
2694 */
2695 unsigned long SVGElementInstanceList::getLength()
2696 { return items.size(); }
2698 /**
2699 *
2700 */
2701 SVGElementInstance SVGElementInstanceList::item(unsigned long index)
2702 {
2703 if (index >= items.size())
2704 {
2705 SVGElementInstance ret;
2706 return ret;
2707 }
2708 return items[index];
2709 }
2711 /**
2712 * This static method replaces the circular definition of:
2713 * SVGElementInstanceList SVGElementInstance::getChildNodes()
2714 *
2715 */
2716 static SVGElementInstanceList SVGElementInstanceList::getChildNodes(const SVGElementInstance &/*instance*/)
2717 {
2718 SVGElementInstanceList list;
2719 return list;
2720 }
2723 //##################
2724 //# Non-API methods
2725 //##################
2727 /**
2728 *
2729 */
2730 SVGElementInstanceList::SVGElementInstanceList()
2731 {
2732 }
2734 /**
2735 *
2736 */
2737 SVGElementInstanceList::SVGElementInstanceList(const SVGElementInstanceList &other)
2738 {
2739 items = other.items;
2740 }
2742 /**
2743 *
2744 */
2745 SVGElementInstanceList::~SVGElementInstanceList()
2746 {
2747 }
2752 /*#########################################################################
2753 ## SVGValue
2754 #########################################################################*/
2756 /**
2757 * Constructor
2758 */
2759 SVGValue()
2760 {
2761 init();
2762 }
2764 /**
2765 * Copy constructor
2766 */
2767 SVGValue(const SVGValue &other)
2768 {
2769 assign(other);
2770 }
2772 /**
2773 * Assignment
2774 */
2775 SVGValue &operator=(const SVGValue &other)
2776 {
2777 assign(other);
2778 return *this;
2779 }
2781 /**
2782 *
2783 */
2784 ~SVGValue()
2785 {
2786 }
2788 //###########################
2789 // TYPES
2790 //###########################
2792 /**
2793 * Angle
2794 */
2795 SVGValue::SVGValue(const SVGAngle &v)
2796 {
2797 type = SVG_ANGLE;
2798 angleval = v;
2799 }
2801 SVGAngle SVGValue::angleValue()
2802 {
2803 return algleval;
2804 }
2806 /**
2807 * Boolean
2808 */
2809 SVGValue::SVGValue(bool v)
2810 {
2811 type = SVG_BOOLEAN;
2812 bval = v;
2813 }
2815 bool SVGValue::booleanValue()
2816 {
2817 return bval;
2818 }
2821 /**
2822 * Enumeration
2823 */
2824 SVGValue::SVGValue(short v)
2825 {
2826 type = SVG_ENUMERATION;
2827 eval = v;
2828 }
2830 short SVGValue::enumerationValue()
2831 {
2832 return eval;
2833 }
2835 /**
2836 * Integer
2837 */
2838 SVGValue::SVGValue(long v)
2839 {
2840 type = SVG_INTEGER;
2841 ival = v;
2842 }
2844 long SVGValue::integerValue()
2845 {
2846 return ival;
2847 }
2849 /**
2850 * Length
2851 */
2852 SVGValue::SVGValue(const SVGLength &v)
2853 {
2854 type = SVG_LENGTH;
2855 lengthval = v;
2856 }
2858 SVGLength SVGValue::lengthValue()
2859 {
2860 return lengthval;
2861 }
2863 /**
2864 * Number
2865 */
2866 SVGValue::SVGValue(double v)
2867 {
2868 type = SVG_NUMBER;
2869 dval = v;
2870 }
2872 double SVGValue::numberValue()
2873 {
2874 return dval;
2875 }
2877 /**
2878 * Points
2879 */
2880 SVGValue::SVGValue(const SVGPointList &v)
2881 {
2882 type = SVG_POINTS;
2883 plistval = v;
2884 }
2886 SVGPointList SVGValue::pointListValue()
2887 {
2888 return plistval;
2889 }
2892 /**
2893 * PreserveAspectRatio
2894 */
2895 SVGValue::SVGValue(const SVGPreserveAspectRatio &v)
2896 {
2897 type = SVG_PRESERVE_ASPECT_RATIO;
2898 parval = v;
2899 }
2901 SVGPreserveAspectRatio SVGValue::preserveAspectRatioValue()
2902 {
2903 return parval;
2904 }
2906 /**
2907 * Rect
2908 */
2909 SVGValue::SVGValue(const SVGRect &v)
2910 {
2911 type = SVG_RECT;
2912 rectval = v;
2913 }
2915 SVGRect SVGValue::rectValue()
2916 {
2917 return rectval;
2918 }
2920 /**
2921 * String
2922 */
2923 SVGValue::SVGValue(const DOMString &v)
2924 {
2925 type = SVG_STRING;
2926 sval = v;
2927 }
2929 DOMString SVGValue::stringValue()
2930 {
2931 return sval;
2932 }
2935 void SVGValue::init()
2936 {
2937 type = SVG_NUMBER;
2938 bval = false;
2939 eval = 0;
2940 ival = 0;
2941 dval = 0.0;
2942 }
2944 void SVGValue::assign(const SVGValue &other)
2945 {
2946 type = other.type;
2947 angleval = other.angleval;
2948 bval = other.bval;
2949 eval = other.eval;
2950 ival = other.ival;
2951 lengthval = other.lengthval;
2952 dval = other.dval;
2953 parval = other.parval;
2954 rval = other.rval;
2955 sval = other.sval;
2956 }
2959 /*#########################################################################
2960 ## SVGTransformList
2961 #########################################################################*/
2964 /*#########################################################################
2965 ## SVGStringList
2966 #########################################################################*/
2969 /*#########################################################################
2970 ## SVGNumberList
2971 #########################################################################*/
2974 /*#########################################################################
2975 ## SVGLengthList
2976 #########################################################################*/
2979 /*#########################################################################
2980 ## SVGPointList
2981 #########################################################################*/
2983 /*#########################################################################
2984 ## SVGPathSegList
2985 #########################################################################*/
2987 /*#########################################################################
2988 ## SVGValueList
2989 #########################################################################*/
2992 /**
2993 *
2994 */
2995 unsigned long SVGValueList::getNumberOfItems()
2996 {
2997 return items.size();
2998 }
3000 /**
3001 *
3002 */
3003 void SVGValueList::clear() throw (DOMException)
3004 {
3005 items.clear();
3006 }
3008 /**
3009 *
3010 */
3011 SVGValue SVGValueList::initialize(const SVGValue& newItem)
3012 throw (DOMException, SVGException)
3013 {
3014 items.clear();
3015 items.push_back(newItem);
3016 return newItem;
3017 }
3019 /**
3020 *
3021 */
3022 SVGValue SVGValueList::getItem(unsigned long index) throw (DOMException)
3023 {
3024 if (index >= items.size())
3025 return "";
3026 return items[index];
3027 }
3029 /**
3030 *
3031 */
3032 SVGValue SVGValueList::insertItemBefore(const SVGValue& newItem,
3033 unsigned long index)
3034 throw (DOMException, SVGException)
3035 {
3036 if (index>=items.size())
3037 {
3038 items.push_back(newItem);
3039 }
3040 else
3041 {
3042 std::vector<SVGValue>::iterator iter = items.begin() + index;
3043 items.insert(iter, newItem);
3044 }
3045 return newItem;
3046 }
3048 /**
3049 *
3050 */
3051 SVGValue SVGValueList::replaceItem (const SVGValue& newItem,
3052 unsigned long index)
3053 throw (DOMException, SVGException)
3054 {
3055 if (index>=items.size())
3056 return "";
3057 std::vector<SVGValue>::iterator iter = items.begin() + index;
3058 *iter = newItem;
3059 return newItem;
3060 }
3062 /**
3063 *
3064 */
3065 SVGValue SVGValueList::removeItem (unsigned long index)
3066 throw (DOMException)
3067 {
3068 if (index>=items.size())
3069 return "";
3070 std::vector<SVGValue>::iterator iter = items.begin() + index;
3071 SVGValue oldval = *iter;
3072 items.erase(iter);
3073 return oldval;
3074 }
3076 /**
3077 *
3078 */
3079 SVGValue SVGValueList::appendItem (const SVGValue& newItem)
3080 throw (DOMException, SVGException)
3081 {
3082 items.push_back(newItem);
3083 return newItem;
3084 }
3087 /**
3088 * Matrix
3089 */
3090 SVGValue SVGValueList::createSVGTransformFromMatrix(const SVGValue &matrix)
3091 {
3092 }
3094 /**
3095 * Matrix
3096 */
3097 SVGValue SVGValueList::consolidate()
3098 {
3099 }
3103 //##################
3104 //# Non-API methods
3105 //##################
3107 /**
3108 *
3109 */
3110 SVGValueList::SVGValueList()
3111 {
3112 }
3114 /**
3115 *
3116 */
3117 SVGValueList::SVGValueList(const SVGValueList &other)
3118 {
3119 items = other.items;
3120 }
3122 /**
3123 *
3124 */
3125 SVGValueList::~SVGValueList()
3126 {
3127 }
3133 /*#########################################################################
3134 ## SVGAnimatedValue
3135 #########################################################################*/
3140 /**
3141 *
3142 */
3143 SVGValue &SVGAnimatedValue::getBaseVal()
3144 {
3145 return baseVal;
3146 }
3148 /**
3149 *
3150 */
3151 void SVGAnimatedValue::setBaseVal(const SVGValue &val) throw (DOMException)
3152 {
3153 baseVal = val;
3154 }
3156 /**
3157 *
3158 */
3159 SVGValue &SVGAnimatedValue::getAnimVal()
3160 {
3161 return animVal;
3162 }
3165 /**
3166 *
3167 */
3168 SVGAnimatedValue::SVGAnimatedValue()
3169 {
3170 init();
3171 }
3174 /**
3175 *
3176 */
3177 SVGAnimatedValue::SVGAnimatedValue(const SVGValue &v)
3178 {
3179 init();
3180 baseVal = v;
3181 }
3184 /**
3185 *
3186 */
3187 SVGAnimatedValue::SVGAnimatedValue(const SVGValue &bv, const SVGValue &av)
3188 {
3189 init();
3190 baseVal = bv;
3191 animVal = av;
3192 }
3195 /**
3196 *
3197 */
3198 SVGAnimatedValue::SVGAnimatedValue(const SVGAnimatedValue &other)
3199 {
3200 assign(other);
3201 }
3204 /**
3205 *
3206 */
3207 SVGAnimatedValue &SVGAnimatedValue::operator=(const SVGAnimatedValue &other)
3208 {
3209 assign(other);
3210 return *this;
3211 }
3214 /**
3215 *
3216 */
3217 SVGAnimatedValue &SVGAnimatedValue::operator=(const SVGValue &bv)
3218 {
3219 init();
3220 baseVal = bv;
3221 }
3224 /**
3225 *
3226 */
3227 SVGAnimatedValue::~SVGAnimatedValue()
3228 {
3229 }
3233 void SVGAnimatedValue::init()
3234 {
3235 }
3238 void SVGAnimatedValue::assign(const SVGAnimatedValue &other)
3239 {
3240 baseVal = other.baseVal;
3241 animVal = other.animVal;
3242 }
3264 //########################################################################
3265 //########################################################################
3266 //########################################################################
3267 //# D O M
3268 //########################################################################
3269 //########################################################################
3270 //########################################################################
3278 /*#########################################################################
3279 ## SVGElement
3280 #########################################################################*/
3283 //####################################################################
3284 //# BASE METHODS FOR SVGElement
3285 //####################################################################
3287 /**
3288 * Get the value of the id attribute on the given element.
3289 */
3290 DOMString getId()
3291 {
3292 }
3294 /**
3295 * Set the value of the id attribute on the given element.
3296 */
3297 void setId(const DOMString &val) throw (DOMException)
3298 {
3299 }
3302 /**
3303 * Corresponds to attribute xml:base on the given element.
3304 */
3305 DOMString getXmlBase()
3306 {
3307 }
3310 /**
3311 * Corresponds to attribute xml:base on the given element.
3312 */
3313 void setXmlBase(const DOMString &val) throw (DOMException)
3314 {
3315 }
3317 /**
3318 * The nearest ancestor 'svg' element. Null if the given element is the
3319 * outermost 'svg' element.
3320 */
3321 SVGElementPtr getOwnerSVGElement()
3322 {
3323 }
3325 /**
3326 * The element which established the current viewport. Often, the nearest
3327 * ancestor 'svg' element. Null if the given element is the outermost 'svg'
3328 * element.
3329 */
3330 SVGElementPtr getViewportElement()
3331 {
3332 }
3335 //####################################################################
3336 //####################################################################
3337 //# I N T E R F A C E S
3338 //####################################################################
3339 //####################################################################
3341 //####################################################################
3342 //# SVGAngle
3343 //####################################################################
3345 /**
3346 *
3347 */
3348 unsigned short getUnitType()
3349 {
3350 }
3352 /**
3353 *
3354 */
3355 double getValue()
3356 {
3357 }
3359 /**
3360 *
3361 */
3362 void setValue(double val) throw (DOMException)
3363 {
3364 }
3366 /**
3367 *
3368 */
3369 double getValueInSpecifiedUnits()
3370 {
3371 }
3373 /**
3374 *
3375 */
3376 void setValueInSpecifiedUnits(double /*val*/) throw (DOMException)
3377 {
3378 }
3380 /**
3381 *
3382 */
3383 DOMString getValueAsString()
3384 {
3385 }
3387 /**
3388 *
3389 */
3390 void setValueAsString(const DOMString &/*val*/) throw (DOMException)
3391 {
3392 }
3395 /**
3396 *
3397 */
3398 void newValueSpecifiedUnits(unsigned short /*unitType*/,
3399 double /*valueInSpecifiedUnits*/)
3400 {
3401 }
3403 /**
3404 *
3405 */
3406 void convertToSpecifiedUnits(unsigned short /*unitType*/)
3407 {
3408 }
3410 //####################################################################
3411 //## The following animated types are rolled up into a single
3412 //## SVGAnimatedValue interface
3413 //####################################################################
3415 //####################################################################
3416 //## SVGAnimatedAngle
3417 //####################################################################
3419 //####################################################################
3420 //## SVGAnimatedBoolean
3421 //####################################################################
3423 //####################################################################
3424 //## SVGAnimatedEnumeration
3425 //####################################################################
3427 //####################################################################
3428 //## SVGAnimatedInteger
3429 //####################################################################
3431 //####################################################################
3432 //## SVGAnimatedLength
3433 //####################################################################
3435 //####################################################################
3436 //## SVGAnimatedLengthList
3437 //####################################################################
3439 //####################################################################
3440 //## SVGAnimatedNumber
3441 //####################################################################
3443 //####################################################################
3444 //## SVGAnimatedNumberList
3445 //####################################################################
3447 //####################################################################
3448 //## SVGAnimatedPathData
3449 //####################################################################
3451 //####################################################################
3452 //## SVGAnimatedPoints
3453 //####################################################################
3455 //####################################################################
3456 //## SVGAnimatedPreserveAspectRatio
3457 //####################################################################
3459 //####################################################################
3460 //## SVGAnimatedRect
3461 //####################################################################
3463 //####################################################################
3464 //## SVGAnimatedString
3465 //####################################################################
3467 //####################################################################
3468 //## SVGAnimatedTransformList
3469 //####################################################################
3471 //####################################################################
3472 //# SVGAnimatedValue
3473 //####################################################################
3475 /**
3476 *
3477 */
3478 SVGValue &getBaseVal()
3479 {
3480 return baseVal();
3481 }
3483 /**
3484 *
3485 */
3486 void setBaseVal(const SVGValue &val) throw (DOMException)
3487 {
3488 baseVal = val;
3489 }
3491 /**
3492 *
3493 */
3494 SVGValue &getAnimVal()
3495 {
3496 return animVal;
3497 }
3501 //####################################################################
3502 //# SVGColor
3503 //####################################################################
3505 /**
3506 * From CSSValue
3507 * A code defining the type of the value as defined above.
3508 */
3509 unsigned short getCssValueType()
3510 {
3511 }
3513 /**
3514 * From CSSValue
3515 * A string representation of the current value.
3516 */
3517 DOMString getCssText()
3518 {
3519 }
3521 /**
3522 * From CSSValue
3523 * A string representation of the current value.
3524 * Note that setting implies parsing.
3525 */
3526 void setCssText(const DOMString &val) throw (dom::DOMException)
3527 {
3528 }
3531 /**
3532 *
3533 */
3534 unsigned short getColorType()
3535 {
3536 }
3538 /**
3539 *
3540 */
3541 css::RGBColor getRgbColor()
3542 {
3543 }
3545 /**
3546 *
3547 */
3548 SVGICCColor getIccColor()
3549 {
3550 }
3553 /**
3554 *
3555 */
3556 void setRGBColor(const DOMString& /*rgbColor*/) throw (SVGException)
3557 {
3558 }
3560 /**
3561 *
3562 */
3563 void setRGBColorICCColor(const DOMString& /*rgbColor*/,
3564 const DOMString& /*iccColor*/)
3565 throw (SVGException)
3566 {
3567 }
3569 /**
3570 *
3571 */
3572 void setColor(unsigned short /*colorType*/,
3573 const DOMString& /*rgbColor*/,
3574 const DOMString& /*iccColor*/)
3575 throw (SVGException)
3576 {
3577 }
3579 //####################################################################
3580 //# SVGCSSRule
3581 //####################################################################
3583 /**
3584 * From CSSRule
3585 * The type of the rule, as defined above. The expectation is that
3586 * binding-specific casting methods can be used to cast down from an instance of
3587 * the CSSRule interface to the specific derived interface implied by the type.
3588 */
3589 unsigned short getType()
3590 {
3591 }
3593 /**
3594 * From CSSRule
3595 * The parsable textual representation of the rule. This reflects the current
3596 * state of the rule and not its initial value.
3597 */
3598 DOMString getCssText()
3599 {
3600 }
3602 /**
3603 * From CSSRule
3604 * The parsable textual representation of the rule. This reflects the current
3605 * state of the rule and not its initial value.
3606 * Note that setting involves reparsing.
3607 */
3608 void setCssText(const DOMString &val) throw (DOMException)
3609 {
3610 }
3612 /**
3613 * From CSSRule
3614 * The style sheet that contains this rule.
3615 */
3616 css::CSSStyleSheet *getParentStyleSheet()
3617 {
3618 }
3620 /**
3621 * From CSSRule
3622 * If this rule is contained inside another rule(e.g. a style rule inside an
3623 * @media block), this is the containing rule. If this rule is not nested inside
3624 * any other rules, this returns null.
3625 */
3626 css::CSSRule *getParentRule()
3627 {
3628 }
3630 //####################################################################
3631 //# SVGExternalResourcesRequired
3632 //####################################################################
3634 /**
3635 *
3636 */
3637 SVGAnimatedBoolean getExternalResourcesRequired()
3638 {
3639 }
3641 //####################################################################
3642 //# SVGFitToViewBox
3643 //####################################################################
3645 /**
3646 *
3647 */
3648 SVGAnimatedRect getViewBox()
3649 {
3650 }
3652 /**
3653 *
3654 */
3655 SVGAnimatedPreserveAspectRatio getPreserveAspectRatio()
3656 {
3657 }
3659 //####################################################################
3660 //# SVGICCColor
3661 //####################################################################
3663 /**
3664 *
3665 */
3666 DOMString getColorProfile()
3667 {
3668 }
3670 /**
3671 *
3672 */
3673 void setColorProfile(const DOMString &val) throw (DOMException)
3674 {
3675 }
3677 /**
3678 *
3679 */
3680 SVGNumberList &getColors()
3681 {
3682 }
3684 //####################################################################
3685 //# SVGLangSpace
3686 //####################################################################
3688 /**
3689 *
3690 */
3691 DOMString getXmllang()
3692 {
3693 }
3695 /**
3696 *
3697 */
3698 void setXmllang(const DOMString &val) throw (DOMException)
3699 {
3700 }
3702 /**
3703 *
3704 */
3705 DOMString getXmlspace()
3706 {
3707 }
3709 /**
3710 *
3711 */
3712 void setXmlspace(const DOMString &val) throw (DOMException)
3713 {
3714 }
3716 //####################################################################
3717 //# SVGLength
3718 //####################################################################
3720 /**
3721 *
3722 */
3723 unsigned short getUnitType()
3724 {
3725 }
3727 /**
3728 *
3729 */
3730 double getValue()
3731 {
3732 }
3734 /**
3735 *
3736 */
3737 void setValue(double val) throw (DOMException)
3738 {
3739 }
3741 /**
3742 *
3743 */
3744 double getValueInSpecifiedUnits()
3745 {
3746 }
3748 /**
3749 *
3750 */
3751 void setValueInSpecifiedUnits(double /*val*/) throw (DOMException)
3752 {
3753 }
3755 /**
3756 *
3757 */
3758 DOMString getValueAsString()
3759 {
3760 }
3762 /**
3763 *
3764 */
3765 void setValueAsString(const DOMString& /*val*/) throw (DOMException)
3766 {
3767 }
3770 /**
3771 *
3772 */
3773 void newValueSpecifiedUnits(unsigned short /*unitType*/, double /*val*/)
3774 {
3775 }
3777 /**
3778 *
3779 */
3780 void convertToSpecifiedUnits(unsigned short /*unitType*/)
3781 {
3782 }
3785 //####################################################################
3786 //## SVGLengthList - see SVGValueList
3787 //####################################################################
3791 //####################################################################
3792 //# SVGLocatable
3793 //####################################################################
3795 /**
3796 *
3797 */
3798 SVGElementPtr getNearestViewportElement()
3799 {
3800 }
3802 /**
3803 *
3804 */
3805 SVGElement *getFarthestViewportElement()
3806 {
3807 }
3809 /**
3810 *
3811 */
3812 SVGRect getBBox()
3813 {
3814 }
3816 /**
3817 *
3818 */
3819 SVGMatrix getCTM()
3820 {
3821 }
3823 /**
3824 *
3825 */
3826 SVGMatrix getScreenCTM()
3827 {
3828 }
3830 /**
3831 *
3832 */
3833 SVGMatrix getTransformToElement(const SVGElement &/*element*/)
3834 throw (SVGException)
3835 {
3836 }
3838 //####################################################################
3839 //# SVGNumber
3840 //####################################################################
3842 /**
3843 *
3844 */
3845 double getValue()
3846 {
3847 }
3849 /**
3850 *
3851 */
3852 void setValue(double val) throw (DOMException)
3853 {
3854 }
3856 //####################################################################
3857 //# SVGNumberList - see SVGValueList
3858 //####################################################################
3861 //####################################################################
3862 //# SVGRect
3863 //####################################################################
3865 /**
3866 *
3867 */
3868 double getX()
3869 {
3870 }
3872 /**
3873 *
3874 */
3875 void setX(double val) throw (DOMException)
3876 {
3877 }
3879 /**
3880 *
3881 */
3882 double getY()
3883 {
3884 }
3886 /**
3887 *
3888 */
3889 void setY(double val) throw (DOMException)
3890 {
3891 }
3893 /**
3894 *
3895 */
3896 double getWidth()
3897 {
3898 }
3900 /**
3901 *
3902 */
3903 void setWidth(double val) throw (DOMException)
3904 {
3905 }
3907 /**
3908 *
3909 */
3910 double getHeight()
3911 {
3912 }
3914 /**
3915 *
3916 */
3917 void setHeight(double val) throw (DOMException)
3918 {
3919 }
3921 //####################################################################
3922 //# SVGRenderingIntent
3923 //####################################################################
3925 //####################################################################
3926 //# SVGStringList - see SVGValueList
3927 //####################################################################
3929 //####################################################################
3930 //# SVGStylable
3931 //####################################################################
3933 /**
3934 *
3935 */
3936 SVGAnimatedString getClassName()
3937 {
3938 }
3940 /**
3941 *
3942 */
3943 css::CSSStyleDeclaration getStyle()
3944 {
3945 }
3947 /**
3948 *
3949 */
3950 css::CSSValue getPresentationAttribute(const DOMString& /*name*/)
3951 {
3952 }
3954 //####################################################################
3955 //# SVGTests
3956 //####################################################################
3958 /**
3959 *
3960 */
3961 SVGValueList &getRequiredFeatures()
3962 {
3963 }
3965 /**
3966 *
3967 */
3968 SVGValueList &getRequiredExtensions()
3969 {
3970 }
3972 /**
3973 *
3974 */
3975 SVGValueList &getSystemLanguage()
3976 {
3977 }
3979 /**
3980 *
3981 */
3982 bool hasExtension(const DOMString& /*extension*/)
3983 {
3984 }
3986 //####################################################################
3987 //# SVGTransformable
3988 //####################################################################
3990 /**
3991 *
3992 */
3993 SVGAnimatedList &getTransform()
3994 {
3995 }
3997 //####################################################################
3998 //# SVGUnitTypes
3999 //####################################################################
4001 //####################################################################
4002 //# SVGURIReference
4003 //####################################################################
4005 /**
4006 *
4007 */
4008 SVGAnimatedValue getHref()
4009 {
4010 }
4012 //####################################################################
4013 //## SVGValueList - consolidation of other lists
4014 //####################################################################
4016 /**
4017 *
4018 */
4019 unsigned long SVGElement::getNumberOfItems()
4020 {
4021 return items.size();
4022 }
4024 /**
4025 *
4026 */
4027 void SVGElement::clear() throw (DOMException)
4028 {
4029 items.clear();
4030 }
4032 /**
4033 *
4034 */
4035 SVGValue SVGElement::initialize(const SVGValue& newItem)
4036 throw (DOMException, SVGException)
4037 {
4038 items.clear();
4039 items.push_back(newItem);
4040 return newItem;
4041 }
4043 /**
4044 *
4045 */
4046 SVGValue SVGElement::getItem(unsigned long index) throw (DOMException)
4047 {
4048 if (index >= items.size())
4049 return "";
4050 return items[index];
4051 }
4053 /**
4054 *
4055 */
4056 SVGValue SVGElement::insertItemBefore(const SVGValue& newItem,
4057 unsigned long index)
4058 throw (DOMException, SVGException)
4059 {
4060 if (index>=items.size())
4061 {
4062 items.push_back(newItem);
4063 }
4064 else
4065 {
4066 std::vector<SVGValue>::iterator iter = items.begin() + index;
4067 items.insert(iter, newItem);
4068 }
4069 return newItem;
4070 }
4072 /**
4073 *
4074 */
4075 SVGValue SVGElement::replaceItem (const SVGValue& newItem,
4076 unsigned long index)
4077 throw (DOMException, SVGException)
4078 {
4079 if (index>=items.size())
4080 return "";
4081 std::vector<SVGValue>::iterator iter = items.begin() + index;
4082 *iter = newItem;
4083 return newItem;
4084 }
4086 /**
4087 *
4088 */
4089 SVGValue SVGElement::removeItem (unsigned long index)
4090 throw (DOMException)
4091 {
4092 if (index>=items.size())
4093 return "";
4094 std::vector<SVGValue>::iterator iter = items.begin() + index;
4095 SVGValue oldval = *iter;
4096 items.erase(iter);
4097 return oldval;
4098 }
4100 /**
4101 *
4102 */
4103 SVGValue SVGElement::appendItem (const SVGValue& newItem)
4104 throw (DOMException, SVGException)
4105 {
4106 items.push_back(newItem);
4107 return newItem;
4108 }
4111 /**
4112 * Matrix
4113 */
4114 SVGValue SVGElement::createSVGTransformFromMatrix(const SVGValue &matrix)
4115 {
4116 }
4118 /**
4119 * Matrix
4120 */
4121 SVGValue SVGElement::consolidate()
4122 {
4123 }
4126 //####################################################################
4127 //# SVGViewSpec
4128 //####################################################################
4130 /**
4131 *
4132 */
4133 //SVGTransformList getTransform()
4134 //{
4135 //}
4137 /**
4138 *
4139 */
4140 SVGElementPtr getViewTarget()
4141 {
4142 }
4144 /**
4145 *
4146 */
4147 DOMString getViewBoxString()
4148 {
4149 }
4151 /**
4152 *
4153 */
4154 DOMString getPreserveAspectRatioString()
4155 {
4156 }
4158 /**
4159 *
4160 */
4161 DOMString getTransformString()
4162 {
4163 }
4165 /**
4166 *
4167 */
4168 DOMString getViewTargetString()
4169 {
4170 }
4172 //####################################################################
4173 //# SVGZoomAndPan
4174 //####################################################################
4176 /**
4177 *
4178 */
4179 unsigned short getZoomAndPan()
4180 {
4181 }
4183 /**
4184 *
4185 */
4186 void setZoomAndPan(unsigned short val) throw (DOMException)
4187 {
4188 }
4190 //####################################################################
4191 //####################################################################
4192 //# E L E M E N T S
4193 //####################################################################
4194 //####################################################################
4196 //####################################################################
4197 //# SVGAElement
4198 //####################################################################
4201 /**
4202 *
4203 */
4204 SVGAnimatedString getTarget()
4205 {
4206 }
4210 //####################################################################
4211 //# SVGAltGlyphElement
4212 //####################################################################
4215 /**
4216 * Get the attribute glyphRef on the given element.
4217 */
4218 DOMString getGlyphRef()
4219 {
4220 }
4222 /**
4223 * Set the attribute glyphRef on the given element.
4224 */
4225 void setGlyphRef(const DOMString &val) throw (DOMException)
4226 {
4227 }
4229 /**
4230 * Get the attribute format on the given element.
4231 */
4232 DOMString getFormat()
4233 {
4234 }
4236 /**
4237 * Set the attribute format on the given element.
4238 */
4239 void setFormat(const DOMString &val) throw (DOMException)
4240 {
4241 }
4244 //####################################################################
4245 //# SVGAltGlyphDefElement
4246 //####################################################################
4248 //####################################################################
4249 //# SVGAltGlyphItemElement
4250 //####################################################################
4253 //####################################################################
4254 //# SVGAnimateElement
4255 //####################################################################
4258 //####################################################################
4259 //# SVGAnimateColorElement
4260 //####################################################################
4262 //####################################################################
4263 //# SVGAnimateMotionElement
4264 //####################################################################
4267 //####################################################################
4268 //# SVGAnimateTransformElement
4269 //####################################################################
4272 //####################################################################
4273 //# SVGAnimationElement
4274 //####################################################################
4277 /**
4278 *
4279 */
4280 SVGElementPtr getTargetElement()
4281 {
4282 }
4284 /**
4285 *
4286 */
4287 double getStartTime()
4288 {
4289 }
4291 /**
4292 *
4293 */
4294 double getCurrentTime()
4295 {
4296 }
4298 /**
4299 *
4300 */
4301 double getSimpleDuration() throw (DOMException)
4302 {
4303 }
4307 //####################################################################
4308 //# SVGCircleElement
4309 //####################################################################
4311 /**
4312 * Corresponds to attribute cx on the given 'circle' element.
4313 */
4314 SVGAnimatedLength getCx()
4315 {
4316 }
4318 /**
4319 * Corresponds to attribute cy on the given 'circle' element.
4320 */
4321 SVGAnimatedLength getCy()
4322 {
4323 }
4325 /**
4326 * Corresponds to attribute r on the given 'circle' element.
4327 */
4328 SVGAnimatedLength getR()
4329 {
4330 }
4332 //####################################################################
4333 //# SVGClipPathElement
4334 //####################################################################
4337 /**
4338 * Corresponds to attribute clipPathUnits on the given 'clipPath' element.
4339 * Takes one of the constants defined in SVGUnitTypes.
4340 */
4341 SVGAnimatedEnumeration getClipPathUnits()
4342 {
4343 }
4347 //####################################################################
4348 //# SVGColorProfileElement
4349 //####################################################################
4352 /**
4353 * Get the attribute local on the given element.
4354 */
4355 DOMString getLocal()
4356 {
4357 }
4359 /**
4360 * Set the attribute local on the given element.
4361 */
4362 void setLocal(const DOMString &val) throw (DOMException)
4363 {
4364 }
4366 /**
4367 * Get the attribute name on the given element.
4368 */
4369 DOMString getName()
4370 {
4371 }
4373 /**
4374 * Set the attribute name on the given element.
4375 */
4376 void setName(const DOMString &val) throw (DOMException)
4377 {
4378 }
4380 /**
4381 * Set the attribute rendering-intent on the given element.
4382 * The type of rendering intent, identified by one of the
4383 * SVGRenderingIntent constants.
4384 */
4385 unsigned short getRenderingIntent()
4386 {
4387 }
4389 /**
4390 * Get the attribute rendering-intent on the given element.
4391 */
4392 void setRenderingIntent(unsigned short val) throw (DOMException)
4393 {
4394 }
4397 //####################################################################
4398 //# SVGComponentTransferFunctionElement
4399 //####################################################################
4401 /**
4402 * Corresponds to attribute type on the given element. Takes one
4403 * of the Component Transfer Types.
4404 */
4405 SVGAnimatedEnumeration getType()
4406 {
4407 }
4409 /**
4410 * Corresponds to attribute tableValues on the given element.
4411 */
4412 SVGAnimatedNumberList getTableValues()
4413 {
4414 }
4416 /**
4417 * Corresponds to attribute slope on the given element.
4418 */
4419 SVGAnimatedNumber getSlope()
4420 {
4421 }
4423 /**
4424 * Corresponds to attribute intercept on the given element.
4425 */
4426 SVGAnimatedNumber getIntercept()
4427 {
4428 }
4430 /**
4431 * Corresponds to attribute amplitude on the given element.
4432 */
4433 SVGAnimatedNumber getAmplitude()
4434 {
4435 }
4437 /**
4438 * Corresponds to attribute exponent on the given element.
4439 */
4440 SVGAnimatedNumber getExponent()
4441 {
4442 }
4444 /**
4445 * Corresponds to attribute offset on the given element.
4446 */
4447 SVGAnimatedNumber getOffset()
4448 {
4449 }
4451 //####################################################################
4452 //# SVGCursorElement
4453 //####################################################################
4455 /**
4456 *
4457 */
4458 SVGAnimatedLength getX()
4459 {
4460 }
4462 /**
4463 *
4464 */
4465 SVGAnimatedLength getY()
4466 {
4467 }
4470 //####################################################################
4471 //# SVGDefinitionSrcElement
4472 //####################################################################
4474 //####################################################################
4475 //# SVGDefsElement
4476 //####################################################################
4478 //####################################################################
4479 //# SVGDescElement
4480 //####################################################################
4482 //####################################################################
4483 //# SVGEllipseElement
4484 //####################################################################
4486 /**
4487 * Corresponds to attribute cx on the given 'ellipse' element.
4488 */
4489 SVGAnimatedLength getCx()
4490 {
4491 }
4493 /**
4494 * Corresponds to attribute cy on the given 'ellipse' element.
4495 */
4496 SVGAnimatedLength getCy()
4497 {
4498 }
4500 /**
4501 * Corresponds to attribute rx on the given 'ellipse' element.
4502 */
4503 SVGAnimatedLength getRx()
4504 {
4505 }
4507 /**
4508 * Corresponds to attribute ry on the given 'ellipse' element.
4509 */
4510 SVGAnimatedLength getRy()
4511 {
4512 }
4515 //####################################################################
4516 //# SVGFEBlendElement
4517 //####################################################################
4519 /**
4520 * Corresponds to attribute in on the given 'feBlend' element.
4521 */
4522 SVGAnimatedString getIn1()
4523 {
4524 }
4526 /**
4527 * Corresponds to attribute in2 on the given 'feBlend' element.
4528 */
4529 SVGAnimatedString getIn2()
4530 {
4531 }
4533 /**
4534 * Corresponds to attribute mode on the given 'feBlend' element.
4535 * Takes one of the Blend Mode Types.
4536 */
4537 SVGAnimatedEnumeration getMode()
4538 {
4539 }
4542 //####################################################################
4543 //# SVGFEColorMatrixElement
4544 //####################################################################
4546 /**
4547 * Corresponds to attribute in on the given 'feColorMatrix' element.
4548 */
4549 SVGAnimatedString getIn1()
4550 {
4551 }
4553 /**
4554 * Corresponds to attribute type on the given 'feColorMatrix' element.
4555 * Takes one of the Color Matrix Types.
4556 */
4557 SVGAnimatedEnumeration getType()
4558 {
4559 }
4561 /**
4562 * Corresponds to attribute values on the given 'feColorMatrix' element.
4563 * Provides access to the contents of the values attribute.
4564 */
4565 SVGAnimatedNumberList getValues()
4566 {
4567 }
4570 //####################################################################
4571 //# SVGFEComponentTransferElement
4572 //####################################################################
4575 /**
4576 * Corresponds to attribute in on the given 'feComponentTransfer' element.
4577 */
4578 SVGAnimatedString getIn1()
4579 {
4580 }
4582 //####################################################################
4583 //# SVGFECompositeElement
4584 //####################################################################
4586 /**
4587 * Corresponds to attribute in on the given 'feComposite' element.
4588 */
4589 SVGAnimatedString getIn1()
4590 {
4591 }
4593 /**
4594 * Corresponds to attribute in2 on the given 'feComposite' element.
4595 */
4596 SVGAnimatedString getIn2()
4597 {
4598 }
4600 /**
4601 * Corresponds to attribute operator on the given 'feComposite' element.
4602 * Takes one of the Composite Operators.
4603 */
4604 SVGAnimatedEnumeration getOperator()
4605 {
4606 }
4608 /**
4609 * Corresponds to attribute k1 on the given 'feComposite' element.
4610 */
4611 SVGAnimatedNumber getK1()
4612 {
4613 }
4615 /**
4616 * Corresponds to attribute k2 on the given 'feComposite' element.
4617 */
4618 SVGAnimatedNumber getK2()
4619 {
4620 }
4622 /**
4623 * Corresponds to attribute k3 on the given 'feComposite' element.
4624 */
4625 SVGAnimatedNumber getK3()
4626 {
4627 }
4629 /**
4630 * Corresponds to attribute k4 on the given 'feComposite' element.
4631 */
4632 SVGAnimatedNumber getK4()
4633 {
4634 }
4637 //####################################################################
4638 //# SVGFEConvolveMatrixElement
4639 //####################################################################
4642 /**
4643 * Corresponds to attribute order on the given 'feConvolveMatrix' element.
4644 */
4645 SVGAnimatedInteger getOrderX()
4646 {
4647 }
4649 /**
4650 * Corresponds to attribute order on the given 'feConvolveMatrix' element.
4651 */
4652 SVGAnimatedInteger getOrderY()
4653 {
4654 }
4656 /**
4657 * Corresponds to attribute kernelMatrix on the given element.
4658 */
4659 SVGAnimatedNumberList getKernelMatrix()
4660 {
4661 }
4663 /**
4664 * Corresponds to attribute divisor on the given 'feConvolveMatrix' element.
4665 */
4666 SVGAnimatedNumber getDivisor()
4667 {
4668 }
4670 /**
4671 * Corresponds to attribute bias on the given 'feConvolveMatrix' element.
4672 */
4673 SVGAnimatedNumber getBias()
4674 {
4675 }
4677 /**
4678 * Corresponds to attribute targetX on the given 'feConvolveMatrix' element.
4679 */
4680 SVGAnimatedInteger getTargetX()
4681 {
4682 }
4684 /**
4685 * Corresponds to attribute targetY on the given 'feConvolveMatrix' element.
4686 */
4687 SVGAnimatedInteger getTargetY()
4688 {
4689 }
4691 /**
4692 * Corresponds to attribute edgeMode on the given 'feConvolveMatrix'
4693 * element. Takes one of the Edge Mode Types.
4694 */
4695 SVGAnimatedEnumeration getEdgeMode()
4696 {
4697 }
4699 /**
4700 * Corresponds to attribute kernelUnitLength on the
4701 * given 'feConvolveMatrix' element.
4702 */
4703 SVGAnimatedLength getKernelUnitLengthX()
4704 {
4705 }
4707 /**
4708 * Corresponds to attribute kernelUnitLength on the given
4709 * 'feConvolveMatrix' element.
4710 */
4711 SVGAnimatedLength getKernelUnitLengthY()
4712 {
4713 }
4715 /**
4716 * Corresponds to attribute preserveAlpha on the
4717 * given 'feConvolveMatrix' element.
4718 */
4719 SVGAnimatedBoolean getPreserveAlpha()
4720 {
4721 }
4725 //####################################################################
4726 //# SVGFEDiffuseLightingElement
4727 //####################################################################
4730 /**
4731 * Corresponds to attribute in on the given 'feDiffuseLighting' element.
4732 */
4733 SVGAnimatedString getIn1()
4734 {
4735 }
4737 /**
4738 * Corresponds to attribute surfaceScale on the given
4739 * 'feDiffuseLighting' element.
4740 */
4741 SVGAnimatedNumber getSurfaceScale()
4742 {
4743 }
4745 /**
4746 * Corresponds to attribute diffuseConstant on the given
4747 * 'feDiffuseLighting' element.
4748 */
4749 SVGAnimatedNumber getDiffuseConstant()
4750 {
4751 }
4753 /**
4754 * Corresponds to attribute kernelUnitLength on the given
4755 * 'feDiffuseLighting' element.
4756 */
4757 SVGAnimatedNumber getKernelUnitLengthX()
4758 {
4759 }
4761 /**
4762 * Corresponds to attribute kernelUnitLength on the given
4763 * 'feDiffuseLighting' element.
4764 */
4765 SVGAnimatedNumber getKernelUnitLengthY()
4766 {
4767 }
4772 //####################################################################
4773 //# SVGFEDisplacementMapElement
4774 //####################################################################
4776 /**
4777 *
4778 */
4779 SVGAnimatedString getIn1()
4780 {
4781 }
4783 /**
4784 *
4785 */
4786 SVGAnimatedString getIn2()
4787 {
4788 }
4791 /**
4792 *
4793 */
4794 SVGAnimatedNumber getScale()
4795 {
4796 }
4798 /**
4799 *
4800 */
4801 SVGAnimatedEnumeration getXChannelSelector()
4802 {
4803 }
4805 /**
4806 *
4807 */
4808 SVGAnimatedEnumeration getYChannelSelector()
4809 {
4810 }
4812 //####################################################################
4813 //# SVGFEDistantLightElement
4814 //####################################################################
4817 /**
4818 * Corresponds to attribute azimuth on the given 'feDistantLight' element.
4819 */
4820 SVGAnimatedNumber getAzimuth()
4821 {
4822 }
4825 /**
4826 * Corresponds to attribute elevation on the given 'feDistantLight'
4827 * element
4828 */
4829 SVGAnimatedNumber getElevation()
4830 {
4831 }
4834 //####################################################################
4835 //# SVGFEFloodElement
4836 //####################################################################
4839 /**
4840 *
4841 */
4842 SVGAnimatedString getIn1()
4843 {
4844 }
4847 //####################################################################
4848 //# SVGFEFuncAElement
4849 //####################################################################
4851 //####################################################################
4852 //# SVGFEFuncBElement
4853 //####################################################################
4855 //####################################################################
4856 //# SVGFEFuncGElement
4857 //####################################################################
4859 //####################################################################
4860 //# SVGFEFuncRElement
4861 //####################################################################
4864 //####################################################################
4865 //# SVGFEGaussianBlurElement
4866 //####################################################################
4869 /**
4870 *
4871 */
4872 SVGAnimatedString getIn1()
4873 {
4874 }
4877 /**
4878 *
4879 */
4880 SVGAnimatedNumber getStdDeviationX()
4881 {
4882 }
4884 /**
4885 *
4886 */
4887 SVGAnimatedNumber getStdDeviationY()
4888 {
4889 }
4892 /**
4893 *
4894 */
4895 void setStdDeviation(double stdDeviationX, double stdDeviationY)
4896 {
4897 }
4900 //####################################################################
4901 //# SVGFEImageElement
4902 //####################################################################
4905 //####################################################################
4906 //# SVGFEMergeElement
4907 //####################################################################
4909 //####################################################################
4910 //# SVGFEMergeNodeElement
4911 //####################################################################
4913 //####################################################################
4914 //# SVGFEMorphologyElement
4915 //####################################################################
4917 /**
4918 *
4919 */
4920 SVGAnimatedString getIn1()
4921 {
4922 }
4925 /**
4926 *
4927 */
4928 SVGAnimatedEnumeration getOperator()
4929 {
4930 }
4932 /**
4933 *
4934 */
4935 SVGAnimatedLength getRadiusX()
4936 {
4937 }
4939 /**
4940 *
4941 */
4942 SVGAnimatedLength getRadiusY()
4943 {
4944 }
4946 //####################################################################
4947 //# SVGFEOffsetElement
4948 //####################################################################
4950 /**
4951 *
4952 */
4953 SVGAnimatedString getIn1()
4954 {
4955 }
4957 /**
4958 *
4959 */
4960 SVGAnimatedLength getDx()
4961 {
4962 }
4964 /**
4965 *
4966 */
4967 SVGAnimatedLength getDy()
4968 {
4969 }
4972 //####################################################################
4973 //# SVGFEPointLightElement
4974 //####################################################################
4976 /**
4977 * Corresponds to attribute x on the given 'fePointLight' element.
4978 */
4979 SVGAnimatedNumber getX()
4980 {
4981 }
4983 /**
4984 * Corresponds to attribute y on the given 'fePointLight' element.
4985 */
4986 SVGAnimatedNumber getY()
4987 {
4988 }
4990 /**
4991 * Corresponds to attribute z on the given 'fePointLight' element.
4992 */
4993 SVGAnimatedNumber getZ()
4994 {
4995 }
4997 //####################################################################
4998 //# SVGFESpecularLightingElement
4999 //####################################################################
5002 /**
5003 *
5004 */
5005 SVGAnimatedString getIn1()
5006 {
5007 }
5009 /**
5010 *
5011 */
5012 SVGAnimatedNumber getSurfaceScale()
5013 {
5014 }
5016 /**
5017 *
5018 */
5019 SVGAnimatedNumber getSpecularConstant()
5020 {
5021 }
5023 /**
5024 *
5025 */
5026 SVGAnimatedNumber getSpecularExponent()
5027 {
5028 }
5031 //####################################################################
5032 //# SVGFESpotLightElement
5033 //####################################################################
5035 /**
5036 * Corresponds to attribute x on the given 'feSpotLight' element.
5037 */
5038 SVGAnimatedNumber getX()
5039 {
5040 }
5042 /**
5043 * Corresponds to attribute y on the given 'feSpotLight' element.
5044 */
5045 SVGAnimatedNumber getY()
5046 {
5047 }
5049 /**
5050 * Corresponds to attribute z on the given 'feSpotLight' element.
5051 */
5052 SVGAnimatedNumber getZ()
5053 {
5054 }
5056 /**
5057 * Corresponds to attribute pointsAtX on the given 'feSpotLight' element.
5058 */
5059 SVGAnimatedNumber getPointsAtX()
5060 {
5061 }
5063 /**
5064 * Corresponds to attribute pointsAtY on the given 'feSpotLight' element.
5065 */
5066 SVGAnimatedNumber getPointsAtY()
5067 {
5068 }
5070 /**
5071 * Corresponds to attribute pointsAtZ on the given 'feSpotLight' element.
5072 */
5073 SVGAnimatedNumber getPointsAtZ()
5074 {
5075 }
5077 /**
5078 * Corresponds to attribute specularExponent on the
5079 * given 'feSpotLight' element.
5080 */
5081 SVGAnimatedNumber getSpecularExponent()
5082 {
5083 }
5085 /**
5086 * Corresponds to attribute limitingConeAngle on the
5087 * given 'feSpotLight' element.
5088 */
5089 SVGAnimatedNumber getLimitingConeAngle()
5090 {
5091 }
5094 //####################################################################
5095 //# SVGFETileElement
5096 //####################################################################
5099 /**
5100 *
5101 */
5102 SVGAnimatedString getIn1()
5103 {
5104 }
5107 //####################################################################
5108 //# SVGFETurbulenceElement
5109 //####################################################################
5112 /**
5113 *
5114 */
5115 SVGAnimatedNumber getBaseFrequencyX()
5116 {
5117 }
5119 /**
5120 *
5121 */
5122 SVGAnimatedNumber getBaseFrequencyY()
5123 {
5124 }
5126 /**
5127 *
5128 */
5129 SVGAnimatedInteger getNumOctaves()
5130 {
5131 }
5133 /**
5134 *
5135 */
5136 SVGAnimatedNumber getSeed()
5137 {
5138 }
5140 /**
5141 *
5142 */
5143 SVGAnimatedEnumeration getStitchTiles()
5144 {
5145 }
5147 /**
5148 *
5149 */
5150 SVGAnimatedEnumeration getType()
5151 {
5152 }
5156 //####################################################################
5157 //# SVGFilterElement
5158 //####################################################################
5161 /**
5162 * Corresponds to attribute filterUnits on the given 'filter' element. Takes one
5163 * of the constants defined in SVGUnitTypes.
5164 */
5165 SVGAnimatedEnumeration getFilterUnits()
5166 {
5167 }
5169 /**
5170 * Corresponds to attribute primitiveUnits on the given 'filter' element. Takes
5171 * one of the constants defined in SVGUnitTypes.
5172 */
5173 SVGAnimatedEnumeration getPrimitiveUnits()
5174 {
5175 }
5177 /**
5178 *
5179 */
5180 SVGAnimatedLength getX()
5181 {
5182 }
5184 /**
5185 * Corresponds to attribute x on the given 'filter' element.
5186 */
5187 SVGAnimatedLength getY()
5188 {
5189 }
5191 /**
5192 * Corresponds to attribute y on the given 'filter' element.
5193 */
5194 SVGAnimatedLength getWidth()
5195 {
5196 }
5198 /**
5199 * Corresponds to attribute height on the given 'filter' element.
5200 */
5201 SVGAnimatedLength getHeight()
5202 {
5203 }
5206 /**
5207 * Corresponds to attribute filterRes on the given 'filter' element.
5208 * Contains the X component of attribute filterRes.
5209 */
5210 SVGAnimatedInteger getFilterResX()
5211 {
5212 }
5214 /**
5215 * Corresponds to attribute filterRes on the given 'filter' element.
5216 * Contains the Y component(possibly computed automatically)
5217 * of attribute filterRes.
5218 */
5219 SVGAnimatedInteger getFilterResY()
5220 {
5221 }
5223 /**
5224 * Sets the values for attribute filterRes.
5225 */
5226 void setFilterRes(unsigned long filterResX, unsigned long filterResY)
5227 {
5228 }
5231 //####################################################################
5232 //# SVGFontElement
5233 //####################################################################
5235 //####################################################################
5236 //# SVGFontFaceElement
5237 //####################################################################
5239 //####################################################################
5240 //# SVGFontFaceFormatElement
5241 //####################################################################
5243 //####################################################################
5244 //# SVGFontFaceNameElement
5245 //####################################################################
5247 //####################################################################
5248 //# SVGFontFaceSrcElement
5249 //####################################################################
5251 //####################################################################
5252 //# SVGFontFaceUriElement
5253 //####################################################################
5255 //####################################################################
5256 //# SVGForeignObjectElement
5257 //####################################################################
5259 /**
5260 *
5261 */
5262 SVGAnimatedLength getX()
5263 {
5264 }
5266 /**
5267 *
5268 */
5269 SVGAnimatedLength getY()
5270 {
5271 }
5273 /**
5274 *
5275 */
5276 SVGAnimatedLength getWidth()
5277 {
5278 }
5280 /**
5281 *
5282 */
5283 SVGAnimatedLength getHeight()
5284 {
5285 }
5289 //####################################################################
5290 //# SVGGlyphRefElement
5291 //####################################################################
5294 /**
5295 * Get the attribute glyphRef on the given element.
5296 */
5297 DOMString getGlyphRef()
5298 {
5299 }
5301 /**
5302 * Set the attribute glyphRef on the given element.
5303 */
5304 void setGlyphRef(const DOMString &val) throw (DOMException)
5305 {
5306 }
5308 /**
5309 * Get the attribute format on the given element.
5310 */
5311 DOMString getFormat()
5312 {
5313 }
5315 /**
5316 * Set the attribute format on the given element.
5317 */
5318 void setFormat(const DOMString &val) throw (DOMException)
5319 {
5320 }
5322 /**
5323 * Get the attribute x on the given element.
5324 */
5325 double getX()
5326 {
5327 }
5329 /**
5330 * Set the attribute x on the given element.
5331 */
5332 void setX(double val) throw (DOMException)
5333 {
5334 }
5336 /**
5337 * Get the attribute y on the given element.
5338 */
5339 double getY()
5340 {
5341 }
5343 /**
5344 * Set the attribute y on the given element.
5345 */
5346 void setY(double val) throw (DOMException)
5347 {
5348 }
5350 /**
5351 * Get the attribute dx on the given element.
5352 */
5353 double getDx()
5354 {
5355 }
5357 /**
5358 * Set the attribute dx on the given element.
5359 */
5360 void setDx(double val) throw (DOMException)
5361 {
5362 }
5364 /**
5365 * Get the attribute dy on the given element.
5366 */
5367 double getDy()
5368 {
5369 }
5371 /**
5372 * Set the attribute dy on the given element.
5373 */
5374 void setDy(double val) throw (DOMException)
5375 {
5376 }
5379 //####################################################################
5380 //# SVGGradientElement
5381 //####################################################################
5383 /**
5384 * Corresponds to attribute gradientUnits on the given element.
5385 * Takes one of the constants defined in SVGUnitTypes.
5386 */
5387 SVGAnimatedEnumeration getGradientUnits()
5388 {
5389 }
5391 /**
5392 * Corresponds to attribute gradientTransform on the given element.
5393 */
5394 SVGAnimatedTransformList getGradientTransform()
5395 {
5396 }
5398 /**
5399 * Corresponds to attribute spreadMethod on the given element.
5400 * One of the Spread Method Types.
5401 */
5402 SVGAnimatedEnumeration getSpreadMethod()
5403 {
5404 }
5408 //####################################################################
5409 //# SVGHKernElement
5410 //####################################################################
5412 //####################################################################
5413 //# SVGImageElement
5414 //####################################################################
5416 /**
5417 * Corresponds to attribute x on the given 'image' element.
5418 */
5419 SVGAnimatedLength getX()
5420 {
5421 }
5423 /**
5424 * Corresponds to attribute y on the given 'image' element.
5425 */
5426 SVGAnimatedLength getY()
5427 {
5428 }
5430 /**
5431 * Corresponds to attribute width on the given 'image' element.
5432 */
5433 SVGAnimatedLength getWidth()
5434 {
5435 }
5437 /**
5438 * Corresponds to attribute height on the given 'image' element.
5439 */
5440 SVGAnimatedLength getHeight()
5441 {
5442 }
5445 /**
5446 * Corresponds to attribute preserveAspectRatio on the given element.
5447 */
5448 SVGAnimatedPreserveAspectRatio getPreserveAspectRatio()
5449 {
5450 }
5452 //####################################################################
5453 //# SVGLinearGradientElement
5454 //####################################################################
5456 /**
5457 * Corresponds to attribute x1 on the given 'linearGradient' element.
5458 */
5459 SVGAnimatedLength getX1()
5460 {
5461 }
5463 /**
5464 * Corresponds to attribute y1 on the given 'linearGradient' element.
5465 */
5466 SVGAnimatedLength getY1()
5467 {
5468 }
5470 /**
5471 * Corresponds to attribute x2 on the given 'linearGradient' element.
5472 */
5473 SVGAnimatedLength getX2()
5474 {
5475 }
5477 /**
5478 * Corresponds to attribute y2 on the given 'linearGradient' element.
5479 */
5480 SVGAnimatedLength getY2()
5481 {
5482 }
5486 //####################################################################
5487 //# SVGLineElement
5488 //####################################################################
5490 /**
5491 * Corresponds to attribute x1 on the given 'line' element.
5492 */
5493 SVGAnimatedLength getX1()
5494 {
5495 }
5497 /**
5498 * Corresponds to attribute y1 on the given 'line' element.
5499 */
5500 SVGAnimatedLength getY1()
5501 {
5502 }
5504 /**
5505 * Corresponds to attribute x2 on the given 'line' element.
5506 */
5507 SVGAnimatedLength getX2()
5508 {
5509 }
5511 /**
5512 * Corresponds to attribute y2 on the given 'line' element.
5513 */
5514 SVGAnimatedLength getY2()
5515 {
5516 }
5519 //####################################################################
5520 //# SVGMarkerElement
5521 //####################################################################
5524 /**
5525 * Corresponds to attribute refX on the given 'marker' element.
5526 */
5527 SVGAnimatedLength getRefX()
5528 {
5529 }
5531 /**
5532 * Corresponds to attribute refY on the given 'marker' element.
5533 */
5534 SVGAnimatedLength getRefY()
5535 {
5536 }
5538 /**
5539 * Corresponds to attribute markerUnits on the given 'marker' element.
5540 * One of the Marker Units Types defined above.
5541 */
5542 SVGAnimatedEnumeration getMarkerUnits()
5543 {
5544 }
5546 /**
5547 * Corresponds to attribute markerWidth on the given 'marker' element.
5548 */
5549 SVGAnimatedLength getMarkerWidth()
5550 {
5551 }
5553 /**
5554 * Corresponds to attribute markerHeight on the given 'marker' element.
5555 */
5556 SVGAnimatedLength getMarkerHeight()
5557 {
5558 }
5560 /**
5561 * Corresponds to attribute orient on the given 'marker' element.
5562 * One of the Marker Orientation Types defined above.
5563 */
5564 SVGAnimatedEnumeration getOrientType()
5565 {
5566 }
5568 /**
5569 * Corresponds to attribute orient on the given 'marker' element.
5570 * If markerUnits is SVG_MARKER_ORIENT_ANGLE, the angle value for
5571 * attribute orient ; otherwise, it will be set to zero.
5572 */
5573 SVGAnimatedAngle getOrientAngle()
5574 {
5575 }
5578 /**
5579 * Sets the value of attribute orient to 'auto'.
5580 */
5581 void setOrientToAuto()
5582 {
5583 }
5585 /**
5586 * Sets the value of attribute orient to the given angle.
5587 */
5588 void setOrientToAngle(const SVGAngle &angle)
5589 {
5590 }
5593 //####################################################################
5594 //# SVGMaskElement
5595 //####################################################################
5598 /**
5599 * Corresponds to attribute maskUnits on the given 'mask' element. Takes one of
5600 * the constants defined in SVGUnitTypes.
5601 */
5602 SVGAnimatedEnumeration getMaskUnits()
5603 {
5604 }
5606 /**
5607 * Corresponds to attribute maskContentUnits on the given 'mask' element. Takes
5608 * one of the constants defined in SVGUnitTypes.
5609 */
5610 SVGAnimatedEnumeration getMaskContentUnits()
5611 {
5612 }
5614 /**
5615 * Corresponds to attribute x on the given 'mask' element.
5616 */
5617 SVGAnimatedLength getX()
5618 {
5619 }
5621 /**
5622 * Corresponds to attribute y on the given 'mask' element.
5623 */
5624 SVGAnimatedLength getY()
5625 {
5626 }
5628 /**
5629 * Corresponds to attribute width on the given 'mask' element.
5630 */
5631 SVGAnimatedLength getWidth()
5632 {
5633 }
5635 /**
5636 * Corresponds to attribute height on the given 'mask' element.
5637 */
5638 SVGAnimatedLength getHeight()
5639 {
5640 }
5642 //####################################################################
5643 //# SVGMetadataElement
5644 //####################################################################
5646 //####################################################################
5647 //# SVGMissingGlyphElement
5648 //####################################################################
5650 //####################################################################
5651 //# SVGMPathElement
5652 //####################################################################
5654 //####################################################################
5655 //# SVGPathElement
5656 //####################################################################
5658 /**
5659 * Corresponds to attribute pathLength on the given 'path' element.
5660 */
5661 SVGAnimatedNumber getPathLength()
5662 {
5663 }
5665 /**
5666 * Returns the user agent's computed value for the total length of the path using
5667 * the user agent's distance-along-a-path algorithm, as a distance in the current
5668 * user coordinate system.
5669 */
5670 double getTotalLength()
5671 {
5672 }
5674 /**
5675 * Returns the(x,y) coordinate in user space which is distance units along the
5676 * path, utilizing the user agent's distance-along-a-path algorithm.
5677 */
5678 SVGPoint getPointAtLength(double distance)
5679 {
5680 }
5682 /**
5683 * Returns the index into pathSegList which is distance units along the path,
5684 * utilizing the user agent's distance-along-a-path algorithm.
5685 */
5686 unsigned long getPathSegAtLength(double distance)
5687 {
5688 }
5690 /**
5691 * Returns a stand-alone, parentless SVGPathSegClosePath object.
5692 */
5693 SVGPathSeg createSVGPathSegClosePath()
5694 {
5695 SVGPathSeg seg(PATHSEG_CLOSEPATH);
5696 return seg;
5697 }
5699 /**
5700 * Returns a stand-alone, parentless SVGPathSegMovetoAbs object.
5701 */
5702 SVGPathSeg createSVGPathSegMovetoAbs(double x, double y)
5703 {
5704 SVGPathSeg seg(PATHSEG_MOVETO_ABS);
5705 seg.setX(x);
5706 seg.setY(y);
5707 return seg;
5708 }
5710 /**
5711 * Returns a stand-alone, parentless SVGPathSegMovetoRel object.
5712 */
5713 SVGPathSeg createSVGPathSegMovetoRel(double x, double y)
5714 {
5715 SVGPathSeg seg(PATHSEG_MOVETO_REL);
5716 seg.setX(x);
5717 seg.setY(y);
5718 return seg;
5719 }
5721 /**
5722 * Returns a stand-alone, parentless SVGPathSegLinetoAbs object.
5723 */
5724 SVGPathSeg createSVGPathSegLinetoAbs(double x, double y)
5725 {
5726 SVGPathSeg seg(PATHSEG_LINETO_ABS);
5727 seg.setX(x);
5728 seg.setY(y);
5729 return seg;
5730 }
5732 /**
5733 * Returns a stand-alone, parentless SVGPathSegLinetoRel object.
5734 */
5735 SVGPathSeg createSVGPathSegLinetoRel(double x, double y)
5736 {
5737 SVGPathSeg seg(PATHSEG_LINETO_REL);
5738 seg.setX(x);
5739 seg.setY(y);
5740 return seg;
5741 }
5743 /**
5744 * Returns a stand-alone, parentless SVGPathSegCurvetoCubicAbs object.
5745 */
5746 SVGPathSeg createSVGPathSegCurvetoCubicAbs(double x, double y,
5747 double x1, double y1, double x2, double y2)
5748 {
5749 SVGPathSeg seg(PATHSEG_CURVETO_CUBIC_ABS);
5750 seg.setX(x);
5751 seg.setY(y);
5752 seg.setX1(x1);
5753 seg.setY1(y1);
5754 seg.setX2(x2);
5755 seg.setY2(y2);
5756 return seg;
5757 }
5759 /**
5760 * Returns a stand-alone, parentless SVGPathSegCurvetoCubicRel object.
5761 */
5762 SVGPathSeg createSVGPathSegCurvetoCubicRel(double x, double y,
5763 double x1, double y1, double x2, double y2)
5764 {
5765 SVGPathSeg seg(PATHSEG_CURVETO_CUBIC_REL);
5766 seg.setX(x);
5767 seg.setY(y);
5768 seg.setX1(x1);
5769 seg.setY1(y1);
5770 seg.setX2(x2);
5771 seg.setY2(y2);
5772 return seg;
5773 }
5775 /**
5776 * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticAbs object.
5777 */
5778 SVGPathSeg createSVGPathSegCurvetoQuadraticAbs(double x, double y,
5779 double x1, double y1)
5780 {
5781 SVGPathSeg seg(PATHSEG_CURVETO_QUADRATIC_ABS);
5782 seg.setX(x);
5783 seg.setY(y);
5784 seg.setX1(x1);
5785 seg.setY1(y1);
5786 return seg;
5787 }
5789 /**
5790 * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticRel object.
5791 */
5792 SVGPathSeg createSVGPathSegCurvetoQuadraticRel(double x, double y,
5793 double x1, double y1)
5794 {
5795 SVGPathSeg seg(PATHSEG_CURVETO_QUADRATIC_REL);
5796 seg.setX(x);
5797 seg.setY(y);
5798 seg.setX1(x1);
5799 seg.setY1(y1);
5800 return seg;
5801 }
5803 /**
5804 * Returns a stand-alone, parentless SVGPathSegArcAbs object.
5805 */
5806 SVGPathSeg createSVGPathSegArcAbs(double x, double y,
5807 double r1, double r2, double angle,
5808 bool largeArcFlag, bool sweepFlag)
5809 {
5810 SVGPathSeg seg(PATHSEG_ARC_ABS);
5811 seg.setX(x);
5812 seg.setY(y);
5813 seg.setR1(r1);
5814 seg.setR2(r2);
5815 seg.setAngle(angle);
5816 seg.setLargeArcFlag(largeArcFlag);
5817 seg.setSweepFlag(sweepFlag);
5818 return seg;
5819 }
5821 /**
5822 * Returns a stand-alone, parentless SVGPathSegArcRel object.
5823 */
5824 SVGPathSeg createSVGPathSegArcRel(double x, double y, double r1,
5825 double r2, double angle, bool largeArcFlag,
5826 bool sweepFlag)
5827 {
5828 SVGPathSeg seg(PATHSEG_ARC_REL);
5829 seg.setX(x);
5830 seg.setY(y);
5831 seg.setR1(r1);
5832 seg.setR2(r2);
5833 seg.setAngle(angle);
5834 seg.setLargeArcFlag(largeArcFlag);
5835 seg.setSweepFlag(sweepFlag);
5836 return seg;
5837 }
5839 /**
5840 * Returns a stand-alone, parentless SVGPathSegLinetoHorizontalAbs object.
5841 */
5842 SVGPathSeg createSVGPathSegLinetoHorizontalAbs(double x)
5843 {
5844 SVGPathSeg seg(PATHSEG_LINETO_HORIZONTAL_ABS);
5845 seg.setX(x);
5846 return seg;
5847 }
5849 /**
5850 * Returns a stand-alone, parentless SVGPathSegLinetoHorizontalRel object.
5851 */
5852 SVGPathSeg createSVGPathSegLinetoHorizontalRel(double x)
5853 {
5854 SVGPathSeg seg(PATHSEG_LINETO_HORIZONTAL_REL);
5855 seg.setX(x);
5856 return seg;
5857 }
5859 /**
5860 * Returns a stand-alone, parentless SVGPathSegLinetoVerticalAbs object.
5861 */
5862 SVGPathSeg createSVGPathSegLinetoVerticalAbs(double y)
5863 {
5864 SVGPathSeg seg(PATHSEG_LINETO_VERTICAL_ABS);
5865 seg.setY(y);
5866 return seg;
5867 }
5869 /**
5870 * Returns a stand-alone, parentless SVGPathSegLinetoVerticalRel object.
5871 */
5872 SVGPathSeg createSVGPathSegLinetoVerticalRel(double y)
5873 {
5874 SVGPathSeg seg(PATHSEG_LINETO_VERTICAL_REL);
5875 seg.setY(y);
5876 return seg;
5877 }
5879 /**
5880 * Returns a stand-alone, parentless SVGPathSegCurvetoCubicSmoothAbs object.
5881 */
5882 SVGPathSeg createSVGPathSegCurvetoCubicSmoothAbs(double x, double y,
5883 double x2, double y2)
5884 {
5885 SVGPathSeg seg(PATHSEG_CURVETO_CUBIC_SMOOTH_ABS);
5886 seg.setX(x);
5887 seg.setY(y);
5888 seg.setX2(x2);
5889 seg.setY2(y2);
5890 return seg;
5891 }
5893 /**
5894 * Returns a stand-alone, parentless SVGPathSegCurvetoCubicSmoothRel object.
5895 */
5896 SVGPathSeg createSVGPathSegCurvetoCubicSmoothRel(double x, double y,
5897 double x2, double y2)
5898 {
5899 SVGPathSeg seg(PATHSEG_CURVETO_CUBIC_SMOOTH_REL);
5900 seg.setX(x);
5901 seg.setY(y);
5902 seg.setX2(x2);
5903 seg.setY2(y2);
5904 return seg;
5905 }
5907 /**
5908 * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticSmoothAbs
5909 * object.
5910 */
5911 SVGPathSeg createSVGPathSegCurvetoQuadraticSmoothAbs(double x, double y)
5912 {
5913 SVGPathSeg seg(PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS);
5914 seg.setX(x);
5915 seg.setY(y);
5916 return seg;
5917 }
5919 /**
5920 * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticSmoothRel
5921 * object.
5922 */
5923 SVGPathSeg createSVGPathSegCurvetoQuadraticSmoothRel(double x, double y)
5924 {
5925 SVGPathSeg seg(PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL);
5926 seg.setX(x);
5927 seg.setY(y);
5928 return seg;
5929 }
5932 //####################################################################
5933 //# SVGPatternElement
5934 //####################################################################
5936 /**
5937 * Corresponds to attribute patternUnits on the given 'pattern' element.
5938 * Takes one of the constants defined in SVGUnitTypes.
5939 */
5940 SVGAnimatedEnumeration getPatternUnits()
5941 {
5942 }
5944 /**
5945 * Corresponds to attribute patternContentUnits on the given 'pattern'
5946 * element. Takes one of the constants defined in SVGUnitTypes.
5947 */
5948 SVGAnimatedEnumeration getPatternContentUnits()
5949 {
5950 }
5952 /**
5953 * Corresponds to attribute patternTransform on the given 'pattern' element.
5954 */
5955 SVGAnimatedTransformList getPatternTransform()
5956 {
5957 }
5959 /**
5960 * Corresponds to attribute x on the given 'pattern' element.
5961 */
5962 SVGAnimatedLength getX()
5963 {
5964 }
5966 /**
5967 *
5968 */
5969 SVGAnimatedLength getY()
5970 {
5971 }
5973 /**
5974 * Corresponds to attribute width on the given 'pattern' element.
5975 */
5976 SVGAnimatedLength getWidth()
5977 {
5978 }
5980 /**
5981 * Corresponds to attribute height on the given 'pattern' element.
5982 */
5983 SVGAnimatedLength getHeight()
5984 {
5985 }
5988 //####################################################################
5989 //# SVGPolyLineElement
5990 //####################################################################
5992 //####################################################################
5993 //# SVGPolygonElement
5994 //####################################################################
5997 //####################################################################
5998 //# SVGRadialGradientElement
5999 //####################################################################
6002 /**
6003 * Corresponds to attribute cx on the given 'radialGradient' element.
6004 */
6005 SVGAnimatedLength getCx()
6006 {
6007 }
6010 /**
6011 * Corresponds to attribute cy on the given 'radialGradient' element.
6012 */
6013 SVGAnimatedLength getCy()
6014 {
6015 }
6018 /**
6019 * Corresponds to attribute r on the given 'radialGradient' element.
6020 */
6021 SVGAnimatedLength getR()
6022 {
6023 }
6026 /**
6027 * Corresponds to attribute fx on the given 'radialGradient' element.
6028 */
6029 SVGAnimatedLength getFx()
6030 {
6031 }
6034 /**
6035 * Corresponds to attribute fy on the given 'radialGradient' element.
6036 */
6037 SVGAnimatedLength getFy()
6038 {
6039 }
6042 //####################################################################
6043 //# SVGRectElement
6044 //####################################################################
6046 /**
6047 * Corresponds to attribute x on the given 'rect' element.
6048 */
6049 SVGAnimatedLength getX()
6050 {
6051 }
6053 /**
6054 * Corresponds to attribute y on the given 'rect' element.
6055 */
6056 SVGAnimatedLength getY()
6057 {
6058 }
6060 /**
6061 * Corresponds to attribute width on the given 'rect' element.
6062 */
6063 SVGAnimatedLength getWidth()
6064 {
6065 }
6067 /**
6068 * Corresponds to attribute height on the given 'rect' element.
6069 */
6070 SVGAnimatedLength getHeight()
6071 {
6072 }
6075 /**
6076 * Corresponds to attribute rx on the given 'rect' element.
6077 */
6078 SVGAnimatedLength getRx()
6079 {
6080 }
6082 /**
6083 * Corresponds to attribute ry on the given 'rect' element.
6084 */
6085 SVGAnimatedLength getRy()
6086 {
6087 }
6090 //####################################################################
6091 //# SVGScriptElement
6092 //####################################################################
6094 /**
6095 *
6096 */
6097 DOMString getType()
6098 {
6099 }
6101 /**
6102 *
6103 */
6104 void setType(const DOMString &val) throw (DOMException)
6105 {
6106 }
6108 //####################################################################
6109 //# SVGSetElement
6110 //####################################################################
6112 //####################################################################
6113 //# SVGStopElement
6114 //####################################################################
6117 /**
6118 * Corresponds to attribute offset on the given 'stop' element.
6119 */
6120 SVGAnimatedNumber getOffset()
6121 {
6122 }
6125 //####################################################################
6126 //# SVGStyleElement
6127 //####################################################################
6129 /**
6130 * Get the attribute xml:space on the given element.
6131 */
6132 DOMString getXmlspace()
6133 {
6134 }
6136 /**
6137 * Set the attribute xml:space on the given element.
6138 */
6139 void setXmlspace(const DOMString &val) throw (DOMException)
6140 {
6141 }
6143 /**
6144 * Get the attribute type on the given 'style' element.
6145 */
6146 DOMString getType()
6147 {
6148 }
6150 /**
6151 * Set the attribute type on the given 'style' element.
6152 */
6153 void setType(const DOMString &val) throw (DOMException)
6154 {
6155 }
6157 /**
6158 * Get the attribute media on the given 'style' element.
6159 */
6160 DOMString getMedia()
6161 {
6162 }
6164 /**
6165 * Set the attribute media on the given 'style' element.
6166 */
6167 void setMedia(const DOMString &val) throw (DOMException)
6168 {
6169 }
6171 /**
6172 * Get the attribute title on the given 'style' element.
6173 */
6174 DOMString getTitle()
6175 {
6176 }
6178 /**
6179 * Set the attribute title on the given 'style' element.
6180 */
6181 void setTitle(const DOMString &val) throw (DOMException)
6182 {
6183 }
6185 //####################################################################
6186 //# SVGSymbolElement
6187 //####################################################################
6189 //####################################################################
6190 //# SVGSVGElement
6191 //####################################################################
6193 /**
6194 * Corresponds to attribute x on the given 'svg' element.
6195 */
6196 SVGAnimatedLength getX()
6197 {
6198 }
6200 /**
6201 * Corresponds to attribute y on the given 'svg' element.
6202 */
6203 SVGAnimatedLength getY()
6204 {
6205 }
6207 /**
6208 * Corresponds to attribute width on the given 'svg' element.
6209 */
6210 SVGAnimatedLength getWidth()
6211 {
6212 }
6214 /**
6215 * Corresponds to attribute height on the given 'svg' element.
6216 */
6217 SVGAnimatedLength getHeight()
6218 {
6219 }
6221 /**
6222 * Get the attribute contentScriptType on the given 'svg' element.
6223 */
6224 DOMString getContentScriptType()
6225 {
6226 }
6228 /**
6229 * Set the attribute contentScriptType on the given 'svg' element.
6230 */
6231 void setContentScriptType(const DOMString &val) throw (DOMException)
6232 {
6233 }
6236 /**
6237 * Get the attribute contentStyleType on the given 'svg' element.
6238 */
6239 DOMString getContentStyleType()
6240 {
6241 }
6243 /**
6244 * Set the attribute contentStyleType on the given 'svg' element.
6245 */
6246 void setContentStyleType(const DOMString &val) throw (DOMException)
6247 {
6248 }
6250 /**
6251 * The position and size of the viewport(implicit or explicit) that corresponds
6252 * to this 'svg' element. When the user agent is actually rendering the content,
6253 * then the position and size values represent the actual values when rendering.
6254 * The position and size values are unitless values in the coordinate system of
6255 * the parent element. If no parent element exists(i.e., 'svg' element
6256 * represents the root of the document tree), if this SVG document is embedded as
6257 * part of another document(e.g., via the HTML 'object' element), then the
6258 * position and size are unitless values in the coordinate system of the parent
6259 * document.(If the parent uses CSS or XSL layout, then unitless values
6260 * represent pixel units for the current CSS or XSL viewport, as described in the
6261 * CSS2 specification.) If the parent element does not have a coordinate system,
6262 * then the user agent should provide reasonable default values for this attribute.
6263 */
6264 SVGRect getViewport()
6265 {
6266 }
6268 /**
6269 * Size of a pixel units(as defined by CSS2) along the x-axis of the viewport,
6270 * which represents a unit somewhere in the range of 70dpi to 120dpi, and, on
6271 * systems that support this, might actually match the characteristics of the
6272 * target medium. On systems where it is impossible to know the size of a pixel,
6273 * a suitable default pixel size is provided.
6274 */
6275 double getPixelUnitToMillimeterX()
6276 {
6277 }
6279 /**
6280 * Corresponding size of a pixel unit along the y-axis of the viewport.
6281 */
6282 double getPixelUnitToMillimeterY()
6283 {
6284 }
6286 /**
6287 * User interface(UI) events in DOM Level 2 indicate the screen positions at
6288 * which the given UI event occurred. When the user agent actually knows the
6289 * physical size of a "screen unit", this attribute will express that information
6290 {
6291 }
6292 * otherwise, user agents will provide a suitable default value such as .28mm.
6293 */
6294 double getScreenPixelToMillimeterX()
6295 {
6296 }
6298 /**
6299 * Corresponding size of a screen pixel along the y-axis of the viewport.
6300 */
6301 double getScreenPixelToMillimeterY()
6302 {
6303 }
6306 /**
6307 * The initial view(i.e., before magnification and panning) of the current
6308 * innermost SVG document fragment can be either the "standard" view(i.e., based
6309 * on attributes on the 'svg' element such as fitBoxToViewport) or to a "custom"
6310 * view(i.e., a hyperlink into a particular 'view' or other element - see
6311 * Linking into SVG content: URI fragments and SVG views). If the initial view is
6312 * the "standard" view, then this attribute is false. If the initial view is a
6313 * "custom" view, then this attribute is true.
6314 */
6315 bool getUseCurrentView()
6316 {
6317 }
6319 /**
6320 * Set the value above
6321 */
6322 void setUseCurrentView(bool val) throw (DOMException)
6323 {
6324 }
6326 /**
6327 * The definition of the initial view(i.e., before magnification and panning) of
6328 * the current innermost SVG document fragment. The meaning depends on the
6329 * situation:
6330 *
6331 * * If the initial view was a "standard" view, then:
6332 * o the values for viewBox, preserveAspectRatio and zoomAndPan within
6333 * currentView will match the values for the corresponding DOM attributes that
6334 * are on SVGSVGElement directly
6335 * o the values for transform and viewTarget within currentView will be null
6336 * * If the initial view was a link into a 'view' element, then:
6337 * o the values for viewBox, preserveAspectRatio and zoomAndPan within
6338 * currentView will correspond to the corresponding attributes for the given
6339 * 'view' element
6340 * o the values for transform and viewTarget within currentView will be null
6341 * * If the initial view was a link into another element(i.e., other than a
6342 * 'view'), then:
6343 * o the values for viewBox, preserveAspectRatio and zoomAndPan within
6344 * currentView will match the values for the corresponding DOM attributes that
6345 * are on SVGSVGElement directly for the closest ancestor 'svg' element
6346 * o the values for transform within currentView will be null
6347 * o the viewTarget within currentView will represent the target of the link
6348 * * If the initial view was a link into the SVG document fragment using an SVG
6349 * view specification fragment identifier(i.e., #svgView(...)), then:
6350 * o the values for viewBox, preserveAspectRatio, zoomAndPan, transform and
6351 * viewTarget within currentView will correspond to the values from the SVG view
6352 * specification fragment identifier
6353 *
6354 */
6355 SVGViewSpec getCurrentView()
6356 {
6357 }
6360 /**
6361 * This attribute indicates the current scale factor relative to the initial view
6362 * to take into account user magnification and panning operations, as described
6363 * under Magnification and panning. DOM attributes currentScale and
6364 * currentTranslate are equivalent to the 2x3 matrix [a b c d e f] =
6365 * [currentScale 0 0 currentScale currentTranslate.x currentTranslate.y]. If
6366 * "magnification" is enabled(i.e., zoomAndPan="magnify"), then the effect is as
6367 * if an extra transformation were placed at the outermost level on the SVG
6368 * document fragment(i.e., outside the outermost 'svg' element).
6369 */
6370 double getCurrentScale()
6371 {
6372 }
6374 /**
6375 * Set the value above.
6376 */
6377 void setCurrentScale(double val) throw (DOMException)
6378 {
6379 }
6381 /**
6382 * The corresponding translation factor that takes into account
6383 * user "magnification".
6384 */
6385 SVGPoint getCurrentTranslate()
6386 {
6387 }
6389 /**
6390 * Takes a time-out value which indicates that redraw shall not occur until:(a)
6391 * the corresponding unsuspendRedraw(suspend_handle_id) call has been made,(b)
6392 * an unsuspendRedrawAll() call has been made, or(c) its timer has timed out. In
6393 * environments that do not support interactivity(e.g., print media), then
6394 * redraw shall not be suspended. suspend_handle_id =
6395 * suspendRedraw(max_wait_milliseconds) and unsuspendRedraw(suspend_handle_id)
6396 * must be packaged as balanced pairs. When you want to suspend redraw actions as
6397 * a collection of SVG DOM changes occur, then precede the changes to the SVG DOM
6398 * with a method call similar to suspend_handle_id =
6399 * suspendRedraw(max_wait_milliseconds) and follow the changes with a method call
6400 * similar to unsuspendRedraw(suspend_handle_id). Note that multiple
6401 * suspendRedraw calls can be used at once and that each such method call is
6402 * treated independently of the other suspendRedraw method calls.
6403 */
6404 unsigned long suspendRedraw(unsigned long max_wait_milliseconds)
6405 {
6406 }
6408 /**
6409 * Cancels a specified suspendRedraw() by providing a unique suspend_handle_id.
6410 */
6411 void unsuspendRedraw(unsigned long suspend_handle_id) throw (DOMException)
6412 {
6413 }
6415 /**
6416 * Cancels all currently active suspendRedraw() method calls. This method is most
6417 * useful at the very end of a set of SVG DOM calls to ensure that all pending
6418 * suspendRedraw() method calls have been cancelled.
6419 */
6420 void unsuspendRedrawAll()
6421 {
6422 }
6424 /**
6425 * In rendering environments supporting interactivity, forces the user agent to
6426 * immediately redraw all regions of the viewport that require updating.
6427 */
6428 void forceRedraw()
6429 {
6430 }
6432 /**
6433 * Suspends(i.e., pauses) all currently running animations that are defined
6434 * within the SVG document fragment corresponding to this 'svg' element, causing
6435 * the animation clock corresponding to this document fragment to stand still
6436 * until it is unpaused.
6437 */
6438 void pauseAnimations()
6439 {
6440 }
6442 /**
6443 * Unsuspends(i.e., unpauses) currently running animations that are defined
6444 * within the SVG document fragment, causing the animation clock to continue from
6445 * the time at which it was suspended.
6446 */
6447 void unpauseAnimations()
6448 {
6449 }
6451 /**
6452 * Returns true if this SVG document fragment is in a paused state.
6453 */
6454 bool animationsPaused()
6455 {
6456 }
6458 /**
6459 * Returns the current time in seconds relative to the start time for
6460 * the current SVG document fragment.
6461 */
6462 double getCurrentTime()
6463 {
6464 }
6466 /**
6467 * Adjusts the clock for this SVG document fragment, establishing
6468 * a new current time.
6469 */
6470 void setCurrentTime(double seconds)
6471 {
6472 }
6474 /**
6475 * Returns the list of graphics elements whose rendered content intersects the
6476 * supplied rectangle, honoring the 'pointer-events' property value on each
6477 * candidate graphics element.
6478 */
6479 NodeList getIntersectionList(const SVGRect &rect,
6480 const SVGElementPtr referenceElement)
6481 {
6482 }
6484 /**
6485 * Returns the list of graphics elements whose rendered content is entirely
6486 * contained within the supplied rectangle, honoring the 'pointer-events'
6487 * property value on each candidate graphics element.
6488 */
6489 NodeList getEnclosureList(const SVGRect &rect,
6490 const SVGElementPtr referenceElement)
6491 {
6492 }
6494 /**
6495 * Returns true if the rendered content of the given element intersects the
6496 * supplied rectangle, honoring the 'pointer-events' property value on each
6497 * candidate graphics element.
6498 */
6499 bool checkIntersection(const SVGElementPtr element, const SVGRect &rect)
6500 {
6501 }
6503 /**
6504 * Returns true if the rendered content of the given element is entirely
6505 * contained within the supplied rectangle, honoring the 'pointer-events'
6506 * property value on each candidate graphics element.
6507 */
6508 bool checkEnclosure(const SVGElementPtr element, const SVGRect &rect)
6509 {
6510 }
6512 /**
6513 * Unselects any selected objects, including any selections of text
6514 * strings and type-in bars.
6515 */
6516 void deselectAll()
6517 {
6518 }
6520 /**
6521 * Creates an SVGNumber object outside of any document trees. The object
6522 * is initialized to a value of zero.
6523 */
6524 SVGNumber createSVGNumber()
6525 {
6526 }
6528 /**
6529 * Creates an SVGLength object outside of any document trees. The object
6530 * is initialized to the value of 0 user units.
6531 */
6532 SVGLength createSVGLength()
6533 {
6534 }
6536 /**
6537 * Creates an SVGAngle object outside of any document trees. The object
6538 * is initialized to the value 0 degrees(unitless).
6539 */
6540 SVGAngle createSVGAngle()
6541 {
6542 }
6544 /**
6545 * Creates an SVGPoint object outside of any document trees. The object
6546 * is initialized to the point(0,0) in the user coordinate system.
6547 */
6548 SVGPoint createSVGPoint()
6549 {
6550 }
6552 /**
6553 * Creates an SVGMatrix object outside of any document trees. The object
6554 * is initialized to the identity matrix.
6555 */
6556 SVGMatrix createSVGMatrix()
6557 {
6558 }
6560 /**
6561 * Creates an SVGRect object outside of any document trees. The object
6562 * is initialized such that all values are set to 0 user units.
6563 */
6564 SVGRect createSVGRect()
6565 {
6566 }
6568 /**
6569 * Creates an SVGTransform object outside of any document trees.
6570 * The object is initialized to an identity matrix transform
6571 * (SVG_TRANSFORM_MATRIX).
6572 */
6573 SVGTransform createSVGTransform()
6574 {
6575 }
6577 /**
6578 * Creates an SVGTransform object outside of any document trees.
6579 * The object is initialized to the given matrix transform
6580 * (i.e., SVG_TRANSFORM_MATRIX).
6581 */
6582 SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix)
6583 {
6584 }
6586 /**
6587 * Searches this SVG document fragment(i.e., the search is restricted to a
6588 * subset of the document tree) for an Element whose id is given by elementId. If
6589 * an Element is found, that Element is returned. If no such element exists,
6590 * returns null. Behavior is not defined if more than one element has this id.
6591 */
6592 ElementPtr getElementById(const DOMString& elementId)
6593 {
6594 }
6597 //####################################################################
6598 //# SVGTextElement
6599 //####################################################################
6602 //####################################################################
6603 //# SVGTextContentElement
6604 //####################################################################
6607 /**
6608 * Corresponds to attribute textLength on the given element.
6609 */
6610 SVGAnimatedLength getTextLength()
6611 {
6612 }
6615 /**
6616 * Corresponds to attribute lengthAdjust on the given element. The value must be
6617 * one of the length adjust constants specified above.
6618 */
6619 SVGAnimatedEnumeration getLengthAdjust()
6620 {
6621 }
6624 /**
6625 * Returns the total number of characters to be rendered within the current
6626 * element. Includes characters which are included via a 'tref' reference.
6627 */
6628 long getNumberOfChars()
6629 {
6630 }
6632 /**
6633 * The total sum of all of the advance values from rendering all of the
6634 * characters within this element, including the advance value on the glyphs
6635 *(horizontal or vertical), the effect of properties 'kerning', 'letter-spacing'
6636 * and 'word-spacing' and adjustments due to attributes dx and dy on 'tspan'
6637 * elements. For non-rendering environments, the user agent shall make reasonable
6638 * assumptions about glyph metrics.
6639 */
6640 double getComputedTextLength()
6641 {
6642 }
6644 /**
6645 * The total sum of all of the advance values from rendering the specified
6646 * substring of the characters, including the advance value on the glyphs
6647 *(horizontal or vertical), the effect of properties 'kerning', 'letter-spacing'
6648 * and 'word-spacing' and adjustments due to attributes dx and dy on 'tspan'
6649 * elements. For non-rendering environments, the user agent shall make reasonable
6650 * assumptions about glyph metrics.
6651 */
6652 double getSubStringLength(unsigned long charnum, unsigned long nchars)
6653 throw (DOMException)
6654 {
6655 }
6657 /**
6658 * Returns the current text position before rendering the character in the user
6659 * coordinate system for rendering the glyph(s) that correspond to the specified
6660 * character. The current text position has already taken into account the
6661 * effects of any inter-character adjustments due to properties 'kerning',
6662 * 'letter-spacing' and 'word-spacing' and adjustments due to attributes x, y, dx
6663 * and dy. If multiple consecutive characters are rendered inseparably(e.g., as
6664 * a single glyph or a sequence of glyphs), then each of the inseparable
6665 * characters will return the start position for the first glyph.
6666 */
6667 SVGPoint getStartPositionOfChar(unsigned long charnum) throw (DOMException)
6668 {
6669 }
6671 /**
6672 * Returns the current text position after rendering the character in the user
6673 * coordinate system for rendering the glyph(s) that correspond to the specified
6674 * character. This current text position does not take into account the effects
6675 * of any inter-character adjustments to prepare for the next character, such as
6676 * properties 'kerning', 'letter-spacing' and 'word-spacing' and adjustments due
6677 * to attributes x, y, dx and dy. If multiple consecutive characters are rendered
6678 * inseparably(e.g., as a single glyph or a sequence of glyphs), then each of
6679 * the inseparable characters will return the end position for the last glyph.
6680 */
6681 SVGPoint getEndPositionOfChar(unsigned long charnum) throw (DOMException)
6682 {
6683 }
6685 /**
6686 * Returns a tightest rectangle which defines the minimum and maximum X and Y
6687 * values in the user coordinate system for rendering the glyph(s) that
6688 * correspond to the specified character. The calculations assume that all glyphs
6689 * occupy the full standard glyph cell for the font. If multiple consecutive
6690 * characters are rendered inseparably(e.g., as a single glyph or a sequence of
6691 * glyphs), then each of the inseparable characters will return the same extent.
6692 */
6693 SVGRect getExtentOfChar(unsigned long charnum) throw (DOMException)
6694 {
6695 }
6697 /**
6698 * Returns the rotation value relative to the current user coordinate system used
6699 * to render the glyph(s) corresponding to the specified character. If multiple
6700 * glyph(s) are used to render the given character and the glyphs each have
6701 * different rotations(e.g., due to text-on-a-path), the user agent shall return
6702 * an average value(e.g., the rotation angle at the midpoint along the path for
6703 * all glyphs used to render this character). The rotation value represents the
6704 * rotation that is supplemental to any rotation due to properties
6705 * 'glyph-orientation-horizontal' and 'glyph-orientation-vertical'; thus, any
6706 * glyph rotations due to these properties are not included into the returned
6707 * rotation value. If multiple consecutive characters are rendered inseparably
6708 *(e.g., as a single glyph or a sequence of glyphs), then each of the
6709 * inseparable characters will return the same rotation value.
6710 */
6711 double getRotationOfChar(unsigned long charnum) throw (DOMException)
6712 {
6713 }
6715 /**
6716 * Returns the index of the character whose corresponding glyph cell bounding box
6717 * contains the specified point. The calculations assume that all glyphs occupy
6718 * the full standard glyph cell for the font. If no such character exists, a
6719 * value of -1 is returned. If multiple such characters exist, the character
6720 * within the element whose glyphs were rendered last(i.e., take into account
6721 * any reordering such as for bidirectional text) is used. If multiple
6722 * consecutive characters are rendered inseparably(e.g., as a single glyph or a
6723 * sequence of glyphs), then the user agent shall allocate an equal percentage of
6724 * the text advance amount to each of the contributing characters in determining
6725 * which of the characters is chosen.
6726 */
6727 long getCharNumAtPosition(const SVGPoint &point)
6728 {
6729 }
6731 /**
6732 * Causes the specified substring to be selected just as if the user
6733 * selected the substring interactively.
6734 */
6735 void selectSubString(unsigned long charnum, unsigned long nchars)
6736 throw (DOMException)
6737 {
6738 }
6744 //####################################################################
6745 //# SVGTextPathElement
6746 //####################################################################
6749 /**
6750 * Corresponds to attribute startOffset on the given 'textPath' element.
6751 */
6752 SVGAnimatedLength getStartOffset()
6753 {
6754 }
6756 /**
6757 * Corresponds to attribute method on the given 'textPath' element. The value
6758 * must be one of the method type constants specified above.
6759 */
6760 SVGAnimatedEnumeration getMethod()
6761 {
6762 }
6764 /**
6765 * Corresponds to attribute spacing on the given 'textPath' element.
6766 * The value must be one of the spacing type constants specified above.
6767 */
6768 SVGAnimatedEnumeration getSpacing()
6769 {
6770 }
6773 //####################################################################
6774 //# SVGTextPositioningElement
6775 //####################################################################
6778 /**
6779 * Corresponds to attribute x on the given element.
6780 */
6781 SVGAnimatedLength getX()
6782 {
6783 }
6785 /**
6786 * Corresponds to attribute y on the given element.
6787 */
6788 SVGAnimatedLength getY()
6789 {
6790 }
6792 /**
6793 * Corresponds to attribute dx on the given element.
6794 */
6795 SVGAnimatedLength getDx()
6796 {
6797 }
6799 /**
6800 * Corresponds to attribute dy on the given element.
6801 */
6802 SVGAnimatedLength getDy()
6803 {
6804 }
6807 /**
6808 * Corresponds to attribute rotate on the given element.
6809 */
6810 SVGAnimatedNumberList getRotate()
6811 {
6812 }
6815 //####################################################################
6816 //# SVGTitleElement
6817 //####################################################################
6819 //####################################################################
6820 //# SVGTRefElement
6821 //####################################################################
6823 //####################################################################
6824 //# SVGTSpanElement
6825 //####################################################################
6827 //####################################################################
6828 //# SVGSwitchElement
6829 //####################################################################
6831 //####################################################################
6832 //# SVGUseElement
6833 //####################################################################
6835 /**
6836 * Corresponds to attribute x on the given 'use' element.
6837 */
6838 SVGAnimatedLength getX()
6839 {
6840 }
6842 /**
6843 * Corresponds to attribute y on the given 'use' element.
6844 */
6845 SVGAnimatedLength getY()
6846 {
6847 }
6849 /**
6850 * Corresponds to attribute width on the given 'use' element.
6851 */
6852 SVGAnimatedLength getWidth()
6853 {
6854 }
6856 /**
6857 * Corresponds to attribute height on the given 'use' element.
6858 */
6859 SVGAnimatedLength getHeight()
6860 {
6861 }
6863 /**
6864 * The root of the "instance tree". See description of SVGElementInstance for
6865 * a discussion on the instance tree.
6866 * */
6867 SVGElementInstance getInstanceRoot()
6868 {
6869 }
6871 /**
6872 * If the 'href' attribute is being animated, contains the current animated root
6873 * of the "instance tree". If the 'href' attribute is not currently being
6874 * animated, contains the same value as 'instanceRoot'. The root of the "instance
6875 * tree". See description of SVGElementInstance for a discussion on the instance
6876 * tree.
6877 */
6878 SVGElementInstance getAnimatedInstanceRoot()
6879 {
6880 }
6883 //####################################################################
6884 //# SVGVKernElement
6885 //####################################################################
6887 //####################################################################
6888 //# SVGViewElement
6889 //####################################################################
6892 /**
6893 *
6894 */
6895 SVGStringList getViewTarget();
6900 //##################
6901 //# Non-API methods
6902 //##################
6905 /**
6906 *
6907 */
6908 SVGElement::~SVGElement()
6909 {
6910 }
6915 /*#########################################################################
6916 ## SVGDocument
6917 #########################################################################*/
6920 /**
6921 * The title of a document as specified by the title sub-element of the 'svg'
6922 * root element(i.e., <svg><title>Here is the title</title>...</svg>)
6923 */
6924 DOMString SVGDocument::getTitle()
6925 {
6926 }
6928 /**
6929 * Returns the URI of the page that linked to this page. The value is an empty
6930 * string if the user navigated to the page directly(not through a link, but,
6931 * for example, via a bookmark).
6932 */
6933 DOMString SVGDocument::getReferrer()
6934 {
6935 }
6938 /**
6939 * The domain name of the server that served the document, or a null string if
6940 * the server cannot be identified by a domain name.
6941 */
6942 DOMString SVGDocument::getDomain()
6943 {
6944 }
6947 /**
6948 * The complete URI of the document.
6949 */
6950 DOMString SVGDocument::getURL()
6951 {
6952 }
6955 /**
6956 * The root 'svg' element in the document hierarchy.
6957 */
6958 SVGElementPtr SVGDocument::getRootElement()
6959 {
6960 }
6963 /**
6964 * Overloaded from Document
6965 *
6966 */
6967 ElementPtr SVGDocument::createElement(const DOMString &tagName)
6968 {
6969 ElementPtr ptr;
6970 return ptr;
6971 }
6974 /**
6975 * Overloaded from Document
6976 *
6977 */
6978 ElementPtr SVGDocument::createElementNS(const DOMString &tagName,
6979 const DOMString &namespaceURI)
6980 {
6981 ElementPtr ptr;
6982 return ptr;
6983 }
6986 /**
6987 * The root 'svg' element in the document hierarchy.
6988 */
6989 SVGElementPtr SVGDocument::getRootElement()
6990 {
6991 }
6995 //##################
6996 //# Non-API methods
6997 //##################
6999 /**
7000 *
7001 */
7002 SVGDocument::~SVGDocument()
7003 {
7004 }
7008 /*#########################################################################
7009 ## GetSVGDocument
7010 #########################################################################*/
7013 /**
7014 * Returns the SVGDocument object for the referenced SVG document.
7015 */
7016 SVGDocumentPtr GetSVGDocument::getSVGDocument()
7017 throw (DOMException)
7018 {
7019 SVGDocumentPtr ptr;
7020 return ptr;
7021 }
7023 //##################
7024 //# Non-API methods
7025 //##################
7027 /**
7028 *
7029 */
7030 GetSVGDocument::~GetSVGDocument()
7031 {
7032 }
7040 } //namespace svg
7041 } //namespace dom
7042 } //namespace w3c
7043 } //namespace org
7045 #endif // __SVG_H__
7046 /*#########################################################################
7047 ## E N D O F F I L E
7048 #########################################################################*/