src/dom/svgtypes.h

   1 #ifndef __SVGTYPES_H__
   2 #define __SVGTYPES_H__
   3
   4 /**
   5  * Phoebe DOM Implementation.
   6  *
   7  * This is a C++ approximation of the W3C DOM model, which follows
   8  * fairly closely the specifications in the various .idl files, copies of
   9  * which are provided for reference.  Most important is this one:
  10  *
  11  * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
  12  *
  13  * Authors:
  14  *   Bob Jamison
  15  *
  16  * Copyright (C) 2006-2008 Bob Jamison
  17  *
  18  *  This library is free software; you can redistribute it and/or
  19  *  modify it under the terms of the GNU Lesser General Public
  20  *  License as published by the Free Software Foundation; either
  21  *  version 2.1 of the License, or (at your option) any later version.
  22  *
  23  *  This library is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26  *  Lesser General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU Lesser General Public
  29  *  License along with this library; if not, write to the Free Software
  30  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  31  *
  32  * =======================================================================
  33  * NOTES
  34  *
  35  * This API follows:
  36  * http://www.w3.org/TR/SVG11/svgdom.html
  37  *
  38  * This file contains the definitions of the non-Node SVG classes.  DOM Nodes
  39  * for SVG are defined in svg.h.
  40  *
  41  */
  42
  43
  44 // For access to DOM2 core
  45 #include "dom/dom.h"
  46
  47 // For access to DOM2 events
  48 #include "dom/events.h"
  49
  50 // For access to those parts from DOM2 CSS OM used by SVG DOM.
  51 #include "dom/css.h"
  52
  53 // For access to those parts from DOM2 Views OM used by SVG DOM.
  54 #include "dom/views.h"
  55
  56 // For access to the SMIL OM used by SVG DOM.
  57 #include "dom/smil.h"
  58
  59
  60 #include <math.h>
  61
  62
  63
  64 namespace org {
  65 namespace w3c {
  66 namespace dom {
  67 namespace svg {
  68
  69
  70
  71
  72 //local definitions
  73 typedef dom::DOMString DOMString;
  74 typedef dom::DOMException DOMException;
  75 typedef dom::Element Element;
  76 typedef dom::Document Document;
  77 typedef dom::NodeList NodeList;
  78
  79
  80 class SVGElement;
  81 typedef Ptr<SVGElement> SVGElementPtr;
  82 class SVGUseElement;
  83 typedef Ptr<SVGUseElement> SVGUseElementPtr;
  84 class SVGAnimatedPreserveAspectRatio;
  85
  86
  87 /*#########################################################################
  88 ## SVGException
  89 #########################################################################*/
  90
  91 /**
  92  *
  93  */
  94 class SVGException
  95 {
  96 public:
  97     // unsigned short   code;  //inherited
  98 };
  99
 100     /**
 101      * SVGExceptionCode
 102      */
 103     typedef enum
 104         {
 105         SVG_WRONG_TYPE_ERR           = 0,
 106         SVG_INVALID_VALUE_ERR        = 1,
 107         SVG_MATRIX_NOT_INVERTABLE    = 2
 108         } SVGExceptionCode;
 109
 110
 111
 112
 113
 114 /*#########################################################################
 115 ## SVGMatrix
 116 #########################################################################*/
 117
 118 /**
 119  *  In SVG, a Matrix is defined like this:
 120  *
 121  * | a  c  e |
 122  * | b  d  f |
 123  * | 0  0  1 |
 124  *
 125  */
 126 class SVGMatrix
 127 {
 128 public:
 129
 130
 131     /**
 132      *
 133      */
 134     virtual double getA()
 135         { return a; }
 136
 137     /**
 138      *
 139      */
 140     virtual void setA(double val) throw (DOMException)
 141         { a = val; }
 142
 143     /**
 144      *
 145      */
 146     virtual double getB()
 147         { return b; }
 148
 149     /**
 150      *
 151      */
 152     virtual void setB(double val) throw (DOMException)
 153         { b = val; }
 154
 155     /**
 156      *
 157      */
 158     virtual double getC()
 159         { return c; }
 160
 161     /**
 162      *
 163      */
 164     virtual void setC(double val) throw (DOMException)
 165         { c = val; }
 166
 167     /**
 168      *
 169      */
 170     virtual double getD()
 171         { return d; }
 172
 173     /**
 174      *
 175      */
 176     virtual void setD(double val) throw (DOMException)
 177         { d = val; }
 178     /**
 179      *
 180      */
 181     virtual double getE()
 182         { return e; }
 183
 184     /**
 185      *
 186      */
 187     virtual void setE(double val) throw (DOMException)
 188         { e = val; }
 189     /**
 190      *
 191      */
 192     virtual double getF()
 193         { return f; }
 194
 195     /**
 196      *
 197      */
 198     virtual void setF(double val) throw (DOMException)
 199         { f = val; }
 200
 201
 202     /**
 203      * Return the result of postmultiplying this matrix with another.
 204      */
 205     virtual SVGMatrix multiply(const SVGMatrix &other)
 206         {
 207         SVGMatrix result;
 208         result.a = a * other.a  +  c * other.b;
 209         result.b = b * other.a  +  d * other.b;
 210         result.c = a * other.c  +  c * other.d;
 211         result.d = b * other.c  +  d * other.d;
 212         result.e = a * other.e  +  c * other.f  +  e;
 213         result.f = b * other.e  +  d * other.f  +  f;
 214         return result;
 215         }
 216
 217     /**
 218      *  Calculate the inverse of this matrix
 219      *
 220      */
 221     virtual SVGMatrix inverse(  ) throw( SVGException )
 222         {
 223         /*###########################################
 224         The determinant of a 3x3 matrix E
 225            (let's use our own notation for a bit)
 226
 227             A  B  C
 228             D  E  F
 229             G  H  I
 230         is
 231             AEI - AFH - BDI + BFG + CDH - CEG
 232
 233         Since in our affine transforms, G and H==0 and I==1,
 234         this reduces to:
 235             AE - BD
 236         In SVG's naming scheme, that is:  a * d - c * b .  SIMPLE!
 237
 238         In a similar method of attack, SVG's adjunct matrix is:
 239
 240            d  -c   cf-ed
 241           -b   a   eb-af
 242            0   0   ad-cb
 243
 244         To get the inverse matrix, we divide the adjunct matrix by
 245         the determinant.  Notice that (ad-cb)/(ad-cb)==1.  Very cool.
 246         So what we end up with is this:
 247
 248            a =  d/(ad-cb)  c = -c/(ad-cb)   e = (cf-ed)/(ad-cb)
 249            b = -b/(ad-cb)  d =  a/(ad-cb)   f = (eb-af)/(ad-cb)
 250
 251         (Since this would be in all SVG-DOM implementations,
 252          somebody needed to document this!  ^^ )
 253         #############################################*/
 254
 255         SVGMatrix result;
 256         double determinant = a * d  -  c * b;
 257         if (determinant < 1.0e-18)//invertible?
 258             {
 259             result.identity();//cop out
 260             return result;
 261             }
 262
 263         double idet = 1.0 / determinant;
 264         result.a =   d * idet;
 265         result.b =  -b * idet;
 266         result.c =  -c * idet;
 267         result.d =   a * idet;
 268         result.e =  (c*f - e*d) * idet;
 269         result.f =  (e*b - a*f) * idet;
 270         return result;
 271         }
 272
 273     /**
 274      * Equivalent to multiplying by:
 275      *  | 1  0  x |
 276      *  | 0  1  y |
 277      *  | 0  0  1 |
 278      *
 279      */
 280     virtual SVGMatrix translate(double x, double y )
 281         {
 282         SVGMatrix result;
 283         result.a = a;
 284         result.b = b;
 285         result.c = c;
 286         result.d = d;
 287         result.e = a * x  +  c * y  +  e;
 288         result.f = b * x  +  d * y  +  f;
 289         return result;
 290         }
 291
 292     /**
 293      * Equivalent to multiplying by:
 294      *  | scale  0      0 |
 295      *  | 0      scale  0 |
 296      *  | 0      0      1 |
 297      *
 298      */
 299     virtual SVGMatrix scale(double scale)
 300         {
 301         SVGMatrix result;
 302         result.a = a * scale;
 303         result.b = b * scale;
 304         result.c = c * scale;
 305         result.d = d * scale;
 306         result.e = e;
 307         result.f = f;
 308         return result;
 309         }
 310
 311     /**
 312      * Equivalent to multiplying by:
 313      *  | scaleX  0       0 |
 314      *  | 0       scaleY  0 |
 315      *  | 0       0       1 |
 316      *
 317      */
 318     virtual SVGMatrix scaleNonUniform(double scaleX,
 319                                       double scaleY )
 320         {
 321         SVGMatrix result;
 322         result.a = a * scaleX;
 323         result.b = b * scaleX;
 324         result.c = c * scaleY;
 325         result.d = d * scaleY;
 326         result.e = e;
 327         result.f = f;
 328         return result;
 329         }
 330
 331     /**
 332      * Equivalent to multiplying by:
 333      *  | cos(a) -sin(a)   0 |
 334      *  | sin(a)  cos(a)   0 |
 335      *  | 0       0        1 |
 336      *
 337      */
 338     virtual SVGMatrix rotate (double angle)
 339         {
 340         double sina  = sin(angle);
 341         double msina = -sina;
 342         double cosa  = cos(angle);
 343         SVGMatrix result;
 344         result.a = a * cosa   +  c * sina;
 345         result.b = b * cosa   +  d + sina;
 346         result.c = a * msina  +  c * cosa;
 347         result.d = b * msina  +  d * cosa;
 348         result.e = e;
 349         result.f = f;
 350         return result;
 351         }
 352
 353     /**
 354      * Equivalent to multiplying by:
 355      *  | cos(a) -sin(a)   0 |
 356      *  | sin(a)  cos(a)   0 |
 357      *  | 0       0        1 |
 358      *  In this case, angle 'a' is computed as the artangent
 359      *  of the slope y/x .  It is negative if the slope is negative.
 360      */
 361     virtual SVGMatrix rotateFromVector(double x, double y)
 362                                       throw( SVGException )
 363         {
 364         double angle = atan(y / x);
 365         if (y < 0.0)
 366             angle = -angle;
 367         SVGMatrix result;
 368         double sina  = sin(angle);
 369         double msina = -sina;
 370         double cosa  = cos(angle);
 371         result.a = a * cosa   +  c * sina;
 372         result.b = b * cosa   +  d + sina;
 373         result.c = a * msina  +  c * cosa;
 374         result.d = b * msina  +  d * cosa;
 375         result.e = e;
 376         result.f = f;
 377         return result;
 378         }
 379
 380     /**
 381      * Equivalent to multiplying by:
 382      *  | -1   0   0 |
 383      *  | 0    1   0 |
 384      *  | 0    0   1 |
 385      *
 386      */
 387     virtual SVGMatrix flipX(  )
 388         {
 389         SVGMatrix result;
 390         result.a = -a;
 391         result.b = -b;
 392         result.c =  c;
 393         result.d =  d;
 394         result.e =  e;
 395         result.f =  f;
 396         return result;
 397         }
 398
 399     /**
 400      * Equivalent to multiplying by:
 401      *  | 1   0   0 |
 402      *  | 0  -1   0 |
 403      *  | 0   0   1 |
 404      *
 405      */
 406     virtual SVGMatrix flipY( )
 407         {
 408         SVGMatrix result;
 409         result.a =  a;
 410         result.b =  b;
 411         result.c = -c;
 412         result.d = -d;
 413         result.e =  e;
 414         result.f =  f;
 415         return result;
 416         }
 417
 418     /**
 419      *  | 1   tan(a)  0 |
 420      *  | 0   1       0 |
 421      *  | 0   0       1 |
 422      *
 423      */
 424     virtual SVGMatrix skewX(double angle)
 425         {
 426         double tana = tan(angle);
 427         SVGMatrix result;
 428         result.a =  a;
 429         result.b =  b;
 430         result.c =  a * tana + c;
 431         result.d =  b * tana + d;
 432         result.e =  e;
 433         result.f =  f;
 434         return result;
 435         }
 436
 437     /**
 438      * Equivalent to multiplying by:
 439      *  | 1       0   0 |
 440      *  | tan(a)  1   0 |
 441      *  | 0       0   1 |
 442      *
 443      */
 444     virtual SVGMatrix skewY(double angle)
 445         {
 446         double tana = tan(angle);
 447         SVGMatrix result;
 448         result.a =  a + c * tana;
 449         result.b =  b + d * tana;
 450         result.c =  c;
 451         result.d =  d;
 452         result.e =  e;
 453         result.f =  f;
 454         return result;
 455         }
 456
 457
 458
 459     //##################
 460     //# Non-API methods
 461     //##################
 462
 463     /**
 464      *
 465      */
 466     SVGMatrix()
 467         {
 468         identity();
 469         }
 470
 471     /**
 472      *
 473      */
 474     SVGMatrix(double aArg, double bArg, double cArg,
 475               double dArg, double eArg, double fArg )
 476         {
 477         a = aArg; b = bArg; c = cArg;
 478         d = dArg; e = eArg; f = fArg;
 479         }
 480
 481     /**
 482      * Copy constructor
 483      */
 484     SVGMatrix(const SVGMatrix &other)
 485         {
 486         a = other.a;
 487         b = other.b;
 488         c = other.c;
 489         d = other.d;
 490         e = other.e;
 491         f = other.f;
 492         }
 493
 494
 495
 496     /**
 497      *
 498      */
 499     virtual ~SVGMatrix() {}
 500
 501 protected:
 502
 503 friend class SVGTransform;
 504
 505     /*
 506      * Set to the identify matrix
 507      */
 508    void identity()
 509        {
 510        a = 1.0;
 511        b = 0.0;
 512        c = 0.0;
 513        d = 1.0;
 514        e = 0.0;
 515        f = 0.0;
 516        }
 517
 518     double a, b, c, d, e, f;
 519
 520 };
 521
 522
 523 /*#########################################################################
 524 ## SVGTransform
 525 #########################################################################*/
 526
 527 /**
 528  *
 529  */
 530 class SVGTransform
 531 {
 532 public:
 533
 534     /**
 535      * Transform Types
 536      */
 537     typedef enum
 538         {
 539         SVG_TRANSFORM_UNKNOWN   = 0,
 540         SVG_TRANSFORM_MATRIX    = 1,
 541         SVG_TRANSFORM_TRANSLATE = 2,
 542         SVG_TRANSFORM_SCALE     = 3,
 543         SVG_TRANSFORM_ROTATE    = 4,
 544         SVG_TRANSFORM_SKEWX     = 5,
 545         SVG_TRANSFORM_SKEWY     = 6,
 546         } TransformType;
 547
 548     /**
 549      *
 550      */
 551     virtual unsigned short getType()
 552         { return type; }
 553
 554
 555     /**
 556      *
 557      */
 558     virtual SVGMatrix getMatrix()
 559         {
 560         return matrix;
 561         }
 562
 563     /**
 564      *
 565      */
 566     virtual double getAngle()
 567         {
 568         return angle;
 569         }
 570
 571
 572     /**
 573      *
 574      */
 575     virtual void setMatrix(const SVGMatrix &matrixArg)
 576         {
 577         type = SVG_TRANSFORM_MATRIX;
 578         matrix = matrixArg;
 579         }
 580
 581     /**
 582      *
 583      */
 584     virtual void setTranslate (double tx, double ty )
 585         {
 586         type = SVG_TRANSFORM_TRANSLATE;
 587         matrix.setA(1.0);
 588         matrix.setB(0.0);
 589         matrix.setC(0.0);
 590         matrix.setD(1.0);
 591         matrix.setE(tx);
 592         matrix.setF(ty);
 593         }
 594
 595     /**
 596      *
 597      */
 598     virtual void setScale (double sx, double sy )
 599         {
 600         type = SVG_TRANSFORM_SCALE;
 601         matrix.setA(sx);
 602         matrix.setB(0.0);
 603         matrix.setC(0.0);
 604         matrix.setD(sy);
 605         matrix.setE(0.0);
 606         matrix.setF(0.0);
 607         }
 608
 609     /**
 610      *
 611      */
 612     virtual void setRotate (double angleArg, double cx, double cy)
 613         {
 614         angle = angleArg;
 615         setTranslate(cx, cy);
 616         type = SVG_TRANSFORM_ROTATE;
 617         matrix.rotate(angle);
 618         }
 619
 620     /**
 621      *
 622      */
 623     virtual void setSkewX (double angleArg)
 624         {
 625         angle = angleArg;
 626         type = SVG_TRANSFORM_SKEWX;
 627         matrix.identity();
 628         matrix.skewX(angle);
 629         }
 630
 631     /**
 632      *
 633      */
 634     virtual void setSkewY (double angleArg)
 635         {
 636         angle = angleArg;
 637         type = SVG_TRANSFORM_SKEWY;
 638         matrix.identity();
 639         matrix.skewY(angle);
 640         }
 641
 642
 643     //##################
 644     //# Non-API methods
 645     //##################
 646
 647     /**
 648      *
 649      */
 650     SVGTransform()
 651         {
 652         type = SVG_TRANSFORM_UNKNOWN;
 653         angle = 0.0;
 654         }
 655
 656     /**
 657      *
 658      */
 659     SVGTransform(const SVGTransform &other)
 660         {
 661         type   = other.type;
 662         angle  = other.angle;
 663         matrix = other.matrix;
 664         }
 665
 666     /**
 667      *
 668      */
 669     virtual ~SVGTransform()
 670         {}
 671
 672 protected:
 673
 674     int type;
 675     double angle;
 676
 677     SVGMatrix matrix;
 678 };
 679
 680
 681
 682
 683
 684
 685 /*#########################################################################
 686 ## SVGTransformList
 687 #########################################################################*/
 688
 689 /**
 690  *
 691  */
 692 class SVGTransformList
 693 {
 694 public:
 695
 696
 697     /**
 698      *
 699      */
 700     virtual unsigned long getNumberOfItems()
 701         { return items.size(); }
 702
 703
 704     /**
 705      *
 706      */
 707     virtual void clear( ) throw( DOMException )
 708         { items.clear(); }
 709
 710     /**
 711      *
 712      */
 713     virtual SVGTransform initialize (const SVGTransform &newItem)
 714                          throw( DOMException, SVGException )
 715         {
 716         items.clear();
 717         items.push_back(newItem);
 718         return newItem;
 719         }
 720
 721     /**
 722      *
 723      */
 724     virtual SVGTransform getItem (unsigned long index )
 725                     throw( DOMException )
 726         {
 727         if (index>=items.size())
 728             {
 729             SVGTransform transform;
 730             return transform;
 731             }
 732         return items[index];
 733         }
 734
 735     /**
 736      *
 737      */
 738     virtual SVGTransform insertItemBefore (const SVGTransform &newItem,
 739                                            unsigned long index )
 740                                       throw( DOMException, SVGException )
 741         {
 742         if (index > items.size())
 743             items.push_back(newItem);
 744         else
 745             {
 746             std::vector<SVGTransform>::iterator iter = items.begin() + index;
 747             items.insert(iter, newItem);
 748             }
 749         return newItem;
 750         }
 751
 752     /**
 753      *
 754      */
 755     virtual SVGTransform replaceItem (const SVGTransform &newItem,
 756                                        unsigned long index )
 757                                 throw( DOMException, SVGException )
 758         {
 759         if (index>=items.size())
 760             {
 761             SVGTransform transform;
 762             return transform;
 763             }
 764         else
 765             {
 766             std::vector<SVGTransform>::iterator iter = items.begin() + index;
 767             *iter = newItem;
 768             }
 769         return newItem;
 770         }
 771
 772     /**
 773      *
 774      */
 775     virtual SVGTransform removeItem (unsigned long index )
 776                                      throw( DOMException )
 777         {
 778         if (index>=items.size())
 779             {
 780             SVGTransform transform;
 781             return transform;
 782             }
 783         std::vector<SVGTransform>::iterator iter = items.begin() + index;
 784         SVGTransform oldItem = *iter;
 785         items.erase(iter);
 786         return oldItem;
 787         }
 788
 789     /**
 790      *
 791      */
 792     virtual SVGTransform appendItem (const SVGTransform &newItem)
 793                                   throw( DOMException, SVGException )
 794         {
 795         items.push_back(newItem);
 796         return newItem;
 797         }
 798
 799     /**
 800      *
 801      */
 802     virtual SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix)
 803         {
 804         SVGTransform transform;
 805         transform.setMatrix(matrix);
 806         return transform;
 807         }
 808
 809     /**
 810      *
 811      */
 812     virtual SVGTransform consolidate()
 813         {
 814         SVGMatrix matrix;
 815         for (unsigned int i=0 ; i<items.size() ; i++)
 816             matrix = matrix.multiply(items[i].getMatrix());
 817         SVGTransform transform;
 818         transform.setMatrix(matrix);
 819         items.clear();
 820         items.push_back(transform);
 821         return transform;
 822         }
 823
 824
 825
 826     //##################
 827     //# Non-API methods
 828     //##################
 829
 830     /**
 831      *
 832      */
 833     SVGTransformList()
 834         {}
 835
 836     /**
 837      *
 838      */
 839     SVGTransformList(const SVGTransformList &other)
 840         {
 841         items = other.items;
 842         }
 843
 844     /**
 845      *
 846      */
 847     virtual ~SVGTransformList() {}
 848
 849 protected:
 850
 851     std::vector<SVGTransform> items;
 852
 853 };
 854
 855
 856
 857
 858
 859
 860 /*#########################################################################
 861 ## SVGAnimatedTransformList
 862 #########################################################################*/
 863
 864 /**
 865  *
 866  */
 867 class SVGAnimatedTransformList
 868 {
 869 public:
 870
 871     /**
 872      *
 873      */
 874     virtual SVGTransformList getBaseVal()
 875         { return baseVal; }
 876
 877     /**
 878      *
 879      */
 880     virtual SVGTransformList getAnimVal()
 881         { return animVal; }
 882
 883
 884
 885     //##################
 886     //# Non-API methods
 887     //##################
 888
 889     /**
 890      *
 891      */
 892     SVGAnimatedTransformList()
 893         {}
 894
 895     /**
 896      *
 897      */
 898     SVGAnimatedTransformList(const SVGAnimatedTransformList &other)
 899         {
 900         baseVal = other.baseVal;
 901         animVal = other.animVal;
 902         }
 903
 904     /**
 905      *
 906      */
 907     virtual ~SVGAnimatedTransformList() {}
 908
 909 protected:
 910
 911     SVGTransformList baseVal;
 912     SVGTransformList animVal;
 913
 914 };
 915
 916
 917
 918
 919 /*#########################################################################
 920 ## SVGAnimatedBoolean
 921 #########################################################################*/
 922
 923 /**
 924  *
 925  */
 926 class SVGAnimatedBoolean
 927 {
 928 public:
 929
 930     /**
 931      *
 932      */
 933     virtual bool getBaseVal()
 934         {
 935         return baseVal;
 936         }
 937
 938     /**
 939      *
 940      */
 941     virtual void setBaseVal(bool val) throw (DOMException)
 942         {
 943         baseVal = val;
 944         }
 945
 946     /**
 947      *
 948      */
 949     virtual bool getAnimVal()
 950         {
 951         return animVal;
 952         }
 953
 954
 955     //##################
 956     //# Non-API methods
 957     //##################
 958
 959     /**
 960      *
 961      */
 962     SVGAnimatedBoolean()
 963         {
 964         baseVal = animVal = false;
 965         }
 966
 967     /**
 968      *
 969      */
 970     SVGAnimatedBoolean(const SVGAnimatedBoolean &other)
 971         {
 972         baseVal = other.baseVal;
 973         animVal = other.animVal;
 974         }
 975
 976     /**
 977      *
 978      */
 979     virtual ~SVGAnimatedBoolean() {}
 980
 981 protected:
 982
 983     bool baseVal, animVal;
 984
 985 };
 986
 987
 988
 989
 990 /*#########################################################################
 991 ## SVGAnimatedString
 992 #########################################################################*/
 993
 994 /**
 995  *
 996  */
 997 class SVGAnimatedString
 998 {
 999 public:
1000
1001     /**
1002      *
1003      */
1004     virtual DOMString getBaseVal()
1005         {
1006         return baseVal;
1007         }
1008
1009     /**
1010      *
1011      */
1012     virtual void setBaseVal(const DOMString &val)
1013                             throw (DOMException)
1014         {
1015         baseVal = val;
1016         }
1017
1018     /**
1019      *
1020      */
1021     virtual DOMString getAnimVal()
1022         {
1023         return animVal;
1024         }
1025
1026
1027     //##################
1028     //# Non-API methods
1029     //##################
1030
1031
1032     /**
1033      *
1034      */
1035     SVGAnimatedString()
1036         {
1037         baseVal = "";
1038         animVal = "";
1039         }
1040
1041     /**
1042      *
1043      */
1044     SVGAnimatedString(const SVGAnimatedString &other)
1045         {
1046         baseVal = other.baseVal;
1047         animVal = other.animVal;
1048         }
1049
1050     /**
1051      *
1052      */
1053     virtual ~SVGAnimatedString() {}
1054
1055 protected:
1056
1057     DOMString baseVal, animVal;
1058
1059 };
1060
1061
1062
1063
1064
1065 /*#########################################################################
1066 ## SVGStringList
1067 #########################################################################*/
1068
1069 /**
1070  *
1071  */
1072 class SVGStringList
1073 {
1074 public:
1075
1076
1077     /**
1078      *
1079      */
1080     virtual unsigned long getNumberOfItems()
1081         {
1082         return items.size();
1083         }
1084
1085     /**
1086      *
1087      */
1088     virtual void clear () throw( DOMException )
1089        {
1090        items.clear();
1091        }
1092
1093     /**
1094      *
1095      */
1096     virtual DOMString initialize ( const DOMString& newItem )
1097                     throw( DOMException, SVGException )
1098         {
1099         items.clear();
1100         items.push_back(newItem);
1101         return newItem;
1102         }
1103
1104     /**
1105      *
1106      */
1107     virtual DOMString getItem ( unsigned long index )
1108                     throw( DOMException )
1109         {
1110         if (index >= items.size())
1111             return "";
1112         return items[index];
1113         }
1114
1115     /**
1116      *
1117      */
1118     virtual DOMString insertItemBefore ( const DOMString& newItem,
1119                                  unsigned long index )
1120                                throw( DOMException, SVGException )
1121         {
1122         if (index>=items.size())
1123             {
1124             items.push_back(newItem);
1125             }
1126         else
1127             {
1128             std::vector<DOMString>::iterator iter = items.begin() + index;
1129             items.insert(iter, newItem);
1130             }
1131         return newItem;
1132         }
1133
1134     /**
1135      *
1136      */
1137     virtual DOMString replaceItem ( const DOMString& newItem,
1138                                     unsigned long index )
1139                                 throw( DOMException, SVGException )
1140         {
1141         if (index>=items.size())
1142             return "";
1143         std::vector<DOMString>::iterator iter = items.begin() + index;
1144         *iter = newItem;
1145         return newItem;
1146         }
1147
1148     /**
1149      *
1150      */
1151     virtual DOMString removeItem ( unsigned long index )
1152                     throw( DOMException )
1153         {
1154         if (index>=items.size())
1155             return "";
1156         std::vector<DOMString>::iterator iter = items.begin() + index;
1157         DOMString oldstr = *iter;
1158         items.erase(iter);
1159         return oldstr;
1160         }
1161
1162     /**
1163      *
1164      */
1165     virtual DOMString appendItem ( const DOMString& newItem )
1166                     throw( DOMException, SVGException )
1167         {
1168         items.push_back(newItem);
1169         return newItem;
1170         }
1171
1172
1173
1174     //##################
1175     //# Non-API methods
1176     //##################
1177
1178     /**
1179      *
1180      */
1181     SVGStringList() {}
1182
1183     /**
1184      *
1185      */
1186    SVGStringList(const SVGStringList &other)
1187        {
1188        items = other.items;
1189        }
1190
1191     /**
1192      *
1193      */
1194     virtual ~SVGStringList() {}
1195
1196 protected:
1197
1198     std::vector<DOMString>items;
1199
1200 };
1201
1202
1203
1204
1205
1206 /*#########################################################################
1207 ## SVGAnimatedEnumeration
1208 #########################################################################*/
1209
1210 /**
1211  *
1212  */
1213 class SVGAnimatedEnumeration
1214 {
1215 public:
1216
1217     /**
1218      *
1219      */
1220     virtual unsigned short getBaseVal()
1221         {
1222         return baseVal;
1223         }
1224
1225     /**
1226      *
1227      */
1228     virtual void setBaseVal(unsigned short val)
1229                                      throw (DOMException)
1230         {
1231         baseVal = val;
1232         }
1233
1234     /**
1235      *
1236      */
1237     virtual unsigned short getAnimVal()
1238         {
1239         return animVal;
1240         }
1241
1242
1243
1244     //##################
1245     //# Non-API methods
1246     //##################
1247
1248
1249     /**
1250      *
1251      */
1252     SVGAnimatedEnumeration()
1253         {
1254         baseVal = animVal = 0;
1255         }
1256
1257     /**
1258      *
1259      */
1260     SVGAnimatedEnumeration(const SVGAnimatedEnumeration &other)
1261         {
1262         baseVal = other.baseVal;
1263         animVal = other.animVal;
1264         }
1265
1266     /**
1267      *
1268      */
1269     virtual ~SVGAnimatedEnumeration() {}
1270
1271 protected:
1272
1273     int baseVal, animVal;
1274
1275 };
1276
1277
1278
1279
1280
1281 /*#########################################################################
1282 ## SVGAnimatedInteger
1283 #########################################################################*/
1284
1285 /**
1286  *
1287  */
1288 class SVGAnimatedInteger
1289 {
1290 public:
1291
1292
1293     /**
1294      *
1295      */
1296     virtual long getBaseVal()
1297         {
1298         return baseVal;
1299         }
1300
1301     /**
1302      *
1303      */
1304     virtual void setBaseVal(long val) throw (DOMException)
1305         {
1306         baseVal = val;
1307         }
1308
1309     /**
1310      *
1311      */
1312     virtual long getAnimVal()
1313         {
1314         return animVal;
1315         }
1316
1317
1318
1319     //##################
1320     //# Non-API methods
1321     //##################
1322
1323
1324     /**
1325      *
1326      */
1327     SVGAnimatedInteger()
1328         { baseVal = animVal = 0L;}
1329
1330
1331     /**
1332      *
1333      */
1334     SVGAnimatedInteger(long value)
1335         {
1336         baseVal = value;
1337         animVal = 0L;
1338         }
1339
1340     /**
1341      *
1342      */
1343     SVGAnimatedInteger(long baseValArg, long animValArg)
1344         {
1345         baseVal = baseValArg;
1346         animVal = animValArg;
1347         }
1348
1349
1350     /**
1351      *
1352      */
1353     SVGAnimatedInteger(const SVGAnimatedInteger &other)
1354         {
1355         baseVal = other.baseVal;
1356         animVal = other.animVal;
1357         }
1358
1359     /**
1360      *
1361      */
1362     virtual ~SVGAnimatedInteger() {}
1363
1364 protected:
1365
1366     long baseVal, animVal;
1367
1368 };
1369
1370
1371
1372
1373
1374 /*#########################################################################
1375 ## SVGNumber
1376 #########################################################################*/
1377
1378 /**
1379  *
1380  */
1381 class SVGNumber
1382 {
1383 public:
1384
1385
1386     /**
1387      *
1388      */
1389     virtual double getValue()
1390         {
1391         return value;
1392         }
1393
1394     /**
1395      *
1396      */
1397     virtual void setValue(double val) throw (DOMException)
1398         {
1399         value = val;
1400         }
1401
1402
1403     //##################
1404     //# Non-API methods
1405     //##################
1406
1407     /**
1408      *
1409      */
1410     SVGNumber()
1411         {
1412         value = 0.0;
1413         }
1414
1415     /**
1416      *
1417      */
1418     SVGNumber(const SVGNumber &other)
1419         {
1420         value = other.value;
1421         }
1422
1423     /**
1424      *
1425      */
1426     virtual ~SVGNumber() {}
1427
1428 protected:
1429
1430     double value;
1431
1432 };
1433
1434
1435
1436
1437
1438 /*#########################################################################
1439 ## SVGAnimatedNumber
1440 #########################################################################*/
1441
1442 /**
1443  *
1444  */
1445 class SVGAnimatedNumber
1446 {
1447 public:
1448
1449
1450
1451     /**
1452      *
1453      */
1454     virtual double getBaseVal()
1455         {
1456         return baseVal;
1457         }
1458
1459     /**
1460      *
1461      */
1462     virtual void setBaseVal(double val) throw (DOMException)
1463         {
1464         baseVal = val;
1465         }
1466
1467     /**
1468      *
1469      */
1470     virtual double getAnimVal()
1471         {
1472         return animVal;
1473         }
1474
1475
1476
1477     //##################
1478     //# Non-API methods
1479     //##################
1480
1481     /**
1482      *
1483      */
1484     SVGAnimatedNumber()
1485         {
1486         baseVal = animVal = 0.0;
1487         }
1488
1489
1490     /**
1491      *
1492      */
1493     SVGAnimatedNumber(double val)
1494         {
1495         baseVal = val;
1496         animVal = 0.0;
1497         }
1498
1499
1500     /**
1501      *
1502      */
1503     SVGAnimatedNumber(double baseValArg, double animValArg)
1504         {
1505         baseVal = baseValArg;
1506         animVal = animValArg;
1507         }
1508
1509     /**
1510      *
1511      */
1512     SVGAnimatedNumber(const SVGAnimatedNumber &other)
1513         {
1514         baseVal = other.baseVal;
1515         animVal = other.animVal;
1516         }
1517
1518     /**
1519      *
1520      */
1521     virtual ~SVGAnimatedNumber() {}
1522
1523 protected:
1524
1525     double baseVal, animVal;
1526
1527 };
1528
1529
1530
1531
1532
1533 /*#########################################################################
1534 ## SVGNumberList
1535 #########################################################################*/
1536
1537 /**
1538  *
1539  */
1540 class SVGNumberList
1541 {
1542 public:
1543
1544     /**
1545      *
1546      */
1547     virtual unsigned long getNumberOfItems()
1548         {
1549         return items.size();
1550         }
1551
1552
1553     /**
1554      *
1555      */
1556     virtual void clear() throw( DOMException )
1557         {
1558         items.clear();
1559         }
1560
1561     /**
1562      *
1563      */
1564     virtual SVGNumber initialize (const SVGNumber &newItem)
1565                     throw( DOMException, SVGException )
1566         {
1567         items.clear();
1568         items.push_back(newItem);
1569         return newItem;
1570         }
1571
1572     /**
1573      *
1574      */
1575     virtual SVGNumber getItem ( unsigned long index )
1576                                   throw( DOMException )
1577         {
1578         if (index>=items.size())
1579             {
1580             SVGNumber num;
1581             return num;
1582             }
1583         return items[index];
1584         }
1585
1586     /**
1587      *
1588      */
1589     virtual SVGNumber insertItemBefore ( const SVGNumber &newItem,
1590                                          unsigned long index )
1591                                          throw( DOMException, SVGException )
1592         {
1593         if (index>=items.size())
1594             {
1595             items.push_back(newItem);
1596             }
1597         else
1598             {
1599             std::vector<SVGNumber>::iterator iter = items.begin() + index;
1600             items.insert(iter, newItem);
1601             }
1602         return newItem;
1603         }
1604
1605     /**
1606      *
1607      */
1608     virtual SVGNumber replaceItem ( const SVGNumber &newItem,
1609                                     unsigned long index )
1610                                     throw( DOMException, SVGException )
1611         {
1612         if (index>=items.size())
1613             {
1614             SVGNumber num;
1615             return num;
1616             }
1617         std::vector<SVGNumber>::iterator iter = items.begin() + index;
1618         *iter = newItem;
1619         return newItem;
1620         }
1621
1622     /**
1623      *
1624      */
1625     virtual SVGNumber removeItem ( unsigned long index )
1626                                   throw( DOMException )
1627         {
1628         if (index>=items.size())
1629             {
1630             SVGNumber num;
1631             return num;
1632             }
1633         std::vector<SVGNumber>::iterator iter = items.begin() + index;
1634         SVGNumber oldval = *iter;
1635         items.erase(iter);
1636         return oldval;
1637         }
1638
1639     /**
1640      *
1641      */
1642     virtual SVGNumber appendItem ( const SVGNumber &newItem )
1643                                    throw( DOMException, SVGException )
1644         {
1645         items.push_back(newItem);
1646         return newItem;
1647         }
1648
1649
1650     //##################
1651     //# Non-API methods
1652     //##################
1653
1654     /**
1655      *
1656      */
1657     SVGNumberList() {}
1658
1659     /**
1660      *
1661      */
1662     SVGNumberList(const SVGNumberList &other)
1663         {
1664         items = other.items;
1665         }
1666
1667     /**
1668      *
1669      */
1670     virtual ~SVGNumberList() {}
1671
1672 protected:
1673
1674     std::vector<SVGNumber>items;
1675
1676 };
1677
1678
1679
1680
1681
1682 /*#########################################################################
1683 ## SVGAnimatedNumberList
1684 #########################################################################*/
1685
1686 /**
1687  *
1688  */
1689 class SVGAnimatedNumberList
1690 {
1691 public:
1692
1693
1694     /**
1695      *
1696      */
1697     virtual SVGNumberList &getBaseVal()
1698         {
1699         return baseVal;
1700         }
1701
1702     /**
1703      *
1704      */
1705     virtual SVGNumberList &getAnimVal()
1706         {
1707         return animVal;
1708         }
1709
1710
1711
1712     //##################
1713     //# Non-API methods
1714     //##################
1715
1716     /**
1717      *
1718      */
1719     SVGAnimatedNumberList() {}
1720
1721     /**
1722      *
1723      */
1724     SVGAnimatedNumberList(const SVGAnimatedNumberList &other)
1725         {
1726         baseVal = other.baseVal;
1727         animVal = other.animVal;
1728         }
1729
1730     /**
1731      *
1732      */
1733     virtual ~SVGAnimatedNumberList() {}
1734
1735 protected:
1736
1737     SVGNumberList baseVal;
1738     SVGNumberList animVal;
1739
1740 };
1741
1742
1743
1744
1745
1746
1747 /*#########################################################################
1748 ## SVGLength
1749 #########################################################################*/
1750
1751 /**
1752  *
1753  */
1754 class SVGLength
1755 {
1756 public:
1757
1758     /**
1759      * Length Unit Types
1760      */
1761     typedef enum
1762         {
1763         SVG_LENGTHTYPE_UNKNOWN    = 0,
1764         SVG_LENGTHTYPE_NUMBER     = 1,
1765         SVG_LENGTHTYPE_PERCENTAGE = 2,
1766         SVG_LENGTHTYPE_EMS        = 3,
1767         SVG_LENGTHTYPE_EXS        = 4,
1768         SVG_LENGTHTYPE_PX         = 5,
1769         SVG_LENGTHTYPE_CM         = 6,
1770         SVG_LENGTHTYPE_MM         = 7,
1771         SVG_LENGTHTYPE_IN         = 8,
1772         SVG_LENGTHTYPE_PT         = 9,
1773         SVG_LENGTHTYPE_PC         = 10
1774         } LengthUnitType;
1775
1776
1777     /**
1778      *
1779      */
1780     virtual unsigned short getUnitType( )
1781         {
1782         return unitType;
1783         }
1784
1785     /**
1786      *
1787      */
1788     virtual double getValue( )
1789         {
1790         return value;
1791         }
1792
1793     /**
1794      *
1795      */
1796     virtual void setValue( double val )  throw (DOMException)
1797         {
1798         value = val;
1799         }
1800
1801     /**
1802      *
1803      */
1804     virtual double getValueInSpecifiedUnits( )
1805         {
1806         double result = 0.0;
1807         //fill this in
1808         return result;
1809         }
1810
1811     /**
1812      *
1813      */
1814     virtual void setValueInSpecifiedUnits( double /*val*/ )
1815                                            throw (DOMException)
1816         {
1817         //fill this in
1818         }
1819
1820     /**
1821      *
1822      */
1823     virtual DOMString getValueAsString( )
1824         {
1825         DOMString ret;
1826         char buf[32];
1827         snprintf(buf, 31, "%f", value);
1828         ret.append(buf);
1829         return ret;
1830         }
1831
1832     /**
1833      *
1834      */
1835     virtual void setValueAsString( const DOMString& /*val*/ )
1836                                    throw (DOMException)
1837         {
1838         }
1839
1840
1841     /**
1842      *
1843      */
1844     virtual void newValueSpecifiedUnits ( unsigned short /*unitType*/, double /*val*/ )
1845         {
1846         }
1847
1848     /**
1849      *
1850      */
1851     virtual void convertToSpecifiedUnits ( unsigned short /*unitType*/ )
1852         {
1853         }
1854
1855
1856
1857     //##################
1858     //# Non-API methods
1859     //##################
1860
1861     /**
1862      *
1863      */
1864     SVGLength()
1865         {
1866         unitType = SVG_LENGTHTYPE_UNKNOWN;
1867         value    = 0.0;
1868         }
1869
1870
1871     /**
1872      *
1873      */
1874     SVGLength(const SVGLength &other)
1875         {
1876         unitType  = other.unitType;
1877         value     = other.value;
1878         }
1879
1880     /**
1881      *
1882      */
1883     virtual ~SVGLength() {}
1884
1885 protected:
1886
1887     int unitType;
1888
1889     double value;
1890
1891 };
1892
1893
1894
1895
1896
1897
1898 /*#########################################################################
1899 ## SVGAnimatedLength
1900 #########################################################################*/
1901
1902 /**
1903  *
1904  */
1905 class SVGAnimatedLength
1906 {
1907 public:
1908
1909     /**
1910      *
1911      */
1912     virtual SVGLength &getBaseVal()
1913         {
1914         return baseVal;
1915         }
1916
1917     /**
1918      *
1919      */
1920     virtual SVGLength &getAnimVal()
1921         {
1922         return animVal;
1923         }
1924
1925
1926
1927     //##################
1928     //# Non-API methods
1929     //##################
1930
1931     /**
1932      *
1933      */
1934     SVGAnimatedLength() {}
1935
1936     /**
1937      *
1938      */
1939     SVGAnimatedLength(const SVGAnimatedLength &other)
1940         {
1941         baseVal = other.baseVal;
1942         animVal = other.animVal;
1943         }
1944
1945     /**
1946      *
1947      */
1948     virtual ~SVGAnimatedLength() {}
1949
1950 protected:
1951
1952     SVGLength baseVal, animVal;
1953
1954 };
1955
1956
1957
1958
1959
1960
1961 /*#########################################################################
1962 ## SVGLengthList
1963 #########################################################################*/
1964
1965 /**
1966  *
1967  */
1968 class SVGLengthList
1969 {
1970 public:
1971
1972     /**
1973      *
1974      */
1975     virtual unsigned long getNumberOfItems()
1976         {
1977         return items.size();
1978         }
1979
1980
1981     /**
1982      *
1983      */
1984     virtual void clear (  ) throw( DOMException )
1985         {
1986         items.clear();
1987         }
1988
1989     /**
1990      *
1991      */
1992     virtual SVGLength initialize (const SVGLength &newItem )
1993                     throw( DOMException, SVGException )
1994         {
1995         items.clear();
1996         items.push_back(newItem);
1997         return newItem;
1998         }
1999
2000     /**
2001      *
2002      */
2003     virtual SVGLength getItem (unsigned long index)
2004                     throw( DOMException )
2005         {
2006         if (index>=items.size())
2007             {
2008             SVGLength ret;
2009             return ret;
2010             }
2011         return items[index];
2012         }
2013
2014     /**
2015      *
2016      */
2017     virtual SVGLength insertItemBefore (const SVGLength &newItem,
2018                                          unsigned long index )
2019                                    throw( DOMException, SVGException )
2020         {
2021         if (index>=items.size())
2022             {
2023             items.push_back(newItem);
2024             }
2025         else
2026             {
2027             std::vector<SVGLength>::iterator iter = items.begin() + index;
2028             items.insert(iter, newItem);
2029             }
2030         return newItem;
2031         }
2032
2033     /**
2034      *
2035      */
2036     virtual SVGLength replaceItem (const SVGLength &newItem,
2037                                     unsigned long index )
2038                                throw( DOMException, SVGException )
2039         {
2040         if (index>=items.size())
2041             {
2042             SVGLength ret;
2043             return ret;
2044             }
2045         std::vector<SVGLength>::iterator iter = items.begin() + index;
2046         *iter = newItem;
2047         return newItem;
2048         }
2049
2050     /**
2051      *
2052      */
2053     virtual SVGLength removeItem (unsigned long index )
2054                     throw( DOMException )
2055         {
2056         if (index>=items.size())
2057             {
2058             SVGLength ret;
2059             return ret;
2060             }
2061         std::vector<SVGLength>::iterator iter = items.begin() + index;
2062         SVGLength oldval = *iter;
2063         items.erase(iter);
2064         return oldval;
2065         }
2066
2067     /**
2068      *
2069      */
2070     virtual SVGLength appendItem (const SVGLength &newItem )
2071                     throw( DOMException, SVGException )
2072         {
2073         items.push_back(newItem);
2074         return newItem;
2075         }
2076
2077
2078     //##################
2079     //# Non-API methods
2080     //##################
2081
2082     /**
2083      *
2084      */
2085     SVGLengthList() {}
2086
2087     /**
2088      *
2089      */
2090     SVGLengthList(const SVGLengthList &other)
2091         {
2092         items = other.items;
2093         }
2094
2095     /**
2096      *
2097      */
2098     virtual ~SVGLengthList() {}
2099
2100 protected:
2101
2102     std::vector<SVGLength>items;
2103
2104 };
2105
2106
2107
2108
2109
2110
2111 /*#########################################################################
2112 ## SVGAnimatedLengthList
2113 #########################################################################*/
2114
2115 /**
2116  *
2117  */
2118 class SVGAnimatedLengthList
2119 {
2120 public:
2121
2122     /**
2123      *
2124      */
2125     virtual SVGLengthList &getBaseVal()
2126         {
2127         return baseVal;
2128         }
2129
2130     /**
2131      *
2132      */
2133     virtual SVGLengthList &getAnimVal()
2134         {
2135         return animVal;
2136         }
2137
2138
2139
2140     //##################
2141     //# Non-API methods
2142     //##################
2143
2144     /**
2145      *
2146      */
2147     SVGAnimatedLengthList() {}
2148
2149     /**
2150      *
2151      */
2152    SVGAnimatedLengthList(const SVGAnimatedLengthList &other)
2153         {
2154         baseVal = other.baseVal;
2155         animVal = other.animVal;
2156         }
2157
2158     /**
2159      *
2160      */
2161     virtual ~SVGAnimatedLengthList() {}
2162
2163 protected:
2164
2165     SVGLengthList baseVal, animVal;
2166
2167 };
2168
2169
2170
2171
2172
2173
2174 /*#########################################################################
2175 ## SVGAngle
2176 #########################################################################*/
2177
2178 /**
2179  *
2180  */
2181 class SVGAngle
2182 {
2183 public:
2184
2185     /**
2186      *  Angle Unit Types
2187      */
2188     typedef enum
2189         {
2190         SVG_ANGLETYPE_UNKNOWN     = 0,
2191         SVG_ANGLETYPE_UNSPECIFIED = 1,
2192         SVG_ANGLETYPE_DEG         = 2,
2193         SVG_ANGLETYPE_RAD         = 3,
2194         SVG_ANGLETYPE_GRAD        = 4
2195         } AngleUnitType;
2196
2197
2198
2199     /**
2200      *
2201      */
2202     virtual unsigned short getUnitType()
2203         {
2204         return unitType;
2205         }
2206
2207     /**
2208      *
2209      */
2210     virtual double getValue()
2211         {
2212         return value;
2213         }
2214
2215     /**
2216      *
2217      */
2218     virtual void setValue(double val) throw (DOMException)
2219         {
2220         value = val;
2221         }
2222
2223     /**
2224      *
2225      */
2226     virtual double getValueInSpecifiedUnits()
2227         {
2228         double result = 0.0;
2229         //convert here
2230         return result;
2231         }
2232
2233     /**
2234      *
2235      */
2236     virtual void setValueInSpecifiedUnits(double /*val*/)
2237                                      throw (DOMException)
2238         {
2239         //do conversion
2240         }
2241
2242     /**
2243      *
2244      */
2245     virtual DOMString getValueAsString()
2246         {
2247         DOMString result;
2248         char buf[32];
2249         snprintf(buf, 31, "%f", value);
2250         result.append(buf);
2251         return result;
2252         }
2253
2254     /**
2255      *
2256      */
2257     virtual void setValueAsString(const DOMString &/*val*/)
2258                                   throw (DOMException)
2259         {
2260         //convert here
2261         }
2262
2263
2264     /**
2265      *
2266      */
2267     virtual void newValueSpecifiedUnits (unsigned short /*unitType*/,
2268                                          double /*valueInSpecifiedUnits*/ )
2269         {
2270         //convert here
2271         }
2272
2273     /**
2274      *
2275      */
2276     virtual void convertToSpecifiedUnits (unsigned short /*unitType*/ )
2277         {
2278         //convert here
2279         }
2280
2281
2282
2283     //##################
2284     //# Non-API methods
2285     //##################
2286
2287     /**
2288      *
2289      */
2290     SVGAngle()
2291         {
2292         unitType = SVG_ANGLETYPE_UNKNOWN;
2293         value    = 0.0;
2294         }
2295
2296     /**
2297      *
2298      */
2299     SVGAngle(const SVGAngle &other)
2300         {
2301         unitType = other.unitType;
2302         value    = other.value;
2303         }
2304
2305     /**
2306      *
2307      */
2308     virtual ~SVGAngle() {}
2309
2310 protected:
2311
2312     int unitType;
2313
2314     double value;
2315
2316 };
2317
2318
2319
2320
2321
2322
2323 /*#########################################################################
2324 ## SVGAnimatedAngle
2325 #########################################################################*/
2326
2327 /**
2328  *
2329  */
2330 class SVGAnimatedAngle
2331 {
2332 public:
2333
2334     /**
2335      *
2336      */
2337     virtual SVGAngle getBaseVal()
2338         {
2339         return baseVal;
2340         }
2341
2342     /**
2343      *
2344      */
2345     virtual SVGAngle getAnimVal()
2346         {
2347         return animVal;
2348         }
2349
2350     //##################
2351     //# Non-API methods
2352     //##################
2353
2354     /**
2355      *
2356      */
2357     SVGAnimatedAngle() {}
2358
2359     /**
2360      *
2361      */
2362     SVGAnimatedAngle(const SVGAngle &angle)
2363         { baseVal = angle; }
2364
2365     /**
2366      *
2367      */
2368     SVGAnimatedAngle(const SVGAnimatedAngle &other)
2369         {
2370         baseVal = other.baseVal;
2371         animVal = other.animVal;
2372         }
2373
2374     /**
2375      *
2376      */
2377     virtual ~SVGAnimatedAngle() {}
2378
2379 protected:
2380
2381     SVGAngle baseVal, animVal;
2382
2383 };
2384
2385
2386
2387
2388
2389
2390 /*#########################################################################
2391 ## SVGICCColor
2392 #########################################################################*/
2393
2394 /**
2395  *
2396  */
2397 class SVGICCColor
2398 {
2399 public:
2400
2401     /**
2402      *
2403      */
2404     virtual DOMString getColorProfile()
2405         {
2406         return colorProfile;
2407         }
2408
2409     /**
2410      *
2411      */
2412     virtual void setColorProfile(const DOMString &val) throw (DOMException)
2413         {
2414         colorProfile = val;
2415         }
2416
2417     /**
2418      *
2419      */
2420     virtual SVGNumberList &getColors()
2421         {
2422         return colors;
2423         }
2424
2425
2426
2427     //##################
2428     //# Non-API methods
2429     //##################
2430
2431     /**
2432      *
2433      */
2434     SVGICCColor() {}
2435
2436     /**
2437      *
2438      */
2439     SVGICCColor(const SVGICCColor &other)
2440         {
2441         colorProfile = other.colorProfile;
2442         colors       = other.colors;
2443         }
2444
2445     /**
2446      *
2447      */
2448     virtual ~SVGICCColor() {}
2449
2450 protected:
2451
2452     DOMString colorProfile;
2453
2454     SVGNumberList colors;
2455
2456 };
2457
2458
2459 /*#########################################################################
2460 ## SVGColor
2461 #########################################################################*/
2462
2463 /**
2464  *
2465  */
2466 class SVGColor : virtual public css::CSSValue
2467 {
2468 public:
2469
2470
2471     /**
2472      * Color Types
2473      */
2474     typedef enum
2475         {
2476         SVG_COLORTYPE_UNKNOWN           = 0,
2477         SVG_COLORTYPE_RGBCOLOR          = 1,
2478         SVG_COLORTYPE_RGBCOLOR_ICCCOLOR = 2,
2479         SVG_COLORTYPE_CURRENTCOLOR      = 3
2480         } ColorType;
2481
2482
2483     /**
2484      *
2485      */
2486     virtual unsigned short getColorType()
2487         {
2488         return colorType;
2489         }
2490
2491     /**
2492      *
2493      */
2494     virtual css::RGBColor getRgbColor()
2495         {
2496         css::RGBColor col;
2497         return col;
2498         }
2499
2500     /**
2501      *
2502      */
2503     virtual SVGICCColor getIccColor()
2504         {
2505         SVGICCColor col;
2506         return col;
2507         }
2508
2509
2510     /**
2511      *
2512      */
2513     virtual void setRGBColor (const DOMString& /*rgbColor*/ )
2514                               throw( SVGException )
2515         {
2516         }
2517
2518     /**
2519      *
2520      */
2521     virtual void setRGBColorICCColor (const DOMString& /*rgbColor*/,
2522                                       const DOMString& /*iccColor*/ )
2523                                       throw( SVGException )
2524         {
2525         }
2526
2527     /**
2528      *
2529      */
2530     virtual void setColor (unsigned short /*colorType*/,
2531                            const DOMString& /*rgbColor*/,
2532                            const DOMString& /*iccColor*/ )
2533                            throw( SVGException )
2534         {
2535         }
2536
2537
2538
2539     //##################
2540     //# Non-API methods
2541     //##################
2542
2543     /**
2544      *
2545      */
2546     SVGColor()
2547         {
2548         colorType = SVG_COLORTYPE_UNKNOWN;
2549         }
2550
2551     /**
2552      *
2553      */
2554     SVGColor(const SVGColor &other) : css::CSSValue(other)
2555         {
2556         colorType = other.colorType;
2557         }
2558
2559     /**
2560      *
2561      */
2562     virtual ~SVGColor() {}
2563
2564 protected:
2565
2566     int colorType;
2567
2568 };
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579 /*#########################################################################
2580 ## SVGRect
2581 #########################################################################*/
2582
2583 /**
2584  *
2585  */
2586 class SVGRect
2587 {
2588 public:
2589
2590     /**
2591      *
2592      */
2593     virtual double getX()
2594         {
2595         return x;
2596         }
2597
2598     /**
2599      *
2600      */
2601     virtual void setX(double val) throw (DOMException)
2602         {
2603         x = val;
2604         }
2605
2606     /**
2607      *
2608      */
2609     virtual double getY()
2610         {
2611         return y;
2612         }
2613
2614     /**
2615      *
2616      */
2617     virtual void setY(double val) throw (DOMException)
2618         {
2619         y = val;
2620         }
2621
2622     /**
2623      *
2624      */
2625     virtual double getWidth()
2626         {
2627         return width;
2628         }
2629
2630     /**
2631      *
2632      */
2633     virtual void setWidth(double val) throw (DOMException)
2634         {
2635         width = val;
2636         }
2637
2638     /**
2639      *
2640      */
2641     virtual double getHeight()
2642         {
2643         return height;
2644         }
2645
2646     /**
2647      *
2648      */
2649     virtual void setHeight(double val) throw (DOMException)
2650         {
2651         height = val;
2652         }
2653
2654
2655     //##################
2656     //# Non-API methods
2657     //##################
2658
2659     /**
2660      *
2661      */
2662     SVGRect()
2663         {
2664         x = y = width = height = 0.0;
2665         }
2666
2667     /**
2668      *
2669      */
2670     SVGRect(const SVGRect &other)
2671         {
2672         x = other.x;
2673         y = other.y;
2674         width = other.width;
2675         height = other.height;
2676         }
2677
2678     /**
2679      *
2680      */
2681     virtual ~SVGRect() {}
2682
2683 protected:
2684
2685     double x, y, width, height;
2686
2687 };
2688
2689
2690
2691
2692
2693
2694 /*#########################################################################
2695 ## SVGAnimatedRect
2696 #########################################################################*/
2697
2698 /**
2699  *
2700  */
2701 class SVGAnimatedRect
2702 {
2703 public:
2704
2705     /**
2706      *
2707      */
2708     virtual SVGRect &getBaseVal()
2709         {
2710         return baseVal;
2711         }
2712
2713     /**
2714      *
2715      */
2716     virtual SVGRect &getAnimVal()
2717         {
2718         return animVal;
2719         }
2720
2721
2722
2723     //##################
2724     //# Non-API methods
2725     //##################
2726
2727     /**
2728      *
2729      */
2730     SVGAnimatedRect()
2731         {
2732         }
2733
2734     /**
2735      *
2736      */
2737     SVGAnimatedRect(const SVGAnimatedRect &other)
2738         {
2739         baseVal = other.baseVal;
2740         animVal = other.animVal;
2741         }
2742
2743     /**
2744      *
2745      */
2746     virtual ~SVGAnimatedRect() {}
2747
2748 protected:
2749
2750     SVGRect baseVal, animVal;
2751
2752 };
2753
2754
2755
2756 /*#########################################################################
2757 ## SVGPoint
2758 #########################################################################*/
2759
2760 /**
2761  *
2762  */
2763 class SVGPoint
2764 {
2765 public:
2766
2767
2768
2769     /**
2770      *
2771      */
2772     virtual double getX()
2773         { return x; }
2774
2775     /**
2776      *
2777      */
2778     virtual void setX(double val) throw (DOMException)
2779         { x = val; }
2780
2781     /**
2782      *
2783      */
2784     virtual double getY()
2785         { return y; }
2786
2787     /**
2788      *
2789      */
2790     virtual void setY(double val) throw (DOMException)
2791         { y = val; }
2792
2793     /**
2794      *
2795      */
2796     virtual SVGPoint matrixTransform(const SVGMatrix &/*matrix*/)
2797         {
2798         SVGPoint point;
2799         return point;
2800         }
2801
2802
2803
2804     //##################
2805     //# Non-API methods
2806     //##################
2807
2808     /**
2809      *
2810      */
2811     SVGPoint()
2812         { x = y = 0; }
2813
2814     /**
2815      *
2816      */
2817     SVGPoint(const SVGPoint &other)
2818         {
2819         x = other.x;
2820         y = other.y;
2821         }
2822
2823     /**
2824      *
2825      */
2826     virtual ~SVGPoint() {}
2827
2828 protected:
2829
2830     double x, y;
2831 };
2832
2833
2834
2835
2836
2837
2838 /*#########################################################################
2839 ## SVGPointList
2840 #########################################################################*/
2841
2842 /**
2843  *
2844  */
2845 class SVGPointList
2846 {
2847 public:
2848
2849     /**
2850      *
2851      */
2852     virtual unsigned long getNumberOfItems()
2853         { return items.size(); }
2854
2855     /**
2856      *
2857      */
2858     virtual void clear() throw( DOMException )
2859         { items.clear(); }
2860
2861     /**
2862      *
2863      */
2864     virtual SVGPoint initialize(const SVGPoint &newItem)
2865                              throw( DOMException, SVGException )
2866         {
2867         items.clear();
2868         items.push_back(newItem);
2869         return newItem;
2870         }
2871
2872     /**
2873      *
2874      */
2875     virtual SVGPoint getItem(unsigned long index )
2876                              throw( DOMException )
2877         {
2878         if (index >= items.size())
2879             {
2880             SVGPoint point;
2881             return point;
2882             }
2883         return items[index];
2884         }
2885
2886     /**
2887      *
2888      */
2889     virtual SVGPoint insertItemBefore(const SVGPoint &newItem,
2890                                       unsigned long index )
2891                                       throw( DOMException, SVGException )
2892         {
2893         if (index >= items.size())
2894             items.push_back(newItem);
2895         else
2896             {
2897             std::vector<SVGPoint>::iterator iter = items.begin() + index;
2898             items.insert(iter, newItem);
2899             }
2900         return newItem;
2901         }
2902
2903     /**
2904      *
2905      */
2906     virtual SVGPoint replaceItem(const SVGPoint &newItem,
2907                                   unsigned long index )
2908                                   throw( DOMException, SVGException )
2909         {
2910         if (index >= items.size())
2911             {
2912             SVGPoint point;
2913             return point;
2914             }
2915         std::vector<SVGPoint>::iterator iter = items.begin() + index;
2916         *iter = newItem;
2917         return newItem;
2918         }
2919
2920     /**
2921      *
2922      */
2923     virtual SVGPoint removeItem(unsigned long index )
2924                                   throw( DOMException )
2925         {
2926         if (index >= items.size())
2927             {
2928             SVGPoint point;
2929             return point;
2930             }
2931         std::vector<SVGPoint>::iterator iter = items.begin() + index;
2932         SVGPoint oldItem = *iter;
2933         items.erase(iter);
2934         return oldItem;
2935         }
2936
2937     /**
2938      *
2939      */
2940     virtual SVGPoint appendItem(const SVGPoint &newItem)
2941                               throw( DOMException, SVGException )
2942         {
2943         items.push_back(newItem);
2944         return newItem;
2945         }
2946
2947
2948     //##################
2949     //# Non-API methods
2950     //##################
2951
2952     /**
2953      *
2954      */
2955     SVGPointList() {}
2956
2957
2958     /**
2959      *
2960      */
2961     SVGPointList(const SVGPointList &other)
2962         {
2963         items = other.items;
2964         }
2965
2966
2967     /**
2968      *
2969      */
2970     virtual ~SVGPointList() {}
2971
2972 protected:
2973
2974     std::vector<SVGPoint> items;
2975
2976 };
2977
2978
2979
2980
2981 /*#########################################################################
2982 ## SVGUnitTypes
2983 #########################################################################*/
2984
2985 /**
2986  *
2987  */
2988 class SVGUnitTypes
2989 {
2990 public:
2991
2992     /**
2993      * Unit Types
2994      */
2995     typedef enum
2996         {
2997         SVG_UNIT_TYPE_UNKNOWN           = 0,
2998         SVG_UNIT_TYPE_USERSPACEONUSE    = 1,
2999         SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2
3000         } UnitType;
3001
3002
3003
3004     //##################
3005     //# Non-API methods
3006     //##################
3007
3008     /**
3009      *
3010      */
3011     SVGUnitTypes() {}
3012
3013     /**
3014      *
3015      */
3016     virtual ~SVGUnitTypes() {}
3017
3018 };
3019
3020
3021
3022
3023
3024
3025 /*#########################################################################
3026 ## SVGStylable
3027 #########################################################################*/
3028
3029 /**
3030  *
3031  */
3032 class SVGStylable
3033 {
3034 public:
3035
3036     /**
3037      *
3038      */
3039     virtual SVGAnimatedString getClassName()
3040         {
3041         return className;
3042         }
3043
3044     /**
3045      *
3046      */
3047     virtual css::CSSStyleDeclaration getStyle()
3048         {
3049         return style;
3050         }
3051
3052
3053     /**
3054      *
3055      */
3056     virtual css::CSSValue getPresentationAttribute (const DOMString& /*name*/ )
3057         {
3058         css::CSSValue val;
3059         //perform a lookup
3060         return val;
3061         }
3062
3063
3064     //##################
3065     //# Non-API methods
3066     //##################
3067
3068     /**
3069      *
3070      */
3071     SVGStylable() {}
3072
3073     /**
3074      *
3075      */
3076     SVGStylable(const SVGStylable &other)
3077         {
3078         className = other.className;
3079         style     = other.style;
3080         }
3081
3082     /**
3083      *
3084      */
3085     virtual ~SVGStylable() {}
3086
3087 protected:
3088
3089     SVGAnimatedString className;
3090     css::CSSStyleDeclaration style;
3091
3092 };
3093
3094
3095 /*#########################################################################
3096 ## SVGLocatable
3097 #########################################################################*/
3098
3099 /**
3100  *
3101  */
3102 class SVGLocatable
3103 {
3104 public:
3105
3106     /**
3107      *
3108      */
3109     virtual SVGElementPtr getNearestViewportElement()
3110         {
3111         SVGElementPtr result;
3112         return result;
3113         }
3114
3115     /**
3116      *
3117      */
3118     virtual SVGElementPtr getFarthestViewportElement()
3119         {
3120         SVGElementPtr result;
3121         return result;
3122         }
3123
3124     /**
3125      *
3126      */
3127     virtual SVGRect getBBox (  )
3128         {
3129         return bbox;
3130         }
3131
3132     /**
3133      *
3134      */
3135     virtual SVGMatrix getCTM (  )
3136         {
3137         return ctm;
3138         }
3139
3140     /**
3141      *
3142      */
3143     virtual SVGMatrix getScreenCTM (  )
3144         {
3145         return screenCtm;
3146         }
3147
3148     /**
3149      *
3150      */
3151     virtual SVGMatrix getTransformToElement (const SVGElement &/*element*/)
3152                     throw( SVGException )
3153         {
3154         SVGMatrix result;
3155         //do calculations
3156         return result;
3157         }
3158
3159
3160
3161     //##################
3162     //# Non-API methods
3163     //##################
3164
3165     /**
3166      *
3167      */
3168     SVGLocatable() {}
3169
3170     /**
3171      *
3172      */
3173     SVGLocatable(const SVGLocatable &/*other*/)
3174         {
3175         }
3176
3177     /**
3178      *
3179      */
3180     virtual ~SVGLocatable() {}
3181
3182 protected:
3183
3184     SVGRect bbox;
3185     SVGMatrix ctm;
3186     SVGMatrix screenCtm;
3187
3188 };
3189
3190
3191
3192
3193
3194
3195 /*#########################################################################
3196 ## SVGTransformable
3197 #########################################################################*/
3198
3199 /**
3200  *
3201  */
3202 class SVGTransformable : public SVGLocatable
3203 {
3204 public:
3205
3206
3207     /**
3208      *
3209      */
3210     virtual SVGAnimatedTransformList &getTransform()
3211         {
3212         return transforms;
3213         }
3214
3215
3216
3217     //##################
3218     //# Non-API methods
3219     //##################
3220
3221     /**
3222      *
3223      */
3224     SVGTransformable() {}
3225
3226     /**
3227      *
3228      */
3229     SVGTransformable(const SVGTransformable &other) : SVGLocatable(other)
3230         {
3231         transforms = other.transforms;
3232         }
3233
3234     /**
3235      *
3236      */
3237     virtual ~SVGTransformable() {}
3238
3239 protected:
3240
3241     SVGAnimatedTransformList transforms;
3242 };
3243
3244
3245
3246
3247
3248
3249 /*#########################################################################
3250 ## SVGTests
3251 #########################################################################*/
3252
3253 /**
3254  *
3255  */
3256 class SVGTests
3257 {
3258 public:
3259
3260
3261     /**
3262      *
3263      */
3264     virtual SVGStringList &getRequiredFeatures()
3265         {
3266         return requiredFeatures;
3267         }
3268
3269     /**
3270      *
3271      */
3272     virtual SVGStringList &getRequiredExtensions()
3273         {
3274         return requiredExtensions;
3275         }
3276
3277     /**
3278      *
3279      */
3280     virtual SVGStringList &getSystemLanguage()
3281         {
3282         return systemLanguage;
3283         }
3284
3285
3286     /**
3287      *
3288      */
3289     virtual bool hasExtension (const DOMString& /*extension*/ )
3290         {
3291         return false;
3292         }
3293
3294
3295
3296     //##################
3297     //# Non-API methods
3298     //##################
3299
3300     /**
3301      *
3302      */
3303     SVGTests() {}
3304
3305     /**
3306      *
3307      */
3308     SVGTests(const SVGTests &other)
3309         {
3310         requiredFeatures   = other.requiredFeatures;
3311         requiredExtensions = other.requiredExtensions;
3312         systemLanguage     = other.systemLanguage;
3313         }
3314
3315     /**
3316      *
3317      */
3318     virtual ~SVGTests() {}
3319
3320 protected:
3321
3322     SVGStringList requiredFeatures;
3323     SVGStringList requiredExtensions;
3324     SVGStringList systemLanguage;
3325
3326 };
3327
3328
3329
3330
3331
3332
3333 /*#########################################################################
3334 ## SVGLangSpace
3335 #########################################################################*/
3336
3337 /**
3338  *
3339  */
3340 class SVGLangSpace
3341 {
3342 public:
3343
3344
3345     /**
3346      *
3347      */
3348     virtual DOMString getXmllang()
3349         {
3350         return xmlLang;
3351         }
3352
3353     /**
3354      *
3355      */
3356     virtual void setXmllang(const DOMString &val)
3357                                      throw (DOMException)
3358         {
3359         xmlLang = val;
3360         }
3361
3362     /**
3363      *
3364      */
3365     virtual DOMString getXmlspace()
3366         {
3367         return xmlSpace;
3368         }
3369
3370     /**
3371      *
3372      */
3373     virtual void setXmlspace(const DOMString &val)
3374                                      throw (DOMException)
3375         {
3376         xmlSpace = val;
3377         }
3378
3379
3380
3381     //##################
3382     //# Non-API methods
3383     //##################
3384
3385     /**
3386      *
3387      */
3388     SVGLangSpace() {}
3389
3390     /**
3391      *
3392      */
3393     SVGLangSpace(const SVGLangSpace &other)
3394         {
3395         xmlLang  = other.xmlLang;
3396         xmlSpace = other.xmlSpace;
3397         }
3398
3399     /**
3400      *
3401      */
3402     virtual ~SVGLangSpace() {}
3403
3404 protected:
3405
3406     DOMString xmlLang;
3407     DOMString xmlSpace;
3408
3409 };
3410
3411
3412
3413
3414
3415
3416 /*#########################################################################
3417 ## SVGExternalResourcesRequired
3418 #########################################################################*/
3419
3420 /**
3421  *
3422  */
3423 class SVGExternalResourcesRequired
3424 {
3425 public:
3426
3427
3428     /**
3429      *
3430      */
3431     virtual SVGAnimatedBoolean getExternalResourcesRequired()
3432         { return required; }
3433
3434
3435
3436     //##################
3437     //# Non-API methods
3438     //##################
3439
3440     /**
3441      *
3442      */
3443     SVGExternalResourcesRequired()
3444         {  }
3445
3446
3447     /**
3448      *
3449      */
3450     SVGExternalResourcesRequired(const SVGExternalResourcesRequired &other)
3451         {
3452         required = other.required;
3453         }
3454
3455     /**
3456      *
3457      */
3458     virtual ~SVGExternalResourcesRequired() {}
3459
3460 protected:
3461
3462     SVGAnimatedBoolean required;
3463
3464 };
3465
3466
3467
3468
3469
3470
3471 /*#########################################################################
3472 ## SVGPreserveAspectRatio
3473 #########################################################################*/
3474
3475 /**
3476  *
3477  */
3478 class SVGPreserveAspectRatio
3479 {
3480 public:
3481
3482
3483     /**
3484      * Alignment Types
3485      */
3486     typedef enum
3487         {
3488         SVG_PRESERVEASPECTRATIO_UNKNOWN  = 0,
3489         SVG_PRESERVEASPECTRATIO_NONE     = 1,
3490         SVG_PRESERVEASPECTRATIO_XMINYMIN = 2,
3491         SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3,
3492         SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4,
3493         SVG_PRESERVEASPECTRATIO_XMINYMID = 5,
3494         SVG_PRESERVEASPECTRATIO_XMIDYMID = 6,
3495         SVG_PRESERVEASPECTRATIO_XMAXYMID = 7,
3496         SVG_PRESERVEASPECTRATIO_XMINYMAX = 8,
3497         SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9,
3498         SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10
3499         } AlignmentType;
3500
3501
3502     /**
3503      * Meet-or-slice Types
3504      */
3505     typedef enum
3506         {
3507         SVG_MEETORSLICE_UNKNOWN  = 0,
3508         SVG_MEETORSLICE_MEET     = 1,
3509         SVG_MEETORSLICE_SLICE    = 2
3510         } MeetOrSliceType;
3511
3512
3513     /**
3514      *
3515      */
3516     virtual unsigned short getAlign()
3517         { return align; }
3518
3519     /**
3520      *
3521      */
3522     virtual void setAlign(unsigned short val) throw (DOMException)
3523         { align = val; }
3524
3525     /**
3526      *
3527      */
3528     virtual unsigned short getMeetOrSlice()
3529         { return meetOrSlice; }
3530
3531     /**
3532      *
3533      */
3534     virtual void setMeetOrSlice(unsigned short val) throw (DOMException)
3535         { meetOrSlice = val; }
3536
3537
3538
3539     //##################
3540     //# Non-API methods
3541     //##################
3542
3543     /**
3544      *
3545      */
3546     SVGPreserveAspectRatio()
3547         {
3548         align       = SVG_PRESERVEASPECTRATIO_UNKNOWN;
3549         meetOrSlice = SVG_MEETORSLICE_UNKNOWN;
3550         }
3551
3552     /**
3553      *
3554      */
3555     SVGPreserveAspectRatio(const SVGPreserveAspectRatio &other)
3556         {
3557         align       = other.align;
3558         meetOrSlice = other.meetOrSlice;
3559         }
3560
3561     /**
3562      *
3563      */
3564     virtual ~SVGPreserveAspectRatio() {}
3565
3566 protected:
3567
3568     unsigned short align;
3569     unsigned short meetOrSlice;
3570
3571 };
3572
3573
3574
3575
3576
3577
3578 /*#########################################################################
3579 ## SVGAnimatedPreserveAspectRatio
3580 #########################################################################*/
3581
3582 /**
3583  *
3584  */
3585 class SVGAnimatedPreserveAspectRatio
3586 {
3587 public:
3588
3589
3590     /**
3591      *
3592      */
3593     virtual SVGPreserveAspectRatio getBaseVal()
3594         { return baseVal; }
3595
3596     /**
3597      *
3598      */
3599     virtual SVGPreserveAspectRatio getAnimVal()
3600         { return animVal; }
3601
3602
3603
3604     //##################
3605     //# Non-API methods
3606     //##################
3607
3608     /**
3609      *
3610      */
3611     SVGAnimatedPreserveAspectRatio() {}
3612
3613     /**
3614      *
3615      */
3616     SVGAnimatedPreserveAspectRatio(const SVGAnimatedPreserveAspectRatio &other)
3617         {
3618         baseVal = other.baseVal;
3619         baseVal = other.animVal;
3620         }
3621
3622     /**
3623      *
3624      */
3625     virtual ~SVGAnimatedPreserveAspectRatio() {}
3626
3627 protected:
3628
3629     SVGPreserveAspectRatio baseVal;
3630     SVGPreserveAspectRatio animVal;
3631
3632 };
3633
3634
3635
3636
3637 /*#########################################################################
3638 ## SVGFitToViewBox
3639 #########################################################################*/
3640
3641 /**
3642  *
3643  */
3644 class SVGFitToViewBox
3645 {
3646 public:
3647
3648     /**
3649      *
3650      */
3651     virtual SVGAnimatedRect getViewBox()
3652         { return viewBox; }
3653
3654     /**
3655      *
3656      */
3657     virtual SVGAnimatedPreserveAspectRatio getPreserveAspectRatio()
3658         { return preserveAspectRatio; }
3659
3660
3661
3662     //##################
3663     //# Non-API methods
3664     //##################
3665
3666     /**
3667      *
3668      */
3669     SVGFitToViewBox()
3670         {}
3671
3672     /**
3673      *
3674      */
3675
3676     SVGFitToViewBox(const SVGFitToViewBox &other)
3677         {
3678         viewBox = other.viewBox;
3679         preserveAspectRatio = other.preserveAspectRatio;
3680         }
3681
3682     /**
3683      *
3684      */
3685     virtual ~SVGFitToViewBox() {}
3686
3687 protected:
3688
3689     SVGAnimatedRect viewBox;
3690
3691     SVGAnimatedPreserveAspectRatio preserveAspectRatio;
3692
3693 };
3694
3695
3696 /*#########################################################################
3697 ## SVGZoomAndPan
3698 #########################################################################*/
3699
3700 /**
3701  *
3702  */
3703 class SVGZoomAndPan
3704 {
3705 public:
3706
3707
3708     /**
3709      * Zoom and Pan Types
3710      */
3711     typedef enum
3712         {
3713         SVG_ZOOMANDPAN_UNKNOWN = 0,
3714         SVG_ZOOMANDPAN_DISABLE = 1,
3715         SVG_ZOOMANDPAN_MAGNIFY = 2
3716         } ZoomAndPanType;
3717
3718
3719     /**
3720      *
3721      */
3722     virtual unsigned short getZoomAndPan()
3723         { return zoomAndPan; }
3724
3725     /**
3726      *
3727      */
3728     virtual void setZoomAndPan(unsigned short val) throw (DOMException)
3729         { zoomAndPan = val; }
3730
3731
3732     //##################
3733     //# Non-API methods
3734     //##################
3735
3736     /**
3737      *
3738      */
3739     SVGZoomAndPan()
3740         { zoomAndPan = SVG_ZOOMANDPAN_UNKNOWN; }
3741
3742     /**
3743      *
3744      */
3745     SVGZoomAndPan(const SVGZoomAndPan &other)
3746         { zoomAndPan = other.zoomAndPan; }
3747
3748     /**
3749      *
3750      */
3751     virtual ~SVGZoomAndPan() {}
3752
3753 protected:
3754
3755     unsigned short zoomAndPan;
3756
3757 };
3758
3759
3760
3761
3762
3763
3764 /*#########################################################################
3765 ## SVGViewSpec
3766 #########################################################################*/
3767
3768 /**
3769  *
3770  */
3771 class SVGViewSpec : public SVGZoomAndPan,
3772                     public SVGFitToViewBox
3773 {
3774 public:
3775
3776     /**
3777      *
3778      */
3779     virtual SVGTransformList getTransform()
3780         { return transform; }
3781
3782     /**
3783      *
3784      */
3785     virtual SVGElementPtr getViewTarget()
3786         { return viewTarget; }
3787
3788     /**
3789      *
3790      */
3791     virtual DOMString getViewBoxString()
3792         {
3793         DOMString ret;
3794         return ret;
3795         }
3796
3797     /**
3798      *
3799      */
3800     virtual DOMString getPreserveAspectRatioString()
3801         {
3802         DOMString ret;
3803         return ret;
3804         }
3805
3806     /**
3807      *
3808      */
3809     virtual DOMString getTransformString()
3810         {
3811         DOMString ret;
3812         return ret;
3813         }
3814
3815     /**
3816      *
3817      */
3818     virtual DOMString getViewTargetString()
3819         {
3820         DOMString ret;
3821         return ret;
3822         }
3823
3824
3825
3826     //##################
3827     //# Non-API methods
3828     //##################
3829
3830     /**
3831      *
3832      */
3833     SVGViewSpec()
3834         {
3835         viewTarget = NULL;
3836         }
3837
3838     /**
3839      *
3840      */
3841     SVGViewSpec(const SVGViewSpec &other) : SVGZoomAndPan(other), SVGFitToViewBox(other)
3842         {
3843         viewTarget = other.viewTarget;
3844         transform  = other.transform;
3845         }
3846
3847     /**
3848      *
3849      */
3850     virtual ~SVGViewSpec() {}
3851
3852 protected:
3853
3854     SVGElementPtr viewTarget;
3855     SVGTransformList transform;
3856 };
3857
3858
3859
3860
3861
3862
3863 /*#########################################################################
3864 ## SVGURIReference
3865 #########################################################################*/
3866
3867 /**
3868  *
3869  */
3870 class SVGURIReference
3871 {
3872 public:
3873
3874     /**
3875      *
3876      */
3877     virtual SVGAnimatedString getHref()
3878         { return href; }
3879
3880
3881
3882     //##################
3883     //# Non-API methods
3884     //##################
3885
3886     /**
3887      *
3888      */
3889     SVGURIReference() {}
3890
3891     /**
3892      *
3893      */
3894     SVGURIReference(const SVGURIReference &other)
3895         {
3896         href = other.href;
3897         }
3898
3899     /**
3900      *
3901      */
3902     virtual ~SVGURIReference() {}
3903
3904 protected:
3905
3906     SVGAnimatedString href;
3907
3908 };
3909
3910
3911
3912
3913
3914
3915 /*#########################################################################
3916 ## SVGCSSRule
3917 #########################################################################*/
3918
3919 /**
3920  *
3921  */
3922 class SVGCSSRule : public css::CSSRule
3923 {
3924 public:
3925
3926
3927     /**
3928      * Additional CSS RuleType to support ICC color specifications
3929      */
3930     typedef enum
3931         {
3932         COLOR_PROFILE_RULE = 7
3933         } ColorProfileRuleType;
3934
3935     //##################
3936     //# Non-API methods
3937     //##################
3938
3939     /**
3940      *
3941      */
3942     SVGCSSRule()
3943         { type = COLOR_PROFILE_RULE; }
3944
3945     /**
3946      *
3947      */
3948     SVGCSSRule(const SVGCSSRule &other) : css::CSSRule(other)
3949         { type = COLOR_PROFILE_RULE; }
3950
3951     /**
3952      *
3953      */
3954     virtual ~SVGCSSRule() {}
3955
3956 };
3957
3958
3959
3960 /*#########################################################################
3961 ## SVGRenderingIntent
3962 #########################################################################*/
3963
3964 /**
3965  *
3966  */
3967 class SVGRenderingIntent
3968 {
3969 public:
3970
3971     /**
3972      * Rendering Intent Types
3973      */
3974     typedef enum
3975         {
3976         RENDERING_INTENT_UNKNOWN               = 0,
3977         RENDERING_INTENT_AUTO                  = 1,
3978         RENDERING_INTENT_PERCEPTUAL            = 2,
3979         RENDERING_INTENT_RELATIVE_COLORIMETRIC = 3,
3980         RENDERING_INTENT_SATURATION            = 4,
3981         RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = 5
3982         } RenderingIntentType;
3983
3984
3985
3986     //##################
3987     //# Non-API methods
3988     //##################
3989
3990     /**
3991      *
3992      */
3993     SVGRenderingIntent()
3994         {
3995         renderingIntentType = RENDERING_INTENT_UNKNOWN;
3996         }
3997
3998     /**
3999      *
4000      */
4001     SVGRenderingIntent(const SVGRenderingIntent &other)
4002         {
4003         renderingIntentType = other.renderingIntentType;
4004         }
4005
4006     /**
4007      *
4008      */
4009     virtual ~SVGRenderingIntent() {}
4010
4011 protected:
4012
4013     unsigned short renderingIntentType;
4014 };
4015
4016
4017
4018
4019
4020
4021
4022 /*#########################################################################
4023 ###########################################################################
4024 ## P A T H    S E G M E N T S
4025 ###########################################################################
4026 #########################################################################*/
4027
4028 static char const *const pathSegLetters[] =
4029 {
4030     "@", // PATHSEG_UNKNOWN,
4031     "z", // PATHSEG_CLOSEPATH
4032     "M", // PATHSEG_MOVETO_ABS
4033     "m", // PATHSEG_MOVETO_REL,
4034     "L", // PATHSEG_LINETO_ABS
4035     "l", // PATHSEG_LINETO_REL
4036     "C", // PATHSEG_CURVETO_CUBIC_ABS
4037     "c", // PATHSEG_CURVETO_CUBIC_REL
4038     "Q", // PATHSEG_CURVETO_QUADRATIC_ABS,
4039     "q", // PATHSEG_CURVETO_QUADRATIC_REL
4040     "A", // PATHSEG_ARC_ABS
4041     "a", // PATHSEG_ARC_REL,
4042     "H", // PATHSEG_LINETO_HORIZONTAL_ABS,
4043     "h", // PATHSEG_LINETO_HORIZONTAL_REL
4044     "V", // PATHSEG_LINETO_VERTICAL_ABS
4045     "v", // PATHSEG_LINETO_VERTICAL_REL
4046     "S", // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
4047     "s", // PATHSEG_CURVETO_CUBIC_SMOOTH_REL
4048     "T", // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
4049     "t"  // PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
4050 };
4051
4052 /*#########################################################################
4053 ## SVGPathSeg
4054 #########################################################################*/
4055
4056 /**
4057  *
4058  */
4059 class SVGPathSeg
4060 {
4061 public:
4062
4063
4064
4065     /**
4066      *  Path Segment Types
4067      */
4068     typedef enum
4069         {
4070         PATHSEG_UNKNOWN                      = 0,
4071         PATHSEG_CLOSEPATH                    = 1,
4072         PATHSEG_MOVETO_ABS                   = 2,
4073         PATHSEG_MOVETO_REL                   = 3,
4074         PATHSEG_LINETO_ABS                   = 4,
4075         PATHSEG_LINETO_REL                   = 5,
4076         PATHSEG_CURVETO_CUBIC_ABS            = 6,
4077         PATHSEG_CURVETO_CUBIC_REL            = 7,
4078         PATHSEG_CURVETO_QUADRATIC_ABS        = 8,
4079         PATHSEG_CURVETO_QUADRATIC_REL        = 9,
4080         PATHSEG_ARC_ABS                      = 10,
4081         PATHSEG_ARC_REL                      = 11,
4082         PATHSEG_LINETO_HORIZONTAL_ABS        = 12,
4083         PATHSEG_LINETO_HORIZONTAL_REL        = 13,
4084         PATHSEG_LINETO_VERTICAL_ABS          = 14,
4085         PATHSEG_LINETO_VERTICAL_REL          = 15,
4086         PATHSEG_CURVETO_CUBIC_SMOOTH_ABS     = 16,
4087         PATHSEG_CURVETO_CUBIC_SMOOTH_REL     = 17,
4088         PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18,
4089         PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19
4090         } PathSegmentType;
4091
4092     /**
4093      *
4094      */
4095     virtual unsigned short getPathSegType()
4096         { return type; }
4097
4098     /**
4099      *
4100      */
4101     virtual DOMString getPathSegTypeAsLetter()
4102         {
4103         int typ = type;
4104         if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL)
4105             typ = PATHSEG_UNKNOWN;
4106         char const *ch = pathSegLetters[typ];
4107         DOMString letter = ch;
4108         return letter;
4109         }
4110
4111
4112
4113     //##################
4114     //# Non-API methods
4115     //##################
4116
4117     /**
4118      *
4119      */
4120     SVGPathSeg()
4121         { type = PATHSEG_UNKNOWN; }
4122
4123     /**
4124      *
4125      */
4126     SVGPathSeg(const SVGPathSeg &other)
4127         {
4128         type = other.type;
4129         }
4130
4131     /**
4132      *
4133      */
4134     virtual ~SVGPathSeg() {}
4135
4136 protected:
4137
4138     int type;
4139
4140 };
4141
4142
4143
4144
4145
4146
4147 /*#########################################################################
4148 ## SVGPathSegClosePath
4149 #########################################################################*/
4150
4151 /**
4152  *
4153  */
4154 class SVGPathSegClosePath : public SVGPathSeg
4155 {
4156 public:
4157
4158     //##################
4159     //# Non-API methods
4160     //##################
4161
4162     /**
4163      *
4164      */
4165     SVGPathSegClosePath()
4166         {
4167         type = PATHSEG_CLOSEPATH;
4168         }
4169
4170     /**
4171      *
4172      */
4173     SVGPathSegClosePath(const SVGPathSegClosePath &other) : SVGPathSeg(other)
4174         {
4175         type = PATHSEG_CLOSEPATH;
4176         }
4177
4178     /**
4179      *
4180      */
4181     virtual ~SVGPathSegClosePath() {}
4182
4183 };
4184
4185
4186
4187
4188 /*#########################################################################
4189 ## SVGPathSegMovetoAbs
4190 #########################################################################*/
4191
4192 /**
4193  *
4194  */
4195 class SVGPathSegMovetoAbs : public SVGPathSeg
4196 {
4197 public:
4198
4199     /**
4200      *
4201      */
4202     virtual double getX()
4203         { return x; }
4204
4205     /**
4206      *
4207      */
4208     virtual void setX(double val) throw (DOMException)
4209         { x = val; }
4210
4211     /**
4212      *
4213      */
4214     virtual double getY()
4215         { return y; }
4216
4217     /**
4218      *
4219      */
4220     virtual void setY(double val) throw (DOMException)
4221         { y = val; }
4222
4223     //##################
4224     //# Non-API methods
4225     //##################
4226
4227     /**
4228      *
4229      */
4230     SVGPathSegMovetoAbs()
4231         {
4232         type = PATHSEG_MOVETO_ABS;
4233         x = y = 0.0;
4234         }
4235
4236     /**
4237      *
4238      */
4239     SVGPathSegMovetoAbs(double xArg, double yArg)
4240         {
4241         type = PATHSEG_MOVETO_ABS;
4242         x = xArg; y = yArg;
4243         }
4244
4245     /**
4246      *
4247      */
4248     SVGPathSegMovetoAbs(const SVGPathSegMovetoAbs &other) : SVGPathSeg(other)
4249         {
4250         type = PATHSEG_MOVETO_ABS;
4251         x = other.x; y = other.y;
4252         }
4253
4254     /**
4255      *
4256      */
4257     virtual ~SVGPathSegMovetoAbs() {}
4258
4259 protected:
4260
4261     double x,y;
4262
4263 };
4264
4265
4266
4267
4268
4269
4270 /*#########################################################################
4271 ## SVGPathSegMovetoRel
4272 #########################################################################*/
4273
4274 /**
4275  *
4276  */
4277 class SVGPathSegMovetoRel : public SVGPathSeg
4278 {
4279 public:
4280
4281     /**
4282      *
4283      */
4284     virtual double getX()
4285         { return x; }
4286
4287     /**
4288      *
4289      */
4290     virtual void setX(double val) throw (DOMException)
4291         { x = val; }
4292
4293     /**
4294      *
4295      */
4296     virtual double getY()
4297         { return y; }
4298
4299     /**
4300      *
4301      */
4302     virtual void setY(double val) throw (DOMException)
4303         { y = val; }
4304
4305     //##################
4306     //# Non-API methods
4307     //##################
4308
4309     /**
4310      *
4311      */
4312     SVGPathSegMovetoRel()
4313         {
4314         type = PATHSEG_MOVETO_REL;
4315         x = y = 0.0;
4316         }
4317
4318
4319     /**
4320      *
4321      */
4322     SVGPathSegMovetoRel(double xArg, double yArg)
4323         {
4324         type = PATHSEG_MOVETO_REL;
4325         x = xArg; y = yArg;
4326         }
4327
4328     /**
4329      *
4330      */
4331     SVGPathSegMovetoRel(const SVGPathSegMovetoRel &other) : SVGPathSeg(other)
4332         {
4333         type = PATHSEG_MOVETO_REL;
4334         x = other.x; y = other.y;
4335         }
4336
4337     /**
4338      *
4339      */
4340     virtual ~SVGPathSegMovetoRel() {}
4341
4342 protected:
4343
4344     double x,y;
4345 };
4346
4347
4348
4349
4350
4351
4352 /*#########################################################################
4353 ## SVGPathSegLinetoAbs
4354 #########################################################################*/
4355
4356 /**
4357  *
4358  */
4359 class SVGPathSegLinetoAbs : public SVGPathSeg
4360 {
4361 public:
4362
4363     /**
4364      *
4365      */
4366     virtual double getX()
4367         { return x; }
4368
4369     /**
4370      *
4371      */
4372     virtual void setX(double val) throw (DOMException)
4373         { x = val; }
4374
4375     /**
4376      *
4377      */
4378     virtual double getY()
4379         { return y; }
4380
4381     /**
4382      *
4383      */
4384     virtual void setY(double val) throw (DOMException)
4385         { y = val; }
4386
4387     //##################
4388     //# Non-API methods
4389     //##################
4390
4391     /**
4392      *
4393      */
4394     SVGPathSegLinetoAbs()
4395         {
4396         type = PATHSEG_LINETO_ABS;
4397         x = y = 0.0;
4398         }
4399
4400
4401     /**
4402      *
4403      */
4404     SVGPathSegLinetoAbs(double xArg, double yArg)
4405         {
4406         type = PATHSEG_LINETO_ABS;
4407         x = xArg; y = yArg;
4408         }
4409
4410     /**
4411      *
4412      */
4413     SVGPathSegLinetoAbs(const SVGPathSegLinetoAbs &other) : SVGPathSeg(other)
4414         {
4415         type = PATHSEG_LINETO_ABS;
4416         x = other.x; y = other.y;
4417         }
4418
4419     /**
4420      *
4421      */
4422     virtual ~SVGPathSegLinetoAbs() {}
4423
4424 protected:
4425
4426     double x,y;
4427 };
4428
4429
4430
4431
4432
4433
4434 /*#########################################################################
4435 ## SVGPathSegLinetoRel
4436 #########################################################################*/
4437
4438 /**
4439  *
4440  */
4441 class SVGPathSegLinetoRel : public SVGPathSeg
4442 {
4443 public:
4444
4445     /**
4446      *
4447      */
4448     virtual double getX()
4449         { return x; }
4450
4451     /**
4452      *
4453      */
4454     virtual void setX(double val) throw (DOMException)
4455         { x = val; }
4456
4457     /**
4458      *
4459      */
4460     virtual double getY()
4461         { return y; }
4462
4463     /**
4464      *
4465      */
4466     virtual void setY(double val) throw (DOMException)
4467         { y = val; }
4468
4469     //##################
4470     //# Non-API methods
4471     //##################
4472
4473     /**
4474      *
4475      */
4476     SVGPathSegLinetoRel()
4477         {
4478         type = PATHSEG_LINETO_REL;
4479         x = y = 0.0;
4480         }
4481
4482
4483     /**
4484      *
4485      */
4486     SVGPathSegLinetoRel(double xArg, double yArg)
4487         {
4488         type = PATHSEG_LINETO_REL;
4489         x = xArg; y = yArg;
4490         }
4491
4492     /**
4493      *
4494      */
4495     SVGPathSegLinetoRel(const SVGPathSegLinetoRel &other) : SVGPathSeg(other)
4496         {
4497         type = PATHSEG_LINETO_REL;
4498         x = other.x; y = other.y;
4499         }
4500
4501     /**
4502      *
4503      */
4504     virtual ~SVGPathSegLinetoRel() {}
4505
4506 protected:
4507
4508     double x,y;
4509 };
4510
4511
4512
4513
4514
4515
4516 /*#########################################################################
4517 ## SVGPathSegCurvetoCubicAbs
4518 #########################################################################*/
4519
4520 /**
4521  *
4522  */
4523 class SVGPathSegCurvetoCubicAbs : public SVGPathSeg
4524 {
4525 public:
4526
4527     /**
4528      *
4529      */
4530     virtual double getX()
4531         { return x; }
4532
4533     /**
4534      *
4535      */
4536     virtual void setX(double val) throw (DOMException)
4537         { x = val; }
4538
4539     /**
4540      *
4541      */
4542     virtual double getY()
4543         { return y; }
4544
4545     /**
4546      *
4547      */
4548     virtual void setY(double val) throw (DOMException)
4549         { y = val; }
4550
4551     /**
4552      *
4553      */
4554     virtual double getX1()
4555         { return x1; }
4556
4557     /**
4558      *
4559      */
4560     virtual void setX1(double val) throw (DOMException)
4561         { x1 = val; }
4562
4563     /**
4564      *
4565      */
4566     virtual double getY1()
4567         { return y1; }
4568
4569     /**
4570      *
4571      */
4572     virtual void setY1(double val) throw (DOMException)
4573         { y1 = val; }
4574
4575
4576     /**
4577      *
4578      */
4579     virtual double getX2()
4580         { return x2; }
4581
4582     /**
4583      *
4584      */
4585     virtual void setX2(double val) throw (DOMException)
4586         { x2 = val; }
4587
4588     /**
4589      *
4590      */
4591     virtual double getY2()
4592         { return y2; }
4593
4594     /**
4595      *
4596      */
4597     virtual void setY2(double val) throw (DOMException)
4598         { y2 = val; }
4599
4600
4601     //##################
4602     //# Non-API methods
4603     //##################
4604
4605
4606     /**
4607      *
4608      */
4609     SVGPathSegCurvetoCubicAbs()
4610         {
4611         type = PATHSEG_CURVETO_CUBIC_ABS;
4612         x = y = x1 = y1 = x2 = y2 = 0.0;
4613         }
4614
4615     /**
4616      *
4617      */
4618     SVGPathSegCurvetoCubicAbs(double xArg,  double yArg,
4619                               double x1Arg, double y1Arg,
4620                               double x2Arg, double y2Arg)
4621         {
4622         type = PATHSEG_CURVETO_CUBIC_ABS;
4623         x  = xArg;   y  = yArg;
4624         x1 = x1Arg;  y1 = y1Arg;
4625         x2 = x2Arg;  y2 = y2Arg;
4626         }
4627
4628     /**
4629      *
4630      */
4631     SVGPathSegCurvetoCubicAbs(const SVGPathSegCurvetoCubicAbs &other)
4632                      : SVGPathSeg(other)
4633         {
4634         type = PATHSEG_CURVETO_CUBIC_ABS;
4635         x  = other.x;  y  = other.y;
4636         x1 = other.x1; y1 = other.y1;
4637         x2 = other.x2; y2 = other.y2;
4638         }
4639
4640     /**
4641      *
4642      */
4643     virtual ~SVGPathSegCurvetoCubicAbs() {}
4644
4645 protected:
4646
4647     double x, y, x1, y1, x2, y2;
4648
4649 };
4650
4651
4652
4653
4654
4655
4656 /*#########################################################################
4657 ## SVGPathSegCurvetoCubicRel
4658 #########################################################################*/
4659
4660 /**
4661  *
4662  */
4663 class SVGPathSegCurvetoCubicRel : public SVGPathSeg
4664 {
4665 public:
4666
4667     /**
4668      *
4669      */
4670     virtual double getX()
4671         { return x; }
4672
4673     /**
4674      *
4675      */
4676     virtual void setX(double val) throw (DOMException)
4677         { x = val; }
4678
4679     /**
4680      *
4681      */
4682     virtual double getY()
4683         { return y; }
4684
4685     /**
4686      *
4687      */
4688     virtual void setY(double val) throw (DOMException)
4689         { y = val; }
4690
4691     /**
4692      *
4693      */
4694     virtual double getX1()
4695         { return x1; }
4696
4697     /**
4698      *
4699      */
4700     virtual void setX1(double val) throw (DOMException)
4701         { x1 = val; }
4702
4703     /**
4704      *
4705      */
4706     virtual double getY1()
4707         { return y1; }
4708
4709     /**
4710      *
4711      */
4712     virtual void setY1(double val) throw (DOMException)
4713         { y1 = val; }
4714
4715
4716     /**
4717      *
4718      */
4719     virtual double getX2()
4720         { return x2; }
4721
4722     /**
4723      *
4724      */
4725     virtual void setX2(double val) throw (DOMException)
4726         { x2 = val; }
4727
4728     /**
4729      *
4730      */
4731     virtual double getY2()
4732         { return y2; }
4733
4734     /**
4735      *
4736      */
4737     virtual void setY2(double val) throw (DOMException)
4738         { y2 = val; }
4739
4740
4741     //##################
4742     //# Non-API methods
4743     //##################
4744
4745
4746     /**
4747      *
4748      */
4749     SVGPathSegCurvetoCubicRel()
4750         {
4751         type = PATHSEG_CURVETO_CUBIC_REL;
4752         x = y = x1 = y1 = x2 = y2 = 0.0;
4753         }
4754
4755
4756     /**
4757      *
4758      */
4759     SVGPathSegCurvetoCubicRel(double xArg,  double yArg,
4760                               double x1Arg, double y1Arg,
4761                               double x2Arg, double y2Arg)
4762         {
4763         type = PATHSEG_CURVETO_CUBIC_REL;
4764         x  = xArg;   y  = yArg;
4765         x1 = x1Arg;  y1 = y1Arg;
4766         x2 = x2Arg;  y2 = y2Arg;
4767         }
4768
4769     /**
4770      *
4771      */
4772     SVGPathSegCurvetoCubicRel(const SVGPathSegCurvetoCubicRel &other)
4773                      : SVGPathSeg(other)
4774         {
4775         type = PATHSEG_CURVETO_CUBIC_REL;
4776         x  = other.x;  y  = other.y;
4777         x1 = other.x1; y1 = other.y1;
4778         x2 = other.x2; y2 = other.y2;
4779         }
4780
4781     /**
4782      *
4783      */
4784     virtual ~SVGPathSegCurvetoCubicRel() {}
4785
4786 protected:
4787
4788     double x, y, x1, y1, x2, y2;
4789
4790 };
4791
4792
4793
4794
4795
4796
4797 /*#########################################################################
4798 ## SVGPathSegCurvetoQuadraticAbs
4799 #########################################################################*/
4800
4801 /**
4802  *
4803  */
4804 class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg
4805 {
4806 public:
4807
4808     /**
4809      *
4810      */
4811     virtual double getX()
4812         { return x; }
4813
4814     /**
4815      *
4816      */
4817     virtual void setX(double val) throw (DOMException)
4818         { x = val; }
4819
4820     /**
4821      *
4822      */
4823     virtual double getY()
4824         { return y; }
4825
4826     /**
4827      *
4828      */
4829     virtual void setY(double val) throw (DOMException)
4830         { y = val; }
4831
4832     /**
4833      *
4834      */
4835     virtual double getX1()
4836         { return x1; }
4837
4838     /**
4839      *
4840      */
4841     virtual void setX1(double val) throw (DOMException)
4842         { x1 = val; }
4843
4844     /**
4845      *
4846      */
4847     virtual double getY1()
4848         { return y1; }
4849
4850     /**
4851      *
4852      */
4853     virtual void setY1(double val) throw (DOMException)
4854         { y1 = val; }
4855
4856
4857     //##################
4858     //# Non-API methods
4859     //##################
4860
4861
4862     /**
4863      *
4864      */
4865     SVGPathSegCurvetoQuadraticAbs()
4866         {
4867         type = PATHSEG_CURVETO_QUADRATIC_ABS;
4868         x = y = x1 = y1 = 0.0;
4869         }
4870
4871     /**
4872      *
4873      */
4874     SVGPathSegCurvetoQuadraticAbs(double xArg,  double yArg,
4875                               double x1Arg, double y1Arg)
4876         {
4877         type = PATHSEG_CURVETO_QUADRATIC_ABS;
4878         x  = xArg;   y  = yArg;
4879         x1 = x1Arg;  y1 = y1Arg;
4880         }
4881
4882     /**
4883      *
4884      */
4885     SVGPathSegCurvetoQuadraticAbs(const SVGPathSegCurvetoQuadraticAbs &other)
4886                      : SVGPathSeg(other)
4887         {
4888         type = PATHSEG_CURVETO_QUADRATIC_ABS;
4889         x  = other.x;  y  = other.y;
4890         x1 = other.x1; y1 = other.y1;
4891         }
4892
4893     /**
4894      *
4895      */
4896     virtual ~SVGPathSegCurvetoQuadraticAbs() {}
4897
4898 protected:
4899
4900     double x, y, x1, y1;
4901
4902 };
4903
4904
4905
4906
4907
4908
4909 /*#########################################################################
4910 ## SVGPathSegCurvetoQuadraticRel
4911 #########################################################################*/
4912
4913 /**
4914  *
4915  */
4916 class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg
4917 {
4918 public:
4919
4920     /**
4921      *
4922      */
4923     virtual double getX()
4924         { return x; }
4925
4926     /**
4927      *
4928      */
4929     virtual void setX(double val) throw (DOMException)
4930         { x = val; }
4931
4932     /**
4933      *
4934      */
4935     virtual double getY()
4936         { return y; }
4937
4938     /**
4939      *
4940      */
4941     virtual void setY(double val) throw (DOMException)
4942         { y = val; }
4943
4944     /**
4945      *
4946      */
4947     virtual double getX1()
4948         { return x1; }
4949
4950     /**
4951      *
4952      */
4953     virtual void setX1(double val) throw (DOMException)
4954         { x1 = val; }
4955
4956     /**
4957      *
4958      */
4959     virtual double getY1()
4960         { return y1; }
4961
4962     /**
4963      *
4964      */
4965     virtual void setY1(double val) throw (DOMException)
4966         { y1 = val; }
4967
4968
4969     //##################
4970     //# Non-API methods
4971     //##################
4972
4973
4974     /**
4975      *
4976      */
4977     SVGPathSegCurvetoQuadraticRel()
4978         {
4979         type = PATHSEG_CURVETO_QUADRATIC_REL;
4980         x = y = x1 = y1 = 0.0;
4981         }
4982
4983
4984     /**
4985      *
4986      */
4987     SVGPathSegCurvetoQuadraticRel(double xArg,  double yArg,
4988                                   double x1Arg, double y1Arg)
4989         {
4990         type = PATHSEG_CURVETO_QUADRATIC_REL;
4991         x  = xArg;   y  = yArg;
4992         x1 = x1Arg;  y1 = y1Arg;
4993         }
4994
4995     /**
4996      *
4997      */
4998     SVGPathSegCurvetoQuadraticRel(const SVGPathSegCurvetoQuadraticRel &other)
4999                      : SVGPathSeg(other)
5000         {
5001         type = PATHSEG_CURVETO_QUADRATIC_REL;
5002         x  = other.x;  y  = other.y;
5003         x1 = other.x1; y1 = other.y1;
5004         }
5005
5006     /**
5007      *
5008      */
5009     virtual ~SVGPathSegCurvetoQuadraticRel() {}
5010
5011 protected:
5012
5013     double x, y, x1, y1;
5014
5015 };
5016
5017
5018
5019
5020
5021
5022 /*#########################################################################
5023 ## SVGPathSegArcAbs
5024 #########################################################################*/
5025
5026 /**
5027  *
5028  */
5029 class SVGPathSegArcAbs : public SVGPathSeg
5030 {
5031 public:
5032
5033     /**
5034      *
5035      */
5036     virtual double getX()
5037         { return x; }
5038
5039     /**
5040      *
5041      */
5042     virtual void setX(double val) throw (DOMException)
5043         { x = val; }
5044
5045     /**
5046      *
5047      */
5048     virtual double getY()
5049         { return y; }
5050
5051     /**
5052      *
5053      */
5054     virtual void setY(double val) throw (DOMException)
5055         { y = val; }
5056
5057     /**
5058      *
5059      */
5060     virtual double getR1()
5061         { return r1; }
5062
5063     /**
5064      *
5065      */
5066     virtual void setR1(double val) throw (DOMException)
5067         { r1 = val; }
5068
5069     /**
5070      *
5071      */
5072     virtual double getR2()
5073         { return r2; }
5074
5075     /**
5076      *
5077      */
5078     virtual void setR2(double val) throw (DOMException)
5079         { r2 = val; }
5080
5081     /**
5082      *
5083      */
5084     virtual double getAngle()
5085         { return angle; }
5086
5087     /**
5088      *
5089      */
5090     virtual void setAngle(double val) throw (DOMException)
5091         { angle = val; }
5092
5093     /**
5094      *
5095      */
5096     virtual bool getLargeArcFlag()
5097         { return largeArcFlag; }
5098
5099     /**
5100      *
5101      */
5102     virtual void setLargeArcFlag(bool val) throw (DOMException)
5103         { largeArcFlag = val; }
5104
5105     /**
5106      *
5107      */
5108     virtual bool getSweepFlag()
5109         { return sweepFlag; }
5110
5111     /**
5112      *
5113      */
5114     virtual void setSweepFlag(bool val) throw (DOMException)
5115         { sweepFlag = val; }
5116
5117     //##################
5118     //# Non-API methods
5119     //##################
5120
5121
5122     /**
5123      *
5124      */
5125     SVGPathSegArcAbs()
5126         {
5127         type = PATHSEG_ARC_ABS;
5128         x = y = r1 = r2 = angle = 0.0;
5129         largeArcFlag = sweepFlag = false;
5130         }
5131
5132     /**
5133      *
5134      */
5135     SVGPathSegArcAbs(double xArg,  double yArg,
5136                      double r1Arg, double r2Arg,
5137                      double angleArg,
5138                      bool largeArcFlagArg,
5139                      bool sweepFlagArg )
5140
5141         {
5142         type = PATHSEG_ARC_ABS;
5143         x  = xArg;   y  = yArg;
5144         r1 = r1Arg;  r2 = r2Arg;
5145         angle        = angleArg;
5146         largeArcFlag = largeArcFlagArg;
5147         sweepFlag    = sweepFlagArg;
5148         }
5149
5150     /**
5151      *
5152      */
5153     SVGPathSegArcAbs(const SVGPathSegArcAbs &other)
5154                      : SVGPathSeg(other)
5155         {
5156         type = PATHSEG_ARC_ABS;
5157         x  = other.x;  y  = other.y;
5158         r1 = other.r1; r2 = other.r2;
5159         angle        = other.angle;
5160         largeArcFlag = other.largeArcFlag;
5161         sweepFlag    = other.sweepFlag;
5162         }
5163
5164     /**
5165      *
5166      */
5167     virtual ~SVGPathSegArcAbs() {}
5168
5169 protected:
5170
5171     double x, y, r1, r2, angle;
5172     bool largeArcFlag;
5173     bool sweepFlag;
5174
5175 };
5176
5177
5178
5179 /*#########################################################################
5180 ## SVGPathSegArcRel
5181 #########################################################################*/
5182
5183 /**
5184  *
5185  */
5186 class SVGPathSegArcRel : public SVGPathSeg
5187 {
5188 public:
5189
5190     /**
5191      *
5192      */
5193     virtual double getX()
5194         { return x; }
5195
5196     /**
5197      *
5198      */
5199     virtual void setX(double val) throw (DOMException)
5200         { x = val; }
5201
5202     /**
5203      *
5204      */
5205     virtual double getY()
5206         { return y; }
5207
5208     /**
5209      *
5210      */
5211     virtual void setY(double val) throw (DOMException)
5212         { y = val; }
5213
5214     /**
5215      *
5216      */
5217     virtual double getR1()
5218         { return r1; }
5219
5220     /**
5221      *
5222      */
5223     virtual void setR1(double val) throw (DOMException)
5224         { r1 = val; }
5225
5226     /**
5227      *
5228      */
5229     virtual double getR2()
5230         { return r2; }
5231
5232     /**
5233      *
5234      */
5235     virtual void setR2(double val) throw (DOMException)
5236         { r2 = val; }
5237
5238     /**
5239      *
5240      */
5241     virtual double getAngle()
5242         { return angle; }
5243
5244     /**
5245      *
5246      */
5247     virtual void setAngle(double val) throw (DOMException)
5248         { angle = val; }
5249
5250     /**
5251      *
5252      */
5253     virtual bool getLargeArcFlag()
5254         { return largeArcFlag; }
5255
5256     /**
5257      *
5258      */
5259     virtual void setLargeArcFlag(bool val) throw (DOMException)
5260         { largeArcFlag = val; }
5261
5262     /**
5263      *
5264      */
5265     virtual bool getSweepFlag()
5266         { return sweepFlag; }
5267
5268     /**
5269      *
5270      */
5271     virtual void setSweepFlag(bool val) throw (DOMException)
5272         { sweepFlag = val; }
5273
5274     //##################
5275     //# Non-API methods
5276     //##################
5277
5278
5279     /**
5280      *
5281      */
5282     SVGPathSegArcRel()
5283         {
5284         type = PATHSEG_ARC_REL;
5285         x = y = r1 = r2 = angle = 0.0;
5286         largeArcFlag = sweepFlag = false;
5287         }
5288
5289
5290     /**
5291      *
5292      */
5293     SVGPathSegArcRel(double xArg, double yArg,
5294                      double r1Arg, double r2Arg,
5295                      double angleArg,
5296                      bool largeArcFlagArg,
5297                      bool sweepFlagArg )
5298
5299         {
5300         type = PATHSEG_ARC_REL;
5301         x  = xArg;   y  = yArg;
5302         r1 = r1Arg;  r2 = r2Arg;
5303         angle        = angleArg;
5304         largeArcFlag = largeArcFlagArg;
5305         sweepFlag    = sweepFlagArg;
5306         }
5307
5308     /**
5309      *
5310      */
5311     SVGPathSegArcRel(const SVGPathSegArcRel &other)
5312                      : SVGPathSeg(other)
5313         {
5314         type = PATHSEG_ARC_REL;
5315         x  = other.x;  y  = other.y;
5316         r1 = other.r1; r2 = other.r2;
5317         angle        = other.angle;
5318         largeArcFlag = other.largeArcFlag;
5319         sweepFlag    = other.sweepFlag;
5320         }
5321
5322     /**
5323      *
5324      */
5325     virtual ~SVGPathSegArcRel() {}
5326
5327 protected:
5328
5329     double x, y, r1, r2, angle;
5330     bool largeArcFlag;
5331     bool sweepFlag;
5332
5333 };
5334
5335
5336
5337
5338
5339
5340 /*#########################################################################
5341 ## SVGPathSegLinetoHorizontalAbs
5342 #########################################################################*/
5343
5344 /**
5345  *
5346  */
5347 class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg
5348 {
5349 public:
5350
5351     /**
5352      *
5353      */
5354     virtual double getX()
5355         { return x; }
5356
5357     /**
5358      *
5359      */
5360     virtual void setX(double val) throw (DOMException)
5361         { x = val; }
5362
5363     //##################
5364     //# Non-API methods
5365     //##################
5366
5367     /**
5368      *
5369      */
5370     SVGPathSegLinetoHorizontalAbs()
5371         {
5372         type = PATHSEG_LINETO_HORIZONTAL_ABS;
5373         x = 0.0;
5374         }
5375
5376
5377     /**
5378      *
5379      */
5380     SVGPathSegLinetoHorizontalAbs(double xArg)
5381         {
5382         type = PATHSEG_LINETO_HORIZONTAL_ABS;
5383         x = xArg;
5384         }
5385
5386     /**
5387      *
5388      */
5389     SVGPathSegLinetoHorizontalAbs(const SVGPathSegLinetoHorizontalAbs &other)
5390                      : SVGPathSeg(other)
5391         {
5392         type = PATHSEG_LINETO_HORIZONTAL_ABS;
5393         x = other.x;
5394         }
5395
5396     /**
5397      *
5398      */
5399     virtual ~SVGPathSegLinetoHorizontalAbs() {}
5400
5401 protected:
5402
5403     double x;
5404
5405 };
5406
5407
5408
5409
5410
5411
5412 /*#########################################################################
5413 ## SVGPathSegLinetoHorizontalRel
5414 #########################################################################*/
5415
5416 /**
5417  *
5418  */
5419 class SVGPathSegLinetoHorizontalRel : public SVGPathSeg
5420 {
5421 public:
5422
5423     /**
5424      *
5425      */
5426     virtual double getX()
5427         { return x; }
5428
5429     /**
5430      *
5431      */
5432     virtual void setX(double val) throw (DOMException)
5433         { x = val; }
5434
5435     //##################
5436     //# Non-API methods
5437     //##################
5438
5439     /**
5440      *
5441      */
5442     SVGPathSegLinetoHorizontalRel()
5443         {
5444         type = PATHSEG_LINETO_HORIZONTAL_REL;
5445         x = 0.0;
5446         }
5447
5448
5449     /**
5450      *
5451      */
5452     SVGPathSegLinetoHorizontalRel(double xArg)
5453         {
5454         type = PATHSEG_LINETO_HORIZONTAL_REL;
5455         x = xArg;
5456         }
5457
5458     /**
5459      *
5460      */
5461     SVGPathSegLinetoHorizontalRel(const SVGPathSegLinetoHorizontalRel &other)
5462                      : SVGPathSeg(other)
5463         {
5464         type = PATHSEG_LINETO_HORIZONTAL_REL;
5465         x = other.x;
5466         }
5467
5468     /**
5469      *
5470      */
5471     virtual ~SVGPathSegLinetoHorizontalRel() {}
5472
5473 protected:
5474
5475     double x;
5476
5477 };
5478
5479
5480
5481 /*#########################################################################
5482 ## SVGPathSegLinetoVerticalAbs
5483 #########################################################################*/
5484
5485 /**
5486  *
5487  */
5488 class SVGPathSegLinetoVerticalAbs : public SVGPathSeg
5489 {
5490 public:
5491
5492     /**
5493      *
5494      */
5495     virtual double getY()
5496         { return y; }
5497
5498     /**
5499      *
5500      */
5501     virtual void setY(double val) throw (DOMException)
5502         { y = val; }
5503
5504     //##################
5505     //# Non-API methods
5506     //##################
5507
5508     /**
5509      *
5510      */
5511     SVGPathSegLinetoVerticalAbs()
5512         {
5513         type = PATHSEG_LINETO_VERTICAL_ABS;
5514         y = 0.0;
5515         }
5516
5517
5518     /**
5519      *
5520      */
5521     SVGPathSegLinetoVerticalAbs(double yArg)
5522         {
5523         type = PATHSEG_LINETO_VERTICAL_ABS;
5524         y = yArg;
5525         }
5526
5527     /**
5528      *
5529      */
5530     SVGPathSegLinetoVerticalAbs(const SVGPathSegLinetoVerticalAbs &other)
5531                      : SVGPathSeg(other)
5532         {
5533         type = PATHSEG_LINETO_VERTICAL_ABS;
5534         y = other.y;
5535         }
5536
5537     /**
5538      *
5539      */
5540     virtual ~SVGPathSegLinetoVerticalAbs() {}
5541
5542 protected:
5543
5544     double y;
5545
5546 };
5547
5548
5549
5550 /*#########################################################################
5551 ## SVGPathSegLinetoVerticalRel
5552 #########################################################################*/
5553
5554 /**
5555  *
5556  */
5557 class SVGPathSegLinetoVerticalRel : public SVGPathSeg
5558 {
5559 public:
5560
5561     /**
5562      *
5563      */
5564     virtual double getY()
5565         { return y; }
5566
5567     /**
5568      *
5569      */
5570     virtual void setY(double val) throw (DOMException)
5571         { y = val; }
5572
5573     //##################
5574     //# Non-API methods
5575     //##################
5576
5577     /**
5578      *
5579      */
5580     SVGPathSegLinetoVerticalRel()
5581         {
5582         type = PATHSEG_LINETO_VERTICAL_REL;
5583         y = 0.0;
5584         }
5585
5586
5587     /**
5588      *
5589      */
5590     SVGPathSegLinetoVerticalRel(double yArg)
5591         {
5592         type = PATHSEG_LINETO_VERTICAL_REL;
5593         y = yArg;
5594         }
5595
5596     /**
5597      *
5598      */
5599     SVGPathSegLinetoVerticalRel(const SVGPathSegLinetoVerticalRel &other)
5600                      : SVGPathSeg(other)
5601         {
5602         type = PATHSEG_LINETO_VERTICAL_REL;
5603         y = other.y;
5604         }
5605
5606     /**
5607      *
5608      */
5609     virtual ~SVGPathSegLinetoVerticalRel() {}
5610
5611 protected:
5612
5613     double y;
5614
5615 };
5616
5617
5618
5619
5620
5621
5622 /*#########################################################################
5623 ## SVGPathSegCurvetoCubicSmoothAbs
5624 #########################################################################*/
5625
5626 /**
5627  *
5628  */
5629 class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg
5630 {
5631 public:
5632
5633     /**
5634      *
5635      */
5636     virtual double getX()
5637         { return x; }
5638
5639     /**
5640      *
5641      */
5642     virtual void setX(double val) throw (DOMException)
5643         { x = val; }
5644
5645     /**
5646      *
5647      */
5648     virtual double getY()
5649         { return y; }
5650
5651     /**
5652      *
5653      */
5654     virtual void setY(double val) throw (DOMException)
5655         { y = val; }
5656
5657     /**
5658      *
5659      */
5660     virtual double getX2()
5661         { return x2; }
5662
5663     /**
5664      *
5665      */
5666     virtual void setX2(double val) throw (DOMException)
5667         { x2 = val; }
5668
5669     /**
5670      *
5671      */
5672     virtual double getY2()
5673         { return y2; }
5674
5675     /**
5676      *
5677      */
5678     virtual void setY2(double val) throw (DOMException)
5679         { y2 = val; }
5680
5681
5682     //##################
5683     //# Non-API methods
5684     //##################
5685
5686     /**
5687      *
5688      */
5689     SVGPathSegCurvetoCubicSmoothAbs()
5690         {
5691         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
5692         x = y = x2 = y2 = 0.0;
5693         }
5694
5695
5696     /**
5697      *
5698      */
5699     SVGPathSegCurvetoCubicSmoothAbs(double xArg,   double yArg,
5700                                     double x2Arg, double y2Arg)
5701         {
5702         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
5703         x  = xArg;    y  = yArg;
5704         x2 = x2Arg;   y2 = y2Arg;
5705         }
5706
5707     /**
5708      *
5709      */
5710     SVGPathSegCurvetoCubicSmoothAbs(const SVGPathSegCurvetoCubicSmoothAbs &other)
5711                      : SVGPathSeg(other)
5712         {
5713         type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
5714         x  = other.x;  y  = other.y;
5715         x2 = other.x2; y2 = other.y2;
5716         }
5717
5718     /**
5719      *
5720      */
5721     virtual ~SVGPathSegCurvetoCubicSmoothAbs() {}
5722
5723 protected:
5724
5725     double x, y, x2, y2;
5726
5727 };
5728
5729
5730
5731 /*#########################################################################
5732 ## SVGPathSegCurvetoCubicSmoothRel
5733 #########################################################################*/
5734
5735 /**
5736  *
5737  */
5738 class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg
5739 {
5740 public:
5741
5742     /**
5743      *
5744      */
5745     virtual double getX()
5746         { return x; }
5747
5748     /**
5749      *
5750      */
5751     virtual void setX(double val) throw (DOMException)
5752         { x = val; }
5753
5754     /**
5755      *
5756      */
5757     virtual double getY()
5758         { return y; }
5759
5760     /**
5761      *
5762      */
5763     virtual void setY(double val) throw (DOMException)
5764         { y = val; }
5765
5766     /**
5767      *
5768      */
5769     virtual double getX2()
5770         { return x2; }
5771
5772     /**
5773      *
5774      */
5775     virtual void setX2(double val) throw (DOMException)
5776         { x2 = val; }
5777
5778     /**
5779      *
5780      */
5781     virtual double getY2()
5782         { return y2; }
5783
5784     /**
5785      *
5786      */
5787     virtual void setY2(double val) throw (DOMException)
5788         { y2 = val; }
5789
5790
5791     //##################
5792     //# Non-API methods
5793     //##################
5794
5795     /**
5796      *
5797      */
5798     SVGPathSegCurvetoCubicSmoothRel()
5799         {
5800         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
5801         x = y = x2 = y2 = 0.0;
5802         }
5803
5804
5805     /**
5806      *
5807      */
5808     SVGPathSegCurvetoCubicSmoothRel(double xArg,   double yArg,
5809                                     double x2Arg, double y2Arg)
5810         {
5811         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
5812         x  = xArg;    y  = yArg;
5813         x2 = x2Arg;   y2 = y2Arg;
5814         }
5815
5816     /**
5817      *
5818      */
5819     SVGPathSegCurvetoCubicSmoothRel(const SVGPathSegCurvetoCubicSmoothRel &other)
5820                      : SVGPathSeg(other)
5821         {
5822         type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
5823         x  = other.x;  y  = other.y;
5824         x2 = other.x2; y2 = other.y2;
5825         }
5826
5827     /**
5828      *
5829      */
5830     virtual ~SVGPathSegCurvetoCubicSmoothRel() {}
5831
5832 protected:
5833
5834     double x, y, x2, y2;
5835
5836 };
5837
5838
5839
5840
5841
5842
5843 /*#########################################################################
5844 ## SVGPathSegCurvetoQuadraticSmoothAbs
5845 #########################################################################*/
5846
5847 /**
5848  *
5849  */
5850 class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg
5851 {
5852 public:
5853
5854     /**
5855      *
5856      */
5857     virtual double getX()
5858         { return x; }
5859
5860     /**
5861      *
5862      */
5863     virtual void setX(double val) throw (DOMException)
5864         { x = val; }
5865
5866     /**
5867      *
5868      */
5869     virtual double getY()
5870         { return y; }
5871
5872     /**
5873      *
5874      */
5875     virtual void setY(double val) throw (DOMException)
5876         { y = val; }
5877
5878
5879
5880     //##################
5881     //# Non-API methods
5882     //##################
5883
5884     /**
5885      *
5886      */
5887     SVGPathSegCurvetoQuadraticSmoothAbs()
5888         {
5889         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
5890         x = y = 0.0;
5891         }
5892
5893
5894     /**
5895      *
5896      */
5897     SVGPathSegCurvetoQuadraticSmoothAbs(double xArg, double yArg)
5898         {
5899         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
5900         x = xArg;     y = yArg;
5901         }
5902
5903     /**
5904      *
5905      */
5906     SVGPathSegCurvetoQuadraticSmoothAbs(const SVGPathSegCurvetoQuadraticSmoothAbs &other)
5907                      : SVGPathSeg(other)
5908         {
5909         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
5910         x = y = 0.0;
5911         }
5912
5913     /**
5914      *
5915      */
5916     virtual ~SVGPathSegCurvetoQuadraticSmoothAbs() {}
5917
5918 protected:
5919
5920     double x, y;
5921
5922 };
5923
5924
5925
5926
5927
5928
5929 /*#########################################################################
5930 ## SVGPathSegCurvetoQuadraticSmoothRel
5931 #########################################################################*/
5932
5933 /**
5934  *
5935  */
5936 class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg
5937 {
5938 public:
5939
5940     /**
5941      *
5942      */
5943     virtual double getX()
5944         { return x; }
5945
5946     /**
5947      *
5948      */
5949     virtual void setX(double val) throw (DOMException)
5950         { x = val; }
5951
5952     /**
5953      *
5954      */
5955     virtual double getY()
5956         { return y; }
5957
5958     /**
5959      *
5960      */
5961     virtual void setY(double val) throw (DOMException)
5962         { y = val; }
5963
5964
5965
5966     //##################
5967     //# Non-API methods
5968     //##################
5969
5970     /**
5971      *
5972      */
5973     SVGPathSegCurvetoQuadraticSmoothRel()
5974         {
5975         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
5976         x = y = 0.0;
5977         }
5978
5979
5980     /**
5981      *
5982      */
5983     SVGPathSegCurvetoQuadraticSmoothRel(double xArg, double yArg)
5984         {
5985         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
5986         x = xArg;     y = yArg;
5987         }
5988
5989     /**
5990      *
5991      */
5992     SVGPathSegCurvetoQuadraticSmoothRel(const SVGPathSegCurvetoQuadraticSmoothRel &other)
5993                      : SVGPathSeg(other)
5994         {
5995         type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
5996         x = y = 0.0;
5997         }
5998
5999     /**
6000      *
6001      */
6002     virtual ~SVGPathSegCurvetoQuadraticSmoothRel() {}
6003
6004 protected:
6005
6006     double x, y;
6007
6008 };
6009
6010
6011
6012
6013
6014
6015 /*#########################################################################
6016 ## SVGPathSegList
6017 #########################################################################*/
6018
6019 /**
6020  *
6021  */
6022 class SVGPathSegList
6023 {
6024 public:
6025
6026     /**
6027      *
6028      */
6029     virtual unsigned long getNumberOfItems()
6030         { return items.size(); }
6031
6032
6033     /**
6034      *
6035      */
6036     virtual void clear () throw( DOMException )
6037         { items.clear(); }
6038
6039     /**
6040      *
6041      */
6042     virtual SVGPathSeg initialize (const SVGPathSeg &newItem)
6043                     throw( DOMException, SVGException )
6044         {
6045         items.clear();
6046         items.push_back(newItem);
6047         return newItem;
6048         }
6049
6050     /**
6051      *
6052      */
6053     virtual SVGPathSeg getItem (unsigned long index)
6054                     throw( DOMException )
6055         {
6056         if (index >= items.size())
6057             {
6058             SVGPathSeg seg;
6059             return seg;
6060             }
6061         return items[index];
6062         }
6063
6064     /**
6065      *
6066      */
6067     virtual SVGPathSeg insertItemBefore(const SVGPathSeg &newItem,
6068                                         unsigned long index )
6069                           throw( DOMException, SVGException )
6070         {
6071         if (index >= items.size())
6072             items.push_back(newItem);
6073         else
6074             {
6075             std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
6076             items.insert(iter, newItem);
6077             }
6078         return newItem;
6079         }
6080
6081     /**
6082      *
6083      */
6084     virtual SVGPathSeg replaceItem(const SVGPathSeg &newItem,
6085                                    unsigned long index )
6086                               throw( DOMException, SVGException )
6087         {
6088         if (index >= items.size())
6089             {
6090             SVGPathSeg seg;
6091             return seg;
6092             }
6093         std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
6094         *iter = newItem;
6095         return newItem;
6096         }
6097
6098     /**
6099      *
6100      */
6101     virtual SVGPathSeg removeItem (unsigned long index)
6102                                   throw (DOMException)
6103         {
6104         if (index >= items.size())
6105             {
6106             SVGPathSeg seg;
6107             return seg;
6108             }
6109         std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
6110         SVGPathSeg olditem = *iter;
6111         items.erase(iter);
6112         return olditem;
6113         }
6114
6115     /**
6116      *
6117      */
6118     virtual SVGPathSeg appendItem (const SVGPathSeg &newItem)
6119                     throw( DOMException, SVGException )
6120         {
6121         items.push_back(newItem);
6122         return newItem;
6123         }
6124
6125
6126
6127     //##################
6128     //# Non-API methods
6129     //##################
6130
6131     /**
6132      *
6133      */
6134     SVGPathSegList() {}
6135
6136
6137     /**
6138      *
6139      */
6140     SVGPathSegList(const SVGPathSegList &other)
6141         {
6142         items = other.items;
6143         }
6144
6145
6146     /**
6147      *
6148      */
6149     virtual ~SVGPathSegList() {}
6150
6151 protected:
6152
6153     std::vector<SVGPathSeg> items;
6154
6155 };
6156
6157
6158
6159
6160
6161
6162 /*#########################################################################
6163 ## SVGAnimatedPathData
6164 #########################################################################*/
6165
6166 /**
6167  *
6168  */
6169 class SVGAnimatedPathData
6170 {
6171 public:
6172
6173     /**
6174      *
6175      */
6176     virtual SVGPathSegList getPathSegList()
6177         {
6178         SVGPathSegList list;
6179         return list;
6180         }
6181
6182     /**
6183      *
6184      */
6185     virtual SVGPathSegList getNormalizedPathSegList()
6186         {
6187         SVGPathSegList list;
6188         return list;
6189         }
6190
6191     /**
6192      *
6193      */
6194     virtual SVGPathSegList getAnimatedPathSegList()
6195         {
6196         SVGPathSegList list;
6197         return list;
6198         }
6199
6200     /**
6201      *
6202      */
6203     virtual SVGPathSegList getAnimatedNormalizedPathSegList()
6204         {
6205         SVGPathSegList list;
6206         return list;
6207         }
6208
6209
6210
6211     //##################
6212     //# Non-API methods
6213     //##################
6214
6215     /**
6216      *
6217      */
6218    SVGAnimatedPathData()
6219         {}
6220
6221     /**
6222      *
6223      */
6224    SVGAnimatedPathData(const SVGAnimatedPathData &/*other*/)
6225         {
6226         }
6227
6228     /**
6229      *
6230      */
6231     virtual ~SVGAnimatedPathData() {}
6232
6233 };
6234
6235
6236
6237
6238
6239
6240 /*#########################################################################
6241 ## SVGAnimatedPoints
6242 #########################################################################*/
6243
6244 /**
6245  *
6246  */
6247 class SVGAnimatedPoints
6248 {
6249 public:
6250
6251     /**
6252      *
6253      */
6254     virtual SVGPointList getPoints()
6255         { return points; }
6256
6257     /**
6258      *
6259      */
6260     virtual SVGPointList getAnimatedPoints()
6261         { return animatedPoints; }
6262
6263
6264
6265     //##################
6266     //# Non-API methods
6267     //##################
6268
6269     /**
6270      *
6271      */
6272     SVGAnimatedPoints() {}
6273
6274     /**
6275      *
6276      */
6277     SVGAnimatedPoints(const SVGAnimatedPoints &other)
6278         {
6279         points         = other.points;
6280         animatedPoints = other.animatedPoints;
6281         }
6282
6283     /**
6284      *
6285      */
6286     virtual ~SVGAnimatedPoints() {}
6287
6288 protected:
6289
6290     SVGPointList points;
6291     SVGPointList animatedPoints;
6292
6293 };
6294
6295
6296
6297
6298
6299 /*#########################################################################
6300 ## SVGPaint
6301 #########################################################################*/
6302
6303 /**
6304  *
6305  */
6306 class SVGPaint : public SVGColor
6307 {
6308 public:
6309
6310
6311     /**
6312      * Paint Types
6313      */
6314     typedef enum
6315         {
6316         SVG_PAINTTYPE_UNKNOWN               = 0,
6317         SVG_PAINTTYPE_RGBCOLOR              = 1,
6318         SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR     = 2,
6319         SVG_PAINTTYPE_NONE                  = 101,
6320         SVG_PAINTTYPE_CURRENTCOLOR          = 102,
6321         SVG_PAINTTYPE_URI_NONE              = 103,
6322         SVG_PAINTTYPE_URI_CURRENTCOLOR      = 104,
6323         SVG_PAINTTYPE_URI_RGBCOLOR          = 105,
6324         SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR = 106,
6325         SVG_PAINTTYPE_URI                   = 107
6326         } PaintType;
6327
6328
6329     /**
6330      *
6331      */
6332     virtual unsigned short getPaintType()
6333         { return paintType; }
6334
6335     /**
6336      *
6337      */
6338     virtual DOMString getUri()
6339         { return uri; }
6340
6341     /**
6342      *
6343      */
6344     virtual void setUri (const DOMString& uriArg )
6345         { uri = uriArg; }
6346
6347     /**
6348      *
6349      */
6350     virtual void setPaint (unsigned short paintTypeArg,
6351                            const DOMString& uriArg,
6352                            const DOMString& /*rgbColor*/,
6353                            const DOMString& /*iccColor*/ )
6354                            throw( SVGException )
6355         {
6356         paintType = paintTypeArg;
6357         uri       = uriArg;
6358         //do something with rgbColor
6359         //do something with iccColor;
6360         }
6361
6362
6363
6364     //##################
6365     //# Non-API methods
6366     //##################
6367
6368     /**
6369      *
6370      */
6371     SVGPaint()
6372         {
6373         uri       = "";
6374         paintType = SVG_PAINTTYPE_UNKNOWN;
6375         }
6376
6377     /**
6378      *
6379      */
6380     SVGPaint(const SVGPaint &other) : css::CSSValue(other), SVGColor(other)
6381         {
6382         uri       = "";
6383         paintType = SVG_PAINTTYPE_UNKNOWN;
6384         }
6385
6386     /**
6387      *
6388      */
6389     virtual ~SVGPaint() {}
6390
6391 protected:
6392
6393     unsigned int paintType;
6394     DOMString uri;
6395
6396 };
6397
6398
6399
6400
6401 /*#########################################################################
6402 ## SVGColorProfileRule
6403 #########################################################################*/
6404
6405 /**
6406  *
6407  */
6408 class SVGColorProfileRule : public SVGCSSRule,
6409                             public SVGRenderingIntent
6410 {
6411
6412 public:
6413    /**
6414      *
6415      */
6416     virtual DOMString getSrc()
6417         { return src; }
6418
6419     /**
6420      *
6421      */
6422     virtual void setSrc(const DOMString &val) throw (DOMException)
6423         { src = val; }
6424
6425     /**
6426      *
6427      */
6428     virtual DOMString getName()
6429         { return name; }
6430
6431     /**
6432      *
6433      */
6434     virtual void setName(const DOMString &val) throw (DOMException)
6435         { name = val; }
6436
6437     /**
6438      *
6439      */
6440     virtual unsigned short getRenderingIntent()
6441         { return renderingIntent; }
6442
6443     /**
6444      *
6445      */
6446     virtual void setRenderingIntent(unsigned short val) throw (DOMException)
6447         { renderingIntent = val; }
6448
6449
6450     //##################
6451     //# Non-API methods
6452     //##################
6453
6454     /**
6455      *
6456      */
6457     SVGColorProfileRule() {}
6458
6459     /**
6460      *
6461      */
6462     SVGColorProfileRule(const SVGColorProfileRule &other)
6463                : SVGCSSRule(other), SVGRenderingIntent(other)
6464         {
6465         renderingIntent = other.renderingIntent;
6466         src             = other.src;
6467         name            = other.name;
6468         }
6469
6470     /**
6471      *
6472      */
6473     virtual ~SVGColorProfileRule() {}
6474
6475 protected:
6476
6477     unsigned short renderingIntent;
6478     DOMString src;
6479     DOMString name;
6480
6481 };
6482
6483
6484
6485 /*#########################################################################
6486 ## SVGFilterPrimitiveStandardAttributes
6487 #########################################################################*/
6488
6489 /**
6490  *
6491  */
6492 class SVGFilterPrimitiveStandardAttributes : public SVGStylable
6493 {
6494 public:
6495
6496
6497
6498     /**
6499      *
6500      */
6501     virtual SVGAnimatedLength getX()
6502         { return x; }
6503
6504     /**
6505      *
6506      */
6507     virtual SVGAnimatedLength getY()
6508         { return y; }
6509
6510     /**
6511      *
6512      */
6513     virtual SVGAnimatedLength getWidth()
6514         { return width; }
6515
6516     /**
6517      *
6518      */
6519     virtual SVGAnimatedLength getHeight()
6520         { return height; }
6521
6522     /**
6523      *
6524      */
6525     virtual SVGAnimatedString getResult()
6526         { return result; }
6527
6528
6529
6530     //##################
6531     //# Non-API methods
6532     //##################
6533
6534
6535     /**
6536      *
6537      */
6538     SVGFilterPrimitiveStandardAttributes()
6539         {}
6540
6541     /**
6542      *
6543      */
6544     SVGFilterPrimitiveStandardAttributes(const SVGFilterPrimitiveStandardAttributes &other)
6545                                  : SVGStylable(other)
6546         {
6547         x      = other.x;
6548         y      = other.y;
6549         width  = other.width;
6550         height = other.height;
6551         result = other.result;
6552         }
6553
6554     /**
6555      *
6556      */
6557     virtual ~SVGFilterPrimitiveStandardAttributes() {}
6558
6559 protected:
6560
6561     SVGAnimatedLength x;
6562     SVGAnimatedLength y;
6563     SVGAnimatedLength width;
6564     SVGAnimatedLength height;
6565     SVGAnimatedString result;
6566
6567 };
6568
6569
6570
6571
6572
6573
6574
6575
6576
6577
6578
6579 /*#########################################################################
6580 ## SVGEvent
6581 #########################################################################*/
6582
6583 /**
6584  *
6585  */
6586 class SVGEvent : events::Event
6587 {
6588 public:
6589
6590     //##################
6591     //# Non-API methods
6592     //##################
6593
6594     /**
6595      *
6596      */
6597     SVGEvent() {}
6598
6599     /**
6600      *
6601      */
6602     SVGEvent(const SVGEvent &other) : events::Event(other)
6603         {}
6604
6605     /**
6606      *
6607      */
6608     virtual ~SVGEvent() {}
6609
6610 };
6611
6612
6613
6614
6615 /*#########################################################################
6616 ## SVGZoomEvent
6617 #########################################################################*/
6618
6619 /**
6620  *
6621  */
6622 class SVGZoomEvent : events::UIEvent
6623 {
6624 public:
6625
6626     /**
6627      *
6628      */
6629     virtual SVGRect getZoomRectScreen()
6630         { return zoomRectScreen; }
6631
6632     /**
6633      *
6634      */
6635     virtual double getPreviousScale()
6636         { return previousScale; }
6637
6638     /**
6639      *
6640      */
6641     virtual SVGPoint getPreviousTranslate()
6642         { return previousTranslate; }
6643
6644     /**
6645      *
6646      */
6647     virtual double getNewScale()
6648         { return newScale; }
6649
6650    /**
6651      *
6652      */
6653     virtual SVGPoint getNewTranslate()
6654         { return newTranslate; }
6655
6656
6657
6658     //##################
6659     //# Non-API methods
6660     //##################
6661
6662     /**
6663      *
6664      */
6665     SVGZoomEvent()
6666         {}
6667
6668     /**
6669      *
6670      */
6671     SVGZoomEvent(const SVGZoomEvent &other) : events::Event(other),
6672                                               events::UIEvent(other)
6673         {
6674         zoomRectScreen    = other.zoomRectScreen;
6675         previousScale     = other.previousScale;
6676         previousTranslate = other.previousTranslate;
6677         newScale          = other.newScale;
6678         newTranslate      = other.newTranslate;
6679         }
6680
6681     /**
6682      *
6683      */
6684     virtual ~SVGZoomEvent() {}
6685
6686 protected:
6687
6688     SVGRect  zoomRectScreen;
6689     double   previousScale;
6690     SVGPoint previousTranslate;
6691     double   newScale;
6692     SVGPoint newTranslate;
6693
6694 };
6695
6696
6697
6698 /*#########################################################################
6699 ## SVGElementInstance
6700 #########################################################################*/
6701
6702 /**
6703  *
6704  */
6705 class SVGElementInstance : public events::EventTarget
6706 {
6707 public:
6708
6709     /**
6710      *
6711      */
6712     virtual SVGElementPtr getCorrespondingElement()
6713         { return correspondingElement; }
6714
6715     /**
6716      *
6717      */
6718     virtual SVGUseElementPtr getCorrespondingUseElement()
6719         { return correspondingUseElement; }
6720
6721     /**
6722      *
6723      */
6724     virtual SVGElementInstance getParentNode()
6725         {
6726         SVGElementInstance ret;
6727         return ret;
6728         }
6729
6730     /**
6731      *  Since we are using stack types and this is a circular definition,
6732      *  we will instead implement this as a global function below:
6733      *   SVGElementInstanceList getChildNodes(const SVGElementInstance instance);
6734      */
6735     //virtual SVGElementInstanceList getChildNodes();
6736
6737     /**
6738      *
6739      */
6740     virtual SVGElementInstance getFirstChild()
6741         {
6742         SVGElementInstance ret;
6743         return ret;
6744         }
6745
6746     /**
6747      *
6748      */
6749     virtual SVGElementInstance getLastChild()
6750         {
6751         SVGElementInstance ret;
6752         return ret;
6753         }
6754
6755     /**
6756      *
6757      */
6758     virtual SVGElementInstance getPreviousSibling()
6759         {
6760         SVGElementInstance ret;
6761         return ret;
6762         }
6763
6764     /**
6765      *
6766      */
6767     virtual SVGElementInstance getNextSibling()
6768         {
6769         SVGElementInstance ret;
6770         return ret;
6771         }
6772
6773
6774     //##################
6775     //# Non-API methods
6776     //##################
6777
6778     /**
6779      *
6780      */
6781     SVGElementInstance() {}
6782
6783     /**
6784      *
6785      */
6786     SVGElementInstance(const SVGElementInstance &other)
6787                         : events::EventTarget(other)
6788         {
6789         }
6790
6791     /**
6792      *
6793      */
6794     virtual ~SVGElementInstance() {}
6795
6796 protected:
6797
6798     SVGElementPtr      correspondingElement;
6799     SVGUseElementPtr   correspondingUseElement;
6800
6801 };
6802
6803
6804
6805
6806
6807
6808 /*#########################################################################
6809 ## SVGElementInstanceList
6810 #########################################################################*/
6811
6812 /**
6813  *
6814  */
6815 class SVGElementInstanceList
6816 {
6817 public:
6818
6819
6820     /**
6821      *
6822      */
6823     virtual unsigned long getLength()
6824         { return items.size(); }
6825
6826     /**
6827      *
6828      */
6829     virtual SVGElementInstance item (unsigned long index )
6830         {
6831         if (index >= items.size())
6832             {
6833             SVGElementInstance ret;
6834             return ret;
6835             }
6836         return items[index];
6837         }
6838
6839     /**
6840      *  This static method replaces the circular definition of:
6841      *        SVGElementInstanceList SVGElementInstance::getChildNodes()
6842      *
6843      */
6844     static SVGElementInstanceList getChildNodes(const SVGElementInstance &/*instance*/)
6845         {
6846         SVGElementInstanceList list;
6847         return list;
6848         }
6849
6850
6851     //##################
6852     //# Non-API methods
6853     //##################
6854
6855     /**
6856      *
6857      */
6858     SVGElementInstanceList() {}
6859
6860     /**
6861      *
6862      */
6863     SVGElementInstanceList(const SVGElementInstanceList &other)
6864         {
6865         items = other.items;
6866         }
6867
6868     /**
6869      *
6870      */
6871     virtual ~SVGElementInstanceList() {}
6872
6873 protected:
6874
6875     std::vector<SVGElementInstance> items;
6876
6877
6878 };
6879
6880
6881
6882
6883
6884
6885
6886
6887
6888
6889
6890
6891
6892 }  //namespace svg
6893 }  //namespace dom
6894 }  //namespace w3c
6895 }  //namespace org
6896
6897 #endif /* __SVGTYPES_H__ */
6898 /*#########################################################################
6899 ## E N D    O F    F I L E
6900 #########################################################################*/
6901