# Appendix C: IDL Definitions

This appendix contains the complete OMG IDL for the SVG Document Object Model definitions. The IDL is also available at: http://www.w3.org/Graphics/SVG/Group/2000/CR-SVG-20001102/idl.zip.

    // File: svg.idl
    #ifndef _SVG_IDL_
    #define _SVG_IDL_

    // For access to DOM2 core
    #include "dom.idl"

    // For access to DOM2 events
    #include "events.idl"

    // For access to those parts from DOM2 CSS OM used by SVG DOM.
    #include "css.idl"

    // For access to those parts from DOM2 Views OM used by SVG DOM.
    #include "views.idl"

    // For access to the SMIL OM used by SVG DOM.
    #include "smil.idl"

    #pragma prefix "dom.w3c.org"
    #pragma javaPackage "org.w3c.dom"
    module svg
    {
      typedef dom::DOMString DOMString;
      typedef dom::DOMException DOMException;
      typedef dom::Element Element;
      typedef dom::Document Document;
      typedef dom::NodeList NodeList;

      // Predeclarations
      interface SVGElement;
      interface SVGList;
      interface SVGLangSpace;
      interface SVGExternalResourcesRequired;
      interface SVGTests;
      interface SVGFitToViewBox;
      interface SVGZoomAndPan;
      interface SVGViewSpec;
      interface SVGURIReference;
      interface SVGPoint;
      interface SVGMatrix;
      interface SVGPreserveAspectRatio;
      interface SVGAnimatedPreserveAspectRatio;
      interface SVGTransformList;
      interface SVGAnimatedTransformList;
      interface SVGTransform;
      interface SVGICCColor;
      interface SVGColor;
      interface SVGPaint;
      interface SVGTransformable;
      interface SVGDocument;
      interface SVGSVGElement;
      interface SVGElementInstance;
      interface SVGElementInstanceList;

      exception SVGException {
        unsigned short   code;
      };

      // SVGExceptionCode
      const unsigned short SVG_WRONG_TYPE_ERR           = 0;
      const unsigned short SVG_INVALID_VALUE_ERR        = 1;
      const unsigned short SVG_MATRIX_NOT_INVERTABLE    = 2;

      interface SVGElement : Element {
                 attribute DOMString id;
                             // raises DOMException on setting
        readonly attribute SVGSVGElement ownerSVGElement;
        readonly attribute SVGElement viewportElement;
      };

      interface SVGAnimatedBoolean {

                 attribute boolean baseVal;
                             // raises DOMException on setting
        readonly attribute boolean animVal;
      };

      interface SVGAnimatedString {

                 attribute DOMString baseVal;
                             // raises DOMException on setting
        readonly attribute DOMString animVal;
      };

      interface SVGStringList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        DOMString initialize ( in DOMString newItem )
                        raises( DOMException, SVGException );
        DOMString getItem ( in unsigned long index )
                        raises( DOMException );
        DOMString insertItemBefore ( in DOMString newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        DOMString replaceItem ( in DOMString newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        DOMString removeItem ( in unsigned long index )
                        raises( DOMException );
        DOMString appendItem ( in DOMString newItem )
                        raises( DOMException, SVGException );
      };

      interface SVGAnimatedEnumeration {

                 attribute unsigned short baseVal;
                             // raises DOMException on setting
        readonly attribute unsigned short animVal;
      };

      interface SVGAnimatedInteger {

                 attribute long baseVal;
                             // raises DOMException on setting
        readonly attribute long animVal;
      };

      interface SVGNumber {

                 attribute float value;
                             // raises DOMException on setting
      };

      interface SVGAnimatedNumber {

                 attribute float baseVal;
                             // raises DOMException on setting
        readonly attribute float animVal;
      };

      interface SVGNumberList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        SVGNumber initialize ( in SVGNumber newItem )
                        raises( DOMException, SVGException );
        SVGNumber getItem ( in unsigned long index )
                        raises( DOMException );
        SVGNumber insertItemBefore ( in SVGNumber newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGNumber replaceItem ( in SVGNumber newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGNumber removeItem ( in unsigned long index )
                        raises( DOMException );
        SVGNumber appendItem ( in SVGNumber newItem )
                        raises( DOMException, SVGException );
      };

      interface SVGAnimatedNumberList {

        readonly attribute SVGNumberList baseVal;
        readonly attribute SVGNumberList animVal;
      };

      interface SVGLength {

        // Length Unit Types
        const unsigned short SVG_LENGTHTYPE_UNKNOWN    = 0;
        const unsigned short SVG_LENGTHTYPE_NUMBER     = 1;
        const unsigned short SVG_LENGTHTYPE_PERCENTAGE = 2;
        const unsigned short SVG_LENGTHTYPE_EMS        = 3;
        const unsigned short SVG_LENGTHTYPE_EXS        = 4;
        const unsigned short SVG_LENGTHTYPE_PX         = 5;
        const unsigned short SVG_LENGTHTYPE_CM         = 6;
        const unsigned short SVG_LENGTHTYPE_MM         = 7;
        const unsigned short SVG_LENGTHTYPE_IN         = 8;
        const unsigned short SVG_LENGTHTYPE_PT         = 9;
        const unsigned short SVG_LENGTHTYPE_PC         = 10;

        readonly attribute unsigned short unitType;
                 attribute float          value;
                             // raises DOMException on setting
                 attribute float          valueInSpecifiedUnits;
                             // raises DOMException on setting
                 attribute DOMString      valueAsString;
                             // raises DOMException on setting

        void newValueSpecifiedUnits ( in unsigned short unitType, in float valueInSpecifiedUnits );
        void convertToSpecifiedUnits ( in unsigned short unitType );
      };

      interface SVGAnimatedLength {

        readonly attribute SVGLength baseVal;
        readonly attribute SVGLength animVal;
      };

      interface SVGLengthList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        SVGLength initialize ( in SVGLength newItem )
                        raises( DOMException, SVGException );
        SVGLength getItem ( in unsigned long index )
                        raises( DOMException );
        SVGLength insertItemBefore ( in SVGLength newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGLength replaceItem ( in SVGLength newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGLength removeItem ( in unsigned long index )
                        raises( DOMException );
        SVGLength appendItem ( in SVGLength newItem )
                        raises( DOMException, SVGException );
      };

      interface SVGAnimatedLengthList {

        readonly attribute SVGLengthList baseVal;
        readonly attribute SVGLengthList animVal;
      };

      interface SVGAngle {

        // Angle Unit Types
        const unsigned short SVG_ANGLETYPE_UNKNOWN     = 0;
        const unsigned short SVG_ANGLETYPE_UNSPECIFIED = 1;
        const unsigned short SVG_ANGLETYPE_DEG         = 2;
        const unsigned short SVG_ANGLETYPE_RAD         = 3;
        const unsigned short SVG_ANGLETYPE_GRAD        = 4;

        readonly attribute unsigned short unitType;
                 attribute float          value;
                             // raises DOMException on setting
                 attribute float          valueInSpecifiedUnits;
                             // raises DOMException on setting
                 attribute DOMString      valueAsString;
                             // raises DOMException on setting

        void newValueSpecifiedUnits ( in unsigned short unitType, in float valueInSpecifiedUnits );
        void convertToSpecifiedUnits ( in unsigned short unitType );
      };

      interface SVGAnimatedAngle {

        readonly attribute SVGAngle baseVal;
        readonly attribute SVGAngle animVal;
      };

      interface SVGColor : css::CSSValue {
        // Color Types
        const unsigned short SVG_COLORTYPE_UNKNOWN           = 0;
        const unsigned short SVG_COLORTYPE_RGBCOLOR          = 1;
        const unsigned short SVG_COLORTYPE_RGBCOLOR_ICCCOLOR = 2;

        readonly attribute unsigned short colorType;
        readonly attribute css::RGBColor       rgbColor;
        readonly attribute SVGICCColor    iccColor;

        void        setRGBColor ( in DOMString rgbColor )
                        raises( SVGException );
        void        setRGBColorICCColor ( in DOMString rgbColor, in DOMString iccColor )
                        raises( SVGException );
      };

      interface SVGICCColor {

                 attribute DOMString      colorProfile;
                             // raises DOMException on setting
        readonly attribute SVGNumberList colors;
      };

      interface SVGRect {

                 attribute float x;
                             // raises DOMException on setting
                 attribute float y;
                             // raises DOMException on setting
                 attribute float width;
                             // raises DOMException on setting
                 attribute float height;
                             // raises DOMException on setting
      };

      interface SVGAnimatedRect {

        readonly attribute SVGRect baseVal;
        readonly attribute SVGRect animVal;
      };

      interface SVGUnitTypes {

        // Unit Types
        const unsigned short SVG_UNIT_TYPE_UNKNOWN           = 0;
        const unsigned short SVG_UNIT_TYPE_USERSPACEONUSE    = 1;
        const unsigned short SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2;
      };

      interface SVGStylable {

        readonly attribute SVGAnimatedString className;
        readonly attribute css::CSSStyleDeclaration style;

        css::CSSValue getPresentationAttribute ( in DOMString name );
      };

      interface SVGLocatable {

        readonly attribute SVGElement              nearestViewportElement;
        readonly attribute SVGElement              farthestViewportElement;

        SVGRect   getBBox (  );
        SVGMatrix getCTM (  );
        SVGMatrix getScreenCTM (  );
        SVGMatrix getTransformToElement ( in SVGElement element )
                        raises( SVGException );
      };

      interface SVGTransformable : SVGLocatable {
        readonly attribute SVGAnimatedTransformList transform;
      };

      interface SVGTests {

        readonly attribute SVGStringList requiredFeatures;
        readonly attribute SVGStringList requiredExtensions;
        readonly attribute SVGStringList systemLanguage;

        boolean hasExtension ( in DOMString extension );
      };

      interface SVGLangSpace {

                 attribute DOMString xmllang;
                             // raises DOMException on setting
                 attribute DOMString xmlspace;
                             // raises DOMException on setting
      };

      interface SVGExternalResourcesRequired {

        readonly attribute SVGAnimatedBoolean externalResourcesRequired;
      };

      interface SVGFitToViewBox {

        readonly attribute SVGAnimatedRect                viewBox;
        readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
      };

      interface SVGZoomAndPan {

        // Zoom and Pan Types
        const unsigned short SVG_ZOOMANDPAN_UNKNOWN   = 0;
        const unsigned short SVG_ZOOMANDPAN_DISABLE = 1;
        const unsigned short SVG_ZOOMANDPAN_MAGNIFY = 2;
        const unsigned short SVG_ZOOMANDPAN_ZOOM    = 3;

                 attribute unsigned short zoomAndPan;
                             // raises DOMException on setting
      };

      interface SVGViewSpec :
                    SVGZoomAndPan,
                    SVGFitToViewBox {

        readonly attribute SVGTransformList transform;
        readonly attribute SVGElement       viewTarget;
        readonly attribute DOMString        viewBoxString;
        readonly attribute DOMString        preserveAspectRatioString;
        readonly attribute DOMString        transformString;
        readonly attribute DOMString        viewTargetString;
      };

      interface SVGURIReference {

                 attribute DOMString xlinkType;
                             // raises DOMException on setting
                 attribute DOMString xlinkRole;
                             // raises DOMException on setting
                 attribute DOMString xlinkArcRole;
                             // raises DOMException on setting
                 attribute DOMString xlinkTitle;
                             // raises DOMException on setting
                 attribute DOMString xlinkShow;
                             // raises DOMException on setting
                 attribute DOMString xlinkActuate;
                             // raises DOMException on setting
        readonly attribute SVGAnimatedString href;
      };

      interface SVGCSSRule : css::CSSRule {
        // Additional CSS RuleType to support ICC color specifications
        const unsigned short COLOR_PROFILE_RULE = 7;
      };

      interface SVGRenderingIntent {

        // Rendering Intent Types
        const unsigned short RENDERING_INTENT_UNKNOWN               = 0;
        const unsigned short RENDERING_INTENT_AUTO                  = 1;
        const unsigned short RENDERING_INTENT_PERCEPTUAL            = 2;
        const unsigned short RENDERING_INTENT_RELATIVE_COLORIMETRIC = 3;
        const unsigned short RENDERING_INTENT_SATURATION            = 4;
        const unsigned short RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = 5;
      };

      interface SVGDocument :
                    Document,
                    events::DocumentEvent {

        readonly attribute DOMString    title;
        readonly attribute DOMString     referrer;
        readonly attribute DOMString      domain;
        readonly attribute DOMString      URL;
        readonly attribute SVGSVGElement rootElement;
      };

      interface SVGSVGElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGLocatable,
                    SVGFitToViewBox,
                    SVGZoomAndPan,
                    events::EventTarget,
                    events::DocumentEvent,
                    css::ViewCSS,
                    css::DocumentCSS {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
        readonly attribute SVGAnimatedLength width;
        readonly attribute SVGAnimatedLength height;
                 attribute DOMString         contentScriptType;
                             // raises DOMException on setting
                 attribute DOMString         contentStyleType;
                             // raises DOMException on setting
        readonly attribute SVGRect           viewport;
        readonly attribute float pixelUnitToMillimeterX;
        readonly attribute float pixelUnitToMillimeterY;
        readonly attribute float screenPixelToMillimeterX;
        readonly attribute float screenPixelToMillimeterY;
                 attribute boolean useCurrentView;
                             // raises DOMException on setting
        readonly attribute SVGViewSpec currentView;
                 attribute float currentScale;
                             // raises DOMException on setting
        readonly attribute SVGPoint currentTranslate;

        unsigned long suspendRedraw ( in unsigned long max_wait_milliseconds );
        void          unsuspendRedraw ( in unsigned long suspend_handle_id )
                        raises( DOMException );
        void          unsuspendRedrawAll (  );
        void          forceRedraw (  );
        void          pauseAnimations (  );
        void          unpauseAnimations (  );
        boolean       animationsPaused (  );
        float         getCurrentTime (  );
        void          setCurrentTime ( in float seconds );
        NodeList      getIntersectionList ( in SVGRect rect, in SVGElement referenceElement );
        NodeList      getEnclosureList ( in SVGRect rect, in SVGElement referenceElement );
        boolean       checkIntersection ( in SVGElement element, in SVGRect rect );
        boolean       checkEnclosure ( in SVGElement element, in SVGRect rect );
        void          deSelectAll (  );
        SVGNumber              createSVGNumber (  );
        SVGLength              createSVGLength (  );
        SVGAngle               createSVGAngle (  );
        SVGPoint               createSVGPoint (  );
        SVGMatrix              createSVGMatrix (  );
        SVGRect                createSVGRect (  );
        SVGTransform           createSVGTransform (  );
        SVGTransform     createSVGTransformFromMatrix ( in SVGMatrix matrix );
        DOMString              createSVGString (  );
        Element         getElementById ( in DOMString elementId );
      };

      interface SVGGElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {};

      interface SVGDefsElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {};

      interface SVGDescElement :
                    SVGElement,
                    SVGLangSpace,
                    SVGStylable {};

      interface SVGTitleElement :
                    SVGElement,
                    SVGLangSpace,
                    SVGStylable {};

      interface SVGSymbolElement :
                    SVGElement,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGFitToViewBox,
                    events::EventTarget {};

      interface SVGUseElement :
                    SVGElement,
                    SVGURIReference,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength   x;
        readonly attribute SVGAnimatedLength   y;
        readonly attribute SVGAnimatedLength   width;
        readonly attribute SVGAnimatedLength   height;
        readonly attribute SVGElementInstance instanceRoot;
        readonly attribute SVGElementInstance animatedInstanceRoot;
      };

      interface SVGElementInstance : events::EventTarget {
        readonly attribute SVGElement correspondingElement;
        readonly attribute SVGUseElement correspondingUseElement;
        readonly attribute SVGElementInstance parentNode;
        readonly attribute SVGElementInstanceList childNodes;
        readonly attribute SVGElementInstance firstChild;
        readonly attribute SVGElementInstance lastChild;
        readonly attribute SVGElementInstance previousSibling;
        readonly attribute SVGElementInstance nextSibling;
      };

      interface SVGElementInstanceList {

        readonly attribute SVGElementInstance length;

        SVGElementInstance item ( in unsigned long index );
      };

      interface SVGImageElement :
                    SVGElement,
                    SVGURIReference,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
        readonly attribute SVGAnimatedLength width;
        readonly attribute SVGAnimatedLength height;
        readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
      };

      interface SVGSwitchElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {};

      interface GetSVGDocument {

        SVGDocument getSVGDocument (  )
                        raises( DOMException );
      };

      interface SVGStyleElement : SVGElement {
                 attribute DOMString xmlspace;
                             // raises DOMException on setting
                 attribute DOMString type;
                             // raises DOMException on setting
                 attribute DOMString media;
                             // raises DOMException on setting
                 attribute DOMString title;
                             // raises DOMException on setting
      };

      interface SVGPoint {

                 attribute float x;
                             // raises DOMException on setting
                 attribute float y;
                             // raises DOMException on setting

        SVGPoint matrixTransform ( in SVGMatrix matrix );
      };

      interface SVGPointList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        SVGPoint initialize ( in SVGPoint newItem )
                        raises( DOMException, SVGException );
        SVGPoint getItem ( in unsigned long index )
                        raises( DOMException );
        SVGPoint insertItemBefore ( in SVGPoint newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGPoint replaceItem ( in SVGPoint newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGPoint removeItem ( in unsigned long index )
                        raises( DOMException );
        SVGPoint appendItem ( in SVGPoint newItem )
                        raises( DOMException, SVGException );
      };

      interface SVGMatrix {

                 attribute float a;
                             // raises DOMException on setting
                 attribute float b;
                             // raises DOMException on setting
                 attribute float c;
                             // raises DOMException on setting
                 attribute float d;
                             // raises DOMException on setting
                 attribute float e;
                             // raises DOMException on setting
                 attribute float f;
                             // raises DOMException on setting

        SVGMatrix multiply ( in SVGMatrix secondMatrix );
        SVGMatrix inverse (  )
                        raises( SVGException );
        SVGMatrix translate ( in float x, in float y );
        SVGMatrix scale ( in float scaleFactor );
        SVGMatrix scaleNonUniform ( in float scaleFactorX, in float scaleFactorY );
        SVGMatrix rotate ( in float angle );
        SVGMatrix rotateFromVector ( in float x, in float y )
                        raises( SVGException );
        SVGMatrix flipX (  );
        SVGMatrix flipY (  );
        SVGMatrix skewX ( in float angle );
        SVGMatrix skewY ( in float angle );
      };

      interface SVGTransform {

        // Transform Types
        const unsigned short SVG_TRANSFORM_UNKNOWN   = 0;
        const unsigned short SVG_TRANSFORM_MATRIX    = 1;
        const unsigned short SVG_TRANSFORM_TRANSLATE = 2;
        const unsigned short SVG_TRANSFORM_SCALE     = 3;
        const unsigned short SVG_TRANSFORM_ROTATE    = 4;
        const unsigned short SVG_TRANSFORM_SKEWX     = 5;
        const unsigned short SVG_TRANSFORM_SKEWY     = 6;

        readonly attribute unsigned short type;
        readonly attribute SVGMatrix matrix;
        readonly attribute float angle;

        void setMatrix ( in SVGMatrix matrix );
        void setTranslate ( in float tx, in float ty );
        void setScale ( in float sx, in float sy );
        void setRotate ( in float angle, in float cx, in float cy );
        void setSkewX ( in float angle );
        void setSkewY ( in float angle );
      };

      interface SVGTransformList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        SVGTransform initialize ( in SVGTransform newItem )
                        raises( DOMException, SVGException );
        SVGTransform getItem ( in unsigned long index )
                        raises( DOMException );
        SVGTransform insertItemBefore ( in SVGTransform newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGTransform replaceItem ( in SVGTransform newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGTransform removeItem ( in unsigned long index )
                        raises( DOMException );
        SVGTransform appendItem ( in SVGTransform newItem )
                        raises( DOMException, SVGException );
        SVGTransform createSVGTransformFromMatrix ( in SVGMatrix matrix );
        SVGTransform consolidate (  );
      };

      interface SVGAnimatedTransformList {

        readonly attribute SVGTransformList baseVal;
        readonly attribute SVGTransformList animVal;
      };

      interface SVGPreserveAspectRatio {

        // Alignment Types
        const unsigned short SVG_PRESERVEASPECTRATIO_UNKNOWN   = 0;
        const unsigned short SVG_PRESERVEASPECTRATIO_NONE     = 1;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMIN = 2;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMID = 5;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMID = 6;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMID = 7;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMINYMAX = 8;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9;
        const unsigned short SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10;
        // Meet-or-slice Types
        const unsigned short SVG_MEETORSLICE_UNKNOWN   = 0;
        const unsigned short SVG_MEETORSLICE_MEET  = 1;
        const unsigned short SVG_MEETORSLICE_SLICE = 2;

                 attribute unsigned short align;
                             // raises DOMException on setting
                 attribute unsigned short meetOrSlice;
                             // raises DOMException on setting
      };

      interface SVGAnimatedPreserveAspectRatio {

        readonly attribute SVGPreserveAspectRatio baseVal;
        readonly attribute SVGPreserveAspectRatio animVal;
      };

      interface SVGPathSeg {

        // Path Segment Types
        const unsigned short PATHSEG_UNKNOWN                      = 0;
        const unsigned short PATHSEG_CLOSEPATH                    = 1;
        const unsigned short PATHSEG_MOVETO_ABS                   = 2;
        const unsigned short PATHSEG_MOVETO_REL                   = 3;
        const unsigned short PATHSEG_LINETO_ABS                   = 4;
        const unsigned short PATHSEG_LINETO_REL                   = 5;
        const unsigned short PATHSEG_CURVETO_CUBIC_ABS            = 6;
        const unsigned short PATHSEG_CURVETO_CUBIC_REL            = 7;
        const unsigned short PATHSEG_CURVETO_QUADRATIC_ABS        = 8;
        const unsigned short PATHSEG_CURVETO_QUADRATIC_REL        = 9;
        const unsigned short PATHSEG_ARC_ABS                      = 10;
        const unsigned short PATHSEG_ARC_REL                      = 11;
        const unsigned short PATHSEG_LINETO_HORIZONTAL_ABS        = 12;
        const unsigned short PATHSEG_LINETO_HORIZONTAL_REL        = 13;
        const unsigned short PATHSEG_LINETO_VERTICAL_ABS          = 14;
        const unsigned short PATHSEG_LINETO_VERTICAL_REL          = 15;
        const unsigned short PATHSEG_CURVETO_CUBIC_SMOOTH_ABS     = 16;
        const unsigned short PATHSEG_CURVETO_CUBIC_SMOOTH_REL     = 17;
        const unsigned short PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;
        const unsigned short PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;

        readonly attribute unsigned short pathSegType;
        readonly attribute DOMString      pathSegTypeAsLetter;
      };

      interface SVGPathSegClosePath : SVGPathSeg {};

      interface SVGPathSegMovetoAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegMovetoRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoCubicAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x1;
                             // raises DOMException on setting
                 attribute float   y1;
                             // raises DOMException on setting
                 attribute float   x2;
                             // raises DOMException on setting
                 attribute float   y2;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoCubicRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x1;
                             // raises DOMException on setting
                 attribute float   y1;
                             // raises DOMException on setting
                 attribute float   x2;
                             // raises DOMException on setting
                 attribute float   y2;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoQuadraticAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x1;
                             // raises DOMException on setting
                 attribute float   y1;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoQuadraticRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x1;
                             // raises DOMException on setting
                 attribute float   y1;
                             // raises DOMException on setting
      };

      interface SVGPathSegArcAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   r1;
                             // raises DOMException on setting
                 attribute float   r2;
                             // raises DOMException on setting
                 attribute float   angle;
                             // raises DOMException on setting
                 attribute boolean largeArcFlag;
                             // raises DOMException on setting
                 attribute boolean sweepFlag;
                             // raises DOMException on setting
      };

      interface SVGPathSegArcRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   r1;
                             // raises DOMException on setting
                 attribute float   r2;
                             // raises DOMException on setting
                 attribute float   angle;
                             // raises DOMException on setting
                 attribute boolean largeArcFlag;
                             // raises DOMException on setting
                 attribute boolean sweepFlag;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoHorizontalAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoHorizontalRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoVerticalAbs : SVGPathSeg {
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegLinetoVerticalRel : SVGPathSeg {
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoCubicSmoothAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x2;
                             // raises DOMException on setting
                 attribute float   y2;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoCubicSmoothRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
                 attribute float   x2;
                             // raises DOMException on setting
                 attribute float   y2;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoQuadraticSmoothAbs : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegCurvetoQuadraticSmoothRel : SVGPathSeg {
                 attribute float   x;
                             // raises DOMException on setting
                 attribute float   y;
                             // raises DOMException on setting
      };

      interface SVGPathSegList {

        readonly attribute unsigned long numberOfItems;

        void   clear (  )
                        raises( DOMException );
        SVGPathSeg initialize ( in SVGPathSeg newItem )
                        raises( DOMException, SVGException );
        SVGPathSeg getItem ( in unsigned long index )
                        raises( DOMException );
        SVGPathSeg insertItemBefore ( in SVGPathSeg newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGPathSeg replaceItem ( in SVGPathSeg newItem, in unsigned long index )
                        raises( DOMException, SVGException );
        SVGPathSeg removeItem ( in unsigned long index )
                        raises( DOMException );
        SVGPathSeg appendItem ( in SVGPathSeg newItem )
                        raises( DOMException, SVGException );
      };

      interface SVGAnimatedPathData {

        readonly attribute SVGPathSegList   pathSegList;
        readonly attribute SVGPathSegList   normalizedPathSegList;
        readonly attribute SVGPathSegList   animatedPathSegList;
        readonly attribute SVGPathSegList   animatedNormalizedPathSegList;
      };

      interface SVGPathElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget,
                    SVGAnimatedPathData {

        readonly attribute SVGAnimatedNumber pathLength;

        float         getTotalLength (  );
        SVGPoint      getPointAtLength ( in float distance );
        unsigned long getPathSegAtLength ( in float distance );
        SVGPathSegClosePath    createSVGPathSegClosePath (  );
        SVGPathSegMovetoAbs    createSVGPathSegMovetoAbs ( in float x, in float y );
        SVGPathSegMovetoRel    createSVGPathSegMovetoRel ( in float x, in float y );
        SVGPathSegLinetoAbs    createSVGPathSegLinetoAbs ( in float x, in float y );
        SVGPathSegLinetoRel    createSVGPathSegLinetoRel ( in float x, in float y );
        SVGPathSegCurvetoCubicAbs    createSVGPathSegCurvetoCubicAbs ( in float x, in float y, in float x1, in float y1, in float x2, in float y2 );
        SVGPathSegCurvetoCubicRel    createSVGPathSegCurvetoCubicRel ( in float x, in float y, in float x1, in float y1, in float x2, in float y2 );
        SVGPathSegCurvetoQuadraticAbs    createSVGPathSegCurvetoQuadraticAbs ( in float x, in float y, in float x1, in float y1 );
        SVGPathSegCurvetoQuadraticRel    createSVGPathSegCurvetoQuadraticRel ( in float x, in float y, in float x1, in float y1 );
        SVGPathSegArcAbs    createSVGPathSegArcAbs ( in float x, in float y, in float r1, in float r2, in float angle, in boolean largeArcFlag, in boolean sweepFlag );
        SVGPathSegArcRel    createSVGPathSegArcRel ( in float x, in float y, in float r1, in float r2, in float angle, in boolean largeArcFlag, in boolean sweepFlag );
        SVGPathSegLinetoHorizontalAbs    createSVGPathSegLinetoHorizontalAbs ( in float x );
        SVGPathSegLinetoHorizontalRel    createSVGPathSegLinetoHorizontalRel ( in float x );
        SVGPathSegLinetoVerticalAbs    createSVGPathSegLinetoVerticalAbs ( in float y );
        SVGPathSegLinetoVerticalRel    createSVGPathSegLinetoVerticalRel ( in float y );
        SVGPathSegCurvetoCubicSmoothAbs    createSVGPathSegCurvetoCubicSmoothAbs ( in float x, in float y, in float x2, in float y2 );
        SVGPathSegCurvetoCubicSmoothRel    createSVGPathSegCurvetoCubicSmoothRel ( in float x, in float y, in float x2, in float y2 );
        SVGPathSegCurvetoQuadraticSmoothAbs    createSVGPathSegCurvetoQuadraticSmoothAbs ( in float x, in float y );
        SVGPathSegCurvetoQuadraticSmoothRel    createSVGPathSegCurvetoQuadraticSmoothRel ( in float x, in float y );
      };

      interface SVGRectElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
        readonly attribute SVGAnimatedLength width;
        readonly attribute SVGAnimatedLength height;
        readonly attribute SVGAnimatedLength rx;
        readonly attribute SVGAnimatedLength ry;
      };

      interface SVGCircleElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength cx;
        readonly attribute SVGAnimatedLength cy;
        readonly attribute SVGAnimatedLength r;
      };

      interface SVGEllipseElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength cx;
        readonly attribute SVGAnimatedLength cy;
        readonly attribute SVGAnimatedLength rx;
        readonly attribute SVGAnimatedLength ry;
      };

      interface SVGLineElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength x1;
        readonly attribute SVGAnimatedLength y1;
        readonly attribute SVGAnimatedLength x2;
        readonly attribute SVGAnimatedLength y2;
      };

      interface SVGAnimatedPoints {

        readonly attribute SVGPointList   points;
        readonly attribute SVGPointList   animatedPoints;
      };

      interface SVGPolylineElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget,
                    SVGAnimatedPoints {};

      interface SVGPolygonElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget,
                    SVGAnimatedPoints {};

      interface SVGTextContentElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    events::EventTarget {

        // lengthAdjust Types
        const unsigned short LENGTHADJUST_UNKNOWN   = 0;
        const unsigned short LENGTHADJUST_SPACING     = 1;
        const unsigned short LENGTHADJUST_SPACINGANDGLYPHS     = 2;

        readonly attribute SVGAnimatedLength      textLength;
        readonly attribute SVGAnimatedEnumeration lengthAdjust;

        long     getNumberOfChars (  );
        float    getComputedTextLength (  );
        float    getSubStringLength ( in unsigned long charnum, in unsigned long nchars )
                        raises( DOMException );
        SVGPoint getStartPositionOfChar ( in unsigned long charnum )
                        raises( DOMException );
        SVGPoint getEndPositionOfChar ( in unsigned long charnum )
                        raises( DOMException );
        SVGRect  getExtentOfChar ( in unsigned long charnum )
                        raises( DOMException );
        float    getRotationOfChar ( in unsigned long charnum )
                        raises( DOMException );
        long     getCharNumAtPosition ( in SVGPoint point );
        void     selectSubString ( in unsigned long charnum, in unsigned long nchars )
                        raises( DOMException );
      };

      interface SVGTextElement :
                    SVGTextContentElement,
                    SVGTransformable {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
      };

      interface SVGTextPositioningElement : SVGTextContentElement {
        readonly attribute SVGAnimatedLengthList x;
        readonly attribute SVGAnimatedLengthList y;
        readonly attribute SVGAnimatedLengthList dx;
        readonly attribute SVGAnimatedLengthList dy;
        readonly attribute SVGAnimatedNumberList rotate;
      };

      interface SVGTSpanElement : SVGTextPositioningElement {};

      interface SVGTRefElement :
                    SVGTextPositioningElement,
                    SVGURIReference {};

      interface SVGTextPathElement :
                    SVGTextContentElement,
                    SVGURIReference {

        // textPath Method Types
        const unsigned short TEXTPATH_METHODTYPE_UNKNOWN   = 0;
        const unsigned short TEXTPATH_METHODTYPE_ALIGN     = 1;
        const unsigned short TEXTPATH_METHODTYPE_STRETCH     = 2;
        // textPath Spacing Types
        const unsigned short TEXTPATH_SPACINGTYPE_UNKNOWN   = 0;
        const unsigned short TEXTPATH_SPACINGTYPE_AUTO     = 1;
        const unsigned short TEXTPATH_SPACINGTYPE_EXACT     = 2;

        readonly attribute SVGAnimatedLength              startOffset;
        readonly attribute SVGAnimatedEnumeration method;
        readonly attribute SVGAnimatedEnumeration spacing;
      };

      interface SVGAltGlyphElement :
                    SVGTextPositioningElement,
                    SVGURIReference {

                 attribute DOMString glyphRef;
                             // raises DOMException on setting
                 attribute DOMString format;
                             // raises DOMException on setting
      };

      interface SVGAltGlyphDefElement : SVGElement {};

      interface SVGAltGlyphItemElement : SVGElement {};

      interface SVGGlyphRefElement :
                    SVGElement,
                    SVGURIReference,
                    SVGStylable {

                 attribute DOMString glyphRef;
                             // raises DOMException on setting
                 attribute DOMString format;
                             // raises DOMException on setting
                 attribute float    x;
                             // raises DOMException on setting
                 attribute float    y;
                             // raises DOMException on setting
                 attribute float    dx;
                             // raises DOMException on setting
                 attribute float    dy;
                             // raises DOMException on setting
      };

      interface SVGPaint : SVGColor {
        // Paint Types
        const unsigned short SVG_PAINTTYPE_UNKNOWN               = 0;
        const unsigned short SVG_PAINTTYPE_RGBCOLOR              = 1;
        const unsigned short SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR     = 2;
        const unsigned short SVG_PAINTTYPE_NONE                  = 101;
        const unsigned short SVG_PAINTTYPE_CURRENTCOLOR          = 102;
        const unsigned short SVG_PAINTTYPE_URI_NONE              = 103;
        const unsigned short SVG_PAINTTYPE_URI_CURRENTCOLOR      = 104;
        const unsigned short SVG_PAINTTYPE_URI_RGBCOLOR          = 105;
        const unsigned short SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR = 106;

        readonly attribute unsigned short paintType;
        readonly attribute DOMString      uri;

        void setUri ( in DOMString uri );
        void setPaint ( in unsigned short paintType, in DOMString uri, in DOMString rgbColor, in DOMString iccColor )
                        raises( SVGException );
      };

      interface SVGMarkerElement :
                    SVGElement,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGFitToViewBox {

        // Marker Unit Types
        const unsigned short SVG_MARKERUNITS_UNKNOWN        = 0;
        const unsigned short SVG_MARKERUNITS_USERSPACEONUSE = 1;
        const unsigned short SVG_MARKERUNITS_STROKEWIDTH    = 2;
        // Marker Orientation Types
        const unsigned short SVG_MARKER_ORIENT_UNKNOWN      = 0;
        const unsigned short SVG_MARKER_ORIENT_AUTO         = 1;
        const unsigned short SVG_MARKER_ORIENT_ANGLE        = 2;

        readonly attribute SVGAnimatedLength      refX;
        readonly attribute SVGAnimatedLength      refY;
        readonly attribute SVGAnimatedEnumeration markerUnits;
        readonly attribute SVGAnimatedLength      markerWidth;
        readonly attribute SVGAnimatedLength      markerHeight;
        readonly attribute SVGAnimatedEnumeration orientType;
        readonly attribute SVGAnimatedAngle      orientAngle;

        void setOrientToAuto (  );
        void setOrientToAngle ( in SVGAngle angle );
      };

      interface SVGColorProfileElement :
                    SVGElement,
                    SVGURIReference,
                    SVGRenderingIntent {

                 attribute DOMString      local;
                             // raises DOMException on setting
                 attribute DOMString      name;
                             // raises DOMException on setting
                 attribute unsigned short renderingIntent;
                             // raises DOMException on setting
      };

      interface SVGColorProfileRule :
                    SVGCSSRule,
                    SVGRenderingIntent {

                 attribute DOMString      src;
                             // raises DOMException on setting
                 attribute DOMString      name;
                             // raises DOMException on setting
                 attribute unsigned short renderingIntent;
                             // raises DOMException on setting
      };

      interface SVGGradientElement :
                    SVGElement,
                    SVGURIReference,
                    SVGExternalResourcesRequired,
                    SVGUnitTypes {

        // Spread Method Types
        const unsigned short SVG_SPREADMETHOD_UNKNOWN = 0;
        const unsigned short SVG_SPREADMETHOD_PAD     = 1;
        const unsigned short SVG_SPREADMETHOD_REFLECT = 2;
        const unsigned short SVG_SPREADMETHOD_REPEAT  = 3;

        readonly attribute SVGAnimatedEnumeration   gradientUnits;
        readonly attribute SVGAnimatedTransformList gradientTransform;
        readonly attribute SVGAnimatedEnumeration   spreadMethod;
      };

      interface SVGLinearGradientElement : SVGGradientElement {
        readonly attribute SVGAnimatedLength x1;
        readonly attribute SVGAnimatedLength y1;
        readonly attribute SVGAnimatedLength x2;
        readonly attribute SVGAnimatedLength y2;
      };

      interface SVGRadialGradientElement : SVGGradientElement {
        readonly attribute SVGAnimatedLength cx;
        readonly attribute SVGAnimatedLength cy;
        readonly attribute SVGAnimatedLength r;
        readonly attribute SVGAnimatedLength fx;
        readonly attribute SVGAnimatedLength fy;
      };

      interface SVGStopElement :
                    SVGElement,
                    SVGStylable {

        readonly attribute SVGAnimatedNumber offset;
      };

      interface SVGPatternElement :
                    SVGElement,
                    SVGURIReference,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGFitToViewBox,
                    SVGUnitTypes {

        readonly attribute SVGAnimatedEnumeration   patternUnits;
        readonly attribute SVGAnimatedTransformList patternTransform;
        readonly attribute SVGAnimatedLength        x;
        readonly attribute SVGAnimatedLength        y;
        readonly attribute SVGAnimatedLength        width;
        readonly attribute SVGAnimatedLength        height;
      };

      interface SVGClipPathElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    SVGUnitTypes {

        readonly attribute SVGAnimatedEnumeration clipPathUnits;
      };

      interface SVGMaskElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    SVGUnitTypes {

        readonly attribute SVGAnimatedEnumeration maskUnits;
        readonly attribute SVGAnimatedLength      x;
        readonly attribute SVGAnimatedLength      y;
        readonly attribute SVGAnimatedLength      width;
        readonly attribute SVGAnimatedLength      height;
      };

      interface SVGFilterElement :
                    SVGElement,
                    SVGURIReference,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGUnitTypes {

        readonly attribute SVGAnimatedEnumeration filterUnits;
        readonly attribute SVGAnimatedEnumeration primitiveUnits;
        readonly attribute SVGAnimatedLength      x;
        readonly attribute SVGAnimatedLength      y;
        readonly attribute SVGAnimatedLength      width;
        readonly attribute SVGAnimatedLength      height;
        readonly attribute SVGAnimatedInteger    filterResX;
        readonly attribute SVGAnimatedInteger    filterResY;

        void setFilterRes ( in unsigned long filterResX, in unsigned long filterResY );
      };

      interface SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
        readonly attribute SVGAnimatedLength width;
        readonly attribute SVGAnimatedLength height;
        readonly attribute SVGAnimatedString result;
      };

      interface SVGFEBlendElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Blend Mode Types
        const unsigned short SVG_FEBLEND_MODE_UNKNOWN  = 0;
        const unsigned short SVG_FEBLEND_MODE_NORMAL   = 1;
        const unsigned short SVG_FEBLEND_MODE_MULTIPLY = 2;
        const unsigned short SVG_FEBLEND_MODE_SCREEN   = 3;
        const unsigned short SVG_FEBLEND_MODE_DARKEN   = 4;
        const unsigned short SVG_FEBLEND_MODE_LIGHTEN  = 5;

        readonly attribute SVGAnimatedString      in1;
        readonly attribute SVGAnimatedString      in2;
        readonly attribute SVGAnimatedEnumeration mode;
      };

      interface SVGFEColorMatrixElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Color Matrix Types
        const unsigned short SVG_FECOLORMATRIX_TYPE_UNKNOWN          = 0;
        const unsigned short SVG_FECOLORMATRIX_TYPE_MATRIX           = 1;
        const unsigned short SVG_FECOLORMATRIX_TYPE_SATURATE         = 2;
        const unsigned short SVG_FECOLORMATRIX_TYPE_HUEROTATE        = 3;
        const unsigned short SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA = 4;

        readonly attribute SVGAnimatedString      in1;
        readonly attribute SVGAnimatedEnumeration type;
        readonly attribute SVGAnimatedNumberList  values;
      };

      interface SVGFEComponentTransferElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
      };

      interface SVGComponentTransferFunctionElement : SVGElement {
        // Component Transfer Types
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN  = 0;
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1;
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_TABLE    = 2;
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE    = 3;
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_LINEAR   = 4;
        const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_GAMMA    = 5;

        readonly attribute SVGAnimatedEnumeration type;
        readonly attribute SVGAnimatedNumberList  tableValues;
        readonly attribute SVGAnimatedNumber      slope;
        readonly attribute SVGAnimatedNumber      intercept;
        readonly attribute SVGAnimatedNumber      amplitude;
        readonly attribute SVGAnimatedNumber      exponent;
        readonly attribute SVGAnimatedNumber      offset;
      };

      interface SVGFEFuncRElement : SVGComponentTransferFunctionElement {};

      interface SVGFEFuncGElement : SVGComponentTransferFunctionElement {};

      interface SVGFEFuncBElement : SVGComponentTransferFunctionElement {};

      interface SVGFEFuncAElement : SVGComponentTransferFunctionElement {};

      interface SVGFECompositeElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Composite Operators
        const unsigned short SVG_FECOMPOSITE_OPERATOR_UNKNOWN    = 0;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_OVER       = 1;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_IN         = 2;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_OUT        = 3;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_ATOP       = 4;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_XOR        = 5;
        const unsigned short SVG_FECOMPOSITE_OPERATOR_ARITHMETIC = 6;

        readonly attribute SVGAnimatedString      in1;
        readonly attribute SVGAnimatedString      in2;
        readonly attribute SVGAnimatedEnumeration operator;
        readonly attribute SVGAnimatedNumber      k1;
        readonly attribute SVGAnimatedNumber      k2;
        readonly attribute SVGAnimatedNumber      k3;
        readonly attribute SVGAnimatedNumber      k4;
      };

      interface SVGFEConvolveMatrixElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Edge Mode Values
        const unsigned short SVG_EDGEMODE_UNKNOWN   = 0;
        const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
        const unsigned short SVG_EDGEMODE_WRAP      = 2;
        const unsigned short SVG_EDGEMODE_NONE      = 3;

        readonly attribute SVGAnimatedInteger     orderX;
        readonly attribute SVGAnimatedInteger     orderY;
        readonly attribute SVGAnimatedNumberList  kernelMatrix;
        readonly attribute SVGAnimatedNumber      divisor;
        readonly attribute SVGAnimatedNumber      bias;
        readonly attribute SVGAnimatedInteger     targetX;
        readonly attribute SVGAnimatedInteger     targetY;
        readonly attribute SVGAnimatedEnumeration edgeMode;
        readonly attribute SVGAnimatedLength      kernelUnitLengthX;
        readonly attribute SVGAnimatedLength      kernelUnitLengthY;
        readonly attribute SVGAnimatedBoolean     preserveAlpha;
      };

      interface SVGFEDiffuseLightingElement :
                    SVGElement,
                    SVGStylable,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
        readonly attribute SVGAnimatedNumber surfaceScale;
        readonly attribute SVGAnimatedNumber diffuseConstant;
      };

      interface SVGFEDistantLightElement : SVGElement {
        readonly attribute SVGAnimatedNumber azimuth;
        readonly attribute SVGAnimatedNumber elevation;
      };

      interface SVGFEPointLightElement : SVGElement {
        readonly attribute SVGAnimatedNumber x;
        readonly attribute SVGAnimatedNumber y;
        readonly attribute SVGAnimatedNumber z;
      };

      interface SVGFESpotLightElement : SVGElement {
        readonly attribute SVGAnimatedNumber x;
        readonly attribute SVGAnimatedNumber y;
        readonly attribute SVGAnimatedNumber z;
        readonly attribute SVGAnimatedNumber pointsAtX;
        readonly attribute SVGAnimatedNumber pointsAtY;
        readonly attribute SVGAnimatedNumber pointsAtZ;
        readonly attribute SVGAnimatedNumber specularExponent;
        readonly attribute SVGAnimatedNumber limitingConeAngle;
      };

      interface SVGFEDisplacementMapElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Channel Selectors
        const unsigned short SVG_CHANNEL_UNKNOWN = 0;
        const unsigned short SVG_CHANNEL_R       = 1;
        const unsigned short SVG_CHANNEL_G       = 2;
        const unsigned short SVG_CHANNEL_B       = 3;
        const unsigned short SVG_CHANNEL_A       = 4;

        readonly attribute SVGAnimatedString      in1;
        readonly attribute SVGAnimatedString      in2;
        readonly attribute SVGAnimatedNumber      scale;
        readonly attribute SVGAnimatedEnumeration xChannelSelector;
        readonly attribute SVGAnimatedEnumeration yChannelSelector;
      };

      interface SVGFEFloodElement :
                    SVGElement,
                    SVGStylable,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString      in1;
      };

      interface SVGFEGaussianBlurElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
        readonly attribute SVGAnimatedNumber stdDeviationX;
        readonly attribute SVGAnimatedNumber stdDeviationY;

        void setStdDeviation ( in float stdDeviationX, in float stdDeviationY );
      };

      interface SVGFEImageElement :
                    SVGElement,
                    SVGURIReference,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    SVGFilterPrimitiveStandardAttributes {};

      interface SVGFEMergeElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {};

      interface SVGFEMergeNodeElement : SVGElement {
        readonly attribute SVGAnimatedString in1;
      };

      interface SVGFEMorphologyElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Morphology Operators
        const unsigned short SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0;
        const unsigned short SVG_MORPHOLOGY_OPERATOR_ERODE   = 1;
        const unsigned short SVG_MORPHOLOGY_OPERATOR_DILATE  = 2;

        readonly attribute SVGAnimatedString      in1;
        readonly attribute SVGAnimatedEnumeration operator;
        readonly attribute SVGAnimatedLength      radiusX;
        readonly attribute SVGAnimatedLength      radiusY;
      };

      interface SVGFEOffsetElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
        readonly attribute SVGAnimatedLength dx;
        readonly attribute SVGAnimatedLength dy;
      };

      interface SVGFESpecularLightingElement :
                    SVGElement,
                    SVGStylable,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
        readonly attribute SVGAnimatedNumber surfaceScale;
        readonly attribute SVGAnimatedNumber specularConstant;
        readonly attribute SVGAnimatedNumber specularExponent;
      };

      interface SVGFETileElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        readonly attribute SVGAnimatedString in1;
      };

      interface SVGFETurbulenceElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

        // Turbulence Types
        const unsigned short SVG_TURBULENCE_TYPE_UNKNOWN      = 0;
        const unsigned short SVG_TURBULENCE_TYPE_FRACTALNOISE = 1;
        const unsigned short SVG_TURBULENCE_TYPE_TURBULENCE   = 2;
        // Stitch Options
        const unsigned short SVG_STITCHTYPE_UNKNOWN  = 0;
        const unsigned short SVG_STITCHTYPE_STITCH   = 1;
        const unsigned short SVG_STITCHTYPE_NOSTITCH = 2;

        readonly attribute SVGAnimatedNumber      baseFrequencyX;
        readonly attribute SVGAnimatedNumber      baseFrequencyY;
        readonly attribute SVGAnimatedInteger     numOctaves;
        readonly attribute SVGAnimatedNumber      seed;
        readonly attribute SVGAnimatedEnumeration stitchTiles;
        readonly attribute SVGAnimatedEnumeration type;
      };

      interface SVGCursorElement :
                    SVGElement,
                    SVGURIReference,
                    SVGTests,
                    SVGExternalResourcesRequired {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
      };

      interface SVGAElement :
                    SVGElement,
                    SVGURIReference,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedString target;
      };

      interface SVGViewElement :
                    SVGElement,
                    SVGExternalResourcesRequired,
                    SVGFitToViewBox,
                    SVGZoomAndPan {

        readonly attribute SVGElement viewTarget;
      };

      interface SVGScriptElement :
                    SVGElement,
                    SVGURIReference,
                    SVGExternalResourcesRequired {

                 attribute DOMString type;
                             // raises DOMException on setting
      };

      interface SVGEvent : events::Event {};

      interface SVGZoomEvent : events::UIEvent {
        readonly attribute SVGRect zoomRectScreen;
        readonly attribute float previousScale;
        readonly attribute SVGPoint previousTranslate;
        readonly attribute float newScale;
        readonly attribute SVGPoint newTranslate;
      };

      interface SVGAnimationElement :
                    SVGElement,
                    SVGTests,
                    SVGExternalResourcesRequired,
                    smil::ElementTimeControl,
                    events::EventTarget {

        readonly attribute SVGElement targetElement;

        float getStartTime (  );
        float getCurrentTime (  );
        float getSimpleDuration (  )
                        raises( DOMException );
      };

      interface SVGAnimateElement : SVGAnimationElement {};

      interface SVGSetElement : SVGAnimationElement {};

      interface SVGAnimateMotionElement : SVGAnimationElement {};

      interface SVGAnimateColorElement : SVGAnimationElement {};

      interface SVGAnimateTransformElement : SVGAnimationElement {};

      interface SVGFontElement :
                    SVGElement,
                    SVGExternalResourcesRequired,
                    SVGStylable {};

      interface SVGGlyphElement :
                    SVGElement,
                    SVGStylable {};

      interface SVGMissingGlyphElement :
                    SVGElement,
                    SVGStylable {};

      interface SVGHKernElement : SVGElement {};

      interface SVGVKernElement : SVGElement {};

      interface SVGFontFaceElement : SVGElement {};

      interface SVGFontFaceSrcElement : SVGElement {};

      interface SVGFontFaceUriElement : SVGElement {};

      interface SVGFontFaceFormatElement : SVGElement {};

      interface SVGFontFaceNameElement : SVGElement {};

      interface SVGDefinitionSrcElement : SVGElement {};

      interface SVGMetadataElement : SVGElement {};

      interface SVGForeignObjectElement :
                    SVGElement,
                    SVGTests,
                    SVGLangSpace,
                    SVGExternalResourcesRequired,
                    SVGStylable,
                    SVGTransformable,
                    events::EventTarget {

        readonly attribute SVGAnimatedLength x;
        readonly attribute SVGAnimatedLength y;
        readonly attribute SVGAnimatedLength width;
        readonly attribute SVGAnimatedLength height;
      };

    };

    #endif // _SVG_IDL_