src/dom/svg2.h

   1 #ifndef __SVG_H__\r
   2 #define __SVG_H__\r
   3 \r
   4 /**\r
   5  * Phoebe DOM Implementation.\r
   6  *\r
   7  * This is a C++ approximation of the W3C DOM model, which follows\r
   8  * fairly closely the specifications in the various .idl files, copies of\r
   9  * which are provided for reference.  Most important is this one:\r
  10  *\r
  11  * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html\r
  12  *\r
  13  * Authors:\r
  14  *   Bob Jamison\r
  15  *\r
  16  * Copyright(C) 2005-2008 Bob Jamison\r
  17  *\r
  18  *  This library is free software; you can redistribute it and/or\r
  19  *  modify it under the terms of the GNU Lesser General Public\r
  20  *  License as published by the Free Software Foundation; either\r
  21  *  version 2.1 of the License, or(at your option) any later version.\r
  22  *\r
  23  *  This library is distributed in the hope that it will be useful,\r
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
  26  *  Lesser General Public License for more details.\r
  27  *\r
  28  *  You should have received a copy of the GNU Lesser General Public\r
  29  *  License along with this library; if not, write to the Free Software\r
  30  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
  31  *\r
  32  * =======================================================================\r
  33  * NOTES\r
  34  *\r
  35  * This API follows:\r
  36  * http://www.w3.org/TR/SVG11/svgdom.html\r
  37  *\r
  38  * This file defines the main SVG-DOM Node types.  Other non-Node types are\r
  39  * defined in svgtypes.h.\r
  40  *    \r
  41  */\r
  42 \r
  43 \r
  44 // For access to DOM2 core\r
  45 #include "dom/dom.h"\r
  46 \r
  47 // For access to DOM2 events\r
  48 #include "dom/events.h"\r
  49 \r
  50 // For access to those parts from DOM2 CSS OM used by SVG DOM.\r
  51 #include "dom/css.h"\r
  52 \r
  53 // For access to those parts from DOM2 Views OM used by SVG DOM.\r
  54 #include "dom/views.h"\r
  55 \r
  56 // For access to the SMIL OM used by SVG DOM.\r
  57 #include "dom/smil.h"\r
  58 \r
  59 \r
  60 \r
  61 #include "svgtypes.h"\r
  62 \r
  63 #include <math.h>\r
  64 \r
  65 #define SVG_NAMESPACE "http://www.w3.org/2000/svg"\r
  66 \r
  67 \r
  68 namespace org\r
  69 {\r
  70 namespace w3c\r
  71 {\r
  72 namespace dom\r
  73 {\r
  74 namespace svg\r
  75 {\r
  76 \r
  77 \r
  78 //local definitions\r
  79 typedef dom::DOMString DOMString;\r
  80 typedef dom::DOMException DOMException;\r
  81 typedef dom::Element Element;\r
  82 typedef dom::ElementPtr ElementPtr;\r
  83 typedef dom::Document Document;\r
  84 typedef dom::DocumentPtr DocumentPtr;\r
  85 typedef dom::NodeList NodeList;\r
  86 \r
  87 \r
  88 \r
  89 \r
  90 class SVGElement;\r
  91 typedef Ptr<SVGElement> SVGElementPtr;\r
  92 class SVGDocument;\r
  93 typedef Ptr<SVGDocument> SVGDocumentPtr;\r
  94 \r
  95 //########################################################################\r
  96 //########################################################################\r
  97 //########################################################################\r
  98 //#   I N T E R F A C E S\r
  99 //########################################################################\r
 100 //########################################################################\r
 101 //########################################################################\r
 102 \r
 103 \r
 104 \r
 105 /*#########################################################################\r
 106 ## SVGMatrix\r
 107 #########################################################################*/\r
 108 \r
 109 /**\r
 110  *  In SVG, a Matrix is defined like this:\r
 111  *\r
 112  * | a  c  e |\r
 113  * | b  d  f |\r
 114  * | 0  0  1 |\r
 115  *\r
 116  */\r
 117 class SVGMatrix\r
 118 {\r
 119 public:\r
 120 \r
 121 \r
 122     /**\r
 123      *\r
 124      */\r
 125     virtual double getA()\r
 126         { return a; }\r
 127 \r
 128     /**\r
 129      *\r
 130      */\r
 131     virtual void setA(double val) throw (DOMException)\r
 132         { a = val; }\r
 133 \r
 134     /**\r
 135      *\r
 136      */\r
 137     virtual double getB()\r
 138         { return b; }\r
 139 \r
 140     /**\r
 141      *\r
 142      */\r
 143     virtual void setB(double val) throw (DOMException)\r
 144         { b = val; }\r
 145 \r
 146     /**\r
 147      *\r
 148      */\r
 149     virtual double getC()\r
 150         { return c; }\r
 151 \r
 152     /**\r
 153      *\r
 154      */\r
 155     virtual void setC(double val) throw (DOMException)\r
 156         { c = val; }\r
 157 \r
 158     /**\r
 159      *\r
 160      */\r
 161     virtual double getD()\r
 162         { return d; }\r
 163 \r
 164     /**\r
 165      *\r
 166      */\r
 167     virtual void setD(double val) throw (DOMException)\r
 168         { d = val; }\r
 169     /**\r
 170      *\r
 171      */\r
 172     virtual double getE()\r
 173         { return e; }\r
 174 \r
 175     /**\r
 176      *\r
 177      */\r
 178     virtual void setE(double val) throw (DOMException)\r
 179         { e = val; }\r
 180     /**\r
 181      *\r
 182      */\r
 183     virtual double getF()\r
 184         { return f; }\r
 185 \r
 186     /**\r
 187      *\r
 188      */\r
 189     virtual void setF(double val) throw (DOMException)\r
 190         { f = val; }\r
 191 \r
 192 \r
 193     /**\r
 194      * Return the result of postmultiplying this matrix with another.\r
 195      */\r
 196     virtual SVGMatrix multiply(const SVGMatrix &other)\r
 197         {\r
 198         SVGMatrix result;\r
 199         result.a = a * other.a  +  c * other.b;\r
 200         result.b = b * other.a  +  d * other.b;\r
 201         result.c = a * other.c  +  c * other.d;\r
 202         result.d = b * other.c  +  d * other.d;\r
 203         result.e = a * other.e  +  c * other.f  +  e;\r
 204         result.f = b * other.e  +  d * other.f  +  f;\r
 205         return result;\r
 206         }\r
 207 \r
 208     /**\r
 209      *  Calculate the inverse of this matrix\r
 210      *\r
 211      */\r
 212     virtual SVGMatrix inverse(  ) throw( SVGException )\r
 213         {\r
 214         /*###########################################\r
 215         The determinant of a 3x3 matrix E\r
 216            (let's use our own notation for a bit)\r
 217 \r
 218             A  B  C\r
 219             D  E  F\r
 220             G  H  I\r
 221         is\r
 222             AEI - AFH - BDI + BFG + CDH - CEG\r
 223 \r
 224         Since in our affine transforms, G and H==0 and I==1,\r
 225         this reduces to:\r
 226             AE - BD\r
 227         In SVG's naming scheme, that is:  a * d - c * b .  SIMPLE!\r
 228 \r
 229         In a similar method of attack, SVG's adjunct matrix is:\r
 230 \r
 231            d  -c   cf-ed\r
 232           -b   a   eb-af\r
 233            0   0   ad-cb\r
 234 \r
 235         To get the inverse matrix, we divide the adjunct matrix by\r
 236         the determinant.  Notice that (ad-cb)/(ad-cb)==1.  Very cool.\r
 237         So what we end up with is this:\r
 238 \r
 239            a =  d/(ad-cb)  c = -c/(ad-cb)   e = (cf-ed)/(ad-cb)\r
 240            b = -b/(ad-cb)  d =  a/(ad-cb)   f = (eb-af)/(ad-cb)\r
 241 \r
 242         (Since this would be in all SVG-DOM implementations,\r
 243          somebody needed to document this!  ^^ )\r
 244         #############################################*/\r
 245 \r
 246         SVGMatrix result;\r
 247         double determinant = a * d  -  c * b;\r
 248         if (determinant < 1.0e-18)//invertible?\r
 249             {\r
 250             result.identity();//cop out\r
 251             return result;\r
 252             }\r
 253 \r
 254         double idet = 1.0 / determinant;\r
 255         result.a =   d * idet;\r
 256         result.b =  -b * idet;\r
 257         result.c =  -c * idet;\r
 258         result.d =   a * idet;\r
 259         result.e =  (c*f - e*d) * idet;\r
 260         result.f =  (e*b - a*f) * idet;\r
 261         return result;\r
 262         }\r
 263 \r
 264     /**\r
 265      * Equivalent to multiplying by:\r
 266      *  | 1  0  x |\r
 267      *  | 0  1  y |\r
 268      *  | 0  0  1 |\r
 269      *\r
 270      */\r
 271     virtual SVGMatrix translate(double x, double y )\r
 272         {\r
 273         SVGMatrix result;\r
 274         result.a = a;\r
 275         result.b = b;\r
 276         result.c = c;\r
 277         result.d = d;\r
 278         result.e = a * x  +  c * y  +  e;\r
 279         result.f = b * x  +  d * y  +  f;\r
 280         return result;\r
 281         }\r
 282 \r
 283     /**\r
 284      * Equivalent to multiplying by:\r
 285      *  | scale  0      0 |\r
 286      *  | 0      scale  0 |\r
 287      *  | 0      0      1 |\r
 288      *\r
 289      */\r
 290     virtual SVGMatrix scale(double scale)\r
 291         {\r
 292         SVGMatrix result;\r
 293         result.a = a * scale;\r
 294         result.b = b * scale;\r
 295         result.c = c * scale;\r
 296         result.d = d * scale;\r
 297         result.e = e;\r
 298         result.f = f;\r
 299         return result;\r
 300         }\r
 301 \r
 302     /**\r
 303      * Equivalent to multiplying by:\r
 304      *  | scaleX  0       0 |\r
 305      *  | 0       scaleY  0 |\r
 306      *  | 0       0       1 |\r
 307      *\r
 308      */\r
 309     virtual SVGMatrix scaleNonUniform(double scaleX,\r
 310                                       double scaleY )\r
 311         {\r
 312         SVGMatrix result;\r
 313         result.a = a * scaleX;\r
 314         result.b = b * scaleX;\r
 315         result.c = c * scaleY;\r
 316         result.d = d * scaleY;\r
 317         result.e = e;\r
 318         result.f = f;\r
 319         return result;\r
 320         }\r
 321 \r
 322     /**\r
 323      * Equivalent to multiplying by:\r
 324      *  | cos(a) -sin(a)   0 |\r
 325      *  | sin(a)  cos(a)   0 |\r
 326      *  | 0       0        1 |\r
 327      *\r
 328      */\r
 329     virtual SVGMatrix rotate (double angle)\r
 330         {\r
 331         double sina  = sin(angle);\r
 332         double msina = -sina;\r
 333         double cosa  = cos(angle);\r
 334         SVGMatrix result;\r
 335         result.a = a * cosa   +  c * sina;\r
 336         result.b = b * cosa   +  d + sina;\r
 337         result.c = a * msina  +  c * cosa;\r
 338         result.d = b * msina  +  d * cosa;\r
 339         result.e = e;\r
 340         result.f = f;\r
 341         return result;\r
 342         }\r
 343 \r
 344     /**\r
 345      * Equivalent to multiplying by:\r
 346      *  | cos(a) -sin(a)   0 |\r
 347      *  | sin(a)  cos(a)   0 |\r
 348      *  | 0       0        1 |\r
 349      *  In this case, angle 'a' is computed as the artangent\r
 350      *  of the slope y/x .  It is negative if the slope is negative.\r
 351      */\r
 352     virtual SVGMatrix rotateFromVector(double x, double y)\r
 353                                       throw( SVGException )\r
 354         {\r
 355         double angle = atan(y / x);\r
 356         if (y < 0.0)\r
 357             angle = -angle;\r
 358         SVGMatrix result;\r
 359         double sina  = sin(angle);\r
 360         double msina = -sina;\r
 361         double cosa  = cos(angle);\r
 362         result.a = a * cosa   +  c * sina;\r
 363         result.b = b * cosa   +  d + sina;\r
 364         result.c = a * msina  +  c * cosa;\r
 365         result.d = b * msina  +  d * cosa;\r
 366         result.e = e;\r
 367         result.f = f;\r
 368         return result;\r
 369         }\r
 370 \r
 371     /**\r
 372      * Equivalent to multiplying by:\r
 373      *  | -1   0   0 |\r
 374      *  | 0    1   0 |\r
 375      *  | 0    0   1 |\r
 376      *\r
 377      */\r
 378     virtual SVGMatrix flipX(  )\r
 379         {\r
 380         SVGMatrix result;\r
 381         result.a = -a;\r
 382         result.b = -b;\r
 383         result.c =  c;\r
 384         result.d =  d;\r
 385         result.e =  e;\r
 386         result.f =  f;\r
 387         return result;\r
 388         }\r
 389 \r
 390     /**\r
 391      * Equivalent to multiplying by:\r
 392      *  | 1   0   0 |\r
 393      *  | 0  -1   0 |\r
 394      *  | 0   0   1 |\r
 395      *\r
 396      */\r
 397     virtual SVGMatrix flipY( )\r
 398         {\r
 399         SVGMatrix result;\r
 400         result.a =  a;\r
 401         result.b =  b;\r
 402         result.c = -c;\r
 403         result.d = -d;\r
 404         result.e =  e;\r
 405         result.f =  f;\r
 406         return result;\r
 407         }\r
 408 \r
 409     /**\r
 410      *  | 1   tan(a)  0 |\r
 411      *  | 0   1       0 |\r
 412      *  | 0   0       1 |\r
 413      *\r
 414      */\r
 415     virtual SVGMatrix skewX(double angle)\r
 416         {\r
 417         double tana = tan(angle);\r
 418         SVGMatrix result;\r
 419         result.a =  a;\r
 420         result.b =  b;\r
 421         result.c =  a * tana + c;\r
 422         result.d =  b * tana + d;\r
 423         result.e =  e;\r
 424         result.f =  f;\r
 425         return result;\r
 426         }\r
 427 \r
 428     /**\r
 429      * Equivalent to multiplying by:\r
 430      *  | 1       0   0 |\r
 431      *  | tan(a)  1   0 |\r
 432      *  | 0       0   1 |\r
 433      *\r
 434      */\r
 435     virtual SVGMatrix skewY(double angle)\r
 436         {\r
 437         double tana = tan(angle);\r
 438         SVGMatrix result;\r
 439         result.a =  a + c * tana;\r
 440         result.b =  b + d * tana;\r
 441         result.c =  c;\r
 442         result.d =  d;\r
 443         result.e =  e;\r
 444         result.f =  f;\r
 445         return result;\r
 446         }\r
 447 \r
 448 \r
 449 \r
 450     //##################\r
 451     //# Non-API methods\r
 452     //##################\r
 453 \r
 454     /**\r
 455      *\r
 456      */\r
 457     SVGMatrix()\r
 458         {\r
 459         identity();\r
 460         }\r
 461 \r
 462     /**\r
 463      *\r
 464      */\r
 465     SVGMatrix(double aArg, double bArg, double cArg,\r
 466               double dArg, double eArg, double fArg )\r
 467         {\r
 468         a = aArg; b = bArg; c = cArg;\r
 469         d = dArg; e = eArg; f = fArg;\r
 470         }\r
 471 \r
 472     /**\r
 473      * Copy constructor\r
 474      */\r
 475     SVGMatrix(const SVGMatrix &other)\r
 476         {\r
 477         a = other.a;\r
 478         b = other.b;\r
 479         c = other.c;\r
 480         d = other.d;\r
 481         e = other.e;\r
 482         f = other.f;\r
 483         }\r
 484 \r
 485 \r
 486 \r
 487     /**\r
 488      *\r
 489      */\r
 490     virtual ~SVGMatrix() {}\r
 491 \r
 492 protected:\r
 493 \r
 494 friend class SVGTransform;\r
 495 \r
 496     /*\r
 497      * Set to the identify matrix\r
 498      */\r
 499    void identity()\r
 500        {\r
 501        a = 1.0;\r
 502        b = 0.0;\r
 503        c = 0.0;\r
 504        d = 1.0;\r
 505        e = 0.0;\r
 506        f = 0.0;\r
 507        }\r
 508 \r
 509     double a, b, c, d, e, f;\r
 510 \r
 511 };\r
 512 \r
 513 \r
 514 /*#########################################################################\r
 515 ## SVGTransform\r
 516 #########################################################################*/\r
 517 \r
 518 /**\r
 519  *\r
 520  */\r
 521 class SVGTransform\r
 522 {\r
 523 public:\r
 524 \r
 525     /**\r
 526      * Transform Types\r
 527      */\r
 528     typedef enum\r
 529         {\r
 530         SVG_TRANSFORM_UNKNOWN   = 0,\r
 531         SVG_TRANSFORM_MATRIX    = 1,\r
 532         SVG_TRANSFORM_TRANSLATE = 2,\r
 533         SVG_TRANSFORM_SCALE     = 3,\r
 534         SVG_TRANSFORM_ROTATE    = 4,\r
 535         SVG_TRANSFORM_SKEWX     = 5,\r
 536         SVG_TRANSFORM_SKEWY     = 6,\r
 537         } TransformType;\r
 538 \r
 539     /**\r
 540      *\r
 541      */\r
 542     virtual unsigned short getType()\r
 543         { return type; }\r
 544 \r
 545 \r
 546     /**\r
 547      *\r
 548      */\r
 549     virtual SVGMatrix getMatrix()\r
 550         {\r
 551         return matrix;\r
 552         }\r
 553 \r
 554     /**\r
 555      *\r
 556      */\r
 557     virtual double getAngle()\r
 558         {\r
 559         return angle;\r
 560         }\r
 561 \r
 562 \r
 563     /**\r
 564      *\r
 565      */\r
 566     virtual void setMatrix(const SVGMatrix &matrixArg)\r
 567         {\r
 568         type = SVG_TRANSFORM_MATRIX;\r
 569         matrix = matrixArg;\r
 570         }\r
 571 \r
 572     /**\r
 573      *\r
 574      */\r
 575     virtual void setTranslate (double tx, double ty )\r
 576         {\r
 577         type = SVG_TRANSFORM_TRANSLATE;\r
 578         matrix.setA(1.0);\r
 579         matrix.setB(0.0);\r
 580         matrix.setC(0.0);\r
 581         matrix.setD(1.0);\r
 582         matrix.setE(tx);\r
 583         matrix.setF(ty);\r
 584         }\r
 585 \r
 586     /**\r
 587      *\r
 588      */\r
 589     virtual void setScale (double sx, double sy )\r
 590         {\r
 591         type = SVG_TRANSFORM_SCALE;\r
 592         matrix.setA(sx);\r
 593         matrix.setB(0.0);\r
 594         matrix.setC(0.0);\r
 595         matrix.setD(sy);\r
 596         matrix.setE(0.0);\r
 597         matrix.setF(0.0);\r
 598         }\r
 599 \r
 600     /**\r
 601      *\r
 602      */\r
 603     virtual void setRotate (double angleArg, double cx, double cy)\r
 604         {\r
 605         angle = angleArg;\r
 606         setTranslate(cx, cy);\r
 607         type = SVG_TRANSFORM_ROTATE;\r
 608         matrix.rotate(angle);\r
 609         }\r
 610 \r
 611     /**\r
 612      *\r
 613      */\r
 614     virtual void setSkewX (double angleArg)\r
 615         {\r
 616         angle = angleArg;\r
 617         type = SVG_TRANSFORM_SKEWX;\r
 618         matrix.identity();\r
 619         matrix.skewX(angle);\r
 620         }\r
 621 \r
 622     /**\r
 623      *\r
 624      */\r
 625     virtual void setSkewY (double angleArg)\r
 626         {\r
 627         angle = angleArg;\r
 628         type = SVG_TRANSFORM_SKEWY;\r
 629         matrix.identity();\r
 630         matrix.skewY(angle);\r
 631         }\r
 632 \r
 633 \r
 634     //##################\r
 635     //# Non-API methods\r
 636     //##################\r
 637 \r
 638     /**\r
 639      *\r
 640      */\r
 641     SVGTransform()\r
 642         {\r
 643         type = SVG_TRANSFORM_UNKNOWN;\r
 644         angle = 0.0;\r
 645         }\r
 646 \r
 647     /**\r
 648      *\r
 649      */\r
 650     SVGTransform(const SVGTransform &other)\r
 651         {\r
 652         type   = other.type;\r
 653         angle  = other.angle;\r
 654         matrix = other.matrix;\r
 655         }\r
 656 \r
 657     /**\r
 658      *\r
 659      */\r
 660     virtual ~SVGTransform()\r
 661         {}\r
 662 \r
 663 protected:\r
 664 \r
 665     int type;\r
 666     double angle;\r
 667 \r
 668     SVGMatrix matrix;\r
 669 };\r
 670 \r
 671 \r
 672 \r
 673 \r
 674 \r
 675 \r
 676 /*#########################################################################\r
 677 ## SVGTransformList\r
 678 #########################################################################*/\r
 679 \r
 680 /**\r
 681  *\r
 682  */\r
 683 class SVGTransformList\r
 684 {\r
 685 public:\r
 686 \r
 687 \r
 688     /**\r
 689      *\r
 690      */\r
 691     virtual unsigned long getNumberOfItems()\r
 692         { return items.size(); }\r
 693 \r
 694 \r
 695     /**\r
 696      *\r
 697      */\r
 698     virtual void clear( ) throw( DOMException )\r
 699         { items.clear(); }\r
 700 \r
 701     /**\r
 702      *\r
 703      */\r
 704     virtual SVGTransform initialize (const SVGTransform &newItem)\r
 705                          throw( DOMException, SVGException )\r
 706         {\r
 707         items.clear();\r
 708         items.push_back(newItem);\r
 709         return newItem;\r
 710         }\r
 711 \r
 712     /**\r
 713      *\r
 714      */\r
 715     virtual SVGTransform getItem (unsigned long index )\r
 716                     throw( DOMException )\r
 717         {\r
 718         if (index>=items.size())\r
 719             {\r
 720             SVGTransform transform;\r
 721             return transform;\r
 722             }\r
 723         return items[index];\r
 724         }\r
 725 \r
 726     /**\r
 727      *\r
 728      */\r
 729     virtual SVGTransform insertItemBefore (const SVGTransform &newItem,\r
 730                                            unsigned long index )\r
 731                                       throw( DOMException, SVGException )\r
 732         {\r
 733         if (index > items.size())\r
 734             items.push_back(newItem);\r
 735         else\r
 736             {\r
 737             std::vector<SVGTransform>::iterator iter = items.begin() + index;\r
 738             items.insert(iter, newItem);\r
 739             }\r
 740         return newItem;\r
 741         }\r
 742 \r
 743     /**\r
 744      *\r
 745      */\r
 746     virtual SVGTransform replaceItem (const SVGTransform &newItem,\r
 747                                        unsigned long index )\r
 748                                 throw( DOMException, SVGException )\r
 749         {\r
 750         if (index>=items.size())\r
 751             {\r
 752             SVGTransform transform;\r
 753             return transform;\r
 754             }\r
 755         else\r
 756             {\r
 757             std::vector<SVGTransform>::iterator iter = items.begin() + index;\r
 758             *iter = newItem;\r
 759             }\r
 760         return newItem;\r
 761         }\r
 762 \r
 763     /**\r
 764      *\r
 765      */\r
 766     virtual SVGTransform removeItem (unsigned long index )\r
 767                                      throw( DOMException )\r
 768         {\r
 769         if (index>=items.size())\r
 770             {\r
 771             SVGTransform transform;\r
 772             return transform;\r
 773             }\r
 774         std::vector<SVGTransform>::iterator iter = items.begin() + index;\r
 775         SVGTransform oldItem = *iter;\r
 776         items.erase(iter);\r
 777         return oldItem;\r
 778         }\r
 779 \r
 780     /**\r
 781      *\r
 782      */\r
 783     virtual SVGTransform appendItem (const SVGTransform &newItem)\r
 784                                   throw( DOMException, SVGException )\r
 785         {\r
 786         items.push_back(newItem);\r
 787         return newItem;\r
 788         }\r
 789 \r
 790     /**\r
 791      *\r
 792      */\r
 793     virtual SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix)\r
 794         {\r
 795         SVGTransform transform;\r
 796         transform.setMatrix(matrix);\r
 797         return transform;\r
 798         }\r
 799 \r
 800     /**\r
 801      *\r
 802      */\r
 803     virtual SVGTransform consolidate()\r
 804         {\r
 805         SVGMatrix matrix;\r
 806         for (unsigned int i=0 ; i<items.size() ; i++)\r
 807             matrix = matrix.multiply(items[i].getMatrix());\r
 808         SVGTransform transform;\r
 809         transform.setMatrix(matrix);\r
 810         items.clear();\r
 811         items.push_back(transform);\r
 812         return transform;\r
 813         }\r
 814 \r
 815 \r
 816 \r
 817     //##################\r
 818     //# Non-API methods\r
 819     //##################\r
 820 \r
 821     /**\r
 822      *\r
 823      */\r
 824     SVGTransformList()\r
 825         {}\r
 826 \r
 827     /**\r
 828      *\r
 829      */\r
 830     SVGTransformList(const SVGTransformList &other)\r
 831         {\r
 832         items = other.items;\r
 833         }\r
 834 \r
 835     /**\r
 836      *\r
 837      */\r
 838     virtual ~SVGTransformList() {}\r
 839 \r
 840 protected:\r
 841 \r
 842     std::vector<SVGTransform> items;\r
 843 \r
 844 };\r
 845 \r
 846 \r
 847 \r
 848 \r
 849 \r
 850 \r
 851 /*#########################################################################\r
 852 ## SVGAnimatedTransformList\r
 853 #########################################################################*/\r
 854 \r
 855 /**\r
 856  *\r
 857  */\r
 858 class SVGAnimatedTransformList\r
 859 {\r
 860 public:\r
 861 \r
 862     /**\r
 863      *\r
 864      */\r
 865     virtual SVGTransformList getBaseVal()\r
 866         { return baseVal; }\r
 867 \r
 868     /**\r
 869      *\r
 870      */\r
 871     virtual SVGTransformList getAnimVal()\r
 872         { return animVal; }\r
 873 \r
 874 \r
 875 \r
 876     //##################\r
 877     //# Non-API methods\r
 878     //##################\r
 879 \r
 880     /**\r
 881      *\r
 882      */\r
 883     SVGAnimatedTransformList()\r
 884         {}\r
 885 \r
 886     /**\r
 887      *\r
 888      */\r
 889     SVGAnimatedTransformList(const SVGAnimatedTransformList &other)\r
 890         {\r
 891         baseVal = other.baseVal;\r
 892         animVal = other.animVal;\r
 893         }\r
 894 \r
 895     /**\r
 896      *\r
 897      */\r
 898     virtual ~SVGAnimatedTransformList() {}\r
 899 \r
 900 protected:\r
 901 \r
 902     SVGTransformList baseVal;\r
 903     SVGTransformList animVal;\r
 904 \r
 905 };\r
 906 \r
 907 \r
 908 \r
 909 \r
 910 /*#########################################################################\r
 911 ## SVGAnimatedBoolean\r
 912 #########################################################################*/\r
 913 \r
 914 /**\r
 915  *\r
 916  */\r
 917 class SVGAnimatedBoolean\r
 918 {\r
 919 public:\r
 920 \r
 921     /**\r
 922      *\r
 923      */\r
 924     virtual bool getBaseVal()\r
 925         {\r
 926         return baseVal;\r
 927         }\r
 928 \r
 929     /**\r
 930      *\r
 931      */\r
 932     virtual void setBaseVal(bool val) throw (DOMException)\r
 933         {\r
 934         baseVal = val;\r
 935         }\r
 936 \r
 937     /**\r
 938      *\r
 939      */\r
 940     virtual bool getAnimVal()\r
 941         {\r
 942         return animVal;\r
 943         }\r
 944 \r
 945 \r
 946     //##################\r
 947     //# Non-API methods\r
 948     //##################\r
 949 \r
 950     /**\r
 951      *\r
 952      */\r
 953     SVGAnimatedBoolean()\r
 954         {\r
 955         baseVal = animVal = false;\r
 956         }\r
 957 \r
 958     /**\r
 959      *\r
 960      */\r
 961     SVGAnimatedBoolean(const SVGAnimatedBoolean &other)\r
 962         {\r
 963         baseVal = other.baseVal;\r
 964         animVal = other.animVal;\r
 965         }\r
 966 \r
 967     /**\r
 968      *\r
 969      */\r
 970     virtual ~SVGAnimatedBoolean() {}\r
 971 \r
 972 protected:\r
 973 \r
 974     bool baseVal, animVal;\r
 975 \r
 976 };\r
 977 \r
 978 \r
 979 \r
 980 \r
 981 /*#########################################################################\r
 982 ## SVGAnimatedString\r
 983 #########################################################################*/\r
 984 \r
 985 /**\r
 986  *\r
 987  */\r
 988 class SVGAnimatedString\r
 989 {\r
 990 public:\r
 991 \r
 992     /**\r
 993      *\r
 994      */\r
 995     virtual DOMString getBaseVal()\r
 996         {\r
 997         return baseVal;\r
 998         }\r
 999 \r
1000     /**\r
1001      *\r
1002      */\r
1003     virtual void setBaseVal(const DOMString &val)\r
1004                             throw (DOMException)\r
1005         {\r
1006         baseVal = val;\r
1007         }\r
1008 \r
1009     /**\r
1010      *\r
1011      */\r
1012     virtual DOMString getAnimVal()\r
1013         {\r
1014         return animVal;\r
1015         }\r
1016 \r
1017 \r
1018     //##################\r
1019     //# Non-API methods\r
1020     //##################\r
1021 \r
1022 \r
1023     /**\r
1024      *\r
1025      */\r
1026     SVGAnimatedString()\r
1027         {\r
1028         baseVal = "";\r
1029         animVal = "";\r
1030         }\r
1031 \r
1032     /**\r
1033      *\r
1034      */\r
1035     SVGAnimatedString(const SVGAnimatedString &other)\r
1036         {\r
1037         baseVal = other.baseVal;\r
1038         animVal = other.animVal;\r
1039         }\r
1040 \r
1041     /**\r
1042      *\r
1043      */\r
1044     virtual ~SVGAnimatedString() {}\r
1045 \r
1046 protected:\r
1047 \r
1048     DOMString baseVal, animVal;\r
1049 \r
1050 };\r
1051 \r
1052 \r
1053 \r
1054 \r
1055 \r
1056 /*#########################################################################\r
1057 ## SVGStringList\r
1058 #########################################################################*/\r
1059 \r
1060 /**\r
1061  *\r
1062  */\r
1063 class SVGStringList\r
1064 {\r
1065 public:\r
1066 \r
1067 \r
1068     /**\r
1069      *\r
1070      */\r
1071     virtual unsigned long getNumberOfItems()\r
1072         {\r
1073         return items.size();\r
1074         }\r
1075 \r
1076     /**\r
1077      *\r
1078      */\r
1079     virtual void clear () throw( DOMException )\r
1080        {\r
1081        items.clear();\r
1082        }\r
1083 \r
1084     /**\r
1085      *\r
1086      */\r
1087     virtual DOMString initialize ( const DOMString& newItem )\r
1088                     throw( DOMException, SVGException )\r
1089         {\r
1090         items.clear();\r
1091         items.push_back(newItem);\r
1092         return newItem;\r
1093         }\r
1094 \r
1095     /**\r
1096      *\r
1097      */\r
1098     virtual DOMString getItem ( unsigned long index )\r
1099                     throw( DOMException )\r
1100         {\r
1101         if (index >= items.size())\r
1102             return "";\r
1103         return items[index];\r
1104         }\r
1105 \r
1106     /**\r
1107      *\r
1108      */\r
1109     virtual DOMString insertItemBefore ( const DOMString& newItem,\r
1110                                  unsigned long index )\r
1111                                throw( DOMException, SVGException )\r
1112         {\r
1113         if (index>=items.size())\r
1114             {\r
1115             items.push_back(newItem);\r
1116             }\r
1117         else\r
1118             {\r
1119             std::vector<DOMString>::iterator iter = items.begin() + index;\r
1120             items.insert(iter, newItem);\r
1121             }\r
1122         return newItem;\r
1123         }\r
1124 \r
1125     /**\r
1126      *\r
1127      */\r
1128     virtual DOMString replaceItem ( const DOMString& newItem,\r
1129                                     unsigned long index )\r
1130                                 throw( DOMException, SVGException )\r
1131         {\r
1132         if (index>=items.size())\r
1133             return "";\r
1134         std::vector<DOMString>::iterator iter = items.begin() + index;\r
1135         *iter = newItem;\r
1136         return newItem;\r
1137         }\r
1138 \r
1139     /**\r
1140      *\r
1141      */\r
1142     virtual DOMString removeItem ( unsigned long index )\r
1143                     throw( DOMException )\r
1144         {\r
1145         if (index>=items.size())\r
1146             return "";\r
1147         std::vector<DOMString>::iterator iter = items.begin() + index;\r
1148         DOMString oldstr = *iter;\r
1149         items.erase(iter);\r
1150         return oldstr;\r
1151         }\r
1152 \r
1153     /**\r
1154      *\r
1155      */\r
1156     virtual DOMString appendItem ( const DOMString& newItem )\r
1157                     throw( DOMException, SVGException )\r
1158         {\r
1159         items.push_back(newItem);\r
1160         return newItem;\r
1161         }\r
1162 \r
1163 \r
1164 \r
1165     //##################\r
1166     //# Non-API methods\r
1167     //##################\r
1168 \r
1169     /**\r
1170      *\r
1171      */\r
1172     SVGStringList() {}\r
1173 \r
1174     /**\r
1175      *\r
1176      */\r
1177    SVGStringList(const SVGStringList &other)\r
1178        {\r
1179        items = other.items;\r
1180        }\r
1181 \r
1182     /**\r
1183      *\r
1184      */\r
1185     virtual ~SVGStringList() {}\r
1186 \r
1187 protected:\r
1188 \r
1189     std::vector<DOMString>items;\r
1190 \r
1191 };\r
1192 \r
1193 \r
1194 \r
1195 \r
1196 \r
1197 /*#########################################################################\r
1198 ## SVGAnimatedEnumeration\r
1199 #########################################################################*/\r
1200 \r
1201 /**\r
1202  *\r
1203  */\r
1204 class SVGAnimatedEnumeration\r
1205 {\r
1206 public:\r
1207 \r
1208     /**\r
1209      *\r
1210      */\r
1211     virtual unsigned short getBaseVal()\r
1212         {\r
1213         return baseVal;\r
1214         }\r
1215 \r
1216     /**\r
1217      *\r
1218      */\r
1219     virtual void setBaseVal(unsigned short val)\r
1220                                      throw (DOMException)\r
1221         {\r
1222         baseVal = val;\r
1223         }\r
1224 \r
1225     /**\r
1226      *\r
1227      */\r
1228     virtual unsigned short getAnimVal()\r
1229         {\r
1230         return animVal;\r
1231         }\r
1232 \r
1233 \r
1234 \r
1235     //##################\r
1236     //# Non-API methods\r
1237     //##################\r
1238 \r
1239 \r
1240     /**\r
1241      *\r
1242      */\r
1243     SVGAnimatedEnumeration()\r
1244         {\r
1245         baseVal = animVal = 0;\r
1246         }\r
1247 \r
1248     /**\r
1249      *\r
1250      */\r
1251     SVGAnimatedEnumeration(const SVGAnimatedEnumeration &other)\r
1252         {\r
1253         baseVal = other.baseVal;\r
1254         animVal = other.animVal;\r
1255         }\r
1256 \r
1257     /**\r
1258      *\r
1259      */\r
1260     virtual ~SVGAnimatedEnumeration() {}\r
1261 \r
1262 protected:\r
1263 \r
1264     int baseVal, animVal;\r
1265 \r
1266 };\r
1267 \r
1268 \r
1269 \r
1270 \r
1271 \r
1272 /*#########################################################################\r
1273 ## SVGAnimatedInteger\r
1274 #########################################################################*/\r
1275 \r
1276 /**\r
1277  *\r
1278  */\r
1279 class SVGAnimatedInteger\r
1280 {\r
1281 public:\r
1282 \r
1283 \r
1284     /**\r
1285      *\r
1286      */\r
1287     virtual long getBaseVal()\r
1288         {\r
1289         return baseVal;\r
1290         }\r
1291 \r
1292     /**\r
1293      *\r
1294      */\r
1295     virtual void setBaseVal(long val) throw (DOMException)\r
1296         {\r
1297         baseVal = val;\r
1298         }\r
1299 \r
1300     /**\r
1301      *\r
1302      */\r
1303     virtual long getAnimVal()\r
1304         {\r
1305         return animVal;\r
1306         }\r
1307 \r
1308 \r
1309 \r
1310     //##################\r
1311     //# Non-API methods\r
1312     //##################\r
1313 \r
1314 \r
1315     /**\r
1316      *\r
1317      */\r
1318     SVGAnimatedInteger()\r
1319         { baseVal = animVal = 0L;}\r
1320 \r
1321 \r
1322     /**\r
1323      *\r
1324      */\r
1325     SVGAnimatedInteger(long value)\r
1326         {\r
1327         baseVal = value;\r
1328         animVal = 0L;\r
1329         }\r
1330 \r
1331     /**\r
1332      *\r
1333      */\r
1334     SVGAnimatedInteger(long baseValArg, long animValArg)\r
1335         {\r
1336         baseVal = baseValArg;\r
1337         animVal = animValArg;\r
1338         }\r
1339 \r
1340 \r
1341     /**\r
1342      *\r
1343      */\r
1344     SVGAnimatedInteger(const SVGAnimatedInteger &other)\r
1345         {\r
1346         baseVal = other.baseVal;\r
1347         animVal = other.animVal;\r
1348         }\r
1349 \r
1350     /**\r
1351      *\r
1352      */\r
1353     virtual ~SVGAnimatedInteger() {}\r
1354 \r
1355 protected:\r
1356 \r
1357     long baseVal, animVal;\r
1358 \r
1359 };\r
1360 \r
1361 \r
1362 \r
1363 \r
1364 \r
1365 /*#########################################################################\r
1366 ## SVGNumber\r
1367 #########################################################################*/\r
1368 \r
1369 /**\r
1370  *\r
1371  */\r
1372 class SVGNumber\r
1373 {\r
1374 public:\r
1375 \r
1376 \r
1377     /**\r
1378      *\r
1379      */\r
1380     virtual double getValue()\r
1381         {\r
1382         return value;\r
1383         }\r
1384 \r
1385     /**\r
1386      *\r
1387      */\r
1388     virtual void setValue(double val) throw (DOMException)\r
1389         {\r
1390         value = val;\r
1391         }\r
1392 \r
1393 \r
1394     //##################\r
1395     //# Non-API methods\r
1396     //##################\r
1397 \r
1398     /**\r
1399      *\r
1400      */\r
1401     SVGNumber()\r
1402         {\r
1403         value = 0.0;\r
1404         }\r
1405 \r
1406     /**\r
1407      *\r
1408      */\r
1409     SVGNumber(const SVGNumber &other)\r
1410         {\r
1411         value = other.value;\r
1412         }\r
1413 \r
1414     /**\r
1415      *\r
1416      */\r
1417     virtual ~SVGNumber() {}\r
1418 \r
1419 protected:\r
1420 \r
1421     double value;\r
1422 \r
1423 };\r
1424 \r
1425 \r
1426 \r
1427 \r
1428 \r
1429 /*#########################################################################\r
1430 ## SVGAnimatedNumber\r
1431 #########################################################################*/\r
1432 \r
1433 /**\r
1434  *\r
1435  */\r
1436 class SVGAnimatedNumber\r
1437 {\r
1438 public:\r
1439 \r
1440 \r
1441 \r
1442     /**\r
1443      *\r
1444      */\r
1445     virtual double getBaseVal()\r
1446         {\r
1447         return baseVal;\r
1448         }\r
1449 \r
1450     /**\r
1451      *\r
1452      */\r
1453     virtual void setBaseVal(double val) throw (DOMException)\r
1454         {\r
1455         baseVal = val;\r
1456         }\r
1457 \r
1458     /**\r
1459      *\r
1460      */\r
1461     virtual double getAnimVal()\r
1462         {\r
1463         return animVal;\r
1464         }\r
1465 \r
1466 \r
1467 \r
1468     //##################\r
1469     //# Non-API methods\r
1470     //##################\r
1471 \r
1472     /**\r
1473      *\r
1474      */\r
1475     SVGAnimatedNumber()\r
1476         {\r
1477         baseVal = animVal = 0.0;\r
1478         }\r
1479 \r
1480 \r
1481     /**\r
1482      *\r
1483      */\r
1484     SVGAnimatedNumber(double val)\r
1485         {\r
1486         baseVal = val;\r
1487         animVal = 0.0;\r
1488         }\r
1489 \r
1490 \r
1491     /**\r
1492      *\r
1493      */\r
1494     SVGAnimatedNumber(double baseValArg, double animValArg)\r
1495         {\r
1496         baseVal = baseValArg;\r
1497         animVal = animValArg;\r
1498         }\r
1499 \r
1500     /**\r
1501      *\r
1502      */\r
1503     SVGAnimatedNumber(const SVGAnimatedNumber &other)\r
1504         {\r
1505         baseVal = other.baseVal;\r
1506         animVal = other.animVal;\r
1507         }\r
1508 \r
1509     /**\r
1510      *\r
1511      */\r
1512     virtual ~SVGAnimatedNumber() {}\r
1513 \r
1514 protected:\r
1515 \r
1516     double baseVal, animVal;\r
1517 \r
1518 };\r
1519 \r
1520 \r
1521 \r
1522 \r
1523 \r
1524 /*#########################################################################\r
1525 ## SVGNumberList\r
1526 #########################################################################*/\r
1527 \r
1528 /**\r
1529  *\r
1530  */\r
1531 class SVGNumberList\r
1532 {\r
1533 public:\r
1534 \r
1535     /**\r
1536      *\r
1537      */\r
1538     virtual unsigned long getNumberOfItems()\r
1539         {\r
1540         return items.size();\r
1541         }\r
1542 \r
1543 \r
1544     /**\r
1545      *\r
1546      */\r
1547     virtual void clear() throw( DOMException )\r
1548         {\r
1549         items.clear();\r
1550         }\r
1551 \r
1552     /**\r
1553      *\r
1554      */\r
1555     virtual SVGNumber initialize (const SVGNumber &newItem)\r
1556                     throw( DOMException, SVGException )\r
1557         {\r
1558         items.clear();\r
1559         items.push_back(newItem);\r
1560         return newItem;\r
1561         }\r
1562 \r
1563     /**\r
1564      *\r
1565      */\r
1566     virtual SVGNumber getItem ( unsigned long index )\r
1567                                   throw( DOMException )\r
1568         {\r
1569         if (index>=items.size())\r
1570             {\r
1571             SVGNumber num;\r
1572             return num;\r
1573             }\r
1574         return items[index];\r
1575         }\r
1576 \r
1577     /**\r
1578      *\r
1579      */\r
1580     virtual SVGNumber insertItemBefore ( const SVGNumber &newItem,\r
1581                                          unsigned long index )\r
1582                                          throw( DOMException, SVGException )\r
1583         {\r
1584         if (index>=items.size())\r
1585             {\r
1586             items.push_back(newItem);\r
1587             }\r
1588         else\r
1589             {\r
1590             std::vector<SVGNumber>::iterator iter = items.begin() + index;\r
1591             items.insert(iter, newItem);\r
1592             }\r
1593         return newItem;\r
1594         }\r
1595 \r
1596     /**\r
1597      *\r
1598      */\r
1599     virtual SVGNumber replaceItem ( const SVGNumber &newItem,\r
1600                                     unsigned long index )\r
1601                                     throw( DOMException, SVGException )\r
1602         {\r
1603         if (index>=items.size())\r
1604             {\r
1605             SVGNumber num;\r
1606             return num;\r
1607             }\r
1608         std::vector<SVGNumber>::iterator iter = items.begin() + index;\r
1609         *iter = newItem;\r
1610         return newItem;\r
1611         }\r
1612 \r
1613     /**\r
1614      *\r
1615      */\r
1616     virtual SVGNumber removeItem ( unsigned long index )\r
1617                                   throw( DOMException )\r
1618         {\r
1619         if (index>=items.size())\r
1620             {\r
1621             SVGNumber num;\r
1622             return num;\r
1623             }\r
1624         std::vector<SVGNumber>::iterator iter = items.begin() + index;\r
1625         SVGNumber oldval = *iter;\r
1626         items.erase(iter);\r
1627         return oldval;\r
1628         }\r
1629 \r
1630     /**\r
1631      *\r
1632      */\r
1633     virtual SVGNumber appendItem ( const SVGNumber &newItem )\r
1634                                    throw( DOMException, SVGException )\r
1635         {\r
1636         items.push_back(newItem);\r
1637         return newItem;\r
1638         }\r
1639 \r
1640 \r
1641     //##################\r
1642     //# Non-API methods\r
1643     //##################\r
1644 \r
1645     /**\r
1646      *\r
1647      */\r
1648     SVGNumberList() {}\r
1649 \r
1650     /**\r
1651      *\r
1652      */\r
1653     SVGNumberList(const SVGNumberList &other)\r
1654         {\r
1655         items = other.items;\r
1656         }\r
1657 \r
1658     /**\r
1659      *\r
1660      */\r
1661     virtual ~SVGNumberList() {}\r
1662 \r
1663 protected:\r
1664 \r
1665     std::vector<SVGNumber>items;\r
1666 \r
1667 };\r
1668 \r
1669 \r
1670 \r
1671 \r
1672 \r
1673 /*#########################################################################\r
1674 ## SVGAnimatedNumberList\r
1675 #########################################################################*/\r
1676 \r
1677 /**\r
1678  *\r
1679  */\r
1680 class SVGAnimatedNumberList\r
1681 {\r
1682 public:\r
1683 \r
1684 \r
1685     /**\r
1686      *\r
1687      */\r
1688     virtual SVGNumberList &getBaseVal()\r
1689         {\r
1690         return baseVal;\r
1691         }\r
1692 \r
1693     /**\r
1694      *\r
1695      */\r
1696     virtual SVGNumberList &getAnimVal()\r
1697         {\r
1698         return animVal;\r
1699         }\r
1700 \r
1701 \r
1702 \r
1703     //##################\r
1704     //# Non-API methods\r
1705     //##################\r
1706 \r
1707     /**\r
1708      *\r
1709      */\r
1710     SVGAnimatedNumberList() {}\r
1711 \r
1712     /**\r
1713      *\r
1714      */\r
1715     SVGAnimatedNumberList(const SVGAnimatedNumberList &other)\r
1716         {\r
1717         baseVal = other.baseVal;\r
1718         animVal = other.animVal;\r
1719         }\r
1720 \r
1721     /**\r
1722      *\r
1723      */\r
1724     virtual ~SVGAnimatedNumberList() {}\r
1725 \r
1726 protected:\r
1727 \r
1728     SVGNumberList baseVal;\r
1729     SVGNumberList animVal;\r
1730 \r
1731 };\r
1732 \r
1733 \r
1734 \r
1735 \r
1736 \r
1737 \r
1738 /*#########################################################################\r
1739 ## SVGLength\r
1740 #########################################################################*/\r
1741 \r
1742 /**\r
1743  *\r
1744  */\r
1745 class SVGLength\r
1746 {\r
1747 public:\r
1748 \r
1749     /**\r
1750      * Length Unit Types\r
1751      */\r
1752     typedef enum\r
1753         {\r
1754         SVG_LENGTHTYPE_UNKNOWN    = 0,\r
1755         SVG_LENGTHTYPE_NUMBER     = 1,\r
1756         SVG_LENGTHTYPE_PERCENTAGE = 2,\r
1757         SVG_LENGTHTYPE_EMS        = 3,\r
1758         SVG_LENGTHTYPE_EXS        = 4,\r
1759         SVG_LENGTHTYPE_PX         = 5,\r
1760         SVG_LENGTHTYPE_CM         = 6,\r
1761         SVG_LENGTHTYPE_MM         = 7,\r
1762         SVG_LENGTHTYPE_IN         = 8,\r
1763         SVG_LENGTHTYPE_PT         = 9,\r
1764         SVG_LENGTHTYPE_PC         = 10\r
1765         } LengthUnitType;\r
1766 \r
1767 \r
1768     /**\r
1769      *\r
1770      */\r
1771     virtual unsigned short getUnitType( )\r
1772         {\r
1773         return unitType;\r
1774         }\r
1775 \r
1776     /**\r
1777      *\r
1778      */\r
1779     virtual double getValue( )\r
1780         {\r
1781         return value;\r
1782         }\r
1783 \r
1784     /**\r
1785      *\r
1786      */\r
1787     virtual void setValue( double val )  throw (DOMException)\r
1788         {\r
1789         value = val;\r
1790         }\r
1791 \r
1792     /**\r
1793      *\r
1794      */\r
1795     virtual double getValueInSpecifiedUnits( )\r
1796         {\r
1797         double result = 0.0;\r
1798         //fill this in\r
1799         return result;\r
1800         }\r
1801 \r
1802     /**\r
1803      *\r
1804      */\r
1805     virtual void setValueInSpecifiedUnits( double /*val*/ )\r
1806                                            throw (DOMException)\r
1807         {\r
1808         //fill this in\r
1809         }\r
1810 \r
1811     /**\r
1812      *\r
1813      */\r
1814     virtual DOMString getValueAsString( )\r
1815         {\r
1816         DOMString ret;\r
1817         char buf[32];\r
1818         snprintf(buf, 31, "%f", value);\r
1819         ret.append(buf);\r
1820         return ret;\r
1821         }\r
1822 \r
1823     /**\r
1824      *\r
1825      */\r
1826     virtual void setValueAsString( const DOMString& /*val*/ )\r
1827                                    throw (DOMException)\r
1828         {\r
1829         }\r
1830 \r
1831 \r
1832     /**\r
1833      *\r
1834      */\r
1835     virtual void newValueSpecifiedUnits ( unsigned short /*unitType*/, double /*val*/ )\r
1836         {\r
1837         }\r
1838 \r
1839     /**\r
1840      *\r
1841      */\r
1842     virtual void convertToSpecifiedUnits ( unsigned short /*unitType*/ )\r
1843         {\r
1844         }\r
1845 \r
1846 \r
1847 \r
1848     //##################\r
1849     //# Non-API methods\r
1850     //##################\r
1851 \r
1852     /**\r
1853      *\r
1854      */\r
1855     SVGLength()\r
1856         {\r
1857         unitType = SVG_LENGTHTYPE_UNKNOWN;\r
1858         value    = 0.0;\r
1859         }\r
1860 \r
1861 \r
1862     /**\r
1863      *\r
1864      */\r
1865     SVGLength(const SVGLength &other)\r
1866         {\r
1867         unitType  = other.unitType;\r
1868         value     = other.value;\r
1869         }\r
1870 \r
1871     /**\r
1872      *\r
1873      */\r
1874     virtual ~SVGLength() {}\r
1875 \r
1876 protected:\r
1877 \r
1878     int unitType;\r
1879 \r
1880     double value;\r
1881 \r
1882 };\r
1883 \r
1884 \r
1885 \r
1886 \r
1887 \r
1888 \r
1889 /*#########################################################################\r
1890 ## SVGAnimatedLength\r
1891 #########################################################################*/\r
1892 \r
1893 /**\r
1894  *\r
1895  */\r
1896 class SVGAnimatedLength\r
1897 {\r
1898 public:\r
1899 \r
1900     /**\r
1901      *\r
1902      */\r
1903     virtual SVGLength &getBaseVal()\r
1904         {\r
1905         return baseVal;\r
1906         }\r
1907 \r
1908     /**\r
1909      *\r
1910      */\r
1911     virtual SVGLength &getAnimVal()\r
1912         {\r
1913         return animVal;\r
1914         }\r
1915 \r
1916 \r
1917 \r
1918     //##################\r
1919     //# Non-API methods\r
1920     //##################\r
1921 \r
1922     /**\r
1923      *\r
1924      */\r
1925     SVGAnimatedLength() {}\r
1926 \r
1927     /**\r
1928      *\r
1929      */\r
1930     SVGAnimatedLength(const SVGAnimatedLength &other)\r
1931         {\r
1932         baseVal = other.baseVal;\r
1933         animVal = other.animVal;\r
1934         }\r
1935 \r
1936     /**\r
1937      *\r
1938      */\r
1939     virtual ~SVGAnimatedLength() {}\r
1940 \r
1941 protected:\r
1942 \r
1943     SVGLength baseVal, animVal;\r
1944 \r
1945 };\r
1946 \r
1947 \r
1948 \r
1949 \r
1950 \r
1951 \r
1952 /*#########################################################################\r
1953 ## SVGLengthList\r
1954 #########################################################################*/\r
1955 \r
1956 /**\r
1957  *\r
1958  */\r
1959 class SVGLengthList\r
1960 {\r
1961 public:\r
1962 \r
1963     /**\r
1964      *\r
1965      */\r
1966     virtual unsigned long getNumberOfItems()\r
1967         {\r
1968         return items.size();\r
1969         }\r
1970 \r
1971 \r
1972     /**\r
1973      *\r
1974      */\r
1975     virtual void clear (  ) throw( DOMException )\r
1976         {\r
1977         items.clear();\r
1978         }\r
1979 \r
1980     /**\r
1981      *\r
1982      */\r
1983     virtual SVGLength initialize (const SVGLength &newItem )\r
1984                     throw( DOMException, SVGException )\r
1985         {\r
1986         items.clear();\r
1987         items.push_back(newItem);\r
1988         return newItem;\r
1989         }\r
1990 \r
1991     /**\r
1992      *\r
1993      */\r
1994     virtual SVGLength getItem (unsigned long index)\r
1995                     throw( DOMException )\r
1996         {\r
1997         if (index>=items.size())\r
1998             {\r
1999             SVGLength ret;\r
2000             return ret;\r
2001             }\r
2002         return items[index];\r
2003         }\r
2004 \r
2005     /**\r
2006      *\r
2007      */\r
2008     virtual SVGLength insertItemBefore (const SVGLength &newItem,\r
2009                                          unsigned long index )\r
2010                                    throw( DOMException, SVGException )\r
2011         {\r
2012         if (index>=items.size())\r
2013             {\r
2014             items.push_back(newItem);\r
2015             }\r
2016         else\r
2017             {\r
2018             std::vector<SVGLength>::iterator iter = items.begin() + index;\r
2019             items.insert(iter, newItem);\r
2020             }\r
2021         return newItem;\r
2022         }\r
2023 \r
2024     /**\r
2025      *\r
2026      */\r
2027     virtual SVGLength replaceItem (const SVGLength &newItem,\r
2028                                     unsigned long index )\r
2029                                throw( DOMException, SVGException )\r
2030         {\r
2031         if (index>=items.size())\r
2032             {\r
2033             SVGLength ret;\r
2034             return ret;\r
2035             }\r
2036         std::vector<SVGLength>::iterator iter = items.begin() + index;\r
2037         *iter = newItem;\r
2038         return newItem;\r
2039         }\r
2040 \r
2041     /**\r
2042      *\r
2043      */\r
2044     virtual SVGLength removeItem (unsigned long index )\r
2045                     throw( DOMException )\r
2046         {\r
2047         if (index>=items.size())\r
2048             {\r
2049             SVGLength ret;\r
2050             return ret;\r
2051             }\r
2052         std::vector<SVGLength>::iterator iter = items.begin() + index;\r
2053         SVGLength oldval = *iter;\r
2054         items.erase(iter);\r
2055         return oldval;\r
2056         }\r
2057 \r
2058     /**\r
2059      *\r
2060      */\r
2061     virtual SVGLength appendItem (const SVGLength &newItem )\r
2062                     throw( DOMException, SVGException )\r
2063         {\r
2064         items.push_back(newItem);\r
2065         return newItem;\r
2066         }\r
2067 \r
2068 \r
2069     //##################\r
2070     //# Non-API methods\r
2071     //##################\r
2072 \r
2073     /**\r
2074      *\r
2075      */\r
2076     SVGLengthList() {}\r
2077 \r
2078     /**\r
2079      *\r
2080      */\r
2081     SVGLengthList(const SVGLengthList &other)\r
2082         {\r
2083         items = other.items;\r
2084         }\r
2085 \r
2086     /**\r
2087      *\r
2088      */\r
2089     virtual ~SVGLengthList() {}\r
2090 \r
2091 protected:\r
2092 \r
2093     std::vector<SVGLength>items;\r
2094 \r
2095 };\r
2096 \r
2097 \r
2098 \r
2099 \r
2100 \r
2101 \r
2102 /*#########################################################################\r
2103 ## SVGAnimatedLengthList\r
2104 #########################################################################*/\r
2105 \r
2106 /**\r
2107  *\r
2108  */\r
2109 class SVGAnimatedLengthList\r
2110 {\r
2111 public:\r
2112 \r
2113     /**\r
2114      *\r
2115      */\r
2116     virtual SVGLengthList &getBaseVal()\r
2117         {\r
2118         return baseVal;\r
2119         }\r
2120 \r
2121     /**\r
2122      *\r
2123      */\r
2124     virtual SVGLengthList &getAnimVal()\r
2125         {\r
2126         return animVal;\r
2127         }\r
2128 \r
2129 \r
2130 \r
2131     //##################\r
2132     //# Non-API methods\r
2133     //##################\r
2134 \r
2135     /**\r
2136      *\r
2137      */\r
2138     SVGAnimatedLengthList() {}\r
2139 \r
2140     /**\r
2141      *\r
2142      */\r
2143    SVGAnimatedLengthList(const SVGAnimatedLengthList &other)\r
2144         {\r
2145         baseVal = other.baseVal;\r
2146         animVal = other.animVal;\r
2147         }\r
2148 \r
2149     /**\r
2150      *\r
2151      */\r
2152     virtual ~SVGAnimatedLengthList() {}\r
2153 \r
2154 protected:\r
2155 \r
2156     SVGLengthList baseVal, animVal;\r
2157 \r
2158 };\r
2159 \r
2160 \r
2161 \r
2162 \r
2163 \r
2164 \r
2165 /*#########################################################################\r
2166 ## SVGAngle\r
2167 #########################################################################*/\r
2168 \r
2169 /**\r
2170  *\r
2171  */\r
2172 class SVGAngle\r
2173 {\r
2174 public:\r
2175 \r
2176     /**\r
2177      *  Angle Unit Types\r
2178      */\r
2179     typedef enum\r
2180         {\r
2181         SVG_ANGLETYPE_UNKNOWN     = 0,\r
2182         SVG_ANGLETYPE_UNSPECIFIED = 1,\r
2183         SVG_ANGLETYPE_DEG         = 2,\r
2184         SVG_ANGLETYPE_RAD         = 3,\r
2185         SVG_ANGLETYPE_GRAD        = 4\r
2186         } AngleUnitType;\r
2187 \r
2188 \r
2189 \r
2190     /**\r
2191      *\r
2192      */\r
2193     virtual unsigned short getUnitType()\r
2194         {\r
2195         return unitType;\r
2196         }\r
2197 \r
2198     /**\r
2199      *\r
2200      */\r
2201     virtual double getValue()\r
2202         {\r
2203         return value;\r
2204         }\r
2205 \r
2206     /**\r
2207      *\r
2208      */\r
2209     virtual void setValue(double val) throw (DOMException)\r
2210         {\r
2211         value = val;\r
2212         }\r
2213 \r
2214     /**\r
2215      *\r
2216      */\r
2217     virtual double getValueInSpecifiedUnits()\r
2218         {\r
2219         double result = 0.0;\r
2220         //convert here\r
2221         return result;\r
2222         }\r
2223 \r
2224     /**\r
2225      *\r
2226      */\r
2227     virtual void setValueInSpecifiedUnits(double /*val*/)\r
2228                                      throw (DOMException)\r
2229         {\r
2230         //do conversion\r
2231         }\r
2232 \r
2233     /**\r
2234      *\r
2235      */\r
2236     virtual DOMString getValueAsString()\r
2237         {\r
2238         DOMString result;\r
2239         char buf[32];\r
2240         snprintf(buf, 31, "%f", value);\r
2241         result.append(buf);\r
2242         return result;\r
2243         }\r
2244 \r
2245     /**\r
2246      *\r
2247      */\r
2248     virtual void setValueAsString(const DOMString &/*val*/)\r
2249                                   throw (DOMException)\r
2250         {\r
2251         //convert here\r
2252         }\r
2253 \r
2254 \r
2255     /**\r
2256      *\r
2257      */\r
2258     virtual void newValueSpecifiedUnits (unsigned short /*unitType*/,\r
2259                                          double /*valueInSpecifiedUnits*/ )\r
2260         {\r
2261         //convert here\r
2262         }\r
2263 \r
2264     /**\r
2265      *\r
2266      */\r
2267     virtual void convertToSpecifiedUnits (unsigned short /*unitType*/ )\r
2268         {\r
2269         //convert here\r
2270         }\r
2271 \r
2272 \r
2273 \r
2274     //##################\r
2275     //# Non-API methods\r
2276     //##################\r
2277 \r
2278     /**\r
2279      *\r
2280      */\r
2281     SVGAngle()\r
2282         {\r
2283         unitType = SVG_ANGLETYPE_UNKNOWN;\r
2284         value    = 0.0;\r
2285         }\r
2286 \r
2287     /**\r
2288      *\r
2289      */\r
2290     SVGAngle(const SVGAngle &other)\r
2291         {\r
2292         unitType = other.unitType;\r
2293         value    = other.value;\r
2294         }\r
2295 \r
2296     /**\r
2297      *\r
2298      */\r
2299     virtual ~SVGAngle() {}\r
2300 \r
2301 protected:\r
2302 \r
2303     int unitType;\r
2304 \r
2305     double value;\r
2306 \r
2307 };\r
2308 \r
2309 \r
2310 \r
2311 \r
2312 \r
2313 \r
2314 /*#########################################################################\r
2315 ## SVGAnimatedAngle\r
2316 #########################################################################*/\r
2317 \r
2318 /**\r
2319  *\r
2320  */\r
2321 class SVGAnimatedAngle\r
2322 {\r
2323 public:\r
2324 \r
2325     /**\r
2326      *\r
2327      */\r
2328     virtual SVGAngle getBaseVal()\r
2329         {\r
2330         return baseVal;\r
2331         }\r
2332 \r
2333     /**\r
2334      *\r
2335      */\r
2336     virtual SVGAngle getAnimVal()\r
2337         {\r
2338         return animVal;\r
2339         }\r
2340 \r
2341     //##################\r
2342     //# Non-API methods\r
2343     //##################\r
2344 \r
2345     /**\r
2346      *\r
2347      */\r
2348     SVGAnimatedAngle() {}\r
2349 \r
2350     /**\r
2351      *\r
2352      */\r
2353     SVGAnimatedAngle(const SVGAngle &angle)\r
2354         { baseVal = angle; }\r
2355 \r
2356     /**\r
2357      *\r
2358      */\r
2359     SVGAnimatedAngle(const SVGAnimatedAngle &other)\r
2360         {\r
2361         baseVal = other.baseVal;\r
2362         animVal = other.animVal;\r
2363         }\r
2364 \r
2365     /**\r
2366      *\r
2367      */\r
2368     virtual ~SVGAnimatedAngle() {}\r
2369 \r
2370 protected:\r
2371 \r
2372     SVGAngle baseVal, animVal;\r
2373 \r
2374 };\r
2375 \r
2376 \r
2377 \r
2378 \r
2379 \r
2380 \r
2381 /*#########################################################################\r
2382 ## SVGICCColor\r
2383 #########################################################################*/\r
2384 \r
2385 /**\r
2386  *\r
2387  */\r
2388 class SVGICCColor\r
2389 {\r
2390 public:\r
2391 \r
2392     /**\r
2393      *\r
2394      */\r
2395     virtual DOMString getColorProfile()\r
2396         {\r
2397         return colorProfile;\r
2398         }\r
2399 \r
2400     /**\r
2401      *\r
2402      */\r
2403     virtual void setColorProfile(const DOMString &val) throw (DOMException)\r
2404         {\r
2405         colorProfile = val;\r
2406         }\r
2407 \r
2408     /**\r
2409      *\r
2410      */\r
2411     virtual SVGNumberList &getColors()\r
2412         {\r
2413         return colors;\r
2414         }\r
2415 \r
2416 \r
2417 \r
2418     //##################\r
2419     //# Non-API methods\r
2420     //##################\r
2421 \r
2422     /**\r
2423      *\r
2424      */\r
2425     SVGICCColor() {}\r
2426 \r
2427     /**\r
2428      *\r
2429      */\r
2430     SVGICCColor(const SVGICCColor &other)\r
2431         {\r
2432         colorProfile = other.colorProfile;\r
2433         colors       = other.colors;\r
2434         }\r
2435 \r
2436     /**\r
2437      *\r
2438      */\r
2439     virtual ~SVGICCColor() {}\r
2440 \r
2441 protected:\r
2442 \r
2443     DOMString colorProfile;\r
2444 \r
2445     SVGNumberList colors;\r
2446 \r
2447 };\r
2448 \r
2449 \r
2450 /*#########################################################################\r
2451 ## SVGColor\r
2452 #########################################################################*/\r
2453 \r
2454 /**\r
2455  *\r
2456  */\r
2457 class SVGColor : virtual public css::CSSValue\r
2458 {\r
2459 public:\r
2460 \r
2461 \r
2462     /**\r
2463      * Color Types\r
2464      */\r
2465     typedef enum\r
2466         {\r
2467         SVG_COLORTYPE_UNKNOWN           = 0,\r
2468         SVG_COLORTYPE_RGBCOLOR          = 1,\r
2469         SVG_COLORTYPE_RGBCOLOR_ICCCOLOR = 2,\r
2470         SVG_COLORTYPE_CURRENTCOLOR      = 3\r
2471         } ColorType;\r
2472 \r
2473 \r
2474     /**\r
2475      *\r
2476      */\r
2477     virtual unsigned short getColorType()\r
2478         {\r
2479         return colorType;\r
2480         }\r
2481 \r
2482     /**\r
2483      *\r
2484      */\r
2485     virtual css::RGBColor getRgbColor()\r
2486         {\r
2487         css::RGBColor col;\r
2488         return col;\r
2489         }\r
2490 \r
2491     /**\r
2492      *\r
2493      */\r
2494     virtual SVGICCColor getIccColor()\r
2495         {\r
2496         SVGICCColor col;\r
2497         return col;\r
2498         }\r
2499 \r
2500 \r
2501     /**\r
2502      *\r
2503      */\r
2504     virtual void setRGBColor (const DOMString& /*rgbColor*/ )\r
2505                               throw( SVGException )\r
2506         {\r
2507         }\r
2508 \r
2509     /**\r
2510      *\r
2511      */\r
2512     virtual void setRGBColorICCColor (const DOMString& /*rgbColor*/,\r
2513                                       const DOMString& /*iccColor*/ )\r
2514                                       throw( SVGException )\r
2515         {\r
2516         }\r
2517 \r
2518     /**\r
2519      *\r
2520      */\r
2521     virtual void setColor (unsigned short /*colorType*/,\r
2522                            const DOMString& /*rgbColor*/,\r
2523                            const DOMString& /*iccColor*/ )\r
2524                            throw( SVGException )\r
2525         {\r
2526         }\r
2527 \r
2528 \r
2529 \r
2530     //##################\r
2531     //# Non-API methods\r
2532     //##################\r
2533 \r
2534     /**\r
2535      *\r
2536      */\r
2537     SVGColor()\r
2538         {\r
2539         colorType = SVG_COLORTYPE_UNKNOWN;\r
2540         }\r
2541 \r
2542     /**\r
2543      *\r
2544      */\r
2545     SVGColor(const SVGColor &other) : css::CSSValue(other)\r
2546         {\r
2547         colorType = other.colorType;\r
2548         }\r
2549 \r
2550     /**\r
2551      *\r
2552      */\r
2553     virtual ~SVGColor() {}\r
2554 \r
2555 protected:\r
2556 \r
2557     int colorType;\r
2558 \r
2559 };\r
2560 \r
2561 \r
2562 \r
2563 \r
2564 \r
2565 \r
2566 \r
2567 \r
2568 \r
2569 \r
2570 /*#########################################################################\r
2571 ## SVGRect\r
2572 #########################################################################*/\r
2573 \r
2574 /**\r
2575  *\r
2576  */\r
2577 class SVGRect\r
2578 {\r
2579 public:\r
2580 \r
2581     /**\r
2582      *\r
2583      */\r
2584     virtual double getX()\r
2585         {\r
2586         return x;\r
2587         }\r
2588 \r
2589     /**\r
2590      *\r
2591      */\r
2592     virtual void setX(double val) throw (DOMException)\r
2593         {\r
2594         x = val;\r
2595         }\r
2596 \r
2597     /**\r
2598      *\r
2599      */\r
2600     virtual double getY()\r
2601         {\r
2602         return y;\r
2603         }\r
2604 \r
2605     /**\r
2606      *\r
2607      */\r
2608     virtual void setY(double val) throw (DOMException)\r
2609         {\r
2610         y = val;\r
2611         }\r
2612 \r
2613     /**\r
2614      *\r
2615      */\r
2616     virtual double getWidth()\r
2617         {\r
2618         return width;\r
2619         }\r
2620 \r
2621     /**\r
2622      *\r
2623      */\r
2624     virtual void setWidth(double val) throw (DOMException)\r
2625         {\r
2626         width = val;\r
2627         }\r
2628 \r
2629     /**\r
2630      *\r
2631      */\r
2632     virtual double getHeight()\r
2633         {\r
2634         return height;\r
2635         }\r
2636 \r
2637     /**\r
2638      *\r
2639      */\r
2640     virtual void setHeight(double val) throw (DOMException)\r
2641         {\r
2642         height = val;\r
2643         }\r
2644 \r
2645 \r
2646     //##################\r
2647     //# Non-API methods\r
2648     //##################\r
2649 \r
2650     /**\r
2651      *\r
2652      */\r
2653     SVGRect()\r
2654         {\r
2655         x = y = width = height = 0.0;\r
2656         }\r
2657 \r
2658     /**\r
2659      *\r
2660      */\r
2661     SVGRect(const SVGRect &other)\r
2662         {\r
2663         x = other.x;\r
2664         y = other.y;\r
2665         width = other.width;\r
2666         height = other.height;\r
2667         }\r
2668 \r
2669     /**\r
2670      *\r
2671      */\r
2672     virtual ~SVGRect() {}\r
2673 \r
2674 protected:\r
2675 \r
2676     double x, y, width, height;\r
2677 \r
2678 };\r
2679 \r
2680 \r
2681 \r
2682 \r
2683 \r
2684 \r
2685 /*#########################################################################\r
2686 ## SVGAnimatedRect\r
2687 #########################################################################*/\r
2688 \r
2689 /**\r
2690  *\r
2691  */\r
2692 class SVGAnimatedRect\r
2693 {\r
2694 public:\r
2695 \r
2696     /**\r
2697      *\r
2698      */\r
2699     virtual SVGRect &getBaseVal()\r
2700         {\r
2701         return baseVal;\r
2702         }\r
2703 \r
2704     /**\r
2705      *\r
2706      */\r
2707     virtual SVGRect &getAnimVal()\r
2708         {\r
2709         return animVal;\r
2710         }\r
2711 \r
2712 \r
2713 \r
2714     //##################\r
2715     //# Non-API methods\r
2716     //##################\r
2717 \r
2718     /**\r
2719      *\r
2720      */\r
2721     SVGAnimatedRect()\r
2722         {\r
2723         }\r
2724 \r
2725     /**\r
2726      *\r
2727      */\r
2728     SVGAnimatedRect(const SVGAnimatedRect &other)\r
2729         {\r
2730         baseVal = other.baseVal;\r
2731         animVal = other.animVal;\r
2732         }\r
2733 \r
2734     /**\r
2735      *\r
2736      */\r
2737     virtual ~SVGAnimatedRect() {}\r
2738 \r
2739 protected:\r
2740 \r
2741     SVGRect baseVal, animVal;\r
2742 \r
2743 };\r
2744 \r
2745 \r
2746 \r
2747 /*#########################################################################\r
2748 ## SVGPoint\r
2749 #########################################################################*/\r
2750 \r
2751 /**\r
2752  *\r
2753  */\r
2754 class SVGPoint\r
2755 {\r
2756 public:\r
2757 \r
2758 \r
2759 \r
2760     /**\r
2761      *\r
2762      */\r
2763     virtual double getX()\r
2764         { return x; }\r
2765 \r
2766     /**\r
2767      *\r
2768      */\r
2769     virtual void setX(double val) throw (DOMException)\r
2770         { x = val; }\r
2771 \r
2772     /**\r
2773      *\r
2774      */\r
2775     virtual double getY()\r
2776         { return y; }\r
2777 \r
2778     /**\r
2779      *\r
2780      */\r
2781     virtual void setY(double val) throw (DOMException)\r
2782         { y = val; }\r
2783 \r
2784     /**\r
2785      *\r
2786      */\r
2787     virtual SVGPoint matrixTransform(const SVGMatrix &/*matrix*/)\r
2788         {\r
2789         SVGPoint point;\r
2790         return point;\r
2791         }\r
2792 \r
2793 \r
2794 \r
2795     //##################\r
2796     //# Non-API methods\r
2797     //##################\r
2798 \r
2799     /**\r
2800      *\r
2801      */\r
2802     SVGPoint()\r
2803         { x = y = 0; }\r
2804 \r
2805     /**\r
2806      *\r
2807      */\r
2808     SVGPoint(const SVGPoint &other)\r
2809         {\r
2810         x = other.x;\r
2811         y = other.y;\r
2812         }\r
2813 \r
2814     /**\r
2815      *\r
2816      */\r
2817     virtual ~SVGPoint() {}\r
2818 \r
2819 protected:\r
2820 \r
2821     double x, y;\r
2822 };\r
2823 \r
2824 \r
2825 \r
2826 \r
2827 \r
2828 \r
2829 /*#########################################################################\r
2830 ## SVGPointList\r
2831 #########################################################################*/\r
2832 \r
2833 /**\r
2834  *\r
2835  */\r
2836 class SVGPointList\r
2837 {\r
2838 public:\r
2839 \r
2840     /**\r
2841      *\r
2842      */\r
2843     virtual unsigned long getNumberOfItems()\r
2844         { return items.size(); }\r
2845 \r
2846     /**\r
2847      *\r
2848      */\r
2849     virtual void clear() throw( DOMException )\r
2850         { items.clear(); }\r
2851 \r
2852     /**\r
2853      *\r
2854      */\r
2855     virtual SVGPoint initialize(const SVGPoint &newItem)\r
2856                              throw( DOMException, SVGException )\r
2857         {\r
2858         items.clear();\r
2859         items.push_back(newItem);\r
2860         return newItem;\r
2861         }\r
2862 \r
2863     /**\r
2864      *\r
2865      */\r
2866     virtual SVGPoint getItem(unsigned long index )\r
2867                              throw( DOMException )\r
2868         {\r
2869         if (index >= items.size())\r
2870             {\r
2871             SVGPoint point;\r
2872             return point;\r
2873             }\r
2874         return items[index];\r
2875         }\r
2876 \r
2877     /**\r
2878      *\r
2879      */\r
2880     virtual SVGPoint insertItemBefore(const SVGPoint &newItem,\r
2881                                       unsigned long index )\r
2882                                       throw( DOMException, SVGException )\r
2883         {\r
2884         if (index >= items.size())\r
2885             items.push_back(newItem);\r
2886         else\r
2887             {\r
2888             std::vector<SVGPoint>::iterator iter = items.begin() + index;\r
2889             items.insert(iter, newItem);\r
2890             }\r
2891         return newItem;\r
2892         }\r
2893 \r
2894     /**\r
2895      *\r
2896      */\r
2897     virtual SVGPoint replaceItem(const SVGPoint &newItem,\r
2898                                   unsigned long index )\r
2899                                   throw( DOMException, SVGException )\r
2900         {\r
2901         if (index >= items.size())\r
2902             {\r
2903             SVGPoint point;\r
2904             return point;\r
2905             }\r
2906         std::vector<SVGPoint>::iterator iter = items.begin() + index;\r
2907         *iter = newItem;\r
2908         return newItem;\r
2909         }\r
2910 \r
2911     /**\r
2912      *\r
2913      */\r
2914     virtual SVGPoint removeItem(unsigned long index )\r
2915                                   throw( DOMException )\r
2916         {\r
2917         if (index >= items.size())\r
2918             {\r
2919             SVGPoint point;\r
2920             return point;\r
2921             }\r
2922         std::vector<SVGPoint>::iterator iter = items.begin() + index;\r
2923         SVGPoint oldItem = *iter;\r
2924         items.erase(iter);\r
2925         return oldItem;\r
2926         }\r
2927 \r
2928     /**\r
2929      *\r
2930      */\r
2931     virtual SVGPoint appendItem(const SVGPoint &newItem)\r
2932                               throw( DOMException, SVGException )\r
2933         {\r
2934         items.push_back(newItem);\r
2935         return newItem;\r
2936         }\r
2937 \r
2938 \r
2939     //##################\r
2940     //# Non-API methods\r
2941     //##################\r
2942 \r
2943     /**\r
2944      *\r
2945      */\r
2946     SVGPointList() {}\r
2947 \r
2948 \r
2949     /**\r
2950      *\r
2951      */\r
2952     SVGPointList(const SVGPointList &other)\r
2953         {\r
2954         items = other.items;\r
2955         }\r
2956 \r
2957 \r
2958     /**\r
2959      *\r
2960      */\r
2961     virtual ~SVGPointList() {}\r
2962 \r
2963 protected:\r
2964 \r
2965     std::vector<SVGPoint> items;\r
2966 \r
2967 };\r
2968 \r
2969 \r
2970 \r
2971 \r
2972 /*#########################################################################\r
2973 ## SVGUnitTypes\r
2974 #########################################################################*/\r
2975 \r
2976 /**\r
2977  *\r
2978  */\r
2979 class SVGUnitTypes\r
2980 {\r
2981 public:\r
2982 \r
2983     /**\r
2984      * Unit Types\r
2985      */\r
2986     typedef enum\r
2987         {\r
2988         SVG_UNIT_TYPE_UNKNOWN           = 0,\r
2989         SVG_UNIT_TYPE_USERSPACEONUSE    = 1,\r
2990         SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2\r
2991         } UnitType;\r
2992 \r
2993 \r
2994 \r
2995     //##################\r
2996     //# Non-API methods\r
2997     //##################\r
2998 \r
2999     /**\r
3000      *\r
3001      */\r
3002     SVGUnitTypes() {}\r
3003 \r
3004     /**\r
3005      *\r
3006      */\r
3007     virtual ~SVGUnitTypes() {}\r
3008 \r
3009 };\r
3010 \r
3011 \r
3012 \r
3013 \r
3014 \r
3015 \r
3016 /*#########################################################################\r
3017 ## SVGStylable\r
3018 #########################################################################*/\r
3019 \r
3020 /**\r
3021  *\r
3022  */\r
3023 class SVGStylable\r
3024 {\r
3025 public:\r
3026 \r
3027     /**\r
3028      *\r
3029      */\r
3030     virtual SVGAnimatedString getClassName()\r
3031         {\r
3032         return className;\r
3033         }\r
3034 \r
3035     /**\r
3036      *\r
3037      */\r
3038     virtual css::CSSStyleDeclaration getStyle()\r
3039         {\r
3040         return style;\r
3041         }\r
3042 \r
3043 \r
3044     /**\r
3045      *\r
3046      */\r
3047     virtual css::CSSValue getPresentationAttribute (const DOMString& /*name*/ )\r
3048         {\r
3049         css::CSSValue val;\r
3050         //perform a lookup\r
3051         return val;\r
3052         }\r
3053 \r
3054 \r
3055     //##################\r
3056     //# Non-API methods\r
3057     //##################\r
3058 \r
3059     /**\r
3060      *\r
3061      */\r
3062     SVGStylable() {}\r
3063 \r
3064     /**\r
3065      *\r
3066      */\r
3067     SVGStylable(const SVGStylable &other)\r
3068         {\r
3069         className = other.className;\r
3070         style     = other.style;\r
3071         }\r
3072 \r
3073     /**\r
3074      *\r
3075      */\r
3076     virtual ~SVGStylable() {}\r
3077 \r
3078 protected:\r
3079 \r
3080     SVGAnimatedString className;\r
3081     css::CSSStyleDeclaration style;\r
3082 \r
3083 };\r
3084 \r
3085 \r
3086 /*#########################################################################\r
3087 ## SVGLocatable\r
3088 #########################################################################*/\r
3089 \r
3090 /**\r
3091  *\r
3092  */\r
3093 class SVGLocatable\r
3094 {\r
3095 public:\r
3096 \r
3097     /**\r
3098      *\r
3099      */\r
3100     virtual SVGElementPtr getNearestViewportElement()\r
3101         {\r
3102         SVGElementPtr result;\r
3103         return result;\r
3104         }\r
3105 \r
3106     /**\r
3107      *\r
3108      */\r
3109     virtual SVGElementPtr getFarthestViewportElement()\r
3110         {\r
3111         SVGElementPtr result;\r
3112         return result;\r
3113         }\r
3114 \r
3115     /**\r
3116      *\r
3117      */\r
3118     virtual SVGRect getBBox (  )\r
3119         {\r
3120         return bbox;\r
3121         }\r
3122 \r
3123     /**\r
3124      *\r
3125      */\r
3126     virtual SVGMatrix getCTM (  )\r
3127         {\r
3128         return ctm;\r
3129         }\r
3130 \r
3131     /**\r
3132      *\r
3133      */\r
3134     virtual SVGMatrix getScreenCTM (  )\r
3135         {\r
3136         return screenCtm;\r
3137         }\r
3138 \r
3139     /**\r
3140      *\r
3141      */\r
3142     virtual SVGMatrix getTransformToElement (const SVGElement &/*element*/)\r
3143                     throw( SVGException )\r
3144         {\r
3145         SVGMatrix result;\r
3146         //do calculations\r
3147         return result;\r
3148         }\r
3149 \r
3150 \r
3151 \r
3152     //##################\r
3153     //# Non-API methods\r
3154     //##################\r
3155 \r
3156     /**\r
3157      *\r
3158      */\r
3159     SVGLocatable() {}\r
3160 \r
3161     /**\r
3162      *\r
3163      */\r
3164     SVGLocatable(const SVGLocatable &/*other*/)\r
3165         {\r
3166         }\r
3167 \r
3168     /**\r
3169      *\r
3170      */\r
3171     virtual ~SVGLocatable() {}\r
3172 \r
3173 protected:\r
3174 \r
3175     SVGRect bbox;\r
3176     SVGMatrix ctm;\r
3177     SVGMatrix screenCtm;\r
3178 \r
3179 };\r
3180 \r
3181 \r
3182 \r
3183 \r
3184 \r
3185 \r
3186 /*#########################################################################\r
3187 ## SVGTransformable\r
3188 #########################################################################*/\r
3189 \r
3190 /**\r
3191  *\r
3192  */\r
3193 class SVGTransformable : public SVGLocatable\r
3194 {\r
3195 public:\r
3196 \r
3197 \r
3198     /**\r
3199      *\r
3200      */\r
3201     virtual SVGAnimatedTransformList &getTransform()\r
3202         {\r
3203         return transforms;\r
3204         }\r
3205 \r
3206 \r
3207 \r
3208     //##################\r
3209     //# Non-API methods\r
3210     //##################\r
3211 \r
3212     /**\r
3213      *\r
3214      */\r
3215     SVGTransformable() {}\r
3216 \r
3217     /**\r
3218      *\r
3219      */\r
3220     SVGTransformable(const SVGTransformable &other) : SVGLocatable(other)\r
3221         {\r
3222         transforms = other.transforms;\r
3223         }\r
3224 \r
3225     /**\r
3226      *\r
3227      */\r
3228     virtual ~SVGTransformable() {}\r
3229 \r
3230 protected:\r
3231 \r
3232     SVGAnimatedTransformList transforms;\r
3233 };\r
3234 \r
3235 \r
3236 \r
3237 \r
3238 \r
3239 \r
3240 /*#########################################################################\r
3241 ## SVGTests\r
3242 #########################################################################*/\r
3243 \r
3244 /**\r
3245  *\r
3246  */\r
3247 class SVGTests\r
3248 {\r
3249 public:\r
3250 \r
3251 \r
3252     /**\r
3253      *\r
3254      */\r
3255     virtual SVGStringList &getRequiredFeatures()\r
3256         {\r
3257         return requiredFeatures;\r
3258         }\r
3259 \r
3260     /**\r
3261      *\r
3262      */\r
3263     virtual SVGStringList &getRequiredExtensions()\r
3264         {\r
3265         return requiredExtensions;\r
3266         }\r
3267 \r
3268     /**\r
3269      *\r
3270      */\r
3271     virtual SVGStringList &getSystemLanguage()\r
3272         {\r
3273         return systemLanguage;\r
3274         }\r
3275 \r
3276 \r
3277     /**\r
3278      *\r
3279      */\r
3280     virtual bool hasExtension (const DOMString& /*extension*/ )\r
3281         {\r
3282         return false;\r
3283         }\r
3284 \r
3285 \r
3286 \r
3287     //##################\r
3288     //# Non-API methods\r
3289     //##################\r
3290 \r
3291     /**\r
3292      *\r
3293      */\r
3294     SVGTests() {}\r
3295 \r
3296     /**\r
3297      *\r
3298      */\r
3299     SVGTests(const SVGTests &other)\r
3300         {\r
3301         requiredFeatures   = other.requiredFeatures;\r
3302         requiredExtensions = other.requiredExtensions;\r
3303         systemLanguage     = other.systemLanguage;\r
3304         }\r
3305 \r
3306     /**\r
3307      *\r
3308      */\r
3309     virtual ~SVGTests() {}\r
3310 \r
3311 protected:\r
3312 \r
3313     SVGStringList requiredFeatures;\r
3314     SVGStringList requiredExtensions;\r
3315     SVGStringList systemLanguage;\r
3316 \r
3317 };\r
3318 \r
3319 \r
3320 \r
3321 \r
3322 \r
3323 \r
3324 /*#########################################################################\r
3325 ## SVGLangSpace\r
3326 #########################################################################*/\r
3327 \r
3328 /**\r
3329  *\r
3330  */\r
3331 class SVGLangSpace\r
3332 {\r
3333 public:\r
3334 \r
3335 \r
3336     /**\r
3337      *\r
3338      */\r
3339     virtual DOMString getXmllang()\r
3340         {\r
3341         return xmlLang;\r
3342         }\r
3343 \r
3344     /**\r
3345      *\r
3346      */\r
3347     virtual void setXmllang(const DOMString &val)\r
3348                                      throw (DOMException)\r
3349         {\r
3350         xmlLang = val;\r
3351         }\r
3352 \r
3353     /**\r
3354      *\r
3355      */\r
3356     virtual DOMString getXmlspace()\r
3357         {\r
3358         return xmlSpace;\r
3359         }\r
3360 \r
3361     /**\r
3362      *\r
3363      */\r
3364     virtual void setXmlspace(const DOMString &val)\r
3365                                      throw (DOMException)\r
3366         {\r
3367         xmlSpace = val;\r
3368         }\r
3369 \r
3370 \r
3371 \r
3372     //##################\r
3373     //# Non-API methods\r
3374     //##################\r
3375 \r
3376     /**\r
3377      *\r
3378      */\r
3379     SVGLangSpace() {}\r
3380 \r
3381     /**\r
3382      *\r
3383      */\r
3384     SVGLangSpace(const SVGLangSpace &other)\r
3385         {\r
3386         xmlLang  = other.xmlLang;\r
3387         xmlSpace = other.xmlSpace;\r
3388         }\r
3389 \r
3390     /**\r
3391      *\r
3392      */\r
3393     virtual ~SVGLangSpace() {}\r
3394 \r
3395 protected:\r
3396 \r
3397     DOMString xmlLang;\r
3398     DOMString xmlSpace;\r
3399 \r
3400 };\r
3401 \r
3402 \r
3403 \r
3404 \r
3405 \r
3406 \r
3407 /*#########################################################################\r
3408 ## SVGExternalResourcesRequired\r
3409 #########################################################################*/\r
3410 \r
3411 /**\r
3412  *\r
3413  */\r
3414 class SVGExternalResourcesRequired\r
3415 {\r
3416 public:\r
3417 \r
3418 \r
3419     /**\r
3420      *\r
3421      */\r
3422     virtual SVGAnimatedBoolean getExternalResourcesRequired()\r
3423         { return required; }\r
3424 \r
3425 \r
3426 \r
3427     //##################\r
3428     //# Non-API methods\r
3429     //##################\r
3430 \r
3431     /**\r
3432      *\r
3433      */\r
3434     SVGExternalResourcesRequired()\r
3435         {  }\r
3436 \r
3437 \r
3438     /**\r
3439      *\r
3440      */\r
3441     SVGExternalResourcesRequired(const SVGExternalResourcesRequired &other)\r
3442         {\r
3443         required = other.required;\r
3444         }\r
3445 \r
3446     /**\r
3447      *\r
3448      */\r
3449     virtual ~SVGExternalResourcesRequired() {}\r
3450 \r
3451 protected:\r
3452 \r
3453     SVGAnimatedBoolean required;\r
3454 \r
3455 };\r
3456 \r
3457 \r
3458 \r
3459 \r
3460 \r
3461 \r
3462 /*#########################################################################\r
3463 ## SVGPreserveAspectRatio\r
3464 #########################################################################*/\r
3465 \r
3466 /**\r
3467  *\r
3468  */\r
3469 class SVGPreserveAspectRatio\r
3470 {\r
3471 public:\r
3472 \r
3473 \r
3474     /**\r
3475      * Alignment Types\r
3476      */\r
3477     typedef enum\r
3478         {\r
3479         SVG_PRESERVEASPECTRATIO_UNKNOWN  = 0,\r
3480         SVG_PRESERVEASPECTRATIO_NONE     = 1,\r
3481         SVG_PRESERVEASPECTRATIO_XMINYMIN = 2,\r
3482         SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3,\r
3483         SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4,\r
3484         SVG_PRESERVEASPECTRATIO_XMINYMID = 5,\r
3485         SVG_PRESERVEASPECTRATIO_XMIDYMID = 6,\r
3486         SVG_PRESERVEASPECTRATIO_XMAXYMID = 7,\r
3487         SVG_PRESERVEASPECTRATIO_XMINYMAX = 8,\r
3488         SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9,\r
3489         SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10\r
3490         } AlignmentType;\r
3491 \r
3492 \r
3493     /**\r
3494      * Meet-or-slice Types\r
3495      */\r
3496     typedef enum\r
3497         {\r
3498         SVG_MEETORSLICE_UNKNOWN  = 0,\r
3499         SVG_MEETORSLICE_MEET     = 1,\r
3500         SVG_MEETORSLICE_SLICE    = 2\r
3501         } MeetOrSliceType;\r
3502 \r
3503 \r
3504     /**\r
3505      *\r
3506      */\r
3507     virtual unsigned short getAlign()\r
3508         { return align; }\r
3509 \r
3510     /**\r
3511      *\r
3512      */\r
3513     virtual void setAlign(unsigned short val) throw (DOMException)\r
3514         { align = val; }\r
3515 \r
3516     /**\r
3517      *\r
3518      */\r
3519     virtual unsigned short getMeetOrSlice()\r
3520         { return meetOrSlice; }\r
3521 \r
3522     /**\r
3523      *\r
3524      */\r
3525     virtual void setMeetOrSlice(unsigned short val) throw (DOMException)\r
3526         { meetOrSlice = val; }\r
3527 \r
3528 \r
3529 \r
3530     //##################\r
3531     //# Non-API methods\r
3532     //##################\r
3533 \r
3534     /**\r
3535      *\r
3536      */\r
3537     SVGPreserveAspectRatio()\r
3538         {\r
3539         align       = SVG_PRESERVEASPECTRATIO_UNKNOWN;\r
3540         meetOrSlice = SVG_MEETORSLICE_UNKNOWN;\r
3541         }\r
3542 \r
3543     /**\r
3544      *\r
3545      */\r
3546     SVGPreserveAspectRatio(const SVGPreserveAspectRatio &other)\r
3547         {\r
3548         align       = other.align;\r
3549         meetOrSlice = other.meetOrSlice;\r
3550         }\r
3551 \r
3552     /**\r
3553      *\r
3554      */\r
3555     virtual ~SVGPreserveAspectRatio() {}\r
3556 \r
3557 protected:\r
3558 \r
3559     unsigned short align;\r
3560     unsigned short meetOrSlice;\r
3561 \r
3562 };\r
3563 \r
3564 \r
3565 \r
3566 \r
3567 \r
3568 \r
3569 /*#########################################################################\r
3570 ## SVGAnimatedPreserveAspectRatio\r
3571 #########################################################################*/\r
3572 \r
3573 /**\r
3574  *\r
3575  */\r
3576 class SVGAnimatedPreserveAspectRatio\r
3577 {\r
3578 public:\r
3579 \r
3580 \r
3581     /**\r
3582      *\r
3583      */\r
3584     virtual SVGPreserveAspectRatio getBaseVal()\r
3585         { return baseVal; }\r
3586 \r
3587     /**\r
3588      *\r
3589      */\r
3590     virtual SVGPreserveAspectRatio getAnimVal()\r
3591         { return animVal; }\r
3592 \r
3593 \r
3594 \r
3595     //##################\r
3596     //# Non-API methods\r
3597     //##################\r
3598 \r
3599     /**\r
3600      *\r
3601      */\r
3602     SVGAnimatedPreserveAspectRatio() {}\r
3603 \r
3604     /**\r
3605      *\r
3606      */\r
3607     SVGAnimatedPreserveAspectRatio(const SVGAnimatedPreserveAspectRatio &other)\r
3608         {\r
3609         baseVal = other.baseVal;\r
3610         baseVal = other.animVal;\r
3611         }\r
3612 \r
3613     /**\r
3614      *\r
3615      */\r
3616     virtual ~SVGAnimatedPreserveAspectRatio() {}\r
3617 \r
3618 protected:\r
3619 \r
3620     SVGPreserveAspectRatio baseVal;\r
3621     SVGPreserveAspectRatio animVal;\r
3622 \r
3623 };\r
3624 \r
3625 \r
3626 \r
3627 \r
3628 /*#########################################################################\r
3629 ## SVGFitToViewBox\r
3630 #########################################################################*/\r
3631 \r
3632 /**\r
3633  *\r
3634  */\r
3635 class SVGFitToViewBox\r
3636 {\r
3637 public:\r
3638 \r
3639     /**\r
3640      *\r
3641      */\r
3642     virtual SVGAnimatedRect getViewBox()\r
3643         { return viewBox; }\r
3644 \r
3645     /**\r
3646      *\r
3647      */\r
3648     virtual SVGAnimatedPreserveAspectRatio getPreserveAspectRatio()\r
3649         { return preserveAspectRatio; }\r
3650 \r
3651 \r
3652 \r
3653     //##################\r
3654     //# Non-API methods\r
3655     //##################\r
3656 \r
3657     /**\r
3658      *\r
3659      */\r
3660     SVGFitToViewBox()\r
3661         {}\r
3662 \r
3663     /**\r
3664      *\r
3665      */\r
3666 \r
3667     SVGFitToViewBox(const SVGFitToViewBox &other)\r
3668         {\r
3669         viewBox = other.viewBox;\r
3670         preserveAspectRatio = other.preserveAspectRatio;\r
3671         }\r
3672 \r
3673     /**\r
3674      *\r
3675      */\r
3676     virtual ~SVGFitToViewBox() {}\r
3677 \r
3678 protected:\r
3679 \r
3680     SVGAnimatedRect viewBox;\r
3681 \r
3682     SVGAnimatedPreserveAspectRatio preserveAspectRatio;\r
3683 \r
3684 };\r
3685 \r
3686 \r
3687 /*#########################################################################\r
3688 ## SVGZoomAndPan\r
3689 #########################################################################*/\r
3690 \r
3691 /**\r
3692  *\r
3693  */\r
3694 class SVGZoomAndPan\r
3695 {\r
3696 public:\r
3697 \r
3698 \r
3699     /**\r
3700      * Zoom and Pan Types\r
3701      */\r
3702     typedef enum\r
3703         {\r
3704         SVG_ZOOMANDPAN_UNKNOWN = 0,\r
3705         SVG_ZOOMANDPAN_DISABLE = 1,\r
3706         SVG_ZOOMANDPAN_MAGNIFY = 2\r
3707         } ZoomAndPanType;\r
3708 \r
3709 \r
3710     /**\r
3711      *\r
3712      */\r
3713     virtual unsigned short getZoomAndPan()\r
3714         { return zoomAndPan; }\r
3715 \r
3716     /**\r
3717      *\r
3718      */\r
3719     virtual void setZoomAndPan(unsigned short val) throw (DOMException)\r
3720         { zoomAndPan = val; }\r
3721 \r
3722 \r
3723     //##################\r
3724     //# Non-API methods\r
3725     //##################\r
3726 \r
3727     /**\r
3728      *\r
3729      */\r
3730     SVGZoomAndPan()\r
3731         { zoomAndPan = SVG_ZOOMANDPAN_UNKNOWN; }\r
3732 \r
3733     /**\r
3734      *\r
3735      */\r
3736     SVGZoomAndPan(const SVGZoomAndPan &other)\r
3737         { zoomAndPan = other.zoomAndPan; }\r
3738 \r
3739     /**\r
3740      *\r
3741      */\r
3742     virtual ~SVGZoomAndPan() {}\r
3743 \r
3744 protected:\r
3745 \r
3746     unsigned short zoomAndPan;\r
3747 \r
3748 };\r
3749 \r
3750 \r
3751 \r
3752 \r
3753 \r
3754 \r
3755 /*#########################################################################\r
3756 ## SVGViewSpec\r
3757 #########################################################################*/\r
3758 \r
3759 /**\r
3760  *\r
3761  */\r
3762 class SVGViewSpec : public SVGZoomAndPan,\r
3763                     public SVGFitToViewBox\r
3764 {\r
3765 public:\r
3766 \r
3767     /**\r
3768      *\r
3769      */\r
3770     virtual SVGTransformList getTransform()\r
3771         { return transform; }\r
3772 \r
3773     /**\r
3774      *\r
3775      */\r
3776     virtual SVGElementPtr getViewTarget()\r
3777         { return viewTarget; }\r
3778 \r
3779     /**\r
3780      *\r
3781      */\r
3782     virtual DOMString getViewBoxString()\r
3783         {\r
3784         DOMString ret;\r
3785         return ret;\r
3786         }\r
3787 \r
3788     /**\r
3789      *\r
3790      */\r
3791     virtual DOMString getPreserveAspectRatioString()\r
3792         {\r
3793         DOMString ret;\r
3794         return ret;\r
3795         }\r
3796 \r
3797     /**\r
3798      *\r
3799      */\r
3800     virtual DOMString getTransformString()\r
3801         {\r
3802         DOMString ret;\r
3803         return ret;\r
3804         }\r
3805 \r
3806     /**\r
3807      *\r
3808      */\r
3809     virtual DOMString getViewTargetString()\r
3810         {\r
3811         DOMString ret;\r
3812         return ret;\r
3813         }\r
3814 \r
3815 \r
3816 \r
3817     //##################\r
3818     //# Non-API methods\r
3819     //##################\r
3820 \r
3821     /**\r
3822      *\r
3823      */\r
3824     SVGViewSpec()\r
3825         {\r
3826         viewTarget = NULL;\r
3827         }\r
3828 \r
3829     /**\r
3830      *\r
3831      */\r
3832     SVGViewSpec(const SVGViewSpec &other) : SVGZoomAndPan(other), SVGFitToViewBox(other)\r
3833         {\r
3834         viewTarget = other.viewTarget;\r
3835         transform  = other.transform;\r
3836         }\r
3837 \r
3838     /**\r
3839      *\r
3840      */\r
3841     virtual ~SVGViewSpec() {}\r
3842 \r
3843 protected:\r
3844 \r
3845     SVGElementPtr viewTarget;\r
3846     SVGTransformList transform;\r
3847 };\r
3848 \r
3849 \r
3850 \r
3851 \r
3852 \r
3853 \r
3854 /*#########################################################################\r
3855 ## SVGURIReference\r
3856 #########################################################################*/\r
3857 \r
3858 /**\r
3859  *\r
3860  */\r
3861 class SVGURIReference\r
3862 {\r
3863 public:\r
3864 \r
3865     /**\r
3866      *\r
3867      */\r
3868     virtual SVGAnimatedString getHref()\r
3869         { return href; }\r
3870 \r
3871 \r
3872 \r
3873     //##################\r
3874     //# Non-API methods\r
3875     //##################\r
3876 \r
3877     /**\r
3878      *\r
3879      */\r
3880     SVGURIReference() {}\r
3881 \r
3882     /**\r
3883      *\r
3884      */\r
3885     SVGURIReference(const SVGURIReference &other)\r
3886         {\r
3887         href = other.href;\r
3888         }\r
3889 \r
3890     /**\r
3891      *\r
3892      */\r
3893     virtual ~SVGURIReference() {}\r
3894 \r
3895 protected:\r
3896 \r
3897     SVGAnimatedString href;\r
3898 \r
3899 };\r
3900 \r
3901 \r
3902 \r
3903 \r
3904 \r
3905 \r
3906 /*#########################################################################\r
3907 ## SVGCSSRule\r
3908 #########################################################################*/\r
3909 \r
3910 /**\r
3911  *\r
3912  */\r
3913 class SVGCSSRule : public css::CSSRule\r
3914 {\r
3915 public:\r
3916 \r
3917 \r
3918     /**\r
3919      * Additional CSS RuleType to support ICC color specifications\r
3920      */\r
3921     typedef enum\r
3922         {\r
3923         COLOR_PROFILE_RULE = 7\r
3924         } ColorProfileRuleType;\r
3925 \r
3926     //##################\r
3927     //# Non-API methods\r
3928     //##################\r
3929 \r
3930     /**\r
3931      *\r
3932      */\r
3933     SVGCSSRule()\r
3934         { type = COLOR_PROFILE_RULE; }\r
3935 \r
3936     /**\r
3937      *\r
3938      */\r
3939     SVGCSSRule(const SVGCSSRule &other) : css::CSSRule(other)\r
3940         { type = COLOR_PROFILE_RULE; }\r
3941 \r
3942     /**\r
3943      *\r
3944      */\r
3945     virtual ~SVGCSSRule() {}\r
3946 \r
3947 };\r
3948 \r
3949 \r
3950 \r
3951 /*#########################################################################\r
3952 ## SVGRenderingIntent\r
3953 #########################################################################*/\r
3954 \r
3955 /**\r
3956  *\r
3957  */\r
3958 class SVGRenderingIntent\r
3959 {\r
3960 public:\r
3961 \r
3962     /**\r
3963      * Rendering Intent Types\r
3964      */\r
3965     typedef enum\r
3966         {\r
3967         RENDERING_INTENT_UNKNOWN               = 0,\r
3968         RENDERING_INTENT_AUTO                  = 1,\r
3969         RENDERING_INTENT_PERCEPTUAL            = 2,\r
3970         RENDERING_INTENT_RELATIVE_COLORIMETRIC = 3,\r
3971         RENDERING_INTENT_SATURATION            = 4,\r
3972         RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = 5\r
3973         } RenderingIntentType;\r
3974 \r
3975 \r
3976 \r
3977     //##################\r
3978     //# Non-API methods\r
3979     //##################\r
3980 \r
3981     /**\r
3982      *\r
3983      */\r
3984     SVGRenderingIntent()\r
3985         {\r
3986         renderingIntentType = RENDERING_INTENT_UNKNOWN;\r
3987         }\r
3988 \r
3989     /**\r
3990      *\r
3991      */\r
3992     SVGRenderingIntent(const SVGRenderingIntent &other)\r
3993         {\r
3994         renderingIntentType = other.renderingIntentType;\r
3995         }\r
3996 \r
3997     /**\r
3998      *\r
3999      */\r
4000     virtual ~SVGRenderingIntent() {}\r
4001 \r
4002 protected:\r
4003 \r
4004     unsigned short renderingIntentType;\r
4005 };\r
4006 \r
4007 \r
4008 \r
4009 \r
4010 \r
4011 \r
4012 \r
4013 /*#########################################################################\r
4014 ###########################################################################\r
4015 ## P A T H    S E G M E N T S\r
4016 ###########################################################################\r
4017 #########################################################################*/\r
4018 \r
4019 static char const *const pathSegLetters[] =\r
4020 {\r
4021     "@", // PATHSEG_UNKNOWN,\r
4022     "z", // PATHSEG_CLOSEPATH\r
4023     "M", // PATHSEG_MOVETO_ABS\r
4024     "m", // PATHSEG_MOVETO_REL,\r
4025     "L", // PATHSEG_LINETO_ABS\r
4026     "l", // PATHSEG_LINETO_REL\r
4027     "C", // PATHSEG_CURVETO_CUBIC_ABS\r
4028     "c", // PATHSEG_CURVETO_CUBIC_REL\r
4029     "Q", // PATHSEG_CURVETO_QUADRATIC_ABS,\r
4030     "q", // PATHSEG_CURVETO_QUADRATIC_REL\r
4031     "A", // PATHSEG_ARC_ABS\r
4032     "a", // PATHSEG_ARC_REL,\r
4033     "H", // PATHSEG_LINETO_HORIZONTAL_ABS,\r
4034     "h", // PATHSEG_LINETO_HORIZONTAL_REL\r
4035     "V", // PATHSEG_LINETO_VERTICAL_ABS\r
4036     "v", // PATHSEG_LINETO_VERTICAL_REL\r
4037     "S", // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS\r
4038     "s", // PATHSEG_CURVETO_CUBIC_SMOOTH_REL\r
4039     "T", // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS\r
4040     "t"  // PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL\r
4041 };\r
4042 \r
4043 /*#########################################################################\r
4044 ## SVGPathSeg\r
4045 #########################################################################*/\r
4046 \r
4047 /**\r
4048  *\r
4049  */\r
4050 class SVGPathSeg\r
4051 {\r
4052 public:\r
4053 \r
4054 \r
4055 \r
4056     /**\r
4057      *  Path Segment Types\r
4058      */\r
4059     typedef enum\r
4060         {\r
4061         PATHSEG_UNKNOWN                      = 0,\r
4062         PATHSEG_CLOSEPATH                    = 1,\r
4063         PATHSEG_MOVETO_ABS                   = 2,\r
4064         PATHSEG_MOVETO_REL                   = 3,\r
4065         PATHSEG_LINETO_ABS                   = 4,\r
4066         PATHSEG_LINETO_REL                   = 5,\r
4067         PATHSEG_CURVETO_CUBIC_ABS            = 6,\r
4068         PATHSEG_CURVETO_CUBIC_REL            = 7,\r
4069         PATHSEG_CURVETO_QUADRATIC_ABS        = 8,\r
4070         PATHSEG_CURVETO_QUADRATIC_REL        = 9,\r
4071         PATHSEG_ARC_ABS                      = 10,\r
4072         PATHSEG_ARC_REL                      = 11,\r
4073         PATHSEG_LINETO_HORIZONTAL_ABS        = 12,\r
4074         PATHSEG_LINETO_HORIZONTAL_REL        = 13,\r
4075         PATHSEG_LINETO_VERTICAL_ABS          = 14,\r
4076         PATHSEG_LINETO_VERTICAL_REL          = 15,\r
4077         PATHSEG_CURVETO_CUBIC_SMOOTH_ABS     = 16,\r
4078         PATHSEG_CURVETO_CUBIC_SMOOTH_REL     = 17,\r
4079         PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18,\r
4080         PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19\r
4081         } PathSegmentType;\r
4082 \r
4083     /**\r
4084      *\r
4085      */\r
4086     virtual unsigned short getPathSegType()\r
4087         { return type; }\r
4088 \r
4089     /**\r
4090      *\r
4091      */\r
4092     virtual DOMString getPathSegTypeAsLetter()\r
4093         {\r
4094         int typ = type;\r
4095         if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL)\r
4096             typ = PATHSEG_UNKNOWN;\r
4097         char const *ch = pathSegLetters[typ];\r
4098         DOMString letter = ch;\r
4099         return letter;\r
4100         }\r
4101 \r
4102 \r
4103 \r
4104     //##################\r
4105     //# Non-API methods\r
4106     //##################\r
4107 \r
4108     /**\r
4109      *\r
4110      */\r
4111     SVGPathSeg()\r
4112         { type = PATHSEG_UNKNOWN; }\r
4113 \r
4114     /**\r
4115      *\r
4116      */\r
4117     SVGPathSeg(const SVGPathSeg &other)\r
4118         {\r
4119         type = other.type;\r
4120         }\r
4121 \r
4122     /**\r
4123      *\r
4124      */\r
4125     virtual ~SVGPathSeg() {}\r
4126 \r
4127 protected:\r
4128 \r
4129     int type;\r
4130 \r
4131 };\r
4132 \r
4133 \r
4134 \r
4135 \r
4136 \r
4137 \r
4138 /*#########################################################################\r
4139 ## SVGPathSegClosePath\r
4140 #########################################################################*/\r
4141 \r
4142 /**\r
4143  *\r
4144  */\r
4145 class SVGPathSegClosePath : public SVGPathSeg\r
4146 {\r
4147 public:\r
4148 \r
4149     //##################\r
4150     //# Non-API methods\r
4151     //##################\r
4152 \r
4153     /**\r
4154      *\r
4155      */\r
4156     SVGPathSegClosePath()\r
4157         {\r
4158         type = PATHSEG_CLOSEPATH;\r
4159         }\r
4160 \r
4161     /**\r
4162      *\r
4163      */\r
4164     SVGPathSegClosePath(const SVGPathSegClosePath &other) : SVGPathSeg(other)\r
4165         {\r
4166         type = PATHSEG_CLOSEPATH;\r
4167         }\r
4168 \r
4169     /**\r
4170      *\r
4171      */\r
4172     virtual ~SVGPathSegClosePath() {}\r
4173 \r
4174 };\r
4175 \r
4176 \r
4177 \r
4178 \r
4179 /*#########################################################################\r
4180 ## SVGPathSegMovetoAbs\r
4181 #########################################################################*/\r
4182 \r
4183 /**\r
4184  *\r
4185  */\r
4186 class SVGPathSegMovetoAbs : public SVGPathSeg\r
4187 {\r
4188 public:\r
4189 \r
4190     /**\r
4191      *\r
4192      */\r
4193     virtual double getX()\r
4194         { return x; }\r
4195 \r
4196     /**\r
4197      *\r
4198      */\r
4199     virtual void setX(double val) throw (DOMException)\r
4200         { x = val; }\r
4201 \r
4202     /**\r
4203      *\r
4204      */\r
4205     virtual double getY()\r
4206         { return y; }\r
4207 \r
4208     /**\r
4209      *\r
4210      */\r
4211     virtual void setY(double val) throw (DOMException)\r
4212         { y = val; }\r
4213 \r
4214     //##################\r
4215     //# Non-API methods\r
4216     //##################\r
4217 \r
4218     /**\r
4219      *\r
4220      */\r
4221     SVGPathSegMovetoAbs()\r
4222         {\r
4223         type = PATHSEG_MOVETO_ABS;\r
4224         x = y = 0.0;\r
4225         }\r
4226 \r
4227     /**\r
4228      *\r
4229      */\r
4230     SVGPathSegMovetoAbs(double xArg, double yArg)\r
4231         {\r
4232         type = PATHSEG_MOVETO_ABS;\r
4233         x = xArg; y = yArg;\r
4234         }\r
4235 \r
4236     /**\r
4237      *\r
4238      */\r
4239     SVGPathSegMovetoAbs(const SVGPathSegMovetoAbs &other) : SVGPathSeg(other)\r
4240         {\r
4241         type = PATHSEG_MOVETO_ABS;\r
4242         x = other.x; y = other.y;\r
4243         }\r
4244 \r
4245     /**\r
4246      *\r
4247      */\r
4248     virtual ~SVGPathSegMovetoAbs() {}\r
4249 \r
4250 protected:\r
4251 \r
4252     double x,y;\r
4253 \r
4254 };\r
4255 \r
4256 \r
4257 \r
4258 \r
4259 \r
4260 \r
4261 /*#########################################################################\r
4262 ## SVGPathSegMovetoRel\r
4263 #########################################################################*/\r
4264 \r
4265 /**\r
4266  *\r
4267  */\r
4268 class SVGPathSegMovetoRel : public SVGPathSeg\r
4269 {\r
4270 public:\r
4271 \r
4272     /**\r
4273      *\r
4274      */\r
4275     virtual double getX()\r
4276         { return x; }\r
4277 \r
4278     /**\r
4279      *\r
4280      */\r
4281     virtual void setX(double val) throw (DOMException)\r
4282         { x = val; }\r
4283 \r
4284     /**\r
4285      *\r
4286      */\r
4287     virtual double getY()\r
4288         { return y; }\r
4289 \r
4290     /**\r
4291      *\r
4292      */\r
4293     virtual void setY(double val) throw (DOMException)\r
4294         { y = val; }\r
4295 \r
4296     //##################\r
4297     //# Non-API methods\r
4298     //##################\r
4299 \r
4300     /**\r
4301      *\r
4302      */\r
4303     SVGPathSegMovetoRel()\r
4304         {\r
4305         type = PATHSEG_MOVETO_REL;\r
4306         x = y = 0.0;\r
4307         }\r
4308 \r
4309 \r
4310     /**\r
4311      *\r
4312      */\r
4313     SVGPathSegMovetoRel(double xArg, double yArg)\r
4314         {\r
4315         type = PATHSEG_MOVETO_REL;\r
4316         x = xArg; y = yArg;\r
4317         }\r
4318 \r
4319     /**\r
4320      *\r
4321      */\r
4322     SVGPathSegMovetoRel(const SVGPathSegMovetoRel &other) : SVGPathSeg(other)\r
4323         {\r
4324         type = PATHSEG_MOVETO_REL;\r
4325         x = other.x; y = other.y;\r
4326         }\r
4327 \r
4328     /**\r
4329      *\r
4330      */\r
4331     virtual ~SVGPathSegMovetoRel() {}\r
4332 \r
4333 protected:\r
4334 \r
4335     double x,y;\r
4336 };\r
4337 \r
4338 \r
4339 \r
4340 \r
4341 \r
4342 \r
4343 /*#########################################################################\r
4344 ## SVGPathSegLinetoAbs\r
4345 #########################################################################*/\r
4346 \r
4347 /**\r
4348  *\r
4349  */\r
4350 class SVGPathSegLinetoAbs : public SVGPathSeg\r
4351 {\r
4352 public:\r
4353 \r
4354     /**\r
4355      *\r
4356      */\r
4357     virtual double getX()\r
4358         { return x; }\r
4359 \r
4360     /**\r
4361      *\r
4362      */\r
4363     virtual void setX(double val) throw (DOMException)\r
4364         { x = val; }\r
4365 \r
4366     /**\r
4367      *\r
4368      */\r
4369     virtual double getY()\r
4370         { return y; }\r
4371 \r
4372     /**\r
4373      *\r
4374      */\r
4375     virtual void setY(double val) throw (DOMException)\r
4376         { y = val; }\r
4377 \r
4378     //##################\r
4379     //# Non-API methods\r
4380     //##################\r
4381 \r
4382     /**\r
4383      *\r
4384      */\r
4385     SVGPathSegLinetoAbs()\r
4386         {\r
4387         type = PATHSEG_LINETO_ABS;\r
4388         x = y = 0.0;\r
4389         }\r
4390 \r
4391 \r
4392     /**\r
4393      *\r
4394      */\r
4395     SVGPathSegLinetoAbs(double xArg, double yArg)\r
4396         {\r
4397         type = PATHSEG_LINETO_ABS;\r
4398         x = xArg; y = yArg;\r
4399         }\r
4400 \r
4401     /**\r
4402      *\r
4403      */\r
4404     SVGPathSegLinetoAbs(const SVGPathSegLinetoAbs &other) : SVGPathSeg(other)\r
4405         {\r
4406         type = PATHSEG_LINETO_ABS;\r
4407         x = other.x; y = other.y;\r
4408         }\r
4409 \r
4410     /**\r
4411      *\r
4412      */\r
4413     virtual ~SVGPathSegLinetoAbs() {}\r
4414 \r
4415 protected:\r
4416 \r
4417     double x,y;\r
4418 };\r
4419 \r
4420 \r
4421 \r
4422 \r
4423 \r
4424 \r
4425 /*#########################################################################\r
4426 ## SVGPathSegLinetoRel\r
4427 #########################################################################*/\r
4428 \r
4429 /**\r
4430  *\r
4431  */\r
4432 class SVGPathSegLinetoRel : public SVGPathSeg\r
4433 {\r
4434 public:\r
4435 \r
4436     /**\r
4437      *\r
4438      */\r
4439     virtual double getX()\r
4440         { return x; }\r
4441 \r
4442     /**\r
4443      *\r
4444      */\r
4445     virtual void setX(double val) throw (DOMException)\r
4446         { x = val; }\r
4447 \r
4448     /**\r
4449      *\r
4450      */\r
4451     virtual double getY()\r
4452         { return y; }\r
4453 \r
4454     /**\r
4455      *\r
4456      */\r
4457     virtual void setY(double val) throw (DOMException)\r
4458         { y = val; }\r
4459 \r
4460     //##################\r
4461     //# Non-API methods\r
4462     //##################\r
4463 \r
4464     /**\r
4465      *\r
4466      */\r
4467     SVGPathSegLinetoRel()\r
4468         {\r
4469         type = PATHSEG_LINETO_REL;\r
4470         x = y = 0.0;\r
4471         }\r
4472 \r
4473 \r
4474     /**\r
4475      *\r
4476      */\r
4477     SVGPathSegLinetoRel(double xArg, double yArg)\r
4478         {\r
4479         type = PATHSEG_LINETO_REL;\r
4480         x = xArg; y = yArg;\r
4481         }\r
4482 \r
4483     /**\r
4484      *\r
4485      */\r
4486     SVGPathSegLinetoRel(const SVGPathSegLinetoRel &other) : SVGPathSeg(other)\r
4487         {\r
4488         type = PATHSEG_LINETO_REL;\r
4489         x = other.x; y = other.y;\r
4490         }\r
4491 \r
4492     /**\r
4493      *\r
4494      */\r
4495     virtual ~SVGPathSegLinetoRel() {}\r
4496 \r
4497 protected:\r
4498 \r
4499     double x,y;\r
4500 };\r
4501 \r
4502 \r
4503 \r
4504 \r
4505 \r
4506 \r
4507 /*#########################################################################\r
4508 ## SVGPathSegCurvetoCubicAbs\r
4509 #########################################################################*/\r
4510 \r
4511 /**\r
4512  *\r
4513  */\r
4514 class SVGPathSegCurvetoCubicAbs : public SVGPathSeg\r
4515 {\r
4516 public:\r
4517 \r
4518     /**\r
4519      *\r
4520      */\r
4521     virtual double getX()\r
4522         { return x; }\r
4523 \r
4524     /**\r
4525      *\r
4526      */\r
4527     virtual void setX(double val) throw (DOMException)\r
4528         { x = val; }\r
4529 \r
4530     /**\r
4531      *\r
4532      */\r
4533     virtual double getY()\r
4534         { return y; }\r
4535 \r
4536     /**\r
4537      *\r
4538      */\r
4539     virtual void setY(double val) throw (DOMException)\r
4540         { y = val; }\r
4541 \r
4542     /**\r
4543      *\r
4544      */\r
4545     virtual double getX1()\r
4546         { return x1; }\r
4547 \r
4548     /**\r
4549      *\r
4550      */\r
4551     virtual void setX1(double val) throw (DOMException)\r
4552         { x1 = val; }\r
4553 \r
4554     /**\r
4555      *\r
4556      */\r
4557     virtual double getY1()\r
4558         { return y1; }\r
4559 \r
4560     /**\r
4561      *\r
4562      */\r
4563     virtual void setY1(double val) throw (DOMException)\r
4564         { y1 = val; }\r
4565 \r
4566 \r
4567     /**\r
4568      *\r
4569      */\r
4570     virtual double getX2()\r
4571         { return x2; }\r
4572 \r
4573     /**\r
4574      *\r
4575      */\r
4576     virtual void setX2(double val) throw (DOMException)\r
4577         { x2 = val; }\r
4578 \r
4579     /**\r
4580      *\r
4581      */\r
4582     virtual double getY2()\r
4583         { return y2; }\r
4584 \r
4585     /**\r
4586      *\r
4587      */\r
4588     virtual void setY2(double val) throw (DOMException)\r
4589         { y2 = val; }\r
4590 \r
4591 \r
4592     //##################\r
4593     //# Non-API methods\r
4594     //##################\r
4595 \r
4596 \r
4597     /**\r
4598      *\r
4599      */\r
4600     SVGPathSegCurvetoCubicAbs()\r
4601         {\r
4602         type = PATHSEG_CURVETO_CUBIC_ABS;\r
4603         x = y = x1 = y1 = x2 = y2 = 0.0;\r
4604         }\r
4605 \r
4606     /**\r
4607      *\r
4608      */\r
4609     SVGPathSegCurvetoCubicAbs(double xArg,  double yArg,\r
4610                               double x1Arg, double y1Arg,\r
4611                               double x2Arg, double y2Arg)\r
4612         {\r
4613         type = PATHSEG_CURVETO_CUBIC_ABS;\r
4614         x  = xArg;   y  = yArg;\r
4615         x1 = x1Arg;  y1 = y1Arg;\r
4616         x2 = x2Arg;  y2 = y2Arg;\r
4617         }\r
4618 \r
4619     /**\r
4620      *\r
4621      */\r
4622     SVGPathSegCurvetoCubicAbs(const SVGPathSegCurvetoCubicAbs &other)\r
4623                      : SVGPathSeg(other)\r
4624         {\r
4625         type = PATHSEG_CURVETO_CUBIC_ABS;\r
4626         x  = other.x;  y  = other.y;\r
4627         x1 = other.x1; y1 = other.y1;\r
4628         x2 = other.x2; y2 = other.y2;\r
4629         }\r
4630 \r
4631     /**\r
4632      *\r
4633      */\r
4634     virtual ~SVGPathSegCurvetoCubicAbs() {}\r
4635 \r
4636 protected:\r
4637 \r
4638     double x, y, x1, y1, x2, y2;\r
4639 \r
4640 };\r
4641 \r
4642 \r
4643 \r
4644 \r
4645 \r
4646 \r
4647 /*#########################################################################\r
4648 ## SVGPathSegCurvetoCubicRel\r
4649 #########################################################################*/\r
4650 \r
4651 /**\r
4652  *\r
4653  */\r
4654 class SVGPathSegCurvetoCubicRel : public SVGPathSeg\r
4655 {\r
4656 public:\r
4657 \r
4658     /**\r
4659      *\r
4660      */\r
4661     virtual double getX()\r
4662         { return x; }\r
4663 \r
4664     /**\r
4665      *\r
4666      */\r
4667     virtual void setX(double val) throw (DOMException)\r
4668         { x = val; }\r
4669 \r
4670     /**\r
4671      *\r
4672      */\r
4673     virtual double getY()\r
4674         { return y; }\r
4675 \r
4676     /**\r
4677      *\r
4678      */\r
4679     virtual void setY(double val) throw (DOMException)\r
4680         { y = val; }\r
4681 \r
4682     /**\r
4683      *\r
4684      */\r
4685     virtual double getX1()\r
4686         { return x1; }\r
4687 \r
4688     /**\r
4689      *\r
4690      */\r
4691     virtual void setX1(double val) throw (DOMException)\r
4692         { x1 = val; }\r
4693 \r
4694     /**\r
4695      *\r
4696      */\r
4697     virtual double getY1()\r
4698         { return y1; }\r
4699 \r
4700     /**\r
4701      *\r
4702      */\r
4703     virtual void setY1(double val) throw (DOMException)\r
4704         { y1 = val; }\r
4705 \r
4706 \r
4707     /**\r
4708      *\r
4709      */\r
4710     virtual double getX2()\r
4711         { return x2; }\r
4712 \r
4713     /**\r
4714      *\r
4715      */\r
4716     virtual void setX2(double val) throw (DOMException)\r
4717         { x2 = val; }\r
4718 \r
4719     /**\r
4720      *\r
4721      */\r
4722     virtual double getY2()\r
4723         { return y2; }\r
4724 \r
4725     /**\r
4726      *\r
4727      */\r
4728     virtual void setY2(double val) throw (DOMException)\r
4729         { y2 = val; }\r
4730 \r
4731 \r
4732     //##################\r
4733     //# Non-API methods\r
4734     //##################\r
4735 \r
4736 \r
4737     /**\r
4738      *\r
4739      */\r
4740     SVGPathSegCurvetoCubicRel()\r
4741         {\r
4742         type = PATHSEG_CURVETO_CUBIC_REL;\r
4743         x = y = x1 = y1 = x2 = y2 = 0.0;\r
4744         }\r
4745 \r
4746 \r
4747     /**\r
4748      *\r
4749      */\r
4750     SVGPathSegCurvetoCubicRel(double xArg,  double yArg,\r
4751                               double x1Arg, double y1Arg,\r
4752                               double x2Arg, double y2Arg)\r
4753         {\r
4754         type = PATHSEG_CURVETO_CUBIC_REL;\r
4755         x  = xArg;   y  = yArg;\r
4756         x1 = x1Arg;  y1 = y1Arg;\r
4757         x2 = x2Arg;  y2 = y2Arg;\r
4758         }\r
4759 \r
4760     /**\r
4761      *\r
4762      */\r
4763     SVGPathSegCurvetoCubicRel(const SVGPathSegCurvetoCubicRel &other)\r
4764                      : SVGPathSeg(other)\r
4765         {\r
4766         type = PATHSEG_CURVETO_CUBIC_REL;\r
4767         x  = other.x;  y  = other.y;\r
4768         x1 = other.x1; y1 = other.y1;\r
4769         x2 = other.x2; y2 = other.y2;\r
4770         }\r
4771 \r
4772     /**\r
4773      *\r
4774      */\r
4775     virtual ~SVGPathSegCurvetoCubicRel() {}\r
4776 \r
4777 protected:\r
4778 \r
4779     double x, y, x1, y1, x2, y2;\r
4780 \r
4781 };\r
4782 \r
4783 \r
4784 \r
4785 \r
4786 \r
4787 \r
4788 /*#########################################################################\r
4789 ## SVGPathSegCurvetoQuadraticAbs\r
4790 #########################################################################*/\r
4791 \r
4792 /**\r
4793  *\r
4794  */\r
4795 class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg\r
4796 {\r
4797 public:\r
4798 \r
4799     /**\r
4800      *\r
4801      */\r
4802     virtual double getX()\r
4803         { return x; }\r
4804 \r
4805     /**\r
4806      *\r
4807      */\r
4808     virtual void setX(double val) throw (DOMException)\r
4809         { x = val; }\r
4810 \r
4811     /**\r
4812      *\r
4813      */\r
4814     virtual double getY()\r
4815         { return y; }\r
4816 \r
4817     /**\r
4818      *\r
4819      */\r
4820     virtual void setY(double val) throw (DOMException)\r
4821         { y = val; }\r
4822 \r
4823     /**\r
4824      *\r
4825      */\r
4826     virtual double getX1()\r
4827         { return x1; }\r
4828 \r
4829     /**\r
4830      *\r
4831      */\r
4832     virtual void setX1(double val) throw (DOMException)\r
4833         { x1 = val; }\r
4834 \r
4835     /**\r
4836      *\r
4837      */\r
4838     virtual double getY1()\r
4839         { return y1; }\r
4840 \r
4841     /**\r
4842      *\r
4843      */\r
4844     virtual void setY1(double val) throw (DOMException)\r
4845         { y1 = val; }\r
4846 \r
4847 \r
4848     //##################\r
4849     //# Non-API methods\r
4850     //##################\r
4851 \r
4852 \r
4853     /**\r
4854      *\r
4855      */\r
4856     SVGPathSegCurvetoQuadraticAbs()\r
4857         {\r
4858         type = PATHSEG_CURVETO_QUADRATIC_ABS;\r
4859         x = y = x1 = y1 = 0.0;\r
4860         }\r
4861 \r
4862     /**\r
4863      *\r
4864      */\r
4865     SVGPathSegCurvetoQuadraticAbs(double xArg,  double yArg,\r
4866                               double x1Arg, double y1Arg)\r
4867         {\r
4868         type = PATHSEG_CURVETO_QUADRATIC_ABS;\r
4869         x  = xArg;   y  = yArg;\r
4870         x1 = x1Arg;  y1 = y1Arg;\r
4871         }\r
4872 \r
4873     /**\r
4874      *\r
4875      */\r
4876     SVGPathSegCurvetoQuadraticAbs(const SVGPathSegCurvetoQuadraticAbs &other)\r
4877                      : SVGPathSeg(other)\r
4878         {\r
4879         type = PATHSEG_CURVETO_QUADRATIC_ABS;\r
4880         x  = other.x;  y  = other.y;\r
4881         x1 = other.x1; y1 = other.y1;\r
4882         }\r
4883 \r
4884     /**\r
4885      *\r
4886      */\r
4887     virtual ~SVGPathSegCurvetoQuadraticAbs() {}\r
4888 \r
4889 protected:\r
4890 \r
4891     double x, y, x1, y1;\r
4892 \r
4893 };\r
4894 \r
4895 \r
4896 \r
4897 \r
4898 \r
4899 \r
4900 /*#########################################################################\r
4901 ## SVGPathSegCurvetoQuadraticRel\r
4902 #########################################################################*/\r
4903 \r
4904 /**\r
4905  *\r
4906  */\r
4907 class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg\r
4908 {\r
4909 public:\r
4910 \r
4911     /**\r
4912      *\r
4913      */\r
4914     virtual double getX()\r
4915         { return x; }\r
4916 \r
4917     /**\r
4918      *\r
4919      */\r
4920     virtual void setX(double val) throw (DOMException)\r
4921         { x = val; }\r
4922 \r
4923     /**\r
4924      *\r
4925      */\r
4926     virtual double getY()\r
4927         { return y; }\r
4928 \r
4929     /**\r
4930      *\r
4931      */\r
4932     virtual void setY(double val) throw (DOMException)\r
4933         { y = val; }\r
4934 \r
4935     /**\r
4936      *\r
4937      */\r
4938     virtual double getX1()\r
4939         { return x1; }\r
4940 \r
4941     /**\r
4942      *\r
4943      */\r
4944     virtual void setX1(double val) throw (DOMException)\r
4945         { x1 = val; }\r
4946 \r
4947     /**\r
4948      *\r
4949      */\r
4950     virtual double getY1()\r
4951         { return y1; }\r
4952 \r
4953     /**\r
4954      *\r
4955      */\r
4956     virtual void setY1(double val) throw (DOMException)\r
4957         { y1 = val; }\r
4958 \r
4959 \r
4960     //##################\r
4961     //# Non-API methods\r
4962     //##################\r
4963 \r
4964 \r
4965     /**\r
4966      *\r
4967      */\r
4968     SVGPathSegCurvetoQuadraticRel()\r
4969         {\r
4970         type = PATHSEG_CURVETO_QUADRATIC_REL;\r
4971         x = y = x1 = y1 = 0.0;\r
4972         }\r
4973 \r
4974 \r
4975     /**\r
4976      *\r
4977      */\r
4978     SVGPathSegCurvetoQuadraticRel(double xArg,  double yArg,\r
4979                                   double x1Arg, double y1Arg)\r
4980         {\r
4981         type = PATHSEG_CURVETO_QUADRATIC_REL;\r
4982         x  = xArg;   y  = yArg;\r
4983         x1 = x1Arg;  y1 = y1Arg;\r
4984         }\r
4985 \r
4986     /**\r
4987      *\r
4988      */\r
4989     SVGPathSegCurvetoQuadraticRel(const SVGPathSegCurvetoQuadraticRel &other)\r
4990                      : SVGPathSeg(other)\r
4991         {\r
4992         type = PATHSEG_CURVETO_QUADRATIC_REL;\r
4993         x  = other.x;  y  = other.y;\r
4994         x1 = other.x1; y1 = other.y1;\r
4995         }\r
4996 \r
4997     /**\r
4998      *\r
4999      */\r
5000     virtual ~SVGPathSegCurvetoQuadraticRel() {}\r
5001 \r
5002 protected:\r
5003 \r
5004     double x, y, x1, y1;\r
5005 \r
5006 };\r
5007 \r
5008 \r
5009 \r
5010 \r
5011 \r
5012 \r
5013 /*#########################################################################\r
5014 ## SVGPathSegArcAbs\r
5015 #########################################################################*/\r
5016 \r
5017 /**\r
5018  *\r
5019  */\r
5020 class SVGPathSegArcAbs : public SVGPathSeg\r
5021 {\r
5022 public:\r
5023 \r
5024     /**\r
5025      *\r
5026      */\r
5027     virtual double getX()\r
5028         { return x; }\r
5029 \r
5030     /**\r
5031      *\r
5032      */\r
5033     virtual void setX(double val) throw (DOMException)\r
5034         { x = val; }\r
5035 \r
5036     /**\r
5037      *\r
5038      */\r
5039     virtual double getY()\r
5040         { return y; }\r
5041 \r
5042     /**\r
5043      *\r
5044      */\r
5045     virtual void setY(double val) throw (DOMException)\r
5046         { y = val; }\r
5047 \r
5048     /**\r
5049      *\r
5050      */\r
5051     virtual double getR1()\r
5052         { return r1; }\r
5053 \r
5054     /**\r
5055      *\r
5056      */\r
5057     virtual void setR1(double val) throw (DOMException)\r
5058         { r1 = val; }\r
5059 \r
5060     /**\r
5061      *\r
5062      */\r
5063     virtual double getR2()\r
5064         { return r2; }\r
5065 \r
5066     /**\r
5067      *\r
5068      */\r
5069     virtual void setR2(double val) throw (DOMException)\r
5070         { r2 = val; }\r
5071 \r
5072     /**\r
5073      *\r
5074      */\r
5075     virtual double getAngle()\r
5076         { return angle; }\r
5077 \r
5078     /**\r
5079      *\r
5080      */\r
5081     virtual void setAngle(double val) throw (DOMException)\r
5082         { angle = val; }\r
5083 \r
5084     /**\r
5085      *\r
5086      */\r
5087     virtual bool getLargeArcFlag()\r
5088         { return largeArcFlag; }\r
5089 \r
5090     /**\r
5091      *\r
5092      */\r
5093     virtual void setLargeArcFlag(bool val) throw (DOMException)\r
5094         { largeArcFlag = val; }\r
5095 \r
5096     /**\r
5097      *\r
5098      */\r
5099     virtual bool getSweepFlag()\r
5100         { return sweepFlag; }\r
5101 \r
5102     /**\r
5103      *\r
5104      */\r
5105     virtual void setSweepFlag(bool val) throw (DOMException)\r
5106         { sweepFlag = val; }\r
5107 \r
5108     //##################\r
5109     //# Non-API methods\r
5110     //##################\r
5111 \r
5112 \r
5113     /**\r
5114      *\r
5115      */\r
5116     SVGPathSegArcAbs()\r
5117         {\r
5118         type = PATHSEG_ARC_ABS;\r
5119         x = y = r1 = r2 = angle = 0.0;\r
5120         largeArcFlag = sweepFlag = false;\r
5121         }\r
5122 \r
5123     /**\r
5124      *\r
5125      */\r
5126     SVGPathSegArcAbs(double xArg,  double yArg,\r
5127                      double r1Arg, double r2Arg,\r
5128                      double angleArg,\r
5129                      bool largeArcFlagArg,\r
5130                      bool sweepFlagArg )\r
5131 \r
5132         {\r
5133         type = PATHSEG_ARC_ABS;\r
5134         x  = xArg;   y  = yArg;\r
5135         r1 = r1Arg;  r2 = r2Arg;\r
5136         angle        = angleArg;\r
5137         largeArcFlag = largeArcFlagArg;\r
5138         sweepFlag    = sweepFlagArg;\r
5139         }\r
5140 \r
5141     /**\r
5142      *\r
5143      */\r
5144     SVGPathSegArcAbs(const SVGPathSegArcAbs &other)\r
5145                      : SVGPathSeg(other)\r
5146         {\r
5147         type = PATHSEG_ARC_ABS;\r
5148         x  = other.x;  y  = other.y;\r
5149         r1 = other.r1; r2 = other.r2;\r
5150         angle        = other.angle;\r
5151         largeArcFlag = other.largeArcFlag;\r
5152         sweepFlag    = other.sweepFlag;\r
5153         }\r
5154 \r
5155     /**\r
5156      *\r
5157      */\r
5158     virtual ~SVGPathSegArcAbs() {}\r
5159 \r
5160 protected:\r
5161 \r
5162     double x, y, r1, r2, angle;\r
5163     bool largeArcFlag;\r
5164     bool sweepFlag;\r
5165 \r
5166 };\r
5167 \r
5168 \r
5169 \r
5170 /*#########################################################################\r
5171 ## SVGPathSegArcRel\r
5172 #########################################################################*/\r
5173 \r
5174 /**\r
5175  *\r
5176  */\r
5177 class SVGPathSegArcRel : public SVGPathSeg\r
5178 {\r
5179 public:\r
5180 \r
5181     /**\r
5182      *\r
5183      */\r
5184     virtual double getX()\r
5185         { return x; }\r
5186 \r
5187     /**\r
5188      *\r
5189      */\r
5190     virtual void setX(double val) throw (DOMException)\r
5191         { x = val; }\r
5192 \r
5193     /**\r
5194      *\r
5195      */\r
5196     virtual double getY()\r
5197         { return y; }\r
5198 \r
5199     /**\r
5200      *\r
5201      */\r
5202     virtual void setY(double val) throw (DOMException)\r
5203         { y = val; }\r
5204 \r
5205     /**\r
5206      *\r
5207      */\r
5208     virtual double getR1()\r
5209         { return r1; }\r
5210 \r
5211     /**\r
5212      *\r
5213      */\r
5214     virtual void setR1(double val) throw (DOMException)\r
5215         { r1 = val; }\r
5216 \r
5217     /**\r
5218      *\r
5219      */\r
5220     virtual double getR2()\r
5221         { return r2; }\r
5222 \r
5223     /**\r
5224      *\r
5225      */\r
5226     virtual void setR2(double val) throw (DOMException)\r
5227         { r2 = val; }\r
5228 \r
5229     /**\r
5230      *\r
5231      */\r
5232     virtual double getAngle()\r
5233         { return angle; }\r
5234 \r
5235     /**\r
5236      *\r
5237      */\r
5238     virtual void setAngle(double val) throw (DOMException)\r
5239         { angle = val; }\r
5240 \r
5241     /**\r
5242      *\r
5243      */\r
5244     virtual bool getLargeArcFlag()\r
5245         { return largeArcFlag; }\r
5246 \r
5247     /**\r
5248      *\r
5249      */\r
5250     virtual void setLargeArcFlag(bool val) throw (DOMException)\r
5251         { largeArcFlag = val; }\r
5252 \r
5253     /**\r
5254      *\r
5255      */\r
5256     virtual bool getSweepFlag()\r
5257         { return sweepFlag; }\r
5258 \r
5259     /**\r
5260      *\r
5261      */\r
5262     virtual void setSweepFlag(bool val) throw (DOMException)\r
5263         { sweepFlag = val; }\r
5264 \r
5265     //##################\r
5266     //# Non-API methods\r
5267     //##################\r
5268 \r
5269 \r
5270     /**\r
5271      *\r
5272      */\r
5273     SVGPathSegArcRel()\r
5274         {\r
5275         type = PATHSEG_ARC_REL;\r
5276         x = y = r1 = r2 = angle = 0.0;\r
5277         largeArcFlag = sweepFlag = false;\r
5278         }\r
5279 \r
5280 \r
5281     /**\r
5282      *\r
5283      */\r
5284     SVGPathSegArcRel(double xArg, double yArg,\r
5285                      double r1Arg, double r2Arg,\r
5286                      double angleArg,\r
5287                      bool largeArcFlagArg,\r
5288                      bool sweepFlagArg )\r
5289 \r
5290         {\r
5291         type = PATHSEG_ARC_REL;\r
5292         x  = xArg;   y  = yArg;\r
5293         r1 = r1Arg;  r2 = r2Arg;\r
5294         angle        = angleArg;\r
5295         largeArcFlag = largeArcFlagArg;\r
5296         sweepFlag    = sweepFlagArg;\r
5297         }\r
5298 \r
5299     /**\r
5300      *\r
5301      */\r
5302     SVGPathSegArcRel(const SVGPathSegArcRel &other)\r
5303                      : SVGPathSeg(other)\r
5304         {\r
5305         type = PATHSEG_ARC_REL;\r
5306         x  = other.x;  y  = other.y;\r
5307         r1 = other.r1; r2 = other.r2;\r
5308         angle        = other.angle;\r
5309         largeArcFlag = other.largeArcFlag;\r
5310         sweepFlag    = other.sweepFlag;\r
5311         }\r
5312 \r
5313     /**\r
5314      *\r
5315      */\r
5316     virtual ~SVGPathSegArcRel() {}\r
5317 \r
5318 protected:\r
5319 \r
5320     double x, y, r1, r2, angle;\r
5321     bool largeArcFlag;\r
5322     bool sweepFlag;\r
5323 \r
5324 };\r
5325 \r
5326 \r
5327 \r
5328 \r
5329 \r
5330 \r
5331 /*#########################################################################\r
5332 ## SVGPathSegLinetoHorizontalAbs\r
5333 #########################################################################*/\r
5334 \r
5335 /**\r
5336  *\r
5337  */\r
5338 class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg\r
5339 {\r
5340 public:\r
5341 \r
5342     /**\r
5343      *\r
5344      */\r
5345     virtual double getX()\r
5346         { return x; }\r
5347 \r
5348     /**\r
5349      *\r
5350      */\r
5351     virtual void setX(double val) throw (DOMException)\r
5352         { x = val; }\r
5353 \r
5354     //##################\r
5355     //# Non-API methods\r
5356     //##################\r
5357 \r
5358     /**\r
5359      *\r
5360      */\r
5361     SVGPathSegLinetoHorizontalAbs()\r
5362         {\r
5363         type = PATHSEG_LINETO_HORIZONTAL_ABS;\r
5364         x = 0.0;\r
5365         }\r
5366 \r
5367 \r
5368     /**\r
5369      *\r
5370      */\r
5371     SVGPathSegLinetoHorizontalAbs(double xArg)\r
5372         {\r
5373         type = PATHSEG_LINETO_HORIZONTAL_ABS;\r
5374         x = xArg;\r
5375         }\r
5376 \r
5377     /**\r
5378      *\r
5379      */\r
5380     SVGPathSegLinetoHorizontalAbs(const SVGPathSegLinetoHorizontalAbs &other)\r
5381                      : SVGPathSeg(other)\r
5382         {\r
5383         type = PATHSEG_LINETO_HORIZONTAL_ABS;\r
5384         x = other.x;\r
5385         }\r
5386 \r
5387     /**\r
5388      *\r
5389      */\r
5390     virtual ~SVGPathSegLinetoHorizontalAbs() {}\r
5391 \r
5392 protected:\r
5393 \r
5394     double x;\r
5395 \r
5396 };\r
5397 \r
5398 \r
5399 \r
5400 \r
5401 \r
5402 \r
5403 /*#########################################################################\r
5404 ## SVGPathSegLinetoHorizontalRel\r
5405 #########################################################################*/\r
5406 \r
5407 /**\r
5408  *\r
5409  */\r
5410 class SVGPathSegLinetoHorizontalRel : public SVGPathSeg\r
5411 {\r
5412 public:\r
5413 \r
5414     /**\r
5415      *\r
5416      */\r
5417     virtual double getX()\r
5418         { return x; }\r
5419 \r
5420     /**\r
5421      *\r
5422      */\r
5423     virtual void setX(double val) throw (DOMException)\r
5424         { x = val; }\r
5425 \r
5426     //##################\r
5427     //# Non-API methods\r
5428     //##################\r
5429 \r
5430     /**\r
5431      *\r
5432      */\r
5433     SVGPathSegLinetoHorizontalRel()\r
5434         {\r
5435         type = PATHSEG_LINETO_HORIZONTAL_REL;\r
5436         x = 0.0;\r
5437         }\r
5438 \r
5439 \r
5440     /**\r
5441      *\r
5442      */\r
5443     SVGPathSegLinetoHorizontalRel(double xArg)\r
5444         {\r
5445         type = PATHSEG_LINETO_HORIZONTAL_REL;\r
5446         x = xArg;\r
5447         }\r
5448 \r
5449     /**\r
5450      *\r
5451      */\r
5452     SVGPathSegLinetoHorizontalRel(const SVGPathSegLinetoHorizontalRel &other)\r
5453                      : SVGPathSeg(other)\r
5454         {\r
5455         type = PATHSEG_LINETO_HORIZONTAL_REL;\r
5456         x = other.x;\r
5457         }\r
5458 \r
5459     /**\r
5460      *\r
5461      */\r
5462     virtual ~SVGPathSegLinetoHorizontalRel() {}\r
5463 \r
5464 protected:\r
5465 \r
5466     double x;\r
5467 \r
5468 };\r
5469 \r
5470 \r
5471 \r
5472 /*#########################################################################\r
5473 ## SVGPathSegLinetoVerticalAbs\r
5474 #########################################################################*/\r
5475 \r
5476 /**\r
5477  *\r
5478  */\r
5479 class SVGPathSegLinetoVerticalAbs : public SVGPathSeg\r
5480 {\r
5481 public:\r
5482 \r
5483     /**\r
5484      *\r
5485      */\r
5486     virtual double getY()\r
5487         { return y; }\r
5488 \r
5489     /**\r
5490      *\r
5491      */\r
5492     virtual void setY(double val) throw (DOMException)\r
5493         { y = val; }\r
5494 \r
5495     //##################\r
5496     //# Non-API methods\r
5497     //##################\r
5498 \r
5499     /**\r
5500      *\r
5501      */\r
5502     SVGPathSegLinetoVerticalAbs()\r
5503         {\r
5504         type = PATHSEG_LINETO_VERTICAL_ABS;\r
5505         y = 0.0;\r
5506         }\r
5507 \r
5508 \r
5509     /**\r
5510      *\r
5511      */\r
5512     SVGPathSegLinetoVerticalAbs(double yArg)\r
5513         {\r
5514         type = PATHSEG_LINETO_VERTICAL_ABS;\r
5515         y = yArg;\r
5516         }\r
5517 \r
5518     /**\r
5519      *\r
5520      */\r
5521     SVGPathSegLinetoVerticalAbs(const SVGPathSegLinetoVerticalAbs &other)\r
5522                      : SVGPathSeg(other)\r
5523         {\r
5524         type = PATHSEG_LINETO_VERTICAL_ABS;\r
5525         y = other.y;\r
5526         }\r
5527 \r
5528     /**\r
5529      *\r
5530      */\r
5531     virtual ~SVGPathSegLinetoVerticalAbs() {}\r
5532 \r
5533 protected:\r
5534 \r
5535     double y;\r
5536 \r
5537 };\r
5538 \r
5539 \r
5540 \r
5541 /*#########################################################################\r
5542 ## SVGPathSegLinetoVerticalRel\r
5543 #########################################################################*/\r
5544 \r
5545 /**\r
5546  *\r
5547  */\r
5548 class SVGPathSegLinetoVerticalRel : public SVGPathSeg\r
5549 {\r
5550 public:\r
5551 \r
5552     /**\r
5553      *\r
5554      */\r
5555     virtual double getY()\r
5556         { return y; }\r
5557 \r
5558     /**\r
5559      *\r
5560      */\r
5561     virtual void setY(double val) throw (DOMException)\r
5562         { y = val; }\r
5563 \r
5564     //##################\r
5565     //# Non-API methods\r
5566     //##################\r
5567 \r
5568     /**\r
5569      *\r
5570      */\r
5571     SVGPathSegLinetoVerticalRel()\r
5572         {\r
5573         type = PATHSEG_LINETO_VERTICAL_REL;\r
5574         y = 0.0;\r
5575         }\r
5576 \r
5577 \r
5578     /**\r
5579      *\r
5580      */\r
5581     SVGPathSegLinetoVerticalRel(double yArg)\r
5582         {\r
5583         type = PATHSEG_LINETO_VERTICAL_REL;\r
5584         y = yArg;\r
5585         }\r
5586 \r
5587     /**\r
5588      *\r
5589      */\r
5590     SVGPathSegLinetoVerticalRel(const SVGPathSegLinetoVerticalRel &other)\r
5591                      : SVGPathSeg(other)\r
5592         {\r
5593         type = PATHSEG_LINETO_VERTICAL_REL;\r
5594         y = other.y;\r
5595         }\r
5596 \r
5597     /**\r
5598      *\r
5599      */\r
5600     virtual ~SVGPathSegLinetoVerticalRel() {}\r
5601 \r
5602 protected:\r
5603 \r
5604     double y;\r
5605 \r
5606 };\r
5607 \r
5608 \r
5609 \r
5610 \r
5611 \r
5612 \r
5613 /*#########################################################################\r
5614 ## SVGPathSegCurvetoCubicSmoothAbs\r
5615 #########################################################################*/\r
5616 \r
5617 /**\r
5618  *\r
5619  */\r
5620 class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg\r
5621 {\r
5622 public:\r
5623 \r
5624     /**\r
5625      *\r
5626      */\r
5627     virtual double getX()\r
5628         { return x; }\r
5629 \r
5630     /**\r
5631      *\r
5632      */\r
5633     virtual void setX(double val) throw (DOMException)\r
5634         { x = val; }\r
5635 \r
5636     /**\r
5637      *\r
5638      */\r
5639     virtual double getY()\r
5640         { return y; }\r
5641 \r
5642     /**\r
5643      *\r
5644      */\r
5645     virtual void setY(double val) throw (DOMException)\r
5646         { y = val; }\r
5647 \r
5648     /**\r
5649      *\r
5650      */\r
5651     virtual double getX2()\r
5652         { return x2; }\r
5653 \r
5654     /**\r
5655      *\r
5656      */\r
5657     virtual void setX2(double val) throw (DOMException)\r
5658         { x2 = val; }\r
5659 \r
5660     /**\r
5661      *\r
5662      */\r
5663     virtual double getY2()\r
5664         { return y2; }\r
5665 \r
5666     /**\r
5667      *\r
5668      */\r
5669     virtual void setY2(double val) throw (DOMException)\r
5670         { y2 = val; }\r
5671 \r
5672 \r
5673     //##################\r
5674     //# Non-API methods\r
5675     //##################\r
5676 \r
5677     /**\r
5678      *\r
5679      */\r
5680     SVGPathSegCurvetoCubicSmoothAbs()\r
5681         {\r
5682         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;\r
5683         x = y = x2 = y2 = 0.0;\r
5684         }\r
5685 \r
5686 \r
5687     /**\r
5688      *\r
5689      */\r
5690     SVGPathSegCurvetoCubicSmoothAbs(double xArg,   double yArg,\r
5691                                     double x2Arg, double y2Arg)\r
5692         {\r
5693         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;\r
5694         x  = xArg;    y  = yArg;\r
5695         x2 = x2Arg;   y2 = y2Arg;\r
5696         }\r
5697 \r
5698     /**\r
5699      *\r
5700      */\r
5701     SVGPathSegCurvetoCubicSmoothAbs(const SVGPathSegCurvetoCubicSmoothAbs &other)\r
5702                      : SVGPathSeg(other)\r
5703         {\r
5704         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;\r
5705         x  = other.x;  y  = other.y;\r
5706         x2 = other.x2; y2 = other.y2;\r
5707         }\r
5708 \r
5709     /**\r
5710      *\r
5711      */\r
5712     virtual ~SVGPathSegCurvetoCubicSmoothAbs() {}\r
5713 \r
5714 protected:\r
5715 \r
5716     double x, y, x2, y2;\r
5717 \r
5718 };\r
5719 \r
5720 \r
5721 \r
5722 /*#########################################################################\r
5723 ## SVGPathSegCurvetoCubicSmoothRel\r
5724 #########################################################################*/\r
5725 \r
5726 /**\r
5727  *\r
5728  */\r
5729 class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg\r
5730 {\r
5731 public:\r
5732 \r
5733     /**\r
5734      *\r
5735      */\r
5736     virtual double getX()\r
5737         { return x; }\r
5738 \r
5739     /**\r
5740      *\r
5741      */\r
5742     virtual void setX(double val) throw (DOMException)\r
5743         { x = val; }\r
5744 \r
5745     /**\r
5746      *\r
5747      */\r
5748     virtual double getY()\r
5749         { return y; }\r
5750 \r
5751     /**\r
5752      *\r
5753      */\r
5754     virtual void setY(double val) throw (DOMException)\r
5755         { y = val; }\r
5756 \r
5757     /**\r
5758      *\r
5759      */\r
5760     virtual double getX2()\r
5761         { return x2; }\r
5762 \r
5763     /**\r
5764      *\r
5765      */\r
5766     virtual void setX2(double val) throw (DOMException)\r
5767         { x2 = val; }\r
5768 \r
5769     /**\r
5770      *\r
5771      */\r
5772     virtual double getY2()\r
5773         { return y2; }\r
5774 \r
5775     /**\r
5776      *\r
5777      */\r
5778     virtual void setY2(double val) throw (DOMException)\r
5779         { y2 = val; }\r
5780 \r
5781 \r
5782     //##################\r
5783     //# Non-API methods\r
5784     //##################\r
5785 \r
5786     /**\r
5787      *\r
5788      */\r
5789     SVGPathSegCurvetoCubicSmoothRel()\r
5790         {\r
5791         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;\r
5792         x = y = x2 = y2 = 0.0;\r
5793         }\r
5794 \r
5795 \r
5796     /**\r
5797      *\r
5798      */\r
5799     SVGPathSegCurvetoCubicSmoothRel(double xArg,   double yArg,\r
5800                                     double x2Arg, double y2Arg)\r
5801         {\r
5802         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;\r
5803         x  = xArg;    y  = yArg;\r
5804         x2 = x2Arg;   y2 = y2Arg;\r
5805         }\r
5806 \r
5807     /**\r
5808      *\r
5809      */\r
5810     SVGPathSegCurvetoCubicSmoothRel(const SVGPathSegCurvetoCubicSmoothRel &other)\r
5811                      : SVGPathSeg(other)\r
5812         {\r
5813         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;\r
5814         x  = other.x;  y  = other.y;\r
5815         x2 = other.x2; y2 = other.y2;\r
5816         }\r
5817 \r
5818     /**\r
5819      *\r
5820      */\r
5821     virtual ~SVGPathSegCurvetoCubicSmoothRel() {}\r
5822 \r
5823 protected:\r
5824 \r
5825     double x, y, x2, y2;\r
5826 \r
5827 };\r
5828 \r
5829 \r
5830 \r
5831 \r
5832 \r
5833 \r
5834 /*#########################################################################\r
5835 ## SVGPathSegCurvetoQuadraticSmoothAbs\r
5836 #########################################################################*/\r
5837 \r
5838 /**\r
5839  *\r
5840  */\r
5841 class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg\r
5842 {\r
5843 public:\r
5844 \r
5845     /**\r
5846      *\r
5847      */\r
5848     virtual double getX()\r
5849         { return x; }\r
5850 \r
5851     /**\r
5852      *\r
5853      */\r
5854     virtual void setX(double val) throw (DOMException)\r
5855         { x = val; }\r
5856 \r
5857     /**\r
5858      *\r
5859      */\r
5860     virtual double getY()\r
5861         { return y; }\r
5862 \r
5863     /**\r
5864      *\r
5865      */\r
5866     virtual void setY(double val) throw (DOMException)\r
5867         { y = val; }\r
5868 \r
5869 \r
5870 \r
5871     //##################\r
5872     //# Non-API methods\r
5873     //##################\r
5874 \r
5875     /**\r
5876      *\r
5877      */\r
5878     SVGPathSegCurvetoQuadraticSmoothAbs()\r
5879         {\r
5880         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;\r
5881         x = y = 0.0;\r
5882         }\r
5883 \r
5884 \r
5885     /**\r
5886      *\r
5887      */\r
5888     SVGPathSegCurvetoQuadraticSmoothAbs(double xArg, double yArg)\r
5889         {\r
5890         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;\r
5891         x = xArg;     y = yArg;\r
5892         }\r
5893 \r
5894     /**\r
5895      *\r
5896      */\r
5897     SVGPathSegCurvetoQuadraticSmoothAbs(const SVGPathSegCurvetoQuadraticSmoothAbs &other)\r
5898                      : SVGPathSeg(other)\r
5899         {\r
5900         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;\r
5901         x = y = 0.0;\r
5902         }\r
5903 \r
5904     /**\r
5905      *\r
5906      */\r
5907     virtual ~SVGPathSegCurvetoQuadraticSmoothAbs() {}\r
5908 \r
5909 protected:\r
5910 \r
5911     double x, y;\r
5912 \r
5913 };\r
5914 \r
5915 \r
5916 \r
5917 \r
5918 \r
5919 \r
5920 /*#########################################################################\r
5921 ## SVGPathSegCurvetoQuadraticSmoothRel\r
5922 #########################################################################*/\r
5923 \r
5924 /**\r
5925  *\r
5926  */\r
5927 class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg\r
5928 {\r
5929 public:\r
5930 \r
5931     /**\r
5932      *\r
5933      */\r
5934     virtual double getX()\r
5935         { return x; }\r
5936 \r
5937     /**\r
5938      *\r
5939      */\r
5940     virtual void setX(double val) throw (DOMException)\r
5941         { x = val; }\r
5942 \r
5943     /**\r
5944      *\r
5945      */\r
5946     virtual double getY()\r
5947         { return y; }\r
5948 \r
5949     /**\r
5950      *\r
5951      */\r
5952     virtual void setY(double val) throw (DOMException)\r
5953         { y = val; }\r
5954 \r
5955 \r
5956 \r
5957     //##################\r
5958     //# Non-API methods\r
5959     //##################\r
5960 \r
5961     /**\r
5962      *\r
5963      */\r
5964     SVGPathSegCurvetoQuadraticSmoothRel()\r
5965         {\r
5966         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;\r
5967         x = y = 0.0;\r
5968         }\r
5969 \r
5970 \r
5971     /**\r
5972      *\r
5973      */\r
5974     SVGPathSegCurvetoQuadraticSmoothRel(double xArg, double yArg)\r
5975         {\r
5976         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;\r
5977         x = xArg;     y = yArg;\r
5978         }\r
5979 \r
5980     /**\r
5981      *\r
5982      */\r
5983     SVGPathSegCurvetoQuadraticSmoothRel(const SVGPathSegCurvetoQuadraticSmoothRel &other)\r
5984                      : SVGPathSeg(other)\r
5985         {\r
5986         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;\r
5987         x = y = 0.0;\r
5988         }\r
5989 \r
5990     /**\r
5991      *\r
5992      */\r
5993     virtual ~SVGPathSegCurvetoQuadraticSmoothRel() {}\r
5994 \r
5995 protected:\r
5996 \r
5997     double x, y;\r
5998 \r
5999 };\r
6000 \r
6001 \r
6002 \r
6003 \r
6004 \r
6005 \r
6006 /*#########################################################################\r
6007 ## SVGPathSegList\r
6008 #########################################################################*/\r
6009 \r
6010 /**\r
6011  *\r
6012  */\r
6013 class SVGPathSegList\r
6014 {\r
6015 public:\r
6016 \r
6017     /**\r
6018      *\r
6019      */\r
6020     virtual unsigned long getNumberOfItems()\r
6021         { return items.size(); }\r
6022 \r
6023 \r
6024     /**\r
6025      *\r
6026      */\r
6027     virtual void clear () throw( DOMException )\r
6028         { items.clear(); }\r
6029 \r
6030     /**\r
6031      *\r
6032      */\r
6033     virtual SVGPathSeg initialize (const SVGPathSeg &newItem)\r
6034                     throw( DOMException, SVGException )\r
6035         {\r
6036         items.clear();\r
6037         items.push_back(newItem);\r
6038         return newItem;\r
6039         }\r
6040 \r
6041     /**\r
6042      *\r
6043      */\r
6044     virtual SVGPathSeg getItem (unsigned long index)\r
6045                     throw( DOMException )\r
6046         {\r
6047         if (index >= items.size())\r
6048             {\r
6049             SVGPathSeg seg;\r
6050             return seg;\r
6051             }\r
6052         return items[index];\r
6053         }\r
6054 \r
6055     /**\r
6056      *\r
6057      */\r
6058     virtual SVGPathSeg insertItemBefore(const SVGPathSeg &newItem,\r
6059                                         unsigned long index )\r
6060                           throw( DOMException, SVGException )\r
6061         {\r
6062         if (index >= items.size())\r
6063             items.push_back(newItem);\r
6064         else\r
6065             {\r
6066             std::vector<SVGPathSeg>::iterator iter = items.begin() + index;\r
6067             items.insert(iter, newItem);\r
6068             }\r
6069         return newItem;\r
6070         }\r
6071 \r
6072     /**\r
6073      *\r
6074      */\r
6075     virtual SVGPathSeg replaceItem(const SVGPathSeg &newItem,\r
6076                                    unsigned long index )\r
6077                               throw( DOMException, SVGException )\r
6078         {\r
6079         if (index >= items.size())\r
6080             {\r
6081             SVGPathSeg seg;\r
6082             return seg;\r
6083             }\r
6084         std::vector<SVGPathSeg>::iterator iter = items.begin() + index;\r
6085         *iter = newItem;\r
6086         return newItem;\r
6087         }\r
6088 \r
6089     /**\r
6090      *\r
6091      */\r
6092     virtual SVGPathSeg removeItem (unsigned long index)\r
6093                                   throw (DOMException)\r
6094         {\r
6095         if (index >= items.size())\r
6096             {\r
6097             SVGPathSeg seg;\r
6098             return seg;\r
6099             }\r
6100         std::vector<SVGPathSeg>::iterator iter = items.begin() + index;\r
6101         SVGPathSeg olditem = *iter;\r
6102         items.erase(iter);\r
6103         return olditem;\r
6104         }\r
6105 \r
6106     /**\r
6107      *\r
6108      */\r
6109     virtual SVGPathSeg appendItem (const SVGPathSeg &newItem)\r
6110                     throw( DOMException, SVGException )\r
6111         {\r
6112         items.push_back(newItem);\r
6113         return newItem;\r
6114         }\r
6115 \r
6116 \r
6117 \r
6118     //##################\r
6119     //# Non-API methods\r
6120     //##################\r
6121 \r
6122     /**\r
6123      *\r
6124      */\r
6125     SVGPathSegList() {}\r
6126 \r
6127 \r
6128     /**\r
6129      *\r
6130      */\r
6131     SVGPathSegList(const SVGPathSegList &other)\r
6132         {\r
6133         items = other.items;\r
6134         }\r
6135 \r
6136 \r
6137     /**\r
6138      *\r
6139      */\r
6140     virtual ~SVGPathSegList() {}\r
6141 \r
6142 protected:\r
6143 \r
6144     std::vector<SVGPathSeg> items;\r
6145 \r
6146 };\r
6147 \r
6148 \r
6149 \r
6150 \r
6151 \r
6152 \r
6153 /*#########################################################################\r
6154 ## SVGAnimatedPathData\r
6155 #########################################################################*/\r
6156 \r
6157 /**\r
6158  *\r
6159  */\r
6160 class SVGAnimatedPathData\r
6161 {\r
6162 public:\r
6163 \r
6164     /**\r
6165      *\r
6166      */\r
6167     virtual SVGPathSegList getPathSegList()\r
6168         {\r
6169         SVGPathSegList list;\r
6170         return list;\r
6171         }\r
6172 \r
6173     /**\r
6174      *\r
6175      */\r
6176     virtual SVGPathSegList getNormalizedPathSegList()\r
6177         {\r
6178         SVGPathSegList list;\r
6179         return list;\r
6180         }\r
6181 \r
6182     /**\r
6183      *\r
6184      */\r
6185     virtual SVGPathSegList getAnimatedPathSegList()\r
6186         {\r
6187         SVGPathSegList list;\r
6188         return list;\r
6189         }\r
6190 \r
6191     /**\r
6192      *\r
6193      */\r
6194     virtual SVGPathSegList getAnimatedNormalizedPathSegList()\r
6195         {\r
6196         SVGPathSegList list;\r
6197         return list;\r
6198         }\r
6199 \r
6200 \r
6201 \r
6202     //##################\r
6203     //# Non-API methods\r
6204     //##################\r
6205 \r
6206     /**\r
6207      *\r
6208      */\r
6209    SVGAnimatedPathData()\r
6210         {}\r
6211 \r
6212     /**\r
6213      *\r
6214      */\r
6215    SVGAnimatedPathData(const SVGAnimatedPathData &/*other*/)\r
6216         {\r
6217         }\r
6218 \r
6219     /**\r
6220      *\r
6221      */\r
6222     virtual ~SVGAnimatedPathData() {}\r
6223 \r
6224 };\r
6225 \r
6226 \r
6227 \r
6228 \r
6229 \r
6230 \r
6231 /*#########################################################################\r
6232 ## SVGAnimatedPoints\r
6233 #########################################################################*/\r
6234 \r
6235 /**\r
6236  *\r
6237  */\r
6238 class SVGAnimatedPoints\r
6239 {\r
6240 public:\r
6241 \r
6242     /**\r
6243      *\r
6244      */\r
6245     virtual SVGPointList getPoints()\r
6246         { return points; }\r
6247 \r
6248     /**\r
6249      *\r
6250      */\r
6251     virtual SVGPointList getAnimatedPoints()\r
6252         { return animatedPoints; }\r
6253 \r
6254 \r
6255 \r
6256     //##################\r
6257     //# Non-API methods\r
6258     //##################\r
6259 \r
6260     /**\r
6261      *\r
6262      */\r
6263     SVGAnimatedPoints() {}\r
6264 \r
6265     /**\r
6266      *\r
6267      */\r
6268     SVGAnimatedPoints(const SVGAnimatedPoints &other)\r
6269         {\r
6270         points         = other.points;\r
6271         animatedPoints = other.animatedPoints;\r
6272         }\r
6273 \r
6274     /**\r
6275      *\r
6276      */\r
6277     virtual ~SVGAnimatedPoints() {}\r
6278 \r
6279 protected:\r
6280 \r
6281     SVGPointList points;\r
6282     SVGPointList animatedPoints;\r
6283 \r
6284 };\r
6285 \r
6286 \r
6287 \r
6288 \r
6289 \r
6290 /*#########################################################################\r
6291 ## SVGPaint\r
6292 #########################################################################*/\r
6293 \r
6294 /**\r
6295  *\r
6296  */\r
6297 class SVGPaint : public SVGColor\r
6298 {\r
6299 public:\r
6300 \r
6301 \r
6302     /**\r
6303      * Paint Types\r
6304      */\r
6305     typedef enum\r
6306         {\r
6307         SVG_PAINTTYPE_UNKNOWN               = 0,\r
6308         SVG_PAINTTYPE_RGBCOLOR              = 1,\r
6309         SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR     = 2,\r
6310         SVG_PAINTTYPE_NONE                  = 101,\r
6311         SVG_PAINTTYPE_CURRENTCOLOR          = 102,\r
6312         SVG_PAINTTYPE_URI_NONE              = 103,\r
6313         SVG_PAINTTYPE_URI_CURRENTCOLOR      = 104,\r
6314         SVG_PAINTTYPE_URI_RGBCOLOR          = 105,\r
6315         SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR = 106,\r
6316         SVG_PAINTTYPE_URI                   = 107\r
6317         } PaintType;\r
6318 \r
6319 \r
6320     /**\r
6321      *\r
6322      */\r
6323     virtual unsigned short getPaintType()\r
6324         { return paintType; }\r
6325 \r
6326     /**\r
6327      *\r
6328      */\r
6329     virtual DOMString getUri()\r
6330         { return uri; }\r
6331 \r
6332     /**\r
6333      *\r
6334      */\r
6335     virtual void setUri (const DOMString& uriArg )\r
6336         { uri = uriArg; }\r
6337 \r
6338     /**\r
6339      *\r
6340      */\r
6341     virtual void setPaint (unsigned short paintTypeArg,\r
6342                            const DOMString& uriArg,\r
6343                            const DOMString& /*rgbColor*/,\r
6344                            const DOMString& /*iccColor*/ )\r
6345                            throw( SVGException )\r
6346         {\r
6347         paintType = paintTypeArg;\r
6348         uri       = uriArg;\r
6349         //do something with rgbColor\r
6350         //do something with iccColor;\r
6351         }\r
6352 \r
6353 \r
6354 \r
6355     //##################\r
6356     //# Non-API methods\r
6357     //##################\r
6358 \r
6359     /**\r
6360      *\r
6361      */\r
6362     SVGPaint()\r
6363         {\r
6364         uri       = "";\r
6365         paintType = SVG_PAINTTYPE_UNKNOWN;\r
6366         }\r
6367 \r
6368     /**\r
6369      *\r
6370      */\r
6371     SVGPaint(const SVGPaint &other) : css::CSSValue(other), SVGColor(other)\r
6372         {\r
6373         uri       = "";\r
6374         paintType = SVG_PAINTTYPE_UNKNOWN;\r
6375         }\r
6376 \r
6377     /**\r
6378      *\r
6379      */\r
6380     virtual ~SVGPaint() {}\r
6381 \r
6382 protected:\r
6383 \r
6384     unsigned int paintType;\r
6385     DOMString uri;\r
6386 \r
6387 };\r
6388 \r
6389 \r
6390 \r
6391 \r
6392 /*#########################################################################\r
6393 ## SVGColorProfileRule\r
6394 #########################################################################*/\r
6395 \r
6396 /**\r
6397  *\r
6398  */\r
6399 class SVGColorProfileRule : public SVGCSSRule,\r
6400                             public SVGRenderingIntent\r
6401 {\r
6402 \r
6403 public:\r
6404    /**\r
6405      *\r
6406      */\r
6407     virtual DOMString getSrc()\r
6408         { return src; }\r
6409 \r
6410     /**\r
6411      *\r
6412      */\r
6413     virtual void setSrc(const DOMString &val) throw (DOMException)\r
6414         { src = val; }\r
6415 \r
6416     /**\r
6417      *\r
6418      */\r
6419     virtual DOMString getName()\r
6420         { return name; }\r
6421 \r
6422     /**\r
6423      *\r
6424      */\r
6425     virtual void setName(const DOMString &val) throw (DOMException)\r
6426         { name = val; }\r
6427 \r
6428     /**\r
6429      *\r
6430      */\r
6431     virtual unsigned short getRenderingIntent()\r
6432         { return renderingIntent; }\r
6433 \r
6434     /**\r
6435      *\r
6436      */\r
6437     virtual void setRenderingIntent(unsigned short val) throw (DOMException)\r
6438         { renderingIntent = val; }\r
6439 \r
6440 \r
6441     //##################\r
6442     //# Non-API methods\r
6443     //##################\r
6444 \r
6445     /**\r
6446      *\r
6447      */\r
6448     SVGColorProfileRule() {}\r
6449 \r
6450     /**\r
6451      *\r
6452      */\r
6453     SVGColorProfileRule(const SVGColorProfileRule &other)\r
6454                : SVGCSSRule(other), SVGRenderingIntent(other)\r
6455         {\r
6456         renderingIntent = other.renderingIntent;\r
6457         src             = other.src;\r
6458         name            = other.name;\r
6459         }\r
6460 \r
6461     /**\r
6462      *\r
6463      */\r
6464     virtual ~SVGColorProfileRule() {}\r
6465 \r
6466 protected:\r
6467 \r
6468     unsigned short renderingIntent;\r
6469     DOMString src;\r
6470     DOMString name;\r
6471 \r
6472 };\r
6473 \r
6474 \r
6475 \r
6476 /*#########################################################################\r
6477 ## SVGFilterPrimitiveStandardAttributes\r
6478 #########################################################################*/\r
6479 \r
6480 /**\r
6481  *\r
6482  */\r
6483 class SVGFilterPrimitiveStandardAttributes : public SVGStylable\r
6484 {\r
6485 public:\r
6486 \r
6487 \r
6488 \r
6489     /**\r
6490      *\r
6491      */\r
6492     virtual SVGAnimatedLength getX()\r
6493         { return x; }\r
6494 \r
6495     /**\r
6496      *\r
6497      */\r
6498     virtual SVGAnimatedLength getY()\r
6499         { return y; }\r
6500 \r
6501     /**\r
6502      *\r
6503      */\r
6504     virtual SVGAnimatedLength getWidth()\r
6505         { return width; }\r
6506 \r
6507     /**\r
6508      *\r
6509      */\r
6510     virtual SVGAnimatedLength getHeight()\r
6511         { return height; }\r
6512 \r
6513     /**\r
6514      *\r
6515      */\r
6516     virtual SVGAnimatedString getResult()\r
6517         { return result; }\r
6518 \r
6519 \r
6520 \r
6521     //##################\r
6522     //# Non-API methods\r
6523     //##################\r
6524 \r
6525 \r
6526     /**\r
6527      *\r
6528      */\r
6529     SVGFilterPrimitiveStandardAttributes()\r
6530         {}\r
6531 \r
6532     /**\r
6533      *\r
6534      */\r
6535     SVGFilterPrimitiveStandardAttributes(const SVGFilterPrimitiveStandardAttributes &other)\r
6536                                  : SVGStylable(other)\r
6537         {\r
6538         x      = other.x;\r
6539         y      = other.y;\r
6540         width  = other.width;\r
6541         height = other.height;\r
6542         result = other.result;\r
6543         }\r
6544 \r
6545     /**\r
6546      *\r
6547      */\r
6548     virtual ~SVGFilterPrimitiveStandardAttributes() {}\r
6549 \r
6550 protected:\r
6551 \r
6552     SVGAnimatedLength x;\r
6553     SVGAnimatedLength y;\r
6554     SVGAnimatedLength width;\r
6555     SVGAnimatedLength height;\r
6556     SVGAnimatedString result;\r
6557 \r
6558 };\r
6559 \r
6560 \r
6561 \r
6562 \r
6563 \r
6564 \r
6565 \r
6566 \r
6567 \r
6568 \r
6569 \r
6570 /*#########################################################################\r
6571 ## SVGEvent\r
6572 #########################################################################*/\r
6573 \r
6574 /**\r
6575  *\r
6576  */\r
6577 class SVGEvent : events::Event\r
6578 {\r
6579 public:\r
6580 \r
6581     //##################\r
6582     //# Non-API methods\r
6583     //##################\r
6584 \r
6585     /**\r
6586      *\r
6587      */\r
6588     SVGEvent() {}\r
6589 \r
6590     /**\r
6591      *\r
6592      */\r
6593     SVGEvent(const SVGEvent &other) : events::Event(other)\r
6594         {}\r
6595 \r
6596     /**\r
6597      *\r
6598      */\r
6599     virtual ~SVGEvent() {}\r
6600 \r
6601 };\r
6602 \r
6603 \r
6604 \r
6605 \r
6606 /*#########################################################################\r
6607 ## SVGZoomEvent\r
6608 #########################################################################*/\r
6609 \r
6610 /**\r
6611  *\r
6612  */\r
6613 class SVGZoomEvent : events::UIEvent\r
6614 {\r
6615 public:\r
6616 \r
6617     /**\r
6618      *\r
6619      */\r
6620     virtual SVGRect getZoomRectScreen()\r
6621         { return zoomRectScreen; }\r
6622 \r
6623     /**\r
6624      *\r
6625      */\r
6626     virtual double getPreviousScale()\r
6627         { return previousScale; }\r
6628 \r
6629     /**\r
6630      *\r
6631      */\r
6632     virtual SVGPoint getPreviousTranslate()\r
6633         { return previousTranslate; }\r
6634 \r
6635     /**\r
6636      *\r
6637      */\r
6638     virtual double getNewScale()\r
6639         { return newScale; }\r
6640 \r
6641    /**\r
6642      *\r
6643      */\r
6644     virtual SVGPoint getNewTranslate()\r
6645         { return newTranslate; }\r
6646 \r
6647 \r
6648 \r
6649     //##################\r
6650     //# Non-API methods\r
6651     //##################\r
6652 \r
6653     /**\r
6654      *\r
6655      */\r
6656     SVGZoomEvent()\r
6657         {}\r
6658 \r
6659     /**\r
6660      *\r
6661      */\r
6662     SVGZoomEvent(const SVGZoomEvent &other) : events::Event(other),\r
6663                                               events::UIEvent(other)\r
6664         {\r
6665         zoomRectScreen    = other.zoomRectScreen;\r
6666         previousScale     = other.previousScale;\r
6667         previousTranslate = other.previousTranslate;\r
6668         newScale          = other.newScale;\r
6669         newTranslate      = other.newTranslate;\r
6670         }\r
6671 \r
6672     /**\r
6673      *\r
6674      */\r
6675     virtual ~SVGZoomEvent() {}\r
6676 \r
6677 protected:\r
6678 \r
6679     SVGRect  zoomRectScreen;\r
6680     double   previousScale;\r
6681     SVGPoint previousTranslate;\r
6682     double   newScale;\r
6683     SVGPoint newTranslate;\r
6684 \r
6685 };\r
6686 \r
6687 \r
6688 \r
6689 /*#########################################################################\r
6690 ## SVGElementInstance\r
6691 #########################################################################*/\r
6692 \r
6693 /**\r
6694  *\r
6695  */\r
6696 class SVGElementInstance : public events::EventTarget\r
6697 {\r
6698 public:\r
6699 \r
6700     /**\r
6701      *\r
6702      */\r
6703     virtual SVGElementPtr getCorrespondingElement()\r
6704         { return correspondingElement; }\r
6705 \r
6706     /**\r
6707      *\r
6708      */\r
6709     virtual SVGUseElementPtr getCorrespondingUseElement()\r
6710         { return correspondingUseElement; }\r
6711 \r
6712     /**\r
6713      *\r
6714      */\r
6715     virtual SVGElementInstance getParentNode()\r
6716         {\r
6717         SVGElementInstance ret;\r
6718         return ret;\r
6719         }\r
6720 \r
6721     /**\r
6722      *  Since we are using stack types and this is a circular definition,\r
6723      *  we will instead implement this as a global function below:\r
6724      *   SVGElementInstanceList getChildNodes(const SVGElementInstance instance);\r
6725      */\r
6726     //virtual SVGElementInstanceList getChildNodes();\r
6727 \r
6728     /**\r
6729      *\r
6730      */\r
6731     virtual SVGElementInstance getFirstChild()\r
6732         {\r
6733         SVGElementInstance ret;\r
6734         return ret;\r
6735         }\r
6736 \r
6737     /**\r
6738      *\r
6739      */\r
6740     virtual SVGElementInstance getLastChild()\r
6741         {\r
6742         SVGElementInstance ret;\r
6743         return ret;\r
6744         }\r
6745 \r
6746     /**\r
6747      *\r
6748      */\r
6749     virtual SVGElementInstance getPreviousSibling()\r
6750         {\r
6751         SVGElementInstance ret;\r
6752         return ret;\r
6753         }\r
6754 \r
6755     /**\r
6756      *\r
6757      */\r
6758     virtual SVGElementInstance getNextSibling()\r
6759         {\r
6760         SVGElementInstance ret;\r
6761         return ret;\r
6762         }\r
6763 \r
6764 \r
6765     //##################\r
6766     //# Non-API methods\r
6767     //##################\r
6768 \r
6769     /**\r
6770      *\r
6771      */\r
6772     SVGElementInstance() {}\r
6773 \r
6774     /**\r
6775      *\r
6776      */\r
6777     SVGElementInstance(const SVGElementInstance &other)\r
6778                         : events::EventTarget(other)\r
6779         {\r
6780         }\r
6781 \r
6782     /**\r
6783      *\r
6784      */\r
6785     virtual ~SVGElementInstance() {}\r
6786 \r
6787 protected:\r
6788 \r
6789     SVGElementPtr      correspondingElement;\r
6790     SVGUseElementPtr   correspondingUseElement;\r
6791 \r
6792 };\r
6793 \r
6794 \r
6795 \r
6796 \r
6797 \r
6798 \r
6799 /*#########################################################################\r
6800 ## SVGElementInstanceList\r
6801 #########################################################################*/\r
6802 \r
6803 /**\r
6804  *\r
6805  */\r
6806 class SVGElementInstanceList\r
6807 {\r
6808 public:\r
6809 \r
6810 \r
6811     /**\r
6812      *\r
6813      */\r
6814     virtual unsigned long getLength()\r
6815         { return items.size(); }\r
6816 \r
6817     /**\r
6818      *\r
6819      */\r
6820     virtual SVGElementInstance item (unsigned long index )\r
6821         {\r
6822         if (index >= items.size())\r
6823             {\r
6824             SVGElementInstance ret;\r
6825             return ret;\r
6826             }\r
6827         return items[index];\r
6828         }\r
6829 \r
6830     /**\r
6831      *  This static method replaces the circular definition of:\r
6832      *        SVGElementInstanceList SVGElementInstance::getChildNodes()\r
6833      *\r
6834      */\r
6835     static SVGElementInstanceList getChildNodes(const SVGElementInstance &/*instance*/)\r
6836         {\r
6837         SVGElementInstanceList list;\r
6838         return list;\r
6839         }\r
6840 \r
6841 \r
6842     //##################\r
6843     //# Non-API methods\r
6844     //##################\r
6845 \r
6846     /**\r
6847      *\r
6848      */\r
6849     SVGElementInstanceList() {}\r
6850 \r
6851     /**\r
6852      *\r
6853      */\r
6854     SVGElementInstanceList(const SVGElementInstanceList &other)\r
6855         {\r
6856         items = other.items;\r
6857         }\r
6858 \r
6859     /**\r
6860      *\r
6861      */\r
6862     virtual ~SVGElementInstanceList() {}\r
6863 \r
6864 protected:\r
6865 \r
6866     std::vector<SVGElementInstance> items;\r
6867 \r
6868 \r
6869 };\r
6870 \r
6871 \r
6872 /**\r
6873  * This is a helper class that will hold several types of data.  It will\r
6874  * be used in those situations where methods are common to different \r
6875  * interfaces, except for the data type.\r
6876  */   \r
6877 class SVGValue\r
6878 {\r
6879 public:\r
6880 \r
6881     typedef enum\r
6882         {\r
6883         SVG_DOUBLE,\r
6884         SVG_INT,\r
6885         SVG_STRING\r
6886             }SVGValueType;\r
6887 \r
6888     SVGValue(long v)\r
6889         {\r
6890         init();\r
6891         ival = d;\r
6892         type = SVG_INT;\r
6893             }\r
6894         \r
6895     SVGValue(double v)\r
6896         {\r
6897         init();\r
6898         dval = v;\r
6899         type = SVG_DOUBLE;\r
6900             }\r
6901         \r
6902     SVGValue(const DOMString &v)\r
6903         {\r
6904         init();\r
6905         sval = v;\r
6906         type = SVG_STRING;\r
6907             }\r
6908         \r
6909     SVGValue(const SVGValue &other)\r
6910         {\r
6911         assign(other);\r
6912             }\r
6913         \r
6914     SVGValue &operator=(const SVGValue &other)\r
6915         {\r
6916         assign(other);\r
6917         return *this;\r
6918             }\r
6919         \r
6920     SVGValue &operator=(long v)\r
6921         {\r
6922         init();\r
6923         ival = v;\r
6924         type = SVG_INT;\r
6925         return *this;\r
6926             }\r
6927         \r
6928     SVGValue &operator=(double v)\r
6929         {\r
6930         init();\r
6931         ival = v;\r
6932         type = SVG_DOUBLE;\r
6933         return *this;\r
6934             }\r
6935         \r
6936     SVGValue &operator=(const DOMString &v)\r
6937         {\r
6938         init();\r
6939         sval = v;\r
6940         type = SVG_STRING;\r
6941         return *this;\r
6942             }\r
6943         \r
6944         ~SVGValue()\r
6945             {}\r
6946             \r
6947         long intValue()\r
6948             { return ival; }\r
6949 \r
6950         double doubleValue()\r
6951             { return ival; }\r
6952 \r
6953         DOMString &stringValue()\r
6954             { return sval; }\r
6955 \r
6956 \r
6957 private:\r
6958 \r
6959     void init()\r
6960         {\r
6961         type = SVG_DOUBLE;\r
6962         ival = 0;\r
6963                 dval = 0.0;    \r
6964                 sval = "";\r
6965             }\r
6966         \r
6967     void assign(const SVGValue &other)\r
6968         {\r
6969         type = other.type;\r
6970         ival = other.ival;\r
6971                 dval = other.dval;\r
6972                 sval = other.sval;\r
6973             }\r
6974         \r
6975         int       type;\r
6976         double    dval;\r
6977         long      ival;\r
6978         DOMString sval;\r
6979 \r
6980 };\r
6981 \r
6982 \r
6983 \r
6984 //########################################################################\r
6985 //########################################################################\r
6986 //########################################################################\r
6987 //#   D O M\r
6988 //########################################################################\r
6989 //########################################################################\r
6990 //########################################################################\r
6991 \r
6992 \r
6993 \r
6994 \r
6995 \r
6996 /*#########################################################################\r
6997 ## Types\r
6998 #########################################################################*/\r
6999 \r
7000 /**\r
7001  * Bitmasks for has_an interface for SVGElement\r
7002  */ \r
7003 #define SVG_ANGLE                          0x00000001\r
7004 #define SVG_ANIMATED_ANGLE                 0x00000002\r
7005 #define SVG_ANIMATED_BOOLEAN               0x00000004\r
7006 #define SVG_ANIMATED_ENUMERATION           0x00000008\r
7007 #define SVG_ANIMATED_INTEGER               0x00000010\r
7008 #define SVG_ANIMATED_LENGTH                0x00000020\r
7009 #define SVG_ANIMATED_LENGTH_LIST           0x00000040\r
7010 #define SVG_ANIMATED_NUMBER                0x00000080\r
7011 #define SVG_ANIMATED_NUMBER_LIST           0x00000100\r
7012 #define SVG_ANIMATED_RECT                  0x00000200\r
7013 #define SVG_ANIMATED_STRING                0x00000400\r
7014 #define SVG_COLOR                          0x00000800\r
7015 #define SVG_CSS_RULE                       0x00001000\r
7016 #define SVG_EXTERNAL_RESOURCES_REQUIRED    0x00002000\r
7017 #define SVG_FIT_TO_VIEWBOX                 0x00004000\r
7018 #define SVG_ICCCOLOR                       0x00008000\r
7019 #define SVG_LANG_SPACE                     0x00010000\r
7020 #define SVG_LENGTH                         0x00020000\r
7021 #define SVG_LENGTH_LIST                    0x00040000\r
7022 #define SVG_LOCATABLE                      0x00080000\r
7023 #define SVG_NUMBER                         0x00100000\r
7024 #define SVG_NUMBER_LIST                    0x00200000\r
7025 #define SVG_RECT                           0x00400000\r
7026 #define SVG_RENDERING_INTENT               0x00800000\r
7027 #define SVG_STRING_LIST                    0x01000000\r
7028 #define SVG_STYLABLE                       0x02000000\r
7029 #define SVG_TESTS                          0x04000000\r
7030 #define SVG_TRANSFORMABLE                  0x08000000\r
7031 #define SVG_UNIT_TYPES                     0x10000000\r
7032 #define SVG_URI_REFERENCE                  0x20000000\r
7033 #define SVG_VIEW_SPEC                      0x40000000\r
7034 #define SVG_ZOOM_AND_PAN                   0x80000000\r
7035 \r
7036 /**\r
7037  * How many above?  Quite handy\r
7038  */ \r
7039 #define SVG_NR_INTERFACES                  32\r
7040 \r
7041 \r
7042 /**\r
7043  * Enumerations for SVGElement types\r
7044  */ \r
7045 typedef enum\r
7046 {\r
7047     SVG_A_ELEMENT = 0,\r
7048     SVG_ALTGLYPH_ELEMENT,\r
7049     SVG_ALTGLYPHDEF_ELEMENT,\r
7050     SVG_ALTGLYPHITEM_ELEMENT,\r
7051     SVG_ANIMATE_ELEMENT,\r
7052     SVG_ANIMATECOLOR_ELEMENT,\r
7053     SVG_ANIMATEMOTION_ELEMENT,\r
7054     SVG_ANIMATETRANSFORM_ELEMENT,\r
7055     SVG_CIRCLE_ELEMENT,\r
7056     SVG_CLIPPATH_ELEMENT,\r
7057     SVG_COLOR_PROFILE_ELEMENT,\r
7058     SVG_CURSOR_ELEMENT,\r
7059     SVG_DEFINITION_SRC_ELEMENT,\r
7060     SVG_DEFS_ELEMENT,\r
7061     SVG_DESC_ELEMENT,\r
7062     SVG_ELLIPSE_ELEMENT,\r
7063     SVG_FEBLEND_ELEMENT,\r
7064     SVG_FECOLORMATRIX_ELEMENT,\r
7065     SVG_FECOMPONENTTRANSFER_ELEMENT,\r
7066     SVG_FECOMPOSITE_ELEMENT,\r
7067     SVG_FECONVOLVEMATRIX_ELEMENT,\r
7068     SVG_FEDIFFUSELIGHTING_ELEMENT,\r
7069     SVG_FEDISPLACEMENTMAP_ELEMENT,\r
7070     SVG_FEDISTANTLIGHT_ELEMENT,\r
7071     SVG_FEFLOOD_ELEMENT,\r
7072     SVG_FEFUNCA_ELEMENT,\r
7073     SVG_FEFUNCB_ELEMENT,\r
7074     SVG_FEFUNCG_ELEMENT,\r
7075     SVG_FEFUNCR_ELEMENT,\r
7076     SVG_FEGAUSSIANBLUR_ELEMENT,\r
7077     SVG_FEIMAGE_ELEMENT,\r
7078     SVG_FEMERGE_ELEMENT,\r
7079     SVG_FEMERGENODE_ELEMENT,\r
7080     SVG_FEMORPHOLOGY_ELEMENT,\r
7081     SVG_FEOFFSET_ELEMENT,\r
7082     SVG_FEPOINTLIGHT_ELEMENT,\r
7083     SVG_FESPECULARLIGHTING_ELEMENT,\r
7084     SVG_FESPOTLIGHT_ELEMENT,\r
7085     SVG_FETILE_ELEMENT,\r
7086     SVG_FETURBULENCE_ELEMENT,\r
7087     SVG_FILTER_ELEMENT,\r
7088     SVG_FONT_ELEMENT,\r
7089     SVG_FONT_FACE_ELEMENT,\r
7090     SVG_FONT_FACE_FORMAT_ELEMENT,\r
7091     SVG_FONT_FACE_NAME_ELEMENT,\r
7092     SVG_FONT_FACE_SRC_ELEMENT,\r
7093     SVG_FONT_FACE_URI_ELEMENT,\r
7094     SVG_FOREIGNOBJECT_ELEMENT,\r
7095     SVG_G_ELEMENT,\r
7096     SVG_GLYPH_ELEMENT,\r
7097     SVG_GLYPHREF_ELEMENT,\r
7098     SVG_HKERN_ELEMENT,\r
7099     SVG_IMAGE_ELEMENT,\r
7100     SVG_LINE_ELEMENT,\r
7101     SVG_LINEARGRADIENT_ELEMENT,\r
7102     SVG_MARKER_ELEMENT,\r
7103     SVG_MASK_ELEMENT,\r
7104     SVG_METADATA_ELEMENT,\r
7105     SVG_MISSING_GLYPH_ELEMENT,\r
7106     SVG_MPATH_ELEMENT,\r
7107     SVG_PATH_ELEMENT,\r
7108     SVG_PATTERN_ELEMENT,\r
7109     SVG_POLYGON_ELEMENT,\r
7110     SVG_POLYLINE_ELEMENT,\r
7111     SVG_RADIALGRADIENT_ELEMENT,\r
7112     SVG_RECT_ELEMENT,\r
7113     SVG_SCRIPT_ELEMENT,\r
7114     SVG_SET_ELEMENT,\r
7115     SVG_STOP_ELEMENT,\r
7116     SVG_STYLE_ELEMENT,\r
7117     SVG_SVG_ELEMENT,\r
7118     SVG_SWITCH_ELEMENT,\r
7119     SVG_SYMBOL_ELEMENT,\r
7120     SVG_TEXT_ELEMENT,\r
7121     SVG_TEXTPATH_ELEMENT,\r
7122     SVG_TITLE_ELEMENT,\r
7123     SVG_TREF_ELEMENT,\r
7124     SVG_TSPAN_ELEMENT,\r
7125     SVG_USE_ELEMENT,\r
7126     SVG_VIEW_ELEMENT,\r
7127     SVG_VKERN_ELEMENT,\r
7128     SVG_MAX_ELEMENT\r
7129 } SVGElementType;\r
7130 \r
7131 \r
7132 \r
7133 \r
7134 /**\r
7135  * Look up the SVG Element type enum for a given string\r
7136  * Return -1 if not found\r
7137  */\r
7138 int svgElementStrToEnum(const char *str);\r
7139 \r
7140 \r
7141 /**\r
7142  * Return the string corresponding to a given SVG element type enum\r
7143  * Return "unknown" if not found\r
7144  */\r
7145 const char *svgElementEnumToStr(int type);\r
7146 \r
7147 \r
7148 \r
7149 /*#########################################################################\r
7150 ## SVGValue\r
7151 #########################################################################*/\r
7152 \r
7153 \r
7154 /**\r
7155  * A helper class to provide a common API across several data types\r
7156  */\r
7157 class SVGValue\r
7158 {\r
7159 public:\r
7160 \r
7161     /**\r
7162      * Constructors\r
7163      */\r
7164     SVGValue()\r
7165         { init(); }\r
7166 \r
7167     SVGValue(const SVGValue &other)\r
7168         { assign(other); }\r
7169 \r
7170     SVGValue(double val)\r
7171         { init(); type = SVG_DOUBLE; dval = val; }\r
7172 \r
7173     SVGValue(long val)\r
7174         { init(); type = SVG_INT; ival = val; }\r
7175 \r
7176     SVGValue(const DOMString &val)\r
7177         { init(); type = SVG_STRING; sval = val; }\r
7178 \r
7179     int getType()\r
7180         { return type; }\r
7181 \r
7182     /**\r
7183      * Assignment\r
7184      */\r
7185     SVGValue &operator=(const SVGValue &val)\r
7186         { assign(val); return *this; }\r
7187 \r
7188     SVGValue &operator=(double val)\r
7189         { init(); type = SVG_DOUBLE; dval = val; return *this; }\r
7190 \r
7191     SVGValue &operator=(long val)\r
7192         { init(); type = SVG_INT; ival = val; return *this; }\r
7193 \r
7194     SVGValue &operator=(const DOMString &val)\r
7195         { init(); type = SVG_STRING; sval = val; return *this; }\r
7196 \r
7197     /**\r
7198      * Getters\r
7199      */\r
7200     double doubleValue()\r
7201         { return dval; }\r
7202         \r
7203     long intValue()\r
7204         { return ival; }\r
7205         \r
7206     DOMString &stringValue()\r
7207         { return sval; }\r
7208 \r
7209 private:\r
7210 \r
7211     void init()\r
7212         {\r
7213         type = SVG_DOUBLE;\r
7214         dval = 0.0;\r
7215         ival = 0;\r
7216         sval.clear();\r
7217         }\r
7218 \r
7219     void assign(const SVGValue &other)\r
7220         {\r
7221         type = other.type;\r
7222         dval = other.dval;\r
7223         ival = other.ival;\r
7224         sval = other.sval;\r
7225         }\r
7226 \r
7227     int       type;\r
7228     double    dval;\r
7229     long      ival;\r
7230     DOMString sval;\r
7231 \r
7232 };\r
7233 \r
7234 \r
7235 /*#########################################################################\r
7236 ## SVGElement\r
7237 #########################################################################*/\r
7238 \r
7239 /**\r
7240  * All of the SVG DOM interfaces that correspond directly to elements in the SVG\r
7241  * language(e.g., the SVGPathElement interface corresponds directly to the\r
7242  * 'path' element in the language) are derivative from base class SVGElement.\r
7243  */\r
7244 class SVGElement : public Element\r
7245 {\r
7246 public:\r
7247 \r
7248     //####################################################################\r
7249     //# BASE METHODS FOR SVGElement\r
7250     //####################################################################\r
7251 \r
7252     /**\r
7253      * Get the value of the id attribute on the given element.\r
7254      */\r
7255     DOMString getId();\r
7256 \r
7257     /**\r
7258      * Set the value of the id attribute on the given element.\r
7259      */\r
7260     void setId(const DOMString &val) throw (DOMException);\r
7261 \r
7262     /**\r
7263      * Corresponds to attribute xml:base on the given element.\r
7264      */\r
7265     DOMString getXmlBase();\r
7266 \r
7267     /**\r
7268      * Corresponds to attribute xml:base on the given element.\r
7269      */\r
7270     void setXmlBase(const DOMString &val) throw (DOMException);\r
7271 \r
7272     /**\r
7273      * The nearest ancestor 'svg' element. Null if the given element is the\r
7274      *      outermost 'svg' element.\r
7275      */\r
7276     SVGElementPtr getOwnerSVGElement();\r
7277 \r
7278     /**\r
7279      * The element which established the current viewport. Often, the nearest\r
7280      * ancestor 'svg' element. Null if the given element is the outermost 'svg'\r
7281      * element.\r
7282      */\r
7283     SVGElementPtr getViewportElement();\r
7284 \r
7285 \r
7286     //####################################################################\r
7287     //####################################################################\r
7288     //# I N T E R F A C E S\r
7289     //####################################################################\r
7290     //####################################################################\r
7291 \r
7292     //####################################################################\r
7293     //# SVGAngle                    \r
7294     //####################################################################\r
7295 \r
7296     /**\r
7297      *\r
7298      */\r
7299     unsigned short getUnitType();\r
7300 \r
7301     /**\r
7302      *\r
7303      */\r
7304     double getValue();\r
7305 \r
7306     /**\r
7307      *\r
7308      */\r
7309     void setValue(double val) throw (DOMException);\r
7310 \r
7311     /**\r
7312      *\r
7313      */\r
7314     double getValueInSpecifiedUnits();\r
7315 \r
7316     /**\r
7317      *\r
7318      */\r
7319     void setValueInSpecifiedUnits(double /*val*/) throw (DOMException);\r
7320 \r
7321     /**\r
7322      *\r
7323      */\r
7324     DOMString getValueAsString();\r
7325 \r
7326     /**\r
7327      *\r
7328      */\r
7329     void setValueAsString(const DOMString &/*val*/) throw (DOMException);\r
7330 \r
7331 \r
7332     /**\r
7333      *\r
7334      */\r
7335     void newValueSpecifiedUnits(unsigned short /*unitType*/,\r
7336                                 double /*valueInSpecifiedUnits*/);\r
7337 \r
7338     /**\r
7339      *\r
7340      */\r
7341     void convertToSpecifiedUnits(unsigned short /*unitType*/);\r
7342 \r
7343     //####################################################################\r
7344     //# SVGAnimatedAngle            \r
7345     //####################################################################\r
7346 \r
7347     /**\r
7348      *\r
7349      */\r
7350     SVGAngle getBaseAngleVal();\r
7351 \r
7352     /**\r
7353      *\r
7354      */\r
7355     SVGAngle getAnimAngleVal();\r
7356 \r
7357 \r
7358     //####################################################################\r
7359     //# SVGAnimatedBoolean          \r
7360     //####################################################################\r
7361 \r
7362     /**\r
7363      *\r
7364      */\r
7365     bool getBaseBooleanVal();\r
7366 \r
7367     /**\r
7368      *\r
7369      */\r
7370     void setBaseBooleanVal(bool val) throw (DOMException);\r
7371 \r
7372     /**\r
7373      *\r
7374      */\r
7375     bool getAnimBooleanVal();\r
7376 \r
7377     //####################################################################\r
7378     //# SVGAnimatedEnumeration      \r
7379     //####################################################################\r
7380 \r
7381     /**\r
7382      *\r
7383      */\r
7384     unsigned short getBaseEnumerationVal();\r
7385 \r
7386     /**\r
7387      *\r
7388      */\r
7389     void setBaseEnumerationVal(unsigned short val) throw (DOMException);\r
7390 \r
7391     /**\r
7392      *\r
7393      */\r
7394     unsigned short getAnimEnumerationVal();\r
7395 \r
7396     //####################################################################\r
7397     //# SVGAnimatedInteger          \r
7398     //####################################################################\r
7399 \r
7400     /**\r
7401      *\r
7402      */\r
7403     long getBaseIntegerVal();\r
7404 \r
7405     /**\r
7406      *\r
7407      */\r
7408     void setBaseIntegerVal(long val) throw (DOMException);\r
7409 \r
7410     /**\r
7411      *\r
7412      */\r
7413     long getAnimIntegerVal();\r
7414 \r
7415     //####################################################################\r
7416     //# SVGAnimatedLength           \r
7417     //####################################################################\r
7418 \r
7419     /**\r
7420      *\r
7421      */\r
7422     SVGLength &getBaseLengthVal();\r
7423 \r
7424     /**\r
7425      *\r
7426      */\r
7427     SVGLength &getAnimLengthVal();\r
7428 \r
7429     //####################################################################\r
7430     //# SVGAnimatedLengthList       \r
7431     //####################################################################\r
7432 \r
7433     /**\r
7434      *\r
7435      */\r
7436     SVGLengthList &getBaseLengthListVal();\r
7437 \r
7438     /**\r
7439      *\r
7440      */\r
7441     SVGLengthList &getAnimLengthListVal();\r
7442 \r
7443     //####################################################################\r
7444     //# SVGAnimatedNumber           \r
7445     //####################################################################\r
7446 \r
7447     /**\r
7448      *\r
7449      */\r
7450     double getBaseNumberVal();\r
7451 \r
7452     /**\r
7453      *\r
7454      */\r
7455     void setBaseNumberVal(double val) throw (DOMException);\r
7456 \r
7457     /**\r
7458      *\r
7459      */\r
7460     double getAnimNumberVal();\r
7461 \r
7462     //####################################################################\r
7463     //# SVGAnimatedNumberList       \r
7464     //####################################################################\r
7465 \r
7466     /**\r
7467      *\r
7468      */\r
7469     SVGNumberList &getBaseNumberListVal();\r
7470 \r
7471     /**\r
7472      *\r
7473      */\r
7474     SVGNumberList &getAnimNumberListVal();\r
7475 \r
7476     //####################################################################\r
7477     //# SVGAnimatedRect             \r
7478     //####################################################################\r
7479 \r
7480     /**\r
7481      *\r
7482      */\r
7483     SVGRect &getBaseRectVal();\r
7484 \r
7485     /**\r
7486      *\r
7487      */\r
7488     SVGRect &getAnimRectVal();\r
7489 \r
7490     //####################################################################\r
7491     //# SVGAnimatedString           \r
7492     //####################################################################\r
7493 \r
7494     /**\r
7495      *\r
7496      */\r
7497     DOMString getBaseVal();\r
7498 \r
7499     /**\r
7500      *\r
7501      */\r
7502     void setBaseVal(const DOMString &val) throw (DOMException);\r
7503 \r
7504     /**\r
7505      *\r
7506      */\r
7507     DOMString getAnimVal();\r
7508 \r
7509     //####################################################################\r
7510     //# SVGColor                    \r
7511     //####################################################################\r
7512 \r
7513     /**\r
7514      * From CSSValue \r
7515      * A code defining the type of the value as defined above.\r
7516      */\r
7517     unsigned short getCssValueType();\r
7518 \r
7519     /**\r
7520      * From CSSValue \r
7521      * A string representation of the current value.\r
7522      */\r
7523     DOMString getCssText();\r
7524 \r
7525     /**\r
7526      * From CSSValue \r
7527      * A string representation of the current value.\r
7528      * Note that setting implies parsing.     \r
7529      */\r
7530     void setCssText(const DOMString &val) throw (dom::DOMException);\r
7531 \r
7532 \r
7533     /**\r
7534      *\r
7535      */\r
7536     unsigned short getColorType();\r
7537 \r
7538     /**\r
7539      *\r
7540      */\r
7541     css::RGBColor getRgbColor();\r
7542 \r
7543     /**\r
7544      *\r
7545      */\r
7546     SVGICCColor getIccColor();\r
7547 \r
7548 \r
7549     /**\r
7550      *\r
7551      */\r
7552     void setRGBColor(const DOMString& /*rgbColor*/) throw (SVGException);\r
7553 \r
7554     /**\r
7555      *\r
7556      */\r
7557     void setRGBColorICCColor(const DOMString& /*rgbColor*/,\r
7558                              const DOMString& /*iccColor*/)\r
7559                              throw (SVGException);\r
7560 \r
7561     /**\r
7562      *\r
7563      */\r
7564     void setColor(unsigned short /*colorType*/,\r
7565                            const DOMString& /*rgbColor*/,\r
7566                            const DOMString& /*iccColor*/)\r
7567                            throw (SVGException);\r
7568 \r
7569     //####################################################################\r
7570     //# SVGCSSRule                  \r
7571     //####################################################################\r
7572 \r
7573     /**\r
7574      * From CSSRule    \r
7575      * The type of the rule, as defined above. The expectation is that \r
7576      * binding-specific casting methods can be used to cast down from an instance of \r
7577      * the CSSRule interface to the specific derived interface implied by the type.\r
7578      */\r
7579     unsigned short getType();\r
7580 \r
7581     /**\r
7582      * From CSSRule    \r
7583      * The parsable textual representation of the rule. This reflects the current \r
7584      * state of the rule and not its initial value.\r
7585      */\r
7586     DOMString getCssText();\r
7587 \r
7588     /**\r
7589      * From CSSRule    \r
7590      * The parsable textual representation of the rule. This reflects the current \r
7591      * state of the rule and not its initial value.\r
7592      * Note that setting involves reparsing.     \r
7593      */\r
7594     void setCssText(const DOMString &val) throw (DOMException);\r
7595 \r
7596     /**\r
7597      * From CSSRule    \r
7598      * The style sheet that contains this rule.\r
7599      */\r
7600     css::CSSStyleSheet *getParentStyleSheet();\r
7601 \r
7602     /**\r
7603      * From CSSRule    \r
7604      * If this rule is contained inside another rule(e.g. a style rule inside an \r
7605      * @media block), this is the containing rule. If this rule is not nested inside \r
7606      * any other rules, this returns null.\r
7607      */\r
7608     css::CSSRule *getParentRule();\r
7609 \r
7610     //####################################################################\r
7611     //# SVGExternalResourcesRequired\r
7612     //####################################################################\r
7613 \r
7614     /**\r
7615      *\r
7616      */\r
7617     SVGAnimatedBoolean getExternalResourcesRequired();\r
7618 \r
7619     //####################################################################\r
7620     //# SVGFitToViewBox             \r
7621     //####################################################################\r
7622 \r
7623     /**\r
7624      *\r
7625      */\r
7626     SVGAnimatedRect getViewBox();\r
7627 \r
7628     /**\r
7629      *\r
7630      */\r
7631     SVGAnimatedPreserveAspectRatio getPreserveAspectRatio();\r
7632 \r
7633     //####################################################################\r
7634     //# SVGICCColor                 \r
7635     //####################################################################\r
7636 \r
7637     /**\r
7638      *\r
7639      */\r
7640     DOMString getColorProfile();\r
7641 \r
7642     /**\r
7643      *\r
7644      */\r
7645     void setColorProfile(const DOMString &val) throw (DOMException);\r
7646 \r
7647     /**\r
7648      *\r
7649      */\r
7650     SVGNumberList &getColors();\r
7651 \r
7652     //####################################################################\r
7653     //# SVGLangSpace                \r
7654     //####################################################################\r
7655 \r
7656     /**\r
7657      *\r
7658      */\r
7659     DOMString getXmllang();\r
7660 \r
7661     /**\r
7662      *\r
7663      */\r
7664     void setXmllang(const DOMString &val) throw (DOMException);\r
7665 \r
7666     /**\r
7667      *\r
7668      */\r
7669     DOMString getXmlspace();\r
7670 \r
7671     /**\r
7672      *\r
7673      */\r
7674     void setXmlspace(const DOMString &val) throw (DOMException);\r
7675 \r
7676     //####################################################################\r
7677     //# SVGLength                   \r
7678     //####################################################################\r
7679 \r
7680     /**\r
7681      *\r
7682      */\r
7683     unsigned short getUnitType();\r
7684 \r
7685     /**\r
7686      *\r
7687      */\r
7688     double getValue();\r
7689 \r
7690     /**\r
7691      *\r
7692      */\r
7693     void setValue(double val) throw (DOMException);\r
7694 \r
7695     /**\r
7696      *\r
7697      */\r
7698     double getValueInSpecifiedUnits();\r
7699 \r
7700     /**\r
7701      *\r
7702      */\r
7703     void setValueInSpecifiedUnits(double /*val*/) throw (DOMException);\r
7704 \r
7705     /**\r
7706      *\r
7707      */\r
7708     DOMString getValueAsString();\r
7709 \r
7710     /**\r
7711      *\r
7712      */\r
7713     void setValueAsString(const DOMString& /*val*/) throw (DOMException);\r
7714 \r
7715 \r
7716     /**\r
7717      *\r
7718      */\r
7719     void newValueSpecifiedUnits(unsigned short /*unitType*/, double /*val*/);\r
7720 \r
7721     /**\r
7722      *\r
7723      */\r
7724     void convertToSpecifiedUnits(unsigned short /*unitType*/);\r
7725 \r
7726     //####################################################################\r
7727     //# SVGLengthList               \r
7728     //####################################################################\r
7729 \r
7730     /**\r
7731      *\r
7732      */\r
7733     unsigned long getNumberOfItems();\r
7734 \r
7735 \r
7736     /**\r
7737      *\r
7738      */\r
7739     void clear() throw (DOMException);\r
7740 \r
7741     /**\r
7742      *\r
7743      */\r
7744     SVGLength initialize(const SVGLength &newItem)\r
7745                     throw (DOMException, SVGException);\r
7746 \r
7747     /**\r
7748      *\r
7749      */\r
7750     SVGLength getItem(unsigned long index) throw (DOMException);\r
7751 \r
7752     /**\r
7753      *\r
7754      */\r
7755     SVGLength insertItemBefore(const SVGLength &newItem, unsigned long index)\r
7756                                    throw (DOMException, SVGException);\r
7757 \r
7758     /**\r
7759      *\r
7760      */\r
7761     SVGLength replaceItem(const SVGLength &newItem, unsigned long index)\r
7762                                throw (DOMException, SVGException);\r
7763 \r
7764     /**\r
7765      *\r
7766      */\r
7767     SVGLength removeItem(unsigned long index) throw (DOMException);\r
7768 \r
7769     /**\r
7770      *\r
7771      */\r
7772     SVGLength appendItem(const SVGLength &newItem)\r
7773                     throw (DOMException, SVGException);\r
7774 \r
7775     //####################################################################\r
7776     //# SVGLocatable                \r
7777     //####################################################################\r
7778 \r
7779     /**\r
7780      *\r
7781      */\r
7782     SVGElementPtr getNearestViewportElement();\r
7783 \r
7784     /**\r
7785      *\r
7786      */\r
7787     SVGElement *getFarthestViewportElement();\r
7788 \r
7789     /**\r
7790      *\r
7791      */\r
7792     SVGRect getBBox();\r
7793 \r
7794     /**\r
7795      *\r
7796      */\r
7797     SVGMatrix getCTM();\r
7798 \r
7799     /**\r
7800      *\r
7801      */\r
7802     SVGMatrix getScreenCTM();\r
7803 \r
7804     /**\r
7805      *\r
7806      */\r
7807     SVGMatrix getTransformToElement(const SVGElement &/*element*/)\r
7808                                     throw (SVGException);\r
7809 \r
7810     //####################################################################\r
7811     //# SVGNumber                   \r
7812     //####################################################################\r
7813 \r
7814     /**\r
7815      *\r
7816      */\r
7817     double getValue();\r
7818 \r
7819     /**\r
7820      *\r
7821      */\r
7822     void setValue(double val) throw (DOMException);\r
7823 \r
7824     //####################################################################\r
7825     //# SVGNumberList               \r
7826     //####################################################################\r
7827 \r
7828     /**\r
7829      *\r
7830      */\r
7831     unsigned long getNumberOfItems();\r
7832 \r
7833 \r
7834     /**\r
7835      *\r
7836      */\r
7837     void clear() throw (DOMException);\r
7838 \r
7839     /**\r
7840      *\r
7841      */\r
7842     SVGNumber initialize(const SVGNumber &newItem)\r
7843                     throw (DOMException, SVGException);\r
7844 \r
7845     /**\r
7846      *\r
7847      */\r
7848     SVGNumber getItem(unsigned long index) throw (DOMException);\r
7849 \r
7850     /**\r
7851      *\r
7852      */\r
7853     SVGNumber insertItemBefore(const SVGNumber &newItem, unsigned long index)\r
7854                                          throw (DOMException, SVGException);\r
7855 \r
7856     /**\r
7857      *\r
7858      */\r
7859     SVGNumber replaceItem(const SVGNumber &newItem, unsigned long index)\r
7860                           throw (DOMException, SVGException);\r
7861 \r
7862     /**\r
7863      *\r
7864      */\r
7865     SVGNumber removeItem(unsigned long index) throw (DOMException);\r
7866 \r
7867     /**\r
7868      *\r
7869      */\r
7870     SVGNumber appendItem(const SVGNumber &newItem)\r
7871                                    throw (DOMException, SVGException);\r
7872 \r
7873     //####################################################################\r
7874     //# SVGRect                     \r
7875     //####################################################################\r
7876 \r
7877     /**\r
7878      *\r
7879      */\r
7880     double getX();\r
7881 \r
7882     /**\r
7883      *\r
7884      */\r
7885     void setX(double val) throw (DOMException);\r
7886 \r
7887     /**\r
7888      *\r
7889      */\r
7890     double getY();\r
7891 \r
7892     /**\r
7893      *\r
7894      */\r
7895     void setY(double val) throw (DOMException);\r
7896 \r
7897     /**\r
7898      *\r
7899      */\r
7900     double getWidth();\r
7901 \r
7902     /**\r
7903      *\r
7904      */\r
7905     void setWidth(double val) throw (DOMException);\r
7906 \r
7907     /**\r
7908      *\r
7909      */\r
7910     double getHeight();\r
7911 \r
7912     /**\r
7913      *\r
7914      */\r
7915     void setHeight(double val) throw (DOMException);\r
7916 \r
7917     //####################################################################\r
7918     //# SVGRenderingIntent          \r
7919     //####################################################################\r
7920 \r
7921     //####################################################################\r
7922     //# SVGStringList               \r
7923     //####################################################################\r
7924 \r
7925     /**\r
7926      *\r
7927      */\r
7928     unsigned long getNumberOfItems();\r
7929 \r
7930     /**\r
7931      *\r
7932      */\r
7933     void clear() throw (DOMException);\r
7934 \r
7935     /**\r
7936      *\r
7937      */\r
7938     DOMString initialize(const DOMString& newItem)\r
7939                     throw (DOMException, SVGException);\r
7940 \r
7941     /**\r
7942      *\r
7943      */\r
7944     DOMString getItem(unsigned long index) throw (DOMException);\r
7945 \r
7946     /**\r
7947      *\r
7948      */\r
7949     DOMString insertItemBefore(const DOMString& newItem, unsigned long index)\r
7950                                throw (DOMException, SVGException);\r
7951 \r
7952     /**\r
7953      *\r
7954      */\r
7955     DOMString replaceItem(const DOMString& newItem, unsigned long index)\r
7956                                 throw (DOMException, SVGException);\r
7957 \r
7958     /**\r
7959      *\r
7960      */\r
7961     DOMString removeItem(unsigned long index) throw (DOMException);\r
7962 \r
7963     /**\r
7964      *\r
7965      */\r
7966     DOMString appendItem(const DOMString& newItem)\r
7967                     throw (DOMException, SVGException);\r
7968 \r
7969     //####################################################################\r
7970     //# SVGStylable                 \r
7971     //####################################################################\r
7972 \r
7973     /**\r
7974      *\r
7975      */\r
7976     SVGAnimatedString getClassName();\r
7977 \r
7978     /**\r
7979      *\r
7980      */\r
7981     css::CSSStyleDeclaration getStyle();\r
7982 \r
7983     /**\r
7984      *\r
7985      */\r
7986     css::CSSValue getPresentationAttribute(const DOMString& /*name*/);\r
7987 \r
7988     //####################################################################\r
7989     //# SVGTests                    \r
7990     //####################################################################\r
7991 \r
7992     /**\r
7993      *\r
7994      */\r
7995     SVGStringList &getRequiredFeatures();\r
7996 \r
7997     /**\r
7998      *\r
7999      */\r
8000     SVGStringList &getRequiredExtensions();\r
8001 \r
8002     /**\r
8003      *\r
8004      */\r
8005     SVGStringList &getSystemLanguage();\r
8006 \r
8007     /**\r
8008      *\r
8009      */\r
8010     bool hasExtension(const DOMString& /*extension*/);\r
8011 \r
8012     //####################################################################\r
8013     //# SVGTransformable            \r
8014     //####################################################################\r
8015 \r
8016     /**\r
8017      *\r
8018      */\r
8019     SVGAnimatedTransformList &getTransform();\r
8020 \r
8021     //####################################################################\r
8022     //# SVGUnitTypes                \r
8023     //####################################################################\r
8024 \r
8025     //####################################################################\r
8026     //# SVGURIReference             \r
8027     //####################################################################\r
8028 \r
8029     /**\r
8030      *\r
8031      */\r
8032     SVGAnimatedString getHref();\r
8033 \r
8034     //####################################################################\r
8035     //# SVGViewSpec                 \r
8036     //####################################################################\r
8037 \r
8038     /**\r
8039      *\r
8040      */\r
8041     SVGTransformList getTransform();\r
8042 \r
8043     /**\r
8044      *\r
8045      */\r
8046     SVGElement *getViewTarget();\r
8047 \r
8048     /**\r
8049      *\r
8050      */\r
8051     DOMString getViewBoxString();\r
8052 \r
8053     /**\r
8054      *\r
8055      */\r
8056     DOMString getPreserveAspectRatioString();\r
8057 \r
8058     /**\r
8059      *\r
8060      */\r
8061     DOMString getTransformString();\r
8062 \r
8063     /**\r
8064      *\r
8065      */\r
8066     DOMString getViewTargetString();\r
8067 \r
8068     //####################################################################\r
8069     //# SVGZoomAndPan               \r
8070     //####################################################################\r
8071 \r
8072     /**\r
8073      *\r
8074      */\r
8075     unsigned short getZoomAndPan();\r
8076 \r
8077     /**\r
8078      *\r
8079      */\r
8080     void setZoomAndPan(unsigned short val) throw (DOMException);\r
8081 \r
8082     //####################################################################\r
8083     //####################################################################\r
8084     //# E L E M E N T S\r
8085     //####################################################################\r
8086     //####################################################################\r
8087 \r
8088     //####################################################################\r
8089     //# SVGAElement\r
8090     //####################################################################\r
8091 \r
8092 \r
8093     /**\r
8094      *\r
8095      */\r
8096     SVGAnimatedString getTarget();\r
8097 \r
8098 \r
8099 \r
8100     //####################################################################\r
8101     //# SVGAltGlyphElement\r
8102     //####################################################################\r
8103 \r
8104 \r
8105     /**\r
8106      * Get the attribute glyphRef on the given element.\r
8107      */\r
8108     DOMString getGlyphRef();\r
8109 \r
8110     /**\r
8111      * Set the attribute glyphRef on the given element.\r
8112      */\r
8113     void setGlyphRef(const DOMString &val) throw (DOMException);\r
8114 \r
8115     /**\r
8116      * Get the attribute format on the given element.\r
8117      */\r
8118     DOMString getFormat();\r
8119 \r
8120     /**\r
8121      * Set the attribute format on the given element.\r
8122      */\r
8123     void setFormat(const DOMString &val) throw (DOMException);\r
8124 \r
8125 \r
8126     //####################################################################\r
8127     //# SVGAltGlyphDefElement\r
8128     //####################################################################\r
8129 \r
8130     //####################################################################\r
8131     //# SVGAltGlyphItemElement\r
8132     //####################################################################\r
8133 \r
8134 \r
8135     //####################################################################\r
8136     //# SVGAnimateElement\r
8137     //####################################################################\r
8138 \r
8139 \r
8140     //####################################################################\r
8141     //# SVGAnimateColorElement\r
8142     //####################################################################\r
8143 \r
8144     //####################################################################\r
8145     //# SVGAnimateMotionElement\r
8146     //####################################################################\r
8147 \r
8148 \r
8149     //####################################################################\r
8150     //# SVGAnimateTransformElement\r
8151     //####################################################################\r
8152 \r
8153 \r
8154     //####################################################################\r
8155     //# SVGAnimationElement\r
8156     //####################################################################\r
8157 \r
8158 \r
8159     /**\r
8160      *\r
8161      */\r
8162     SVGElementPtr getTargetElement();\r
8163 \r
8164     /**\r
8165      *\r
8166      */\r
8167     double getStartTime();\r
8168 \r
8169     /**\r
8170      *\r
8171      */\r
8172     double getCurrentTime();\r
8173 \r
8174     /**\r
8175      *\r
8176      */\r
8177     double getSimpleDuration() throw (DOMException);\r
8178 \r
8179 \r
8180 \r
8181     //####################################################################\r
8182     //# SVGCircleElement\r
8183     //####################################################################\r
8184 \r
8185     /**\r
8186      * Corresponds to attribute cx on the given 'circle' element.\r
8187      */\r
8188     SVGAnimatedLength getCx();\r
8189 \r
8190     /**\r
8191      * Corresponds to attribute cy on the given 'circle' element.\r
8192      */\r
8193     SVGAnimatedLength getCy();\r
8194 \r
8195     /**\r
8196      * Corresponds to attribute r on the given 'circle' element.\r
8197      */\r
8198     SVGAnimatedLength getR();\r
8199 \r
8200     //####################################################################\r
8201     //# SVGClipPathElement\r
8202     //####################################################################\r
8203 \r
8204 \r
8205     /**\r
8206      * Corresponds to attribute clipPathUnits on the given 'clipPath' element.\r
8207      *      Takes one of the constants defined in SVGUnitTypes.\r
8208      */\r
8209     SVGAnimatedEnumeration getClipPathUnits();\r
8210 \r
8211 \r
8212 \r
8213     //####################################################################\r
8214     //# SVGColorProfileElement\r
8215     //####################################################################\r
8216 \r
8217 \r
8218     /**\r
8219      * Get the attribute local on the given element.\r
8220      */\r
8221     DOMString getLocal();\r
8222 \r
8223     /**\r
8224      * Set the attribute local on the given element.\r
8225      */\r
8226     void setLocal(const DOMString &val) throw (DOMException);\r
8227 \r
8228     /**\r
8229      * Get the attribute name on the given element.\r
8230      */\r
8231     DOMString getName();\r
8232 \r
8233     /**\r
8234      * Set the attribute name on the given element.\r
8235      */\r
8236     void setName(const DOMString &val) throw (DOMException);\r
8237 \r
8238     /**\r
8239      * Set the attribute rendering-intent on the given element.\r
8240      * The type of rendering intent, identified by one of the\r
8241      *      SVGRenderingIntent constants.\r
8242      */\r
8243     unsigned short getRenderingIntent();\r
8244 \r
8245     /**\r
8246      * Get the attribute rendering-intent on the given element.\r
8247      */\r
8248     void setRenderingIntent(unsigned short val) throw (DOMException);\r
8249 \r
8250 \r
8251     //####################################################################\r
8252     //# SVGComponentTransferFunctionElement\r
8253     //####################################################################\r
8254 \r
8255 \r
8256     /**\r
8257      * Component Transfer Types\r
8258      */\r
8259     typedef enum\r
8260         {\r
8261         SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN  = 0,\r
8262         SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1,\r
8263         SVG_FECOMPONENTTRANSFER_TYPE_TABLE    = 2,\r
8264         SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE = 3,\r
8265         SVG_FECOMPONENTTRANSFER_TYPE_LINEAR   = 4,\r
8266         SVG_FECOMPONENTTRANSFER_TYPE_GAMMA    = 5\r
8267         } ComponentTransferType;\r
8268 \r
8269 \r
8270     /**\r
8271      * Corresponds to attribute type on the given element. Takes one\\r
8272      *      of the Component Transfer Types.\r
8273      */\r
8274     SVGAnimatedEnumeration getType();\r
8275 \r
8276     /**\r
8277      * Corresponds to attribute tableValues on the given element.\r
8278      */\r
8279     SVGAnimatedNumberList getTableValues();\r
8280 \r
8281     /**\r
8282      * Corresponds to attribute slope on the given element.\r
8283      */\r
8284     SVGAnimatedNumber getSlope();\r
8285 \r
8286     /**\r
8287      * Corresponds to attribute intercept on the given element.\r
8288      */\r
8289     SVGAnimatedNumber getIntercept();\r
8290 \r
8291     /**\r
8292      * Corresponds to attribute amplitude on the given element.\r
8293      */\r
8294     SVGAnimatedNumber getAmplitude();\r
8295 \r
8296     /**\r
8297      * Corresponds to attribute exponent on the given element.\r
8298      */\r
8299     SVGAnimatedNumber getExponent();\r
8300 \r
8301     /**\r
8302      * Corresponds to attribute offset on the given element.\r
8303      */\r
8304     SVGAnimatedNumber getOffset();\r
8305 \r
8306     //####################################################################\r
8307     //# SVGCursorElement\r
8308     //####################################################################\r
8309 \r
8310     /**\r
8311      *\r
8312      */\r
8313     SVGAnimatedLength getX();\r
8314 \r
8315     /**\r
8316      *\r
8317      */\r
8318     SVGAnimatedLength getY();\r
8319 \r
8320 \r
8321     //####################################################################\r
8322     //# SVGDefinitionSrcElement\r
8323     //####################################################################\r
8324 \r
8325     //####################################################################\r
8326     //# SVGDefsElement\r
8327     //####################################################################\r
8328 \r
8329     //####################################################################\r
8330     //# SVGDescElement\r
8331     //####################################################################\r
8332 \r
8333     //####################################################################\r
8334     //# SVGEllipseElement\r
8335     //####################################################################\r
8336 \r
8337     /**\r
8338      * Corresponds to attribute cx on the given 'ellipse' element.\r
8339      */\r
8340     SVGAnimatedLength getCx();\r
8341 \r
8342     /**\r
8343      * Corresponds to attribute cy on the given 'ellipse' element.\r
8344      */\r
8345     SVGAnimatedLength getCy();\r
8346 \r
8347     /**\r
8348      * Corresponds to attribute rx on the given 'ellipse' element.\r
8349      */\r
8350     SVGAnimatedLength getRx();\r
8351 \r
8352     /**\r
8353      * Corresponds to attribute ry on the given 'ellipse' element.\r
8354      */\r
8355     SVGAnimatedLength getRy();\r
8356 \r
8357 \r
8358     //####################################################################\r
8359     //# SVGFEBlendElement\r
8360     //####################################################################\r
8361 \r
8362     /**\r
8363      * Blend Mode Types\r
8364      */\r
8365     typedef enum\r
8366         {\r
8367         SVG_FEBLEND_MODE_UNKNOWN  = 0,\r
8368         SVG_FEBLEND_MODE_NORMAL   = 1,\r
8369         SVG_FEBLEND_MODE_MULTIPLY = 2,\r
8370         SVG_FEBLEND_MODE_SCREEN   = 3,\r
8371         SVG_FEBLEND_MODE_DARKEN   = 4,\r
8372         SVG_FEBLEND_MODE_LIGHTEN  = 5\r
8373         } BlendModeType;\r
8374 \r
8375     /**\r
8376      * Corresponds to attribute in on the given 'feBlend' element.\r
8377      */\r
8378     SVGAnimatedString getIn1();\r
8379 \r
8380     /**\r
8381      * Corresponds to attribute in2 on the given 'feBlend' element.\r
8382      */\r
8383     SVGAnimatedString getIn2();\r
8384 \r
8385     /**\r
8386      * Corresponds to attribute mode on the given 'feBlend' element.\r
8387      *      Takes one of the Blend Mode Types.\r
8388      */\r
8389     SVGAnimatedEnumeration getMode();\r
8390 \r
8391 \r
8392     //####################################################################\r
8393     //# SVGFEColorMatrixElement\r
8394     //####################################################################\r
8395 \r
8396     /**\r
8397      * Color Matrix Types\r
8398      */\r
8399     typedef enum\r
8400         {\r
8401         SVG_FECOLORMATRIX_TYPE_UNKNOWN          = 0,\r
8402         SVG_FECOLORMATRIX_TYPE_MATRIX           = 1,\r
8403         SVG_FECOLORMATRIX_TYPE_SATURATE         = 2,\r
8404         SVG_FECOLORMATRIX_TYPE_HUEROTATE        = 3,\r
8405         SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA = 4\r
8406         } ColorMatrixType;\r
8407 \r
8408 \r
8409     /**\r
8410      * Corresponds to attribute in on the given 'feColorMatrix' element.\r
8411      */\r
8412     SVGAnimatedString getIn1();\r
8413 \r
8414     /**\r
8415      * Corresponds to attribute type on the given 'feColorMatrix' element.\r
8416      *      Takes one of the Color Matrix Types.\r
8417      */\r
8418     SVGAnimatedEnumeration getType();\r
8419 \r
8420     /**\r
8421      * Corresponds to attribute values on the given 'feColorMatrix' element.\r
8422      * Provides access to the contents of the values attribute.\r
8423      */\r
8424     SVGAnimatedNumberList getValues();\r
8425 \r
8426 \r
8427     //####################################################################\r
8428     //# SVGFEComponentTransferElement\r
8429     //####################################################################\r
8430 \r
8431 \r
8432     /**\r
8433      * Corresponds to attribute in on the given 'feComponentTransfer'  element.\r
8434      */\r
8435     SVGAnimatedString getIn1();\r
8436 \r
8437     //####################################################################\r
8438     //# SVGFECompositeElement\r
8439     //####################################################################\r
8440 \r
8441     /**\r
8442      *  Composite Operators\r
8443      */\r
8444     typedef enum\r
8445         {\r
8446         SVG_FECOMPOSITE_OPERATOR_UNKNOWN    = 0,\r
8447         SVG_FECOMPOSITE_OPERATOR_OVER       = 1,\r
8448         SVG_FECOMPOSITE_OPERATOR_IN         = 2,\r
8449         SVG_FECOMPOSITE_OPERATOR_OUT        = 3,\r
8450         SVG_FECOMPOSITE_OPERATOR_ATOP       = 4,\r
8451         SVG_FECOMPOSITE_OPERATOR_XOR        = 5,\r
8452         SVG_FECOMPOSITE_OPERATOR_ARITHMETIC = 6\r
8453         } CompositeOperatorType;\r
8454 \r
8455     /**\r
8456      * Corresponds to attribute in on the given 'feComposite' element.\r
8457      */\r
8458     SVGAnimatedString getIn1();\r
8459 \r
8460     /**\r
8461      * Corresponds to attribute in2 on the given 'feComposite' element.\r
8462      */\r
8463     SVGAnimatedString getIn2();\r
8464 \r
8465     /**\r
8466      * Corresponds to attribute operator on the given 'feComposite' element.\r
8467      *      Takes one of the Composite Operators.\r
8468      */\r
8469     SVGAnimatedEnumeration getOperator();\r
8470 \r
8471     /**\r
8472      * Corresponds to attribute k1 on the given 'feComposite' element.\r
8473      */\r
8474     SVGAnimatedNumber getK1();\r
8475 \r
8476     /**\r
8477      * Corresponds to attribute k2 on the given 'feComposite' element.\r
8478      */\r
8479     SVGAnimatedNumber getK2();\r
8480 \r
8481     /**\r
8482      * Corresponds to attribute k3 on the given 'feComposite' element.\r
8483      */\r
8484     SVGAnimatedNumber getK3();\r
8485 \r
8486     /**\r
8487      * Corresponds to attribute k4 on the given 'feComposite' element.\r
8488      */\r
8489     SVGAnimatedNumber getK4();\r
8490 \r
8491 \r
8492     //####################################################################\r
8493     //# SVGFEConvolveMatrixElement\r
8494     //####################################################################\r
8495 \r
8496 \r
8497     /**\r
8498      * Edge Mode Values\r
8499      */\r
8500     typedef enum\r
8501         {\r
8502         SVG_EDGEMODE_UNKNOWN   = 0,\r
8503         SVG_EDGEMODE_DUPLICATE = 1,\r
8504         SVG_EDGEMODE_WRAP      = 2,\r
8505         SVG_EDGEMODE_NONE      = 3\r
8506         } EdgeModeType;\r
8507 \r
8508 \r
8509     /**\r
8510      * Corresponds to attribute order on the given 'feConvolveMatrix'  element.\r
8511      */\r
8512     SVGAnimatedInteger getOrderX();\r
8513 \r
8514     /**\r
8515      * Corresponds to attribute order on the given 'feConvolveMatrix'  element.\r
8516      */\r
8517     SVGAnimatedInteger getOrderY();\r
8518 \r
8519     /**\r
8520      * Corresponds to attribute kernelMatrix on the given element.\r
8521      */\r
8522     SVGAnimatedNumberList getKernelMatrix();\r
8523 \r
8524     /**\r
8525      * Corresponds to attribute divisor on the given 'feConvolveMatrix' element.\r
8526      */\r
8527     SVGAnimatedNumber getDivisor();\r
8528 \r
8529     /**\r
8530      * Corresponds to attribute bias on the given 'feConvolveMatrix'  element.\r
8531      */\r
8532     SVGAnimatedNumber getBias();\r
8533 \r
8534     /**\r
8535      * Corresponds to attribute targetX on the given 'feConvolveMatrix'  element.\r
8536      */\r
8537     SVGAnimatedInteger getTargetX();\r
8538 \r
8539     /**\r
8540      * Corresponds to attribute targetY on the given 'feConvolveMatrix'  element.\r
8541      */\r
8542     SVGAnimatedInteger getTargetY();\r
8543 \r
8544     /**\r
8545      * Corresponds to attribute edgeMode on the given 'feConvolveMatrix'\r
8546      *      element. Takes one of the Edge Mode Types.\r
8547      */\r
8548     SVGAnimatedEnumeration getEdgeMode();\r
8549 \r
8550     /**\r
8551      * Corresponds to attribute kernelUnitLength on the\r
8552      *      given 'feConvolveMatrix'  element.\r
8553      */\r
8554     SVGAnimatedLength getKernelUnitLengthX();\r
8555 \r
8556     /**\r
8557      * Corresponds to attribute kernelUnitLength on the given\r
8558      *      'feConvolveMatrix'  element.\r
8559      */\r
8560     SVGAnimatedLength getKernelUnitLengthY();\r
8561 \r
8562     /**\r
8563      * Corresponds to attribute preserveAlpha on the\r
8564      *      given 'feConvolveMatrix'  element.\r
8565      */\r
8566     SVGAnimatedBoolean getPreserveAlpha();\r
8567 \r
8568 \r
8569 \r
8570     //####################################################################\r
8571     //# SVGFEDiffuseLightingElement\r
8572     //####################################################################\r
8573 \r
8574 \r
8575     /**\r
8576      * Corresponds to attribute in on the given 'feDiffuseLighting'  element.\r
8577      */\r
8578     SVGAnimatedString getIn1();\r
8579 \r
8580     /**\r
8581      * Corresponds to attribute surfaceScale on the given\r
8582      *      'feDiffuseLighting'  element.\r
8583      */\r
8584     SVGAnimatedNumber getSurfaceScale();\r
8585 \r
8586     /**\r
8587      * Corresponds to attribute diffuseConstant on the given\r
8588      *      'feDiffuseLighting'  element.\r
8589      */\r
8590     SVGAnimatedNumber getDiffuseConstant();\r
8591 \r
8592     /**\r
8593      * Corresponds to attribute kernelUnitLength on the given\r
8594      *      'feDiffuseLighting'  element.\r
8595      */\r
8596     SVGAnimatedNumber getKernelUnitLengthX();\r
8597 \r
8598     /**\r
8599      * Corresponds to attribute kernelUnitLength on the given\r
8600      *      'feDiffuseLighting'  element.\r
8601      */\r
8602     SVGAnimatedNumber getKernelUnitLengthY();\r
8603 \r
8604 \r
8605 \r
8606 \r
8607     //####################################################################\r
8608     //# SVGFEDisplacementMapElement\r
8609     //####################################################################\r
8610 \r
8611 \r
8612     /**\r
8613      *  Channel Selectors\r
8614      */\r
8615     typedef enum\r
8616         {\r
8617         SVG_CHANNEL_UNKNOWN = 0,\r
8618         SVG_CHANNEL_R       = 1,\r
8619         SVG_CHANNEL_G       = 2,\r
8620         SVG_CHANNEL_B       = 3,\r
8621         SVG_CHANNEL_A       = 4\r
8622         } ChannelSelector;\r
8623 \r
8624     /**\r
8625      *\r
8626      */\r
8627     SVGAnimatedString getIn1();\r
8628 \r
8629     /**\r
8630      *\r
8631      */\r
8632     SVGAnimatedString getIn2();\r
8633 \r
8634 \r
8635     /**\r
8636      *\r
8637      */\r
8638     SVGAnimatedNumber getScale();\r
8639 \r
8640     /**\r
8641      *\r
8642      */\r
8643     SVGAnimatedEnumeration getXChannelSelector();\r
8644 \r
8645     /**\r
8646      *\r
8647      */\r
8648     SVGAnimatedEnumeration getYChannelSelector();\r
8649 \r
8650     //####################################################################\r
8651     //# SVGFEDistantLightElement\r
8652     //####################################################################\r
8653 \r
8654 \r
8655     /**\r
8656      * Corresponds to attribute azimuth on the given 'feDistantLight'  element.\r
8657      */\r
8658     SVGAnimatedNumber getAzimuth();\r
8659 \r
8660 \r
8661     /**\r
8662      * Corresponds to attribute elevation on the given 'feDistantLight'\r
8663      *    element\r
8664      */\r
8665     SVGAnimatedNumber getElevation();\r
8666 \r
8667 \r
8668     //####################################################################\r
8669     //# SVGFEFloodElement\r
8670     //####################################################################\r
8671 \r
8672 \r
8673     /**\r
8674      *\r
8675      */\r
8676     SVGAnimatedString getIn1();\r
8677 \r
8678 \r
8679     //####################################################################\r
8680     //# SVGFEFuncAElement\r
8681     //####################################################################\r
8682 \r
8683     //####################################################################\r
8684     //# SVGFEFuncBElement\r
8685     //####################################################################\r
8686 \r
8687     //####################################################################\r
8688     //# SVGFEFuncGElement\r
8689     //####################################################################\r
8690 \r
8691     //####################################################################\r
8692     //# SVGFEFuncRElement\r
8693     //####################################################################\r
8694 \r
8695 \r
8696     //####################################################################\r
8697     //# SVGFEGaussianBlurElement\r
8698     //####################################################################\r
8699 \r
8700 \r
8701     /**\r
8702      *\r
8703      */\r
8704     SVGAnimatedString getIn1();\r
8705 \r
8706 \r
8707     /**\r
8708      *\r
8709      */\r
8710     SVGAnimatedNumber getStdDeviationX();\r
8711 \r
8712     /**\r
8713      *\r
8714      */\r
8715     SVGAnimatedNumber getStdDeviationY();\r
8716 \r
8717 \r
8718     /**\r
8719      *\r
8720      */\r
8721     void setStdDeviation(double stdDeviationX, double stdDeviationY);\r
8722 \r
8723 \r
8724     //####################################################################\r
8725     //# SVGFEImageElement\r
8726     //####################################################################\r
8727 \r
8728 \r
8729     //####################################################################\r
8730     //# SVGFEMergeElement\r
8731     //####################################################################\r
8732 \r
8733     //####################################################################\r
8734     //# SVGFEMergeNodeElement\r
8735     //####################################################################\r
8736 \r
8737     //####################################################################\r
8738     //# SVGFEMorphologyElement\r
8739     //####################################################################\r
8740 \r
8741 \r
8742 \r
8743     /**\r
8744      *  Morphology Operators\r
8745      */\r
8746     typedef enum\r
8747         {\r
8748         SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0,\r
8749         SVG_MORPHOLOGY_OPERATOR_ERODE   = 1,\r
8750         SVG_MORPHOLOGY_OPERATOR_DILATE  = 2\r
8751         } MorphologyOperatorType;\r
8752 \r
8753 \r
8754     /**\r
8755      *\r
8756      */\r
8757     SVGAnimatedString getIn1();\r
8758 \r
8759 \r
8760     /**\r
8761      *\r
8762      */\r
8763     SVGAnimatedEnumeration getOperator();\r
8764 \r
8765     /**\r
8766      *\r
8767      */\r
8768     SVGAnimatedLength getRadiusX();\r
8769 \r
8770     /**\r
8771      *\r
8772      */\r
8773     SVGAnimatedLength getRadiusY();\r
8774 \r
8775     //####################################################################\r
8776     //# SVGFEOffsetElement\r
8777     //####################################################################\r
8778 \r
8779     /**\r
8780      *\r
8781      */\r
8782     SVGAnimatedString getIn1();\r
8783 \r
8784     /**\r
8785      *\r
8786      */\r
8787     SVGAnimatedLength getDx();\r
8788 \r
8789     /**\r
8790      *\r
8791      */\r
8792     SVGAnimatedLength getDy();\r
8793 \r
8794 \r
8795     //####################################################################\r
8796     //# SVGFEPointLightElement\r
8797     //####################################################################\r
8798 \r
8799     /**\r
8800      * Corresponds to attribute x on the given 'fePointLight' element.\r
8801      */\r
8802     SVGAnimatedNumber getX();\r
8803 \r
8804     /**\r
8805      * Corresponds to attribute y on the given 'fePointLight' element.\r
8806      */\r
8807     SVGAnimatedNumber getY();\r
8808 \r
8809     /**\r
8810      * Corresponds to attribute z on the given 'fePointLight' element.\r
8811      */\r
8812     SVGAnimatedNumber getZ();\r
8813 \r
8814     //####################################################################\r
8815     //# SVGFESpecularLightingElement\r
8816     //####################################################################\r
8817 \r
8818 \r
8819     /**\r
8820      *\r
8821      */\r
8822     SVGAnimatedString getIn1();\r
8823 \r
8824     /**\r
8825      *\r
8826      */\r
8827     SVGAnimatedNumber getSurfaceScale();\r
8828 \r
8829     /**\r
8830      *\r
8831      */\r
8832     SVGAnimatedNumber getSpecularConstant();\r
8833 \r
8834     /**\r
8835      *\r
8836      */\r
8837     SVGAnimatedNumber getSpecularExponent();\r
8838 \r
8839 \r
8840     //####################################################################\r
8841     //# SVGFESpotLightElement\r
8842     //####################################################################\r
8843 \r
8844     /**\r
8845      * Corresponds to attribute x on the given 'feSpotLight' element.\r
8846      */\r
8847     SVGAnimatedNumber getX();\r
8848 \r
8849     /**\r
8850      * Corresponds to attribute y on the given 'feSpotLight' element.\r
8851      */\r
8852     SVGAnimatedNumber getY();\r
8853 \r
8854     /**\r
8855      * Corresponds to attribute z on the given 'feSpotLight' element.\r
8856      */\r
8857     SVGAnimatedNumber getZ();\r
8858 \r
8859     /**\r
8860      * Corresponds to attribute pointsAtX on the given 'feSpotLight' element.\r
8861      */\r
8862     SVGAnimatedNumber getPointsAtX();\r
8863 \r
8864     /**\r
8865      * Corresponds to attribute pointsAtY on the given 'feSpotLight' element.\r
8866      */\r
8867     SVGAnimatedNumber getPointsAtY();\r
8868 \r
8869     /**\r
8870      * Corresponds to attribute pointsAtZ on the given 'feSpotLight' element.\r
8871      */\r
8872     SVGAnimatedNumber getPointsAtZ();\r
8873 \r
8874     /**\r
8875      * Corresponds to attribute specularExponent on the\r
8876      *      given 'feSpotLight'  element.\r
8877      */\r
8878     SVGAnimatedNumber getSpecularExponent();\r
8879 \r
8880     /**\r
8881      * Corresponds to attribute limitingConeAngle on the\r
8882      *      given 'feSpotLight'  element.\r
8883      */\r
8884     SVGAnimatedNumber getLimitingConeAngle();\r
8885 \r
8886 \r
8887     //####################################################################\r
8888     //# SVGFETileElement\r
8889     //####################################################################\r
8890 \r
8891 \r
8892     /**\r
8893      *\r
8894      */\r
8895     SVGAnimatedString getIn1();\r
8896 \r
8897 \r
8898     //####################################################################\r
8899     //# SVGFETurbulenceElement\r
8900     //####################################################################\r
8901 \r
8902 \r
8903     /**\r
8904      *  Turbulence Types\r
8905      */\r
8906     typedef enum\r
8907         {\r
8908         SVG_TURBULENCE_TYPE_UNKNOWN      = 0,\r
8909         SVG_TURBULENCE_TYPE_FRACTALNOISE = 1,\r
8910         SVG_TURBULENCE_TYPE_TURBULENCE   = 2\r
8911         } TurbulenceType;\r
8912 \r
8913     /**\r
8914      *  Stitch Options\r
8915      */\r
8916     typedef enum\r
8917         {\r
8918         SVG_STITCHTYPE_UNKNOWN  = 0,\r
8919         SVG_STITCHTYPE_STITCH   = 1,\r
8920         SVG_STITCHTYPE_NOSTITCH = 2\r
8921         } StitchOption;\r
8922 \r
8923 \r
8924 \r
8925     /**\r
8926      *\r
8927      */\r
8928     SVGAnimatedNumber getBaseFrequencyX();\r
8929 \r
8930     /**\r
8931      *\r
8932      */\r
8933     SVGAnimatedNumber getBaseFrequencyY();\r
8934 \r
8935     /**\r
8936      *\r
8937      */\r
8938     SVGAnimatedInteger getNumOctaves();\r
8939 \r
8940     /**\r
8941      *\r
8942      */\r
8943     SVGAnimatedNumber getSeed();\r
8944 \r
8945     /**\r
8946      *\r
8947      */\r
8948     SVGAnimatedEnumeration getStitchTiles();\r
8949 \r
8950     /**\r
8951      *\r
8952      */\r
8953     SVGAnimatedEnumeration getType();\r
8954 \r
8955 \r
8956 \r
8957     //####################################################################\r
8958     //# SVGFilterElement\r
8959     //####################################################################\r
8960 \r
8961 \r
8962     /**\r
8963      * Corresponds to attribute filterUnits on the given 'filter' element. Takes one\r
8964      * of the constants defined in SVGUnitTypes.\r
8965      */\r
8966     SVGAnimatedEnumeration getFilterUnits();\r
8967 \r
8968     /**\r
8969      * Corresponds to attribute primitiveUnits on the given 'filter' element. Takes\r
8970      * one of the constants defined in SVGUnitTypes.\r
8971      */\r
8972     SVGAnimatedEnumeration getPrimitiveUnits();\r
8973 \r
8974     /**\r
8975      *\r
8976      */\r
8977     SVGAnimatedLength getX();\r
8978 \r
8979     /**\r
8980      * Corresponds to attribute x on the given 'filter' element.\r
8981      */\r
8982     SVGAnimatedLength getY();\r
8983 \r
8984     /**\r
8985      * Corresponds to attribute y on the given 'filter' element.\r
8986      */\r
8987     SVGAnimatedLength getWidth();\r
8988 \r
8989     /**\r
8990      * Corresponds to attribute height on the given 'filter' element.\r
8991      */\r
8992     SVGAnimatedLength getHeight();\r
8993 \r
8994 \r
8995     /**\r
8996      * Corresponds to attribute filterRes on the given 'filter' element.\r
8997      *      Contains the X component of attribute filterRes.\r
8998      */\r
8999     SVGAnimatedInteger getFilterResX();\r
9000 \r
9001     /**\r
9002      * Corresponds to attribute filterRes on the given 'filter' element.\r
9003      * Contains the Y component(possibly computed automatically)\r
9004      *      of attribute filterRes.\r
9005      */\r
9006     SVGAnimatedInteger getFilterResY();\r
9007 \r
9008     /**\r
9009      * Sets the values for attribute filterRes.\r
9010      */\r
9011     void setFilterRes(unsigned long filterResX, unsigned long filterResY);\r
9012 \r
9013 \r
9014     //####################################################################\r
9015     //# SVGFontElement\r
9016     //####################################################################\r
9017 \r
9018     //####################################################################\r
9019     //# SVGFontFaceElement\r
9020     //####################################################################\r
9021 \r
9022     //####################################################################\r
9023     //# SVGFontFaceFormatElement\r
9024     //####################################################################\r
9025 \r
9026     //####################################################################\r
9027     //# SVGFontFaceNameElement\r
9028     //####################################################################\r
9029 \r
9030     //####################################################################\r
9031     //# SVGFontFaceSrcElement\r
9032     //####################################################################\r
9033 \r
9034     //####################################################################\r
9035     //# SVGFontFaceUriElement\r
9036     //####################################################################\r
9037 \r
9038     //####################################################################\r
9039     //# SVGForeignObjectElement\r
9040     //####################################################################\r
9041 \r
9042     /**\r
9043      *\r
9044      */\r
9045     SVGAnimatedLength getX();\r
9046 \r
9047     /**\r
9048      *\r
9049      */\r
9050     SVGAnimatedLength getY();\r
9051 \r
9052     /**\r
9053      *\r
9054      */\r
9055     SVGAnimatedLength getWidth();\r
9056 \r
9057     /**\r
9058      *\r
9059      */\r
9060     SVGAnimatedLength getHeight();\r
9061 \r
9062 \r
9063 \r
9064     //####################################################################\r
9065     //# SVGGlyphRefElement\r
9066     //####################################################################\r
9067 \r
9068 \r
9069     /**\r
9070      * Get the attribute glyphRef on the given element.\r
9071      */\r
9072     DOMString getGlyphRef();\r
9073 \r
9074     /**\r
9075      * Set the attribute glyphRef on the given element.\r
9076      */\r
9077     void setGlyphRef(const DOMString &val) throw (DOMException);\r
9078 \r
9079     /**\r
9080      * Get the attribute format on the given element.\r
9081      */\r
9082     DOMString getFormat();\r
9083 \r
9084     /**\r
9085      * Set the attribute format on the given element.\r
9086      */\r
9087     void setFormat(const DOMString &val) throw (DOMException);\r
9088 \r
9089     /**\r
9090      * Get the attribute x on the given element.\r
9091      */\r
9092     double getX();\r
9093 \r
9094     /**\r
9095      * Set the attribute x on the given element.\r
9096      */\r
9097     void setX(double val) throw (DOMException);\r
9098 \r
9099     /**\r
9100      * Get the attribute y on the given element.\r
9101      */\r
9102     double getY();\r
9103 \r
9104     /**\r
9105      * Set the attribute y on the given element.\r
9106      */\r
9107     void setY(double val) throw (DOMException);\r
9108 \r
9109     /**\r
9110      * Get the attribute dx on the given element.\r
9111      */\r
9112     double getDx();\r
9113 \r
9114     /**\r
9115      * Set the attribute dx on the given element.\r
9116      */\r
9117     void setDx(double val) throw (DOMException);\r
9118 \r
9119     /**\r
9120      * Get the attribute dy on the given element.\r
9121      */\r
9122     double getDy();\r
9123 \r
9124     /**\r
9125      * Set the attribute dy on the given element.\r
9126      */\r
9127     void setDy(double val) throw (DOMException);\r
9128 \r
9129 \r
9130     //####################################################################\r
9131     //# SVGGradientElement\r
9132     //####################################################################\r
9133 \r
9134 \r
9135     /**\r
9136      * Spread Method Types\r
9137      */\r
9138     typedef enum\r
9139         {\r
9140         SVG_SPREADMETHOD_UNKNOWN = 0,\r
9141         SVG_SPREADMETHOD_PAD     = 1,\r
9142         SVG_SPREADMETHOD_REFLECT = 2,\r
9143         SVG_SPREADMETHOD_REPEAT  = 3\r
9144         } SpreadMethodType;\r
9145 \r
9146 \r
9147     /**\r
9148      * Corresponds to attribute gradientUnits on the given element.\r
9149      *      Takes one of the constants defined in SVGUnitTypes.\r
9150      */\r
9151     SVGAnimatedEnumeration getGradientUnits();\r
9152 \r
9153     /**\r
9154      * Corresponds to attribute gradientTransform on the given element.\r
9155      */\r
9156     SVGAnimatedTransformList getGradientTransform();\r
9157 \r
9158     /**\r
9159      * Corresponds to attribute spreadMethod on the given element.\r
9160      *      One of the Spread Method Types.\r
9161      */\r
9162     SVGAnimatedEnumeration getSpreadMethod();\r
9163 \r
9164 \r
9165 \r
9166     //####################################################################\r
9167     //# SVGHKernElement\r
9168     //####################################################################\r
9169 \r
9170     //####################################################################\r
9171     //# SVGImageElement\r
9172     //####################################################################\r
9173 \r
9174     /**\r
9175      * Corresponds to attribute x on the given 'image' element.\r
9176      */\r
9177     SVGAnimatedLength getX();\r
9178 \r
9179     /**\r
9180      * Corresponds to attribute y on the given 'image' element.\r
9181      */\r
9182     SVGAnimatedLength getY();\r
9183 \r
9184     /**\r
9185      * Corresponds to attribute width on the given 'image' element.\r
9186      */\r
9187     SVGAnimatedLength getWidth();\r
9188 \r
9189     /**\r
9190      * Corresponds to attribute height on the given 'image' element.\r
9191      */\r
9192     SVGAnimatedLength getHeight();\r
9193 \r
9194 \r
9195     /**\r
9196      * Corresponds to attribute preserveAspectRatio on the given element.\r
9197      */\r
9198     SVGAnimatedPreserveAspectRatio getPreserveAspectRatio();\r
9199 \r
9200     //####################################################################\r
9201     //# SVGLinearGradientElement\r
9202     //####################################################################\r
9203 \r
9204     /**\r
9205      * Corresponds to attribute x1 on the given 'linearGradient'  element.\r
9206      */\r
9207     SVGAnimatedLength getX1();\r
9208 \r
9209     /**\r
9210      * Corresponds to attribute y1 on the given 'linearGradient'  element.\r
9211      */\r
9212     SVGAnimatedLength getY1();\r
9213 \r
9214     /**\r
9215      * Corresponds to attribute x2 on the given 'linearGradient'  element.\r
9216      */\r
9217     SVGAnimatedLength getX2();\r
9218 \r
9219     /**\r
9220      * Corresponds to attribute y2 on the given 'linearGradient'  element.\r
9221      */\r
9222     SVGAnimatedLength getY2();\r
9223 \r
9224 \r
9225 \r
9226     //####################################################################\r
9227     //# SVGLineElement\r
9228     //####################################################################\r
9229 \r
9230     /**\r
9231      * Corresponds to attribute x1 on the given 'line' element.\r
9232      */\r
9233     SVGAnimatedLength getX1();\r
9234 \r
9235     /**\r
9236      * Corresponds to attribute y1 on the given 'line' element.\r
9237      */\r
9238     SVGAnimatedLength getY1();\r
9239 \r
9240     /**\r
9241      * Corresponds to attribute x2 on the given 'line' element.\r
9242      */\r
9243     SVGAnimatedLength getX2();\r
9244 \r
9245     /**\r
9246      * Corresponds to attribute y2 on the given 'line' element.\r
9247      */\r
9248     SVGAnimatedLength getY2();\r
9249 \r
9250 \r
9251     //####################################################################\r
9252     //# SVGMarkerElement\r
9253     //####################################################################\r
9254 \r
9255 \r
9256     /**\r
9257      * Marker Unit Types\r
9258      */\r
9259     typedef enum\r
9260         {\r
9261         SVG_MARKERUNITS_UNKNOWN        = 0,\r
9262         SVG_MARKERUNITS_USERSPACEONUSE = 1,\r
9263         SVG_MARKERUNITS_STROKEWIDTH    = 2\r
9264         } MarkerUnitType;\r
9265 \r
9266     /**\r
9267      * Marker Orientation Types\r
9268      */\r
9269     typedef enum\r
9270         {\r
9271         SVG_MARKER_ORIENT_UNKNOWN      = 0,\r
9272         SVG_MARKER_ORIENT_AUTO         = 1,\r
9273         SVG_MARKER_ORIENT_ANGLE        = 2\r
9274         } MarkerOrientationType;\r
9275 \r
9276 \r
9277     /**\r
9278      * Corresponds to attribute refX on the given 'marker' element.\r
9279      */\r
9280     SVGAnimatedLength getRefX();\r
9281 \r
9282     /**\r
9283      * Corresponds to attribute refY on the given 'marker' element.\r
9284      */\r
9285     SVGAnimatedLength getRefY();\r
9286 \r
9287     /**\r
9288      * Corresponds to attribute markerUnits on the given 'marker' element.\r
9289      *      One of the Marker Units Types defined above.\r
9290      */\r
9291     SVGAnimatedEnumeration getMarkerUnits();\r
9292 \r
9293     /**\r
9294      * Corresponds to attribute markerWidth on the given 'marker' element.\r
9295      */\r
9296     SVGAnimatedLength getMarkerWidth();\r
9297 \r
9298     /**\r
9299      * Corresponds to attribute markerHeight on the given 'marker' element.\r
9300      */\r
9301     SVGAnimatedLength getMarkerHeight();\r
9302 \r
9303     /**\r
9304      * Corresponds to attribute orient on the given 'marker' element.\r
9305      *      One of the Marker Orientation Types defined above.\r
9306      */\r
9307     SVGAnimatedEnumeration getOrientType();\r
9308 \r
9309     /**\r
9310      * Corresponds to attribute orient on the given 'marker' element.\r
9311      * If markerUnits is SVG_MARKER_ORIENT_ANGLE, the angle value for\r
9312      * attribute orient; otherwise, it will be set to zero.\r
9313      */\r
9314     SVGAnimatedAngle getOrientAngle();\r
9315 \r
9316 \r
9317     /**\r
9318      * Sets the value of attribute orient to 'auto'.\r
9319      */\r
9320     void setOrientToAuto();\r
9321 \r
9322     /**\r
9323      * Sets the value of attribute orient to the given angle.\r
9324      */\r
9325     void setOrientToAngle(const SVGAngle &angle);\r
9326 \r
9327 \r
9328     //####################################################################\r
9329     //# SVGMaskElement\r
9330     //####################################################################\r
9331 \r
9332 \r
9333     /**\r
9334      * Corresponds to attribute maskUnits on the given 'mask' element. Takes one of\r
9335      * the constants defined in SVGUnitTypes.\r
9336      */\r
9337     SVGAnimatedEnumeration getMaskUnits();\r
9338 \r
9339     /**\r
9340      * Corresponds to attribute maskContentUnits on the given 'mask' element. Takes\r
9341      * one of the constants defined in SVGUnitTypes.\r
9342      */\r
9343     SVGAnimatedEnumeration getMaskContentUnits();\r
9344 \r
9345     /**\r
9346      * Corresponds to attribute x on the given 'mask' element.\r
9347      */\r
9348     SVGAnimatedLength getX();\r
9349 \r
9350     /**\r
9351      * Corresponds to attribute y on the given 'mask' element.\r
9352      */\r
9353     SVGAnimatedLength getY();\r
9354 \r
9355     /**\r
9356      * Corresponds to attribute width on the given 'mask' element.\r
9357      */\r
9358     SVGAnimatedLength getWidth();\r
9359 \r
9360     /**\r
9361      * Corresponds to attribute height on the given 'mask' element.\r
9362      */\r
9363     SVGAnimatedLength getHeight();\r
9364 \r
9365     //####################################################################\r
9366     //# SVGMetadataElement\r
9367     //####################################################################\r
9368 \r
9369     //####################################################################\r
9370     //# SVGMPathElement\r
9371     //####################################################################\r
9372 \r
9373     //####################################################################\r
9374     //# SVGPathElement\r
9375     //####################################################################\r
9376 \r
9377     //####################################################################\r
9378     //# SVGPatternElement\r
9379     //####################################################################\r
9380 \r
9381     /**\r
9382      * Corresponds to attribute patternUnits on the given 'pattern' element.\r
9383      * Takes one of the constants defined in SVGUnitTypes.\r
9384      */\r
9385     SVGAnimatedEnumeration getPatternUnits();\r
9386 \r
9387     /**\r
9388      * Corresponds to attribute patternContentUnits on the given 'pattern'\r
9389      *      element. Takes one of the constants defined in SVGUnitTypes.\r
9390      */\r
9391     SVGAnimatedEnumeration getPatternContentUnits();\r
9392 \r
9393     /**\r
9394      * Corresponds to attribute patternTransform on the given 'pattern' element.\r
9395      */\r
9396     SVGAnimatedTransformList getPatternTransform();\r
9397 \r
9398     /**\r
9399      * Corresponds to attribute x on the given 'pattern' element.\r
9400      */\r
9401     SVGAnimatedLength getX();\r
9402 \r
9403     /**\r
9404      *\r
9405      */\r
9406     SVGAnimatedLength getY();\r
9407 \r
9408     /**\r
9409      * Corresponds to attribute width on the given 'pattern' element.\r
9410      */\r
9411     SVGAnimatedLength getWidth();\r
9412 \r
9413     /**\r
9414      * Corresponds to attribute height on the given 'pattern' element.\r
9415      */\r
9416     SVGAnimatedLength getHeight();\r
9417 \r
9418 \r
9419     //####################################################################\r
9420     //# SVGPolyLineElement\r
9421     //####################################################################\r
9422 \r
9423     //####################################################################\r
9424     //# SVGPolygonElement\r
9425     //####################################################################\r
9426 \r
9427     //####################################################################\r
9428     //# SVGMissingGlyphElement\r
9429     //####################################################################\r
9430 \r
9431     /**\r
9432      * Corresponds to attribute pathLength on the given 'path' element.\r
9433      */\r
9434     SVGAnimatedNumber getPathLength();\r
9435 \r
9436     /**\r
9437      * Returns the user agent's computed value for the total length of the path using\r
9438      * the user agent's distance-along-a-path algorithm, as a distance in the current\r
9439      * user coordinate system.\r
9440      */\r
9441     double getTotalLength();\r
9442 \r
9443     /**\r
9444      * Returns the(x,y) coordinate in user space which is distance units along the\r
9445      * path, utilizing the user agent's distance-along-a-path algorithm.\r
9446      */\r
9447     SVGPoint getPointAtLength(double distance);\r
9448 \r
9449     /**\r
9450      * Returns the index into pathSegList which is distance units along the path,\r
9451      * utilizing the user agent's distance-along-a-path algorithm.\r
9452      */\r
9453     unsigned long getPathSegAtLength(double distance);\r
9454 \r
9455     /**\r
9456      * Returns a stand-alone, parentless SVGPathSegClosePath object.\r
9457      */\r
9458     SVGPathSegClosePath\r
9459               createSVGPathSegClosePath();\r
9460 \r
9461     /**\r
9462      * Returns a stand-alone, parentless SVGPathSegMovetoAbs object.\r
9463      */\r
9464     SVGPathSegMovetoAbs\r
9465               createSVGPathSegMovetoAbs(double x, double y);\r
9466 \r
9467     /**\r
9468      * Returns a stand-alone, parentless SVGPathSegMovetoRel object.\r
9469      */\r
9470     SVGPathSegMovetoRel\r
9471               createSVGPathSegMovetoRel(double x, double y);\r
9472 \r
9473     /**\r
9474      * Returns a stand-alone, parentless SVGPathSegLinetoAbs object.\r
9475      */\r
9476     SVGPathSegLinetoAbs\r
9477               createSVGPathSegLinetoAbs(double x, double y);\r
9478 \r
9479     /**\r
9480      * Returns a stand-alone, parentless SVGPathSegLinetoRel object.\r
9481      */\r
9482     SVGPathSegLinetoRel\r
9483               createSVGPathSegLinetoRel(double x, double y);\r
9484 \r
9485     /**\r
9486      * Returns a stand-alone, parentless SVGPathSegCurvetoCubicAbs object.\r
9487      */\r
9488     SVGPathSegCurvetoCubicAbs\r
9489               createSVGPathSegCurvetoCubicAbs(double x, double y,\r
9490                         double x1, double y1, double x2, double y2);\r
9491 \r
9492     /**\r
9493      * Returns a stand-alone, parentless SVGPathSegCurvetoCubicRel object.\r
9494      */\r
9495     SVGPathSegCurvetoCubicRel\r
9496               createSVGPathSegCurvetoCubicRel(double x, double y,\r
9497                         double x1, double y1, double x2, double y2);\r
9498 \r
9499     /**\r
9500      * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticAbs object.\r
9501      */\r
9502     SVGPathSegCurvetoQuadraticAbs\r
9503               createSVGPathSegCurvetoQuadraticAbs(double x, double y,\r
9504                          double x1, double y1);\r
9505 \r
9506     /**\r
9507      * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticRel object.\r
9508      */\r
9509     SVGPathSegCurvetoQuadraticRel\r
9510               createSVGPathSegCurvetoQuadraticRel(double x, double y,\r
9511                          double x1, double y1);\r
9512 \r
9513     /**\r
9514      * Returns a stand-alone, parentless SVGPathSegArcAbs object.\r
9515      */\r
9516     SVGPathSegArcAbs\r
9517               createSVGPathSegArcAbs(double x, double y,\r
9518                          double r1, double r2, double angle,\r
9519                          bool largeArcFlag, bool sweepFlag);\r
9520 \r
9521     /**\r
9522      * Returns a stand-alone, parentless SVGPathSegArcRel object.\r
9523      */\r
9524     SVGPathSegArcRel\r
9525               createSVGPathSegArcRel(double x, double y, double r1,\r
9526                          double r2, double angle, bool largeArcFlag,\r
9527                          bool sweepFlag);\r
9528 \r
9529     /**\r
9530      * Returns a stand-alone, parentless SVGPathSegLinetoHorizontalAbs object.\r
9531      */\r
9532     SVGPathSegLinetoHorizontalAbs\r
9533               createSVGPathSegLinetoHorizontalAbs(double x);\r
9534 \r
9535     /**\r
9536      * Returns a stand-alone, parentless SVGPathSegLinetoHorizontalRel object.\r
9537      */\r
9538     SVGPathSegLinetoHorizontalRel\r
9539               createSVGPathSegLinetoHorizontalRel(double x);\r
9540 \r
9541     /**\r
9542      * Returns a stand-alone, parentless SVGPathSegLinetoVerticalAbs object.\r
9543      */\r
9544     SVGPathSegLinetoVerticalAbs\r
9545               createSVGPathSegLinetoVerticalAbs(double y);\r
9546 \r
9547     /**\r
9548      * Returns a stand-alone, parentless SVGPathSegLinetoVerticalRel object.\r
9549      */\r
9550     SVGPathSegLinetoVerticalRel\r
9551               createSVGPathSegLinetoVerticalRel(double y);\r
9552 \r
9553     /**\r
9554      * Returns a stand-alone, parentless SVGPathSegCurvetoCubicSmoothAbs object.\r
9555      */\r
9556     SVGPathSegCurvetoCubicSmoothAbs\r
9557               createSVGPathSegCurvetoCubicSmoothAbs(double x, double y,\r
9558                                              double x2, double y2);\r
9559 \r
9560     /**\r
9561      * Returns a stand-alone, parentless SVGPathSegCurvetoCubicSmoothRel object.\r
9562      */\r
9563     SVGPathSegCurvetoCubicSmoothRel\r
9564               createSVGPathSegCurvetoCubicSmoothRel(double x, double y,\r
9565                                                       double x2, double y2);\r
9566 \r
9567     /**\r
9568      * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticSmoothAbs\r
9569      *      object.\r
9570      */\r
9571     SVGPathSegCurvetoQuadraticSmoothAbs\r
9572               createSVGPathSegCurvetoQuadraticSmoothAbs(double x, double y);\r
9573 \r
9574     /**\r
9575      * Returns a stand-alone, parentless SVGPathSegCurvetoQuadraticSmoothRel\r
9576      *      object.\r
9577      */\r
9578     SVGPathSegCurvetoQuadraticSmoothRel\r
9579               createSVGPathSegCurvetoQuadraticSmoothRel(double x, double y);\r
9580 \r
9581 \r
9582     //####################################################################\r
9583     //# SVGRadialGradientElement\r
9584     //####################################################################\r
9585 \r
9586 \r
9587     /**\r
9588      * Corresponds to attribute cx on the given 'radialGradient'  element.\r
9589      */\r
9590     SVGAnimatedLength getCx();\r
9591 \r
9592 \r
9593     /**\r
9594      * Corresponds to attribute cy on the given 'radialGradient'  element.\r
9595      */\r
9596     SVGAnimatedLength getCy();\r
9597 \r
9598 \r
9599     /**\r
9600      * Corresponds to attribute r on the given 'radialGradient'  element.\r
9601      */\r
9602     SVGAnimatedLength getR();\r
9603 \r
9604 \r
9605     /**\r
9606      * Corresponds to attribute fx on the given 'radialGradient'  element.\r
9607      */\r
9608     SVGAnimatedLength getFx();\r
9609 \r
9610 \r
9611     /**\r
9612      * Corresponds to attribute fy on the given 'radialGradient'  element.\r
9613      */\r
9614     SVGAnimatedLength getFy();\r
9615 \r
9616 \r
9617     //####################################################################\r
9618     //# SVGRectElement\r
9619     //####################################################################\r
9620 \r
9621     /**\r
9622      * Corresponds to attribute x on the given 'rect' element.\r
9623      */\r
9624     SVGAnimatedLength getX();\r
9625 \r
9626     /**\r
9627      * Corresponds to attribute y on the given 'rect' element.\r
9628      */\r
9629     SVGAnimatedLength getY();\r
9630 \r
9631     /**\r
9632      * Corresponds to attribute width on the given 'rect' element.\r
9633      */\r
9634     SVGAnimatedLength getWidth();\r
9635 \r
9636     /**\r
9637      * Corresponds to attribute height on the given 'rect' element.\r
9638      */\r
9639     SVGAnimatedLength getHeight();\r
9640 \r
9641 \r
9642     /**\r
9643      * Corresponds to attribute rx on the given 'rect' element.\r
9644      */\r
9645     SVGAnimatedLength getRx();\r
9646 \r
9647     /**\r
9648      * Corresponds to attribute ry on the given 'rect' element.\r
9649      */\r
9650     SVGAnimatedLength getRy();\r
9651 \r
9652 \r
9653     //####################################################################\r
9654     //# SVGScriptElement\r
9655     //####################################################################\r
9656 \r
9657     /**\r
9658      *\r
9659      */\r
9660     DOMString getType();\r
9661 \r
9662     /**\r
9663      *\r
9664      */\r
9665     void setType(const DOMString &val) throw (DOMException);\r
9666 \r
9667     //####################################################################\r
9668     //# SVGSetElement\r
9669     //####################################################################\r
9670 \r
9671     //####################################################################\r
9672     //# SVGStopElement\r
9673     //####################################################################\r
9674 \r
9675 \r
9676     /**\r
9677      * Corresponds to attribute offset on the given 'stop' element.\r
9678      */\r
9679     SVGAnimatedNumber getOffset();\r
9680 \r
9681 \r
9682     //####################################################################\r
9683     //# SVGStyleElement\r
9684     //####################################################################\r
9685 \r
9686     /**\r
9687      * Get the attribute xml:space on the given element.\r
9688      */\r
9689     DOMString getXmlspace();\r
9690 \r
9691     /**\r
9692      * Set the attribute xml:space on the given element.\r
9693      */\r
9694     void setXmlspace(const DOMString &val) throw (DOMException);\r
9695 \r
9696     /**\r
9697      * Get the attribute type on the given 'style' element.\r
9698      */\r
9699     DOMString getType();\r
9700 \r
9701     /**\r
9702      * Set the attribute type on the given 'style' element.\r
9703      */\r
9704     void setType(const DOMString &val) throw (DOMException);\r
9705 \r
9706     /**\r
9707      * Get the attribute media on the given 'style' element.\r
9708      */\r
9709     DOMString getMedia();\r
9710 \r
9711     /**\r
9712      * Set the attribute media on the given 'style' element.\r
9713      */\r
9714     void setMedia(const DOMString &val) throw (DOMException);\r
9715 \r
9716     /**\r
9717      * Get the attribute title on the given 'style' element.\r
9718      */\r
9719     DOMString getTitle();\r
9720 \r
9721     /**\r
9722      * Set the attribute title on the given 'style' element.\r
9723      */\r
9724     void setTitle(const DOMString &val) throw (DOMException);\r
9725 \r
9726     //####################################################################\r
9727     //# SVGSymbolElement\r
9728     //####################################################################\r
9729 \r
9730     //####################################################################\r
9731     //# SVGSVGElement\r
9732     //####################################################################\r
9733 \r
9734     /**\r
9735      * Corresponds to attribute x on the given 'svg' element.\r
9736      */\r
9737     SVGAnimatedLength getX();\r
9738 \r
9739     /**\r
9740      * Corresponds to attribute y on the given 'svg' element.\r
9741      */\r
9742     SVGAnimatedLength getY();\r
9743 \r
9744     /**\r
9745      * Corresponds to attribute width on the given 'svg' element.\r
9746      */\r
9747     SVGAnimatedLength getWidth();\r
9748 \r
9749     /**\r
9750      * Corresponds to attribute height on the given 'svg' element.\r
9751      */\r
9752     SVGAnimatedLength getHeight();\r
9753 \r
9754     /**\r
9755      * Get the attribute contentScriptType on the given 'svg' element.\r
9756      */\r
9757     DOMString getContentScriptType();\r
9758 \r
9759     /**\r
9760      * Set the attribute contentScriptType on the given 'svg' element.\r
9761      */\r
9762     void setContentScriptType(const DOMString &val) throw (DOMException);\r
9763 \r
9764 \r
9765     /**\r
9766      * Get the attribute contentStyleType on the given 'svg' element.\r
9767      */\r
9768     DOMString getContentStyleType();\r
9769 \r
9770     /**\r
9771      * Set the attribute contentStyleType on the given 'svg' element.\r
9772      */\r
9773     void setContentStyleType(const DOMString &val) throw (DOMException);\r
9774 \r
9775     /**\r
9776      * The position and size of the viewport(implicit or explicit) that corresponds\r
9777      * to this 'svg' element. When the user agent is actually rendering the content,\r
9778      * then the position and size values represent the actual values when rendering.\r
9779      * The position and size values are unitless values in the coordinate system of\r
9780      * the parent element. If no parent element exists(i.e., 'svg' element\r
9781      * represents the root of the document tree), if this SVG document is embedded as\r
9782      * part of another document(e.g., via the HTML 'object' element), then the\r
9783      * position and size are unitless values in the coordinate system of the parent\r
9784      * document.(If the parent uses CSS or XSL layout, then unitless values\r
9785      * represent pixel units for the current CSS or XSL viewport, as described in the\r
9786      * CSS2 specification.) If the parent element does not have a coordinate system,\r
9787      * then the user agent should provide reasonable default values for this attribute.\r
9788      *      */\r
9789     SVGRect getViewport();\r
9790 \r
9791     /**\r
9792      * Size of a pixel units(as defined by CSS2) along the x-axis of the viewport,\r
9793      * which represents a unit somewhere in the range of 70dpi to 120dpi, and, on\r
9794      * systems that support this, might actually match the characteristics of the\r
9795      * target medium. On systems where it is impossible to know the size of a pixel,\r
9796      * a suitable default pixel size is provided.\r
9797      */\r
9798     double getPixelUnitToMillimeterX();\r
9799 \r
9800     /**\r
9801      * Corresponding size of a pixel unit along the y-axis of the viewport.\r
9802      */\r
9803     double getPixelUnitToMillimeterY();\r
9804 \r
9805     /**\r
9806      * User interface(UI) events in DOM Level 2 indicate the screen positions at\r
9807      * which the given UI event occurred. When the user agent actually knows the\r
9808      * physical size of a "screen unit", this attribute will express that information;\r
9809      *  otherwise, user agents will provide a suitable default value such as .28mm.\r
9810      */\r
9811     double getScreenPixelToMillimeterX();\r
9812 \r
9813     /**\r
9814      * Corresponding size of a screen pixel along the y-axis of the viewport.\r
9815      */\r
9816     double getScreenPixelToMillimeterY();\r
9817 \r
9818 \r
9819     /**\r
9820      * The initial view(i.e., before magnification and panning) of the current\r
9821      * innermost SVG document fragment can be either the "standard" view(i.e., based\r
9822      * on attributes on the 'svg' element such as fitBoxToViewport) or to a "custom"\r
9823      * view(i.e., a hyperlink into a particular 'view' or other element - see\r
9824      * Linking into SVG content: URI fragments and SVG views). If the initial view is\r
9825      * the "standard" view, then this attribute is false. If the initial view is a\r
9826      * "custom" view, then this attribute is true.\r
9827      */\r
9828     bool getUseCurrentView();\r
9829 \r
9830     /**\r
9831      * Set the value above\r
9832      */\r
9833     void setUseCurrentView(bool val) throw (DOMException);\r
9834 \r
9835     /**\r
9836      * The definition of the initial view(i.e., before magnification and panning) of\r
9837      * the current innermost SVG document fragment. The meaning depends on the\r
9838      * situation:\r
9839      * \r
9840      *    * If the initial view was a "standard" view, then:\r
9841      *      o the values for viewBox, preserveAspectRatio and zoomAndPan within\r
9842      *        currentView will match the values for the corresponding DOM attributes that\r
9843      *        are on SVGSVGElement directly\r
9844      *      o the values for transform and viewTarget within currentView will be null\r
9845      *    * If the initial view was a link into a 'view' element, then:\r
9846      *      o the values for viewBox, preserveAspectRatio and zoomAndPan within\r
9847      *        currentView will correspond to the corresponding attributes for the given\r
9848      *        'view' element\r
9849      *      o the values for transform and viewTarget within currentView will be null\r
9850      *    * If the initial view was a link into another element(i.e., other than a\r
9851      *      'view'), then:\r
9852      *      o the values for viewBox, preserveAspectRatio and zoomAndPan within\r
9853      *        currentView will match the values for the corresponding DOM attributes that\r
9854      *        are on SVGSVGElement directly for the closest ancestor 'svg' element\r
9855      *      o the values for transform within currentView will be null\r
9856      *      o the viewTarget within currentView will represent the target of the link\r
9857      *    * If the initial view was a link into the SVG document fragment using an SVG\r
9858      *      view specification fragment identifier(i.e., #svgView(...)), then:\r
9859      *      o the values for viewBox, preserveAspectRatio, zoomAndPan, transform and\r
9860      *        viewTarget within currentView will correspond to the values from the SVG view\r
9861      *        specification fragment identifier\r
9862      * \r
9863      */\r
9864     SVGViewSpec getCurrentView();\r
9865 \r
9866 \r
9867     /**\r
9868      * This attribute indicates the current scale factor relative to the initial view\r
9869      * to take into account user magnification and panning operations, as described\r
9870      * under Magnification and panning. DOM attributes currentScale and\r
9871      * currentTranslate are equivalent to the 2x3 matrix [a b c d e f] =\r
9872      * [currentScale 0 0 currentScale currentTranslate.x currentTranslate.y]. If\r
9873      * "magnification" is enabled(i.e., zoomAndPan="magnify"), then the effect is as\r
9874      * if an extra transformation were placed at the outermost level on the SVG\r
9875      * document fragment(i.e., outside the outermost 'svg' element).\r
9876      */\r
9877     double getCurrentScale();\r
9878 \r
9879     /**\r
9880      *  Set the value above.\r
9881      */\r
9882     void setCurrentScale(double val) throw (DOMException);\r
9883 \r
9884     /**\r
9885      * The corresponding translation factor that takes into account\r
9886      *      user "magnification".\r
9887      */\r
9888     SVGPoint getCurrentTranslate();\r
9889 \r
9890     /**\r
9891      * Takes a time-out value which indicates that redraw shall not occur until:(a)\r
9892      * the corresponding unsuspendRedraw(suspend_handle_id) call has been made,(b)\r
9893      * an unsuspendRedrawAll() call has been made, or(c) its timer has timed out. In\r
9894      * environments that do not support interactivity(e.g., print media), then\r
9895      * redraw shall not be suspended. suspend_handle_id =\r
9896      * suspendRedraw(max_wait_milliseconds) and unsuspendRedraw(suspend_handle_id)\r
9897      * must be packaged as balanced pairs. When you want to suspend redraw actions as\r
9898      * a collection of SVG DOM changes occur, then precede the changes to the SVG DOM\r
9899      * with a method call similar to suspend_handle_id =\r
9900      * suspendRedraw(max_wait_milliseconds) and follow the changes with a method call\r
9901      * similar to unsuspendRedraw(suspend_handle_id). Note that multiple\r
9902      * suspendRedraw calls can be used at once and that each such method call is\r
9903      * treated independently of the other suspendRedraw method calls.\r
9904      */\r
9905     unsigned long suspendRedraw(unsigned long max_wait_milliseconds);\r
9906 \r
9907     /**\r
9908      * Cancels a specified suspendRedraw() by providing a unique suspend_handle_id.\r
9909      */\r
9910     void unsuspendRedraw(unsigned long suspend_handle_id) throw (DOMException);\r
9911 \r
9912     /**\r
9913      * Cancels all currently active suspendRedraw() method calls. This method is most\r
9914      * useful at the very end of a set of SVG DOM calls to ensure that all pending\r
9915      * suspendRedraw() method calls have been cancelled.\r
9916      */\r
9917     void unsuspendRedrawAll();\r
9918 \r
9919     /**\r
9920      * In rendering environments supporting interactivity, forces the user agent to\r
9921      * immediately redraw all regions of the viewport that require updating.\r
9922      */\r
9923     void forceRedraw();\r
9924 \r
9925     /**\r
9926      * Suspends(i.e., pauses) all currently running animations that are defined\r
9927      * within the SVG document fragment corresponding to this 'svg' element, causing\r
9928      * the animation clock corresponding to this document fragment to stand still\r
9929      * until it is unpaused.\r
9930      */\r
9931     void pauseAnimations();\r
9932 \r
9933     /**\r
9934      * Unsuspends(i.e., unpauses) currently running animations that are defined\r
9935      * within the SVG document fragment, causing the animation clock to continue from\r
9936      * the time at which it was suspended.\r
9937      */\r
9938     void unpauseAnimations();\r
9939 \r
9940     /**\r
9941      * Returns true if this SVG document fragment is in a paused state.\r
9942      */\r
9943     bool animationsPaused();\r
9944 \r
9945     /**\r
9946      * Returns the current time in seconds relative to the start time for\r
9947      *      the current SVG document fragment.\r
9948      */\r
9949     double getCurrentTime();\r
9950 \r
9951     /**\r
9952      * Adjusts the clock for this SVG document fragment, establishing\r
9953      *      a new current time.\r
9954      */\r
9955     void setCurrentTime(double seconds);\r
9956 \r
9957     /**\r
9958      * Returns the list of graphics elements whose rendered content intersects the\r
9959      * supplied rectangle, honoring the 'pointer-events' property value on each\r
9960      * candidate graphics element.\r
9961      */\r
9962     NodeList getIntersectionList(const SVGRect &rect,\r
9963                                  const SVGElementPtr referenceElement);\r
9964 \r
9965     /**\r
9966      * Returns the list of graphics elements whose rendered content is entirely\r
9967      * contained within the supplied rectangle, honoring the 'pointer-events'\r
9968      * property value on each candidate graphics element.\r
9969      */\r
9970     NodeList getEnclosureList(const SVGRect &rect,\r
9971                               const SVGElementPtr referenceElement);\r
9972 \r
9973     /**\r
9974      * Returns true if the rendered content of the given element intersects the\r
9975      * supplied rectangle, honoring the 'pointer-events' property value on each\r
9976      * candidate graphics element.\r
9977      */\r
9978     bool checkIntersection(const SVGElementPtr element, const SVGRect &rect);\r
9979 \r
9980     /**\r
9981      * Returns true if the rendered content of the given element is entirely\r
9982      * contained within the supplied rectangle, honoring the 'pointer-events'\r
9983      * property value on each candidate graphics element.\r
9984      */\r
9985     bool checkEnclosure(const SVGElementPtr element, const SVGRect &rect);\r
9986 \r
9987     /**\r
9988      * Unselects any selected objects, including any selections of text\r
9989      *      strings and type-in bars.\r
9990      */\r
9991     void deselectAll();\r
9992 \r
9993     /**\r
9994      * Creates an SVGNumber object outside of any document trees. The object\r
9995      *      is initialized to a value of zero.\r
9996      */\r
9997     SVGNumber createSVGNumber();\r
9998 \r
9999     /**\r
10000      * Creates an SVGLength object outside of any document trees. The object\r
10001      *      is initialized to the value of 0 user units.\r
10002      */\r
10003     SVGLength createSVGLength();\r
10004 \r
10005     /**\r
10006      * Creates an SVGAngle object outside of any document trees. The object\r
10007      *      is initialized to the value 0 degrees(unitless).\r
10008      */\r
10009     SVGAngle createSVGAngle();\r
10010 \r
10011     /**\r
10012      * Creates an SVGPoint object outside of any document trees. The object\r
10013      * is initialized to the point(0,0) in the user coordinate system.\r
10014      */\r
10015     SVGPoint createSVGPoint();\r
10016 \r
10017     /**\r
10018      * Creates an SVGMatrix object outside of any document trees. The object\r
10019      *      is initialized to the identity matrix.\r
10020      */\r
10021     SVGMatrix createSVGMatrix();\r
10022 \r
10023     /**\r
10024      * Creates an SVGRect object outside of any document trees. The object\r
10025      *      is initialized such that all values are set to 0 user units.\r
10026      */\r
10027     SVGRect createSVGRect();\r
10028 \r
10029     /**\r
10030      * Creates an SVGTransform object outside of any document trees.\r
10031      * The object is initialized to an identity matrix transform\r
10032      *     (SVG_TRANSFORM_MATRIX).\r
10033      */\r
10034     SVGTransform createSVGTransform();\r
10035 \r
10036     /**\r
10037      * Creates an SVGTransform object outside of any document trees.\r
10038      * The object is initialized to the given matrix transform\r
10039      *     (i.e., SVG_TRANSFORM_MATRIX).\r
10040      */\r
10041     SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix);\r
10042 \r
10043     /**\r
10044      * Searches this SVG document fragment(i.e., the search is restricted to a\r
10045      * subset of the document tree) for an Element whose id is given by elementId. If\r
10046      * an Element is found, that Element is returned. If no such element exists,\r
10047      * returns null. Behavior is not defined if more than one element has this id.\r
10048      */\r
10049     ElementPtr getElementById(const DOMString& elementId);\r
10050 \r
10051 \r
10052     //####################################################################\r
10053     //# SVGTextElement\r
10054     //####################################################################\r
10055 \r
10056 \r
10057     //####################################################################\r
10058     //# SVGTextContentElement\r
10059     //####################################################################\r
10060 \r
10061 \r
10062     /**\r
10063      * lengthAdjust Types\r
10064      */\r
10065     typedef enum\r
10066         {\r
10067         LENGTHADJUST_UNKNOWN          = 0,\r
10068         LENGTHADJUST_SPACING          = 1,\r
10069         LENGTHADJUST_SPACINGANDGLYPHS = 2\r
10070         } LengthAdjustType;\r
10071 \r
10072 \r
10073     /**\r
10074      * Corresponds to attribute textLength on the given element.\r
10075      */\r
10076     SVGAnimatedLength getTextLength();\r
10077 \r
10078 \r
10079     /**\r
10080      * Corresponds to attribute lengthAdjust on the given element. The value must be\r
10081      * one of the length adjust constants specified above.\r
10082      */\r
10083     SVGAnimatedEnumeration getLengthAdjust();\r
10084 \r
10085 \r
10086     /**\r
10087      * Returns the total number of characters to be rendered within the current\r
10088      * element. Includes characters which are included via a 'tref' reference.\r
10089      */\r
10090     long getNumberOfChars();\r
10091 \r
10092     /**\r
10093      * The total sum of all of the advance values from rendering all of the\r
10094      * characters within this element, including the advance value on the glyphs\r
10095      *(horizontal or vertical), the effect of properties 'kerning', 'letter-spacing'\r
10096      * and 'word-spacing' and adjustments due to attributes dx and dy on 'tspan'\r
10097      * elements. For non-rendering environments, the user agent shall make reasonable\r
10098      * assumptions about glyph metrics.\r
10099      */\r
10100     double getComputedTextLength();\r
10101 \r
10102     /**\r
10103      * The total sum of all of the advance values from rendering the specified\r
10104      * substring of the characters, including the advance value on the glyphs\r
10105      *(horizontal or vertical), the effect of properties 'kerning', 'letter-spacing'\r
10106      * and 'word-spacing' and adjustments due to attributes dx and dy on 'tspan'\r
10107      * elements. For non-rendering environments, the user agent shall make reasonable\r
10108      * assumptions about glyph metrics.\r
10109      */\r
10110     double getSubStringLength(unsigned long charnum, unsigned long nchars)\r
10111                                      throw (DOMException);\r
10112 \r
10113     /**\r
10114      * Returns the current text position before rendering the character in the user\r
10115      * coordinate system for rendering the glyph(s) that correspond to the specified\r
10116      * character. The current text position has already taken into account the\r
10117      * effects of any inter-character adjustments due to properties 'kerning',\r
10118      * 'letter-spacing' and 'word-spacing' and adjustments due to attributes x, y, dx\r
10119      * and dy. If multiple consecutive characters are rendered inseparably(e.g., as\r
10120      * a single glyph or a sequence of glyphs), then each of the inseparable\r
10121      * characters will return the start position for the first glyph.\r
10122      */\r
10123     SVGPoint getStartPositionOfChar(unsigned long charnum) throw (DOMException);\r
10124 \r
10125     /**\r
10126      * Returns the current text position after rendering the character in the user\r
10127      * coordinate system for rendering the glyph(s) that correspond to the specified\r
10128      * character. This current text position does not take into account the effects\r
10129      * of any inter-character adjustments to prepare for the next character, such as\r
10130      * properties 'kerning', 'letter-spacing' and 'word-spacing' and adjustments due\r
10131      * to attributes x, y, dx and dy. If multiple consecutive characters are rendered\r
10132      * inseparably(e.g., as a single glyph or a sequence of glyphs), then each of\r
10133      * the inseparable characters will return the end position for the last glyph.\r
10134      */\r
10135     SVGPoint getEndPositionOfChar(unsigned long charnum) throw (DOMException);\r
10136 \r
10137     /**\r
10138      * Returns a tightest rectangle which defines the minimum and maximum X and Y\r
10139      * values in the user coordinate system for rendering the glyph(s) that\r
10140      * correspond to the specified character. The calculations assume that all glyphs\r
10141      * occupy the full standard glyph cell for the font. If multiple consecutive\r
10142      * characters are rendered inseparably(e.g., as a single glyph or a sequence of\r
10143      * glyphs), then each of the inseparable characters will return the same extent.\r
10144      */\r
10145     SVGRect getExtentOfChar(unsigned long charnum) throw (DOMException);\r
10146 \r
10147     /**\r
10148      * Returns the rotation value relative to the current user coordinate system used\r
10149      * to render the glyph(s) corresponding to the specified character. If multiple\r
10150      * glyph(s) are used to render the given character and the glyphs each have\r
10151      * different rotations(e.g., due to text-on-a-path), the user agent shall return\r
10152      * an average value(e.g., the rotation angle at the midpoint along the path for\r
10153      * all glyphs used to render this character). The rotation value represents the\r
10154      * rotation that is supplemental to any rotation due to properties\r
10155      * 'glyph-orientation-horizontal' and 'glyph-orientation-vertical'; thus, any\r
10156      * glyph rotations due to these properties are not included into the returned\r
10157      * rotation value. If multiple consecutive characters are rendered inseparably\r
10158      *(e.g., as a single glyph or a sequence of glyphs), then each of the\r
10159      * inseparable characters will return the same rotation value.\r
10160      */\r
10161     double getRotationOfChar(unsigned long charnum) throw (DOMException);\r
10162 \r
10163     /**\r
10164      * Returns the index of the character whose corresponding glyph cell bounding box\r
10165      * contains the specified point. The calculations assume that all glyphs occupy\r
10166      * the full standard glyph cell for the font. If no such character exists, a\r
10167      * value of -1 is returned. If multiple such characters exist, the character\r
10168      * within the element whose glyphs were rendered last(i.e., take into account\r
10169      * any reordering such as for bidirectional text) is used. If multiple\r
10170      * consecutive characters are rendered inseparably(e.g., as a single glyph or a\r
10171      * sequence of glyphs), then the user agent shall allocate an equal percentage of\r
10172      * the text advance amount to each of the contributing characters in determining\r
10173      * which of the characters is chosen.\r
10174      */\r
10175     long getCharNumAtPosition(const SVGPoint &point);\r
10176 \r
10177     /**\r
10178      * Causes the specified substring to be selected just as if the user\r
10179      *      selected the substring interactively.\r
10180      */\r
10181     void selectSubString(unsigned long charnum, unsigned long nchars)\r
10182                                   throw (DOMException);\r
10183 \r
10184 \r
10185 \r
10186 \r
10187 \r
10188     //####################################################################\r
10189     //# SVGTextPathElement\r
10190     //####################################################################\r
10191 \r
10192 \r
10193     /**\r
10194      * textPath Method Types\r
10195      */\r
10196     typedef enum\r
10197         {\r
10198         TEXTPATH_METHODTYPE_UNKNOWN   = 0,\r
10199         TEXTPATH_METHODTYPE_ALIGN     = 1,\r
10200         TEXTPATH_METHODTYPE_STRETCH   = 2\r
10201         } TextPathMethodType;\r
10202 \r
10203     /**\r
10204      * textPath Spacing Types\r
10205      */\r
10206     typedef enum\r
10207         {\r
10208         TEXTPATH_SPACINGTYPE_UNKNOWN  = 0,\r
10209         TEXTPATH_SPACINGTYPE_AUTO     = 1,\r
10210         TEXTPATH_SPACINGTYPE_EXACT    = 2\r
10211         } TextPathSpacingType;\r
10212 \r
10213 \r
10214     /**\r
10215      * Corresponds to attribute startOffset on the given 'textPath' element.\r
10216      */\r
10217     SVGAnimatedLength getStartOffset();\r
10218 \r
10219     /**\r
10220      * Corresponds to attribute method on the given 'textPath' element. The value\r
10221      * must be one of the method type constants specified above.\r
10222      */\r
10223     SVGAnimatedEnumeration getMethod();\r
10224 \r
10225     /**\r
10226      * Corresponds to attribute spacing on the given 'textPath' element.\r
10227      *  The value must be one of the spacing type constants specified above.\r
10228      */\r
10229     SVGAnimatedEnumeration getSpacing();\r
10230 \r
10231 \r
10232     //####################################################################\r
10233     //# SVGTextPositioningElement\r
10234     //####################################################################\r
10235 \r
10236 \r
10237     /**\r
10238      * Corresponds to attribute x on the given element.\r
10239      */\r
10240     SVGAnimatedLength getX();\r
10241 \r
10242     /**\r
10243      * Corresponds to attribute y on the given element.\r
10244      */\r
10245     SVGAnimatedLength getY();\r
10246 \r
10247     /**\r
10248      * Corresponds to attribute dx on the given element.\r
10249      */\r
10250     SVGAnimatedLength getDx();\r
10251 \r
10252     /**\r
10253      * Corresponds to attribute dy on the given element.\r
10254      */\r
10255     SVGAnimatedLength getDy();\r
10256 \r
10257 \r
10258     /**\r
10259      * Corresponds to attribute rotate on the given element.\r
10260      */\r
10261     SVGAnimatedNumberList getRotate();\r
10262 \r
10263 \r
10264     //####################################################################\r
10265     //# SVGTitleElement\r
10266     //####################################################################\r
10267 \r
10268     //####################################################################\r
10269     //# SVGTRefElement\r
10270     //####################################################################\r
10271 \r
10272     //####################################################################\r
10273     //# SVGTSpanElement\r
10274     //####################################################################\r
10275 \r
10276     //####################################################################\r
10277     //# SVGSwitchElement\r
10278     //####################################################################\r
10279 \r
10280     //####################################################################\r
10281     //# SVGUseElement\r
10282     //####################################################################\r
10283 \r
10284     /**\r
10285      * Corresponds to attribute x on the given 'use' element.\r
10286      */\r
10287     SVGAnimatedLength getX();\r
10288 \r
10289     /**\r
10290      * Corresponds to attribute y on the given 'use' element.\r
10291      */\r
10292     SVGAnimatedLength getY();\r
10293 \r
10294     /**\r
10295      * Corresponds to attribute width on the given 'use' element.\r
10296      */\r
10297     SVGAnimatedLength getWidth();\r
10298 \r
10299     /**\r
10300      * Corresponds to attribute height on the given 'use' element.\r
10301      */\r
10302     SVGAnimatedLength getHeight();\r
10303 \r
10304     /**\r
10305      * The root of the "instance tree". See description of SVGElementInstance for\r
10306      * a discussion on the instance tree.\r
10307      *      */\r
10308     SVGElementInstance getInstanceRoot();\r
10309 \r
10310     /**\r
10311      * If the 'href' attribute is being animated, contains the current animated root\r
10312      * of the "instance tree". If the 'href' attribute is not currently being\r
10313      * animated, contains the same value as 'instanceRoot'. The root of the "instance\r
10314      * tree". See description of SVGElementInstance for a discussion on the instance\r
10315      * tree.\r
10316      */\r
10317     SVGElementInstance getAnimatedInstanceRoot();\r
10318 \r
10319     //####################################################################\r
10320     //# SVGVKernElement\r
10321     //####################################################################\r
10322 \r
10323     //####################################################################\r
10324     //# SVGViewElement\r
10325     //####################################################################\r
10326 \r
10327 \r
10328     /**\r
10329      *\r
10330      */\r
10331     SVGStringList getViewTarget();\r
10332 \r
10333 \r
10334 \r
10335 \r
10336     //##################\r
10337     //# Non-API methods\r
10338     //##################\r
10339 \r
10340 \r
10341     /**\r
10342      *\r
10343      */\r
10344     ~SVGElement() {}\r
10345 \r
10346 \r
10347 };\r
10348 \r
10349 \r
10350 \r
10351 /*#########################################################################\r
10352 ## SVGDocument\r
10353 #########################################################################*/\r
10354 \r
10355 /**\r
10356  * When an 'svg' element is embedded inline as a component of a document from\r
10357  * another namespace, such as when an 'svg' element is embedded inline within an\r
10358  * XHTML document [XHTML], then an SVGDocument object will not exist; instead,\r
10359  * the root object in the document object hierarchy will be a Document object of\r
10360  * a different type, such as an HTMLDocument object.\r
10361  *\r
10362  * However, an SVGDocument object will indeed exist when the root element of the\r
10363  * XML document hierarchy is an 'svg' element, such as when viewing a stand-alone\r
10364  * SVG file(i.e., a file with MIME type "image/svg+xml"). In this case, the\r
10365  * SVGDocument object will be the root object of the document object model\r
10366  * hierarchy.\r
10367  *\r
10368  * In the case where an SVG document is embedded by reference, such as when an\r
10369  * XHTML document has an 'object' element whose href attribute references an SVG\r
10370  * document(i.e., a document whose MIME type is "image/svg+xml" and whose root\r
10371  * element is thus an 'svg' element), there will exist two distinct DOM\r
10372  * hierarchies. The first DOM hierarchy will be for the referencing document\r
10373  *(e.g., an XHTML document). The second DOM hierarchy will be for the referenced\r
10374  * SVG document. In this second DOM hierarchy, the root object of the document\r
10375  * object model hierarchy is an SVGDocument object.\r
10376  */\r
10377 class SVGDocument : public Document,\r
10378                     public events::DocumentEvent\r
10379 {\r
10380 public:\r
10381 \r
10382 \r
10383     /**\r
10384      * The title of a document as specified by the title sub-element of the 'svg'\r
10385      * root element(i.e., <svg><title>Here is the title</title>...</svg>)\r
10386      */\r
10387     DOMString getTitle();\r
10388 \r
10389     /**\r
10390      * Returns the URI of the page that linked to this page. The value is an empty\r
10391      * string if the user navigated to the page directly(not through a link, but,\r
10392      * for example, via a bookmark).\r
10393      */\r
10394     DOMString getReferrer();\r
10395 \r
10396     /**\r
10397      * The domain name of the server that served the document, or a null string if\r
10398      * the server cannot be identified by a domain name.\r
10399      */\r
10400     DOMString getDomain();\r
10401 \r
10402     /**\r
10403      * The complete URI of the document.\r
10404      */\r
10405     DOMString getURL();\r
10406 \r
10407     /**\r
10408      * The root 'svg'  element in the document hierarchy.\r
10409      */\r
10410     SVGElementPtr getRootElement();\r
10411 \r
10412 \r
10413     //##################\r
10414     //# Non-API methods\r
10415     //##################\r
10416 \r
10417     /**\r
10418      *\r
10419      */\r
10420     ~SVGDocument() {}\r
10421 \r
10422 };\r
10423 \r
10424 \r
10425 \r
10426 /*#########################################################################\r
10427 ## GetSVGDocument\r
10428 #########################################################################*/\r
10429 \r
10430 /**\r
10431  * In the case where an SVG document is embedded by reference, such as when an\r
10432  * XHTML document has an 'object' element whose href(or equivalent) attribute\r
10433  * references an SVG document(i.e., a document whose MIME type is\r
10434  * "image/svg+xml" and whose root element is thus an 'svg' element), the SVG user\r
10435  * agent is required to implement the GetSVGDocument interface for the element\r
10436  * which references the SVG document(e.g., the HTML 'object' or comparable\r
10437  * referencing elements).\r
10438  */\r
10439 class GetSVGDocument\r
10440 {\r
10441 public:\r
10442 \r
10443     /**\r
10444      * Returns the SVGDocument  object for the referenced SVG document.\r
10445      */\r
10446     SVGDocumentPtr getSVGDocument()\r
10447                     throw (DOMException);\r
10448 \r
10449     //##################\r
10450     //# Non-API methods\r
10451     //##################\r
10452 \r
10453     /**\r
10454      *\r
10455      */\r
10456     ~GetSVGDocument() {}\r
10457 \r
10458 };\r
10459 \r
10460 \r
10461 \r
10462 \r
10463 \r
10464 \r
10465 \r
10466 }  //namespace svg\r
10467 }  //namespace dom\r
10468 }  //namespace w3c\r
10469 }  //namespace org\r
10470 \r
10471 #endif // __SVG_H__\r
10472 /*#########################################################################\r
10473 ## E N D    O F    F I L E\r
10474 #########################################################################*/\r
10475 \r