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