# 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/TR/2001/REC-SVG-20010904/idl.zip.

The SVG IDL defines the model for the SVG DOM. Note that the SVG IDL is defined such that some interfaces have more than one base class. The different standard language bindings for the SVG DOM are responsible for defining how to map all aspects of the SVG DOM into the given language, including how the language should implement interfaces with more than one base class.

    // 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 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
                 attribute DOMString xmlbase;
                             // 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;
        const unsigned short SVG_COLORTYPE_CURRENTCOLOR      = 3;

        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 );
        void        setColor ( in unsigned short colorType, 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;

                 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 {

        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 );
        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 unsigned long 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 SVGTextPositioningElement : SVGTextContentElement {
        readonly attribute SVGAnimatedLengthList x;
        readonly attribute SVGAnimatedLengthList y;
        readonly attribute SVGAnimatedLengthList dx;
        readonly attribute SVGAnimatedLengthList dy;
        readonly attribute SVGAnimatedNumberList rotate;
      };

      interface SVGTextElement :
                    SVGTextPositioningElement,
                    SVGTransformable {};

      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;
        const unsigned short SVG_PAINTTYPE_URI                   = 107;

        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,
                    SVGStylable,
                    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 SVGAnimatedEnumeration   patternContentUnits;
        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,
                    SVGUnitTypes {

        readonly attribute SVGAnimatedEnumeration maskUnits;
        readonly attribute SVGAnimatedEnumeration maskContentUnits;
        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 : SVGStylable {
        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 SVGAnimatedNumber      kernelUnitLengthX;
        readonly attribute SVGAnimatedNumber      kernelUnitLengthY;
        readonly attribute SVGAnimatedBoolean     preserveAlpha;
      };

      interface SVGFEDiffuseLightingElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

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

      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,
                    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,
                    SVGFilterPrimitiveStandardAttributes {
        readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;

      };

      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 SVGAnimatedNumber      radiusX;
        readonly attribute SVGAnimatedNumber      radiusY;
      };

      interface SVGFEOffsetElement :
                    SVGElement,
                    SVGFilterPrimitiveStandardAttributes {

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

      interface SVGFESpecularLightingElement :
                    SVGElement,
                    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 SVGStringList 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 SVGMPathElement :
                    SVGElement,
                    SVGURIReference,
                    SVGExternalResourcesRequired {};

      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_