src/dom/svgtypes.h

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