svg2.cpp

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