diff options
Diffstat (limited to 'testing/web-platform/tests/svg/interfaces.html')
| -rw-r--r-- | testing/web-platform/tests/svg/interfaces.html | 1565 |
1 files changed, 1565 insertions, 0 deletions
diff --git a/testing/web-platform/tests/svg/interfaces.html b/testing/web-platform/tests/svg/interfaces.html new file mode 100644 index 000000000..3fb951baa --- /dev/null +++ b/testing/web-platform/tests/svg/interfaces.html @@ -0,0 +1,1565 @@ +<!doctype html> +<title>SVG interface tests</title> +<div id=log></div> +<script src=/resources/testharness.js></script> +<script src=/resources/testharnessreport.js></script> +<script src=/resources/WebIDLParser.js></script> +<script src=/resources/idlharness.js></script> +<script type=text/plain id=untested_idl> +interface EventTarget {}; +interface Node : EventTarget {}; +interface Document : Node {}; +interface ProcessingInstruction : Node {}; +interface Element : Node {}; +interface HTMLElement : Element {}; +[PrimaryGlobal] interface Window {}; + +// Just need to know that DOMStringMap exists; its details are tested elsewhere. +interface DOMStringMap { }; + +[TreatNonObjectAsNull] +callback EventHandlerNonNull = any (Event event); +typedef EventHandlerNonNull? EventHandler; + +[TreatNonObjectAsNull] +callback OnErrorEventHandlerNonNull = any ((Event or DOMString) event, optional DOMString source, optional unsigned long lineno, optional unsigned long column, optional any error); +typedef OnErrorEventHandlerNonNull? OnErrorEventHandler; + +[TreatNonObjectAsNull] +callback OnBeforeUnloadEventHandlerNonNull = DOMString? (Event event); +typedef OnBeforeUnloadEventHandlerNonNull? OnBeforeUnloadEventHandler; + +[NoInterfaceObject] +interface GlobalEventHandlers { + attribute EventHandler onabort; + attribute EventHandler onautocomplete; + attribute EventHandler onautocompleteerror; + attribute EventHandler onblur; + attribute EventHandler oncancel; + attribute EventHandler oncanplay; + attribute EventHandler oncanplaythrough; + attribute EventHandler onchange; + attribute EventHandler onclick; + attribute EventHandler onclose; + attribute EventHandler oncontextmenu; + attribute EventHandler oncuechange; + attribute EventHandler ondblclick; + attribute EventHandler ondrag; + attribute EventHandler ondragend; + attribute EventHandler ondragenter; + attribute EventHandler ondragexit; + attribute EventHandler ondragleave; + attribute EventHandler ondragover; + attribute EventHandler ondragstart; + attribute EventHandler ondrop; + attribute EventHandler ondurationchange; + attribute EventHandler onemptied; + attribute EventHandler onended; + attribute OnErrorEventHandler onerror; + attribute EventHandler onfocus; + attribute EventHandler oninput; + attribute EventHandler oninvalid; + attribute EventHandler onkeydown; + attribute EventHandler onkeypress; + attribute EventHandler onkeyup; + attribute EventHandler onload; + attribute EventHandler onloadeddata; + attribute EventHandler onloadedmetadata; + attribute EventHandler onloadstart; + attribute EventHandler onmousedown; + [LenientThis] attribute EventHandler onmouseenter; + [LenientThis] attribute EventHandler onmouseleave; + attribute EventHandler onmousemove; + attribute EventHandler onmouseout; + attribute EventHandler onmouseover; + attribute EventHandler onmouseup; + attribute EventHandler onwheel; + attribute EventHandler onpause; + attribute EventHandler onplay; + attribute EventHandler onplaying; + attribute EventHandler onprogress; + attribute EventHandler onratechange; + attribute EventHandler onreset; + attribute EventHandler onresize; + attribute EventHandler onscroll; + attribute EventHandler onseeked; + attribute EventHandler onseeking; + attribute EventHandler onselect; + attribute EventHandler onshow; + attribute EventHandler onsort; + attribute EventHandler onstalled; + attribute EventHandler onsubmit; + attribute EventHandler onsuspend; + attribute EventHandler ontimeupdate; + attribute EventHandler ontoggle; + attribute EventHandler onvolumechange; + attribute EventHandler onwaiting; +}; + +[NoInterfaceObject] +interface WindowEventHandlers { + attribute EventHandler onafterprint; + attribute EventHandler onbeforeprint; + attribute OnBeforeUnloadEventHandler onbeforeunload; + attribute EventHandler onhashchange; + attribute EventHandler onlanguagechange; + attribute EventHandler onmessage; + attribute EventHandler onoffline; + attribute EventHandler ononline; + attribute EventHandler onpagehide; + attribute EventHandler onpageshow; + attribute EventHandler onpopstate; + attribute EventHandler onrejectionhandled; + attribute EventHandler onstorage; + attribute EventHandler onunhandledrejection; + attribute EventHandler onunload; +}; + +[NoInterfaceObject]interface LinkStyle { + readonly attribute StyleSheet? sheet; +}; + + +[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0, + optional unrestricted double z = 0, optional unrestricted double w = 1), + Exposed=(Window,Worker)] +interface DOMPointReadOnly { + [NewObject] static DOMPointReadOnly fromPoint(optional DOMPointInit point); + + readonly attribute unrestricted double x; + readonly attribute unrestricted double y; + readonly attribute unrestricted double z; + readonly attribute unrestricted double w; + + DOMPoint matrixTransform(optional DOMMatrixInit matrix); +}; + +[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0, + optional unrestricted double z = 0, optional unrestricted double w = 1), + Exposed=(Window,Worker)] +interface DOMPoint : DOMPointReadOnly { + [NewObject] static DOMPoint fromPoint(optional DOMPointInit other); + + inherit attribute unrestricted double x; + inherit attribute unrestricted double y; + inherit attribute unrestricted double z; + inherit attribute unrestricted double w; +}; + +dictionary DOMPointInit { + unrestricted double x = 0; + unrestricted double y = 0; + unrestricted double z = 0; + unrestricted double w = 1; +}; + +[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0, + optional unrestricted double width = 0, optional unrestricted double height = 0), + Exposed=(Window,Worker)] +interface DOMRectReadOnly { + [NewObject] static DOMRectReadOnly fromRect(optional DOMRectInit other); + + readonly attribute unrestricted double x; + readonly attribute unrestricted double y; + readonly attribute unrestricted double width; + readonly attribute unrestricted double height; + readonly attribute unrestricted double top; + readonly attribute unrestricted double right; + readonly attribute unrestricted double bottom; + readonly attribute unrestricted double left; +}; + +[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0, + optional unrestricted double width = 0, optional unrestricted double height = 0), + Exposed=(Window,Worker)] +interface DOMRect : DOMRectReadOnly { + [NewObject] static DOMRect fromRect(optional DOMRectInit other); + + inherit attribute unrestricted double x; + inherit attribute unrestricted double y; + inherit attribute unrestricted double width; + inherit attribute unrestricted double height; +}; + +dictionary DOMRectInit { + unrestricted double x = 0; + unrestricted double y = 0; + unrestricted double width = 0; + unrestricted double height = 0; +}; + +[Constructor(sequence<unrestricted double> numberSequence), + Exposed=(Window,Worker)] +interface DOMMatrixReadOnly { + [NewObject] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other); + [NewObject] static DOMMatrixReadOnly fromString(DOMString transformList); + [NewObject] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32); + [NewObject] static DOMMatrixReadOnly fromFloat64Array(Float64Array array64); + + // These attributes are simple aliases for certain elements of the 4x4 matrix + readonly attribute unrestricted double a; + readonly attribute unrestricted double b; + readonly attribute unrestricted double c; + readonly attribute unrestricted double d; + readonly attribute unrestricted double e; + readonly attribute unrestricted double f; + + readonly attribute unrestricted double m11; + readonly attribute unrestricted double m12; + readonly attribute unrestricted double m13; + readonly attribute unrestricted double m14; + readonly attribute unrestricted double m21; + readonly attribute unrestricted double m22; + readonly attribute unrestricted double m23; + readonly attribute unrestricted double m24; + readonly attribute unrestricted double m31; + readonly attribute unrestricted double m32; + readonly attribute unrestricted double m33; + readonly attribute unrestricted double m34; + readonly attribute unrestricted double m41; + readonly attribute unrestricted double m42; + readonly attribute unrestricted double m43; + readonly attribute unrestricted double m44; + + readonly attribute boolean is2D; + readonly attribute boolean isIdentity; + + // Immutable transform methods + DOMMatrix translate(unrestricted double tx, + unrestricted double ty, + optional unrestricted double tz = 0); + DOMMatrix scale(unrestricted double scale, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0); + DOMMatrix scale3d(unrestricted double scale, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0, + optional unrestricted double originZ = 0); + DOMMatrix scaleNonUniform(unrestricted double scaleX, + optional unrestricted double scaleY = 1, + optional unrestricted double scaleZ = 1, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0, + optional unrestricted double originZ = 0); + DOMMatrix rotate(unrestricted double angle, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0); + DOMMatrix rotateFromVector(unrestricted double x, + unrestricted double y); + DOMMatrix rotateAxisAngle(unrestricted double x, + unrestricted double y, + unrestricted double z, + unrestricted double angle); + DOMMatrix skewX(unrestricted double sx); + DOMMatrix skewY(unrestricted double sy); + DOMMatrix multiply(optional DOMMatrixInit other); + DOMMatrix flipX(); + DOMMatrix flipY(); + DOMMatrix inverse(); + + DOMPoint transformPoint(optional DOMPointInit point); + Float32Array toFloat32Array(); + Float64Array toFloat64Array(); + stringifier; +}; + +[Constructor(sequence<unrestricted double> numberSequence), + Exposed=(Window,Worker)] +interface DOMMatrix : DOMMatrixReadOnly { + [NewObject] static DOMMatrix fromMatrix(optional DOMMatrixInit other); + [NewObject] static DOMMatrix fromString(DOMString transformList); + [NewObject] static DOMMatrix fromFloat32Array(Float32Array array32); + [NewObject] static DOMMatrix fromFloat64Array(Float64Array array64); + + // These attributes are simple aliases for certain elements of the 4x4 matrix + inherit attribute unrestricted double a; + inherit attribute unrestricted double b; + inherit attribute unrestricted double c; + inherit attribute unrestricted double d; + inherit attribute unrestricted double e; + inherit attribute unrestricted double f; + + inherit attribute unrestricted double m11; + inherit attribute unrestricted double m12; + inherit attribute unrestricted double m13; + inherit attribute unrestricted double m14; + inherit attribute unrestricted double m21; + inherit attribute unrestricted double m22; + inherit attribute unrestricted double m23; + inherit attribute unrestricted double m24; + inherit attribute unrestricted double m31; + inherit attribute unrestricted double m32; + inherit attribute unrestricted double m33; + inherit attribute unrestricted double m34; + inherit attribute unrestricted double m41; + inherit attribute unrestricted double m42; + inherit attribute unrestricted double m43; + inherit attribute unrestricted double m44; + + // Mutable transform methods + DOMMatrix multiplySelf(optional DOMMatrixInit other); + DOMMatrix preMultiplySelf(optional DOMMatrixInit other); + DOMMatrix translateSelf(unrestricted double tx, + unrestricted double ty, + optional unrestricted double tz = 0); + DOMMatrix scaleSelf(unrestricted double scale, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0); + DOMMatrix scale3dSelf(unrestricted double scale, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0, + optional unrestricted double originZ = 0); + DOMMatrix scaleNonUniformSelf(unrestricted double scaleX, + optional unrestricted double scaleY = 1, + optional unrestricted double scaleZ = 1, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0, + optional unrestricted double originZ = 0); + DOMMatrix rotateSelf(unrestricted double angle, + optional unrestricted double originX = 0, + optional unrestricted double originY = 0); + DOMMatrix rotateFromVectorSelf(unrestricted double x, + unrestricted double y); + DOMMatrix rotateAxisAngleSelf(unrestricted double x, + unrestricted double y, + unrestricted double z, + unrestricted double angle); + DOMMatrix skewXSelf(unrestricted double sx); + DOMMatrix skewYSelf(unrestricted double sy); + DOMMatrix invertSelf(); + + DOMMatrix setMatrixValue(DOMString transformList); +}; + +dictionary DOMMatrixInit { + unrestricted double a; + unrestricted double b; + unrestricted double c; + unrestricted double d; + unrestricted double e; + unrestricted double f; + unrestricted double m11; + unrestricted double m12; + unrestricted double m13 = 0; + unrestricted double m14 = 0; + unrestricted double m21; + unrestricted double m22; + unrestricted double m23 = 0; + unrestricted double m24 = 0; + unrestricted double m31 = 0; + unrestricted double m32 = 0; + unrestricted double m33 = 1; + unrestricted double m34 = 0; + unrestricted double m41; + unrestricted double m42; + unrestricted double m43 = 0; + unrestricted double m44 = 1; + boolean is2D; +}; +</script> +<script type=text/plain id=idl> +interface SVGElement : Element { + + [SameObject] readonly attribute SVGAnimatedString className; + [SameObject] readonly attribute DOMStringMap dataset; + + readonly attribute SVGSVGElement? ownerSVGElement; + readonly attribute SVGElement? viewportElement; + + attribute long tabIndex; + void focus(); + void blur(); +}; + +SVGElement implements GlobalEventHandlers; + +dictionary SVGBoundingBoxOptions { + boolean fill = true; + boolean stroke = false; + boolean markers = false; + boolean clipped = false; +}; + +interface SVGGraphicsElement : SVGElement { + [SameObject] readonly attribute SVGAnimatedTransformList transform; + + DOMRect getBBox(optional SVGBoundingBoxOptions options); + DOMMatrix? getCTM(); + DOMMatrix? getScreenCTM(); +}; + +SVGGraphicsElement implements SVGTests; + +interface SVGGeometryElement : SVGGraphicsElement { + boolean isPointInFill(DOMPoint point); + boolean isPointInStroke(DOMPoint point); +}; + +interface SVGNumber { + attribute float value; +}; + +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; + attribute float valueInSpecifiedUnits; + attribute DOMString valueAsString; + + void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits); + void convertToSpecifiedUnits(unsigned short unitType); +}; + +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; + attribute float valueInSpecifiedUnits; + attribute DOMString valueAsString; + + void newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits); + void convertToSpecifiedUnits(unsigned short unitType); +}; + +interface SVGNumberList { + + readonly attribute unsigned long length; + readonly attribute unsigned long numberOfItems; + + void clear(); + SVGNumber initialize(SVGNumber newItem); + getter SVGNumber getItem(unsigned long index); + SVGNumber insertItemBefore(SVGNumber newItem, unsigned long index); + SVGNumber replaceItem(SVGNumber newItem, unsigned long index); + SVGNumber removeItem(unsigned long index); + SVGNumber appendItem(SVGNumber newItem); + setter void (unsigned long index, SVGNumber newItem); +}; + +interface SVGLengthList { + + readonly attribute unsigned long length; + readonly attribute unsigned long numberOfItems; + + void clear(); + SVGLength initialize(SVGLength newItem); + getter SVGLength getItem(unsigned long index); + SVGLength insertItemBefore(SVGLength newItem, unsigned long index); + SVGLength replaceItem(SVGLength newItem, unsigned long index); + SVGLength removeItem(unsigned long index); + SVGLength appendItem(SVGLength newItem); + setter void (unsigned long index, SVGLength newItem); +}; + +interface SVGAnimatedBoolean { + attribute boolean baseVal; + readonly attribute boolean animVal; +}; + +interface SVGAnimatedEnumeration { + attribute unsigned short baseVal; + readonly attribute unsigned short animVal; +}; + +interface SVGAnimatedInteger { + attribute long baseVal; + readonly attribute long animVal; +}; + +interface SVGAnimatedNumber { + attribute float baseVal; + readonly attribute float animVal; +}; + +interface SVGAnimatedLength { + [SameObject] readonly attribute SVGLength baseVal; + [SameObject] readonly attribute SVGLength animVal; +}; + +interface SVGAnimatedAngle { + [SameObject] readonly attribute SVGAngle baseVal; + [SameObject] readonly attribute SVGAngle animVal; +}; + +interface SVGAnimatedString { + attribute DOMString baseVal; + readonly attribute DOMString animVal; +}; + +interface SVGAnimatedRect { + [SameObject] readonly attribute DOMRect baseVal; + [SameObject] readonly attribute DOMRectReadOnly animVal; +}; + +interface SVGAnimatedNumberList { + [SameObject] readonly attribute SVGNumberList baseVal; + [SameObject] readonly attribute SVGNumberList animVal; +}; + +interface SVGAnimatedLengthList { + [SameObject] readonly attribute SVGLengthList baseVal; + [SameObject] readonly attribute SVGLengthList animVal; +}; + +interface SVGStringList { + + readonly attribute unsigned long length; + readonly attribute unsigned long numberOfItems; + + void clear(); + DOMString initialize(DOMString newItem); + getter DOMString getItem(unsigned long index); + DOMString insertItemBefore(DOMString newItem, unsigned long index); + DOMString replaceItem(DOMString newItem, unsigned long index); + DOMString removeItem(unsigned long index); + DOMString appendItem(DOMString newItem); + setter void (unsigned long index, DOMString newItem); +}; + +[NoInterfaceObject] +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; +}; + +[NoInterfaceObject] +interface SVGTests { + [SameObject] readonly attribute SVGStringList requiredExtensions; + [SameObject] readonly attribute SVGStringList systemLanguage; +}; + +[NoInterfaceObject] +interface SVGFitToViewBox { + [SameObject] readonly attribute SVGAnimatedRect viewBox; + [SameObject] readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio; +}; + +[NoInterfaceObject] +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; +}; + +[NoInterfaceObject] +interface SVGURIReference { + [SameObject] readonly attribute SVGAnimatedString href; +}; + +partial interface Document { + readonly attribute SVGSVGElement? rootElement; +}; + +interface SVGSVGElement : SVGGraphicsElement { + + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; + + attribute float currentScale; + [SameObject] readonly attribute DOMPointReadOnly currentTranslate; + + NodeList getIntersectionList(DOMRectReadOnly rect, SVGElement? referenceElement); + NodeList getEnclosureList(DOMRectReadOnly rect, SVGElement? referenceElement); + boolean checkIntersection(SVGElement element, DOMRectReadOnly rect); + boolean checkEnclosure(SVGElement element, DOMRectReadOnly rect); + + void deselectAll(); + + SVGNumber createSVGNumber(); + SVGLength createSVGLength(); + SVGAngle createSVGAngle(); + DOMPoint createSVGPoint(); + DOMMatrix createSVGMatrix(); + DOMRect createSVGRect(); + SVGTransform createSVGTransform(); + SVGTransform createSVGTransformFromMatrix(DOMMatrixReadOnly matrix); + + // Deprecated methods that have no effect when called, + // but which are kept for compatibility reasons. + unsigned long suspendRedraw(unsigned long maxWaitMilliseconds); + void unsuspendRedraw(unsigned long suspendHandleID); + void unsuspendRedrawAll(); + void forceRedraw(); +}; + +SVGSVGElement implements SVGFitToViewBox; +SVGSVGElement implements SVGZoomAndPan; +SVGSVGElement implements WindowEventHandlers; + +interface SVGGElement : SVGGraphicsElement { +}; + +interface SVGUnknownElement : SVGGraphicsElement { +}; + +interface SVGDefsElement : SVGGraphicsElement { +}; + +interface SVGDescElement : SVGElement { +}; + +interface SVGMetadataElement : SVGElement { +}; + +interface SVGTitleElement : SVGElement { +}; + +interface SVGSymbolElement : SVGElement { +}; + +SVGSymbolElement implements SVGFitToViewBox; + +interface SVGUseElement : SVGGraphicsElement { + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; +}; + +SVGUseElement implements SVGURIReference; + +interface SVGSwitchElement : SVGGraphicsElement { +}; + +[NoInterfaceObject] +interface GetSVGDocument { + Document getSVGDocument(); +}; + +interface SVGStyleElement : SVGElement { + attribute DOMString type; + attribute DOMString media; + attribute DOMString title; +}; + +SVGStyleElement implements LinkStyle; + +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; + [SameObject] readonly attribute DOMMatrix matrix; + readonly attribute float angle; + + void setMatrix(DOMMatrixReadOnly matrix); + void setTranslate(float tx, float ty); + void setScale(float sx, float sy); + void setRotate(float angle, float cx, float cy); + void setSkewX(float angle); + void setSkewY(float angle); +}; + +interface SVGTransformList { + + readonly attribute unsigned long length; + readonly attribute unsigned long numberOfItems; + + void clear(); + SVGTransform initialize(SVGTransform newItem); + getter SVGTransform getItem(unsigned long index); + SVGTransform insertItemBefore(SVGTransform newItem, unsigned long index); + SVGTransform replaceItem(SVGTransform newItem, unsigned long index); + SVGTransform removeItem(unsigned long index); + SVGTransform appendItem(SVGTransform newItem); + setter void (unsigned long index, SVGTransform newItem); + + // Additional methods not common to other list interfaces. + SVGTransform createSVGTransformFromMatrix(DOMMatrixReadOnly matrix); + SVGTransform? consolidate(); +}; + +interface SVGAnimatedTransformList { + [SameObject] readonly attribute SVGTransformList baseVal; + [SameObject] 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; + attribute unsigned short meetOrSlice; +}; + +interface SVGAnimatedPreserveAspectRatio { + [SameObject] readonly attribute SVGPreserveAspectRatio baseVal; + [SameObject] readonly attribute SVGPreserveAspectRatio animVal; +}; + +interface SVGPathElement : SVGGeometryElement { + + [SameObject] readonly attribute SVGAnimatedNumber pathLength; + + float getTotalLength(); + DOMPoint getPointAtLength(float distance); +}; + +interface SVGRectElement : SVGGeometryElement { + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; + [SameObject] readonly attribute SVGAnimatedLength rx; + [SameObject] readonly attribute SVGAnimatedLength ry; +}; + +interface SVGCircleElement : SVGGeometryElement { + [SameObject] readonly attribute SVGAnimatedLength cx; + [SameObject] readonly attribute SVGAnimatedLength cy; + [SameObject] readonly attribute SVGAnimatedLength r; +}; + +interface SVGEllipseElement : SVGGeometryElement { + [SameObject] readonly attribute SVGAnimatedLength cx; + [SameObject] readonly attribute SVGAnimatedLength cy; + [SameObject] readonly attribute SVGAnimatedLength rx; + [SameObject] readonly attribute SVGAnimatedLength ry; +}; + +interface SVGLineElement : SVGGeometryElement { + [SameObject] readonly attribute SVGAnimatedLength x1; + [SameObject] readonly attribute SVGAnimatedLength y1; + [SameObject] readonly attribute SVGAnimatedLength x2; + [SameObject] readonly attribute SVGAnimatedLength y2; +}; + +[NoInterfaceObject] +interface SVGAnimatedPoints { + [SameObject] readonly attribute SVGPointList points; + [SameObject] readonly attribute SVGPointList animatedPoints; +}; + +interface SVGPointList { + + readonly attribute unsigned long length; + readonly attribute unsigned long numberOfItems; + + void clear(); + DOMPoint initialize(DOMPoint newItem); + getter DOMPoint getItem(unsigned long index); + DOMPoint insertItemBefore(DOMPoint newItem, unsigned long index); + DOMPoint replaceItem(DOMPoint newItem, unsigned long index); + DOMPoint removeItem(unsigned long index); + DOMPoint appendItem(DOMPoint newItem); + setter void (unsigned long index, DOMPoint newItem); +}; + +interface SVGPolylineElement : SVGGeometryElement { +}; + +SVGPolylineElement implements SVGAnimatedPoints; + +interface SVGPolygonElement : SVGGeometryElement { +}; + +SVGPolygonElement implements SVGAnimatedPoints; + +interface SVGTextContentElement : SVGGraphicsElement { + + // lengthAdjust Types + const unsigned short LENGTHADJUST_UNKNOWN = 0; + const unsigned short LENGTHADJUST_SPACING = 1; + const unsigned short LENGTHADJUST_SPACINGANDGLYPHS = 2; + + [SameObject] readonly attribute SVGAnimatedLength textLength; + [SameObject] readonly attribute SVGAnimatedEnumeration lengthAdjust; + + long getNumberOfChars(); + float getComputedTextLength(); + float getSubStringLength(unsigned long charnum, unsigned long nchars); + DOMPoint getStartPositionOfChar(unsigned long charnum); + DOMPoint getEndPositionOfChar(unsigned long charnum); + DOMRect getExtentOfChar(unsigned long charnum); + float getRotationOfChar(unsigned long charnum); + long getCharNumAtPosition(DOMPoint point); + void selectSubString(unsigned long charnum, unsigned long nchars); +}; + +interface SVGTextPositioningElement : SVGTextContentElement { + [SameObject] readonly attribute SVGAnimatedLengthList x; + [SameObject] readonly attribute SVGAnimatedLengthList y; + [SameObject] readonly attribute SVGAnimatedLengthList dx; + [SameObject] readonly attribute SVGAnimatedLengthList dy; + [SameObject] readonly attribute SVGAnimatedNumberList rotate; +}; + +interface SVGTextElement : SVGTextPositioningElement { +}; + +interface SVGTSpanElement : SVGTextPositioningElement { +}; + +interface SVGTextPathElement : SVGTextContentElement { + + // 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; + + [SameObject] readonly attribute SVGAnimatedLength startOffset; + [SameObject] readonly attribute SVGAnimatedEnumeration method; + [SameObject] readonly attribute SVGAnimatedEnumeration spacing; +}; + +SVGTextPathElement implements SVGURIReference; + +interface SVGImageElement : SVGGraphicsElement { + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; + [SameObject] readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio; + attribute DOMString crossOrigin; +}; + +SVGImageElement implements SVGURIReference; + +interface SVGForeignObjectElement : SVGGraphicsElement { + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; +}; + +interface SVGMarkerElement : SVGElement { + + // 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; + + [SameObject] readonly attribute SVGAnimatedLength refX; + [SameObject] readonly attribute SVGAnimatedLength refY; + [SameObject] readonly attribute SVGAnimatedEnumeration markerUnits; + [SameObject] readonly attribute SVGAnimatedLength markerWidth; + [SameObject] readonly attribute SVGAnimatedLength markerHeight; + [SameObject] readonly attribute SVGAnimatedEnumeration orientType; + [SameObject] readonly attribute SVGAnimatedAngle orientAngle; + attribute DOMString orient; + + void setOrientToAuto(); + void setOrientToAngle(SVGAngle angle); +}; + +SVGMarkerElement implements SVGFitToViewBox; + +interface SVGSolidcolorElement : SVGElement { +}; + +interface SVGGradientElement : SVGElement { + + // 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; + + [SameObject] readonly attribute SVGAnimatedEnumeration gradientUnits; + [SameObject] readonly attribute SVGAnimatedTransformList gradientTransform; + [SameObject] readonly attribute SVGAnimatedEnumeration spreadMethod; +}; + +SVGGradientElement implements SVGURIReference; +SVGGradientElement implements SVGUnitTypes; + +interface SVGLinearGradientElement : SVGGradientElement { + [SameObject] readonly attribute SVGAnimatedLength x1; + [SameObject] readonly attribute SVGAnimatedLength y1; + [SameObject] readonly attribute SVGAnimatedLength x2; + [SameObject] readonly attribute SVGAnimatedLength y2; +}; + +interface SVGRadialGradientElement : SVGGradientElement { + [SameObject] readonly attribute SVGAnimatedLength cx; + [SameObject] readonly attribute SVGAnimatedLength cy; + [SameObject] readonly attribute SVGAnimatedLength r; + [SameObject] readonly attribute SVGAnimatedLength fx; + [SameObject] readonly attribute SVGAnimatedLength fy; + [SameObject] readonly attribute SVGAnimatedLength fr; +}; + +interface SVGMeshElement : SVGGradientElement { +}; + +interface SVGMeshrowElement : SVGElement { +}; + +interface SVGMeshpatchElement : SVGElement { +}; + +interface SVGStopElement : SVGElement { + [SameObject] readonly attribute SVGAnimatedNumber offset; +}; + +interface SVGPatternElement : SVGElement { + [SameObject] readonly attribute SVGAnimatedEnumeration patternUnits; + [SameObject] readonly attribute SVGAnimatedEnumeration patternContentUnits; + [SameObject] readonly attribute SVGAnimatedTransformList patternTransform; + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; + [SameObject] readonly attribute SVGAnimatedLength width; + [SameObject] readonly attribute SVGAnimatedLength height; +}; + +SVGPatternElement implements SVGFitToViewBox; +SVGPatternElement implements SVGURIReference; +SVGPatternElement implements SVGUnitTypes; + +interface SVGHatchElement : SVGElement { +}; + +interface SVGHatchpathElement : SVGElement { +}; + +interface SVGCursorElement : SVGElement { + [SameObject] readonly attribute SVGAnimatedLength x; + [SameObject] readonly attribute SVGAnimatedLength y; +}; + +SVGCursorElement implements SVGURIReference; + +interface SVGScriptElement : SVGElement { + attribute DOMString type; + attribute DOMString crossOrigin; +}; + +SVGScriptElement implements SVGURIReference; + +interface SVGZoomEvent : UIEvent { + [SameObject] readonly attribute DOMRectReadOnly zoomRectScreen; + readonly attribute float previousScale; + [SameObject] readonly attribute DOMPointReadOnly previousTranslate; + readonly attribute float newScale; + [SameObject] readonly attribute DOMPointReadOnly newTranslate; +}; + +interface SVGAElement : SVGGraphicsElement { + [SameObject] readonly attribute SVGAnimatedString target; +}; + +SVGAElement implements SVGURIReference; + +interface SVGViewElement : SVGElement {}; + +SVGViewElement implements SVGFitToViewBox; +SVGViewElement implements SVGZoomAndPan; + +interface SVGFilterElement : SVGElement { + readonly attribute SVGAnimatedEnumeration filterUnits; + readonly attribute SVGAnimatedEnumeration primitiveUnits; + readonly attribute SVGAnimatedLength x; + readonly attribute SVGAnimatedLength y; + readonly attribute SVGAnimatedLength width; + readonly attribute SVGAnimatedLength height; +}; + +SVGFilterElement implements SVGURIReference; +SVGFilterElement implements SVGUnitTypes; + +[NoInterfaceObject] +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 { + + // 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; +}; + +SVGFEBlendElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEColorMatrixElement : SVGElement { + + // 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; +}; + +SVGFEColorMatrixElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEComponentTransferElement : SVGElement { + readonly attribute SVGAnimatedString in1; +}; + +SVGFEComponentTransferElement implements SVGFilterPrimitiveStandardAttributes; + +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 { + + // 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; +}; + +SVGFECompositeElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEConvolveMatrixElement : SVGElement { + + // 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 SVGAnimatedString in1; + 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; +}; + +SVGFEConvolveMatrixElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEDiffuseLightingElement : SVGElement { + readonly attribute SVGAnimatedString in1; + readonly attribute SVGAnimatedNumber surfaceScale; + readonly attribute SVGAnimatedNumber diffuseConstant; + readonly attribute SVGAnimatedNumber kernelUnitLengthX; + readonly attribute SVGAnimatedNumber kernelUnitLengthY; +}; + +SVGFEDiffuseLightingElement implements SVGFilterPrimitiveStandardAttributes; + +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 { + + // 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; +}; + +SVGFEDisplacementMapElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEDropShadowElement : SVGElement { + readonly attribute SVGAnimatedString in1; + readonly attribute SVGAnimatedNumber dx; + readonly attribute SVGAnimatedNumber dy; + readonly attribute SVGAnimatedNumber stdDeviationX; + readonly attribute SVGAnimatedNumber stdDeviationY; + + void setStdDeviation(float stdDeviationX, float stdDeviationY); +}; + +SVGFEDropShadowElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEFloodElement : SVGElement { +}; + +SVGFEFloodElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEGaussianBlurElement : SVGElement { + + // 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 SVGAnimatedString in1; + readonly attribute SVGAnimatedNumber stdDeviationX; + readonly attribute SVGAnimatedNumber stdDeviationY; + readonly attribute SVGAnimatedEnumeration edgeMode; + + void setStdDeviation(float stdDeviationX, float stdDeviationY); +}; + +SVGFEGaussianBlurElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEImageElement : SVGElement { + readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio; + readonly attribute SVGAnimatedString crossOrigin; +}; + +SVGFEImageElement implements SVGFilterPrimitiveStandardAttributes; +SVGFEImageElement implements SVGURIReference; + +interface SVGFEMergeElement : SVGElement { +}; + +SVGFEMergeElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEMergeNodeElement : SVGElement { + readonly attribute SVGAnimatedString in1; +}; + +interface SVGFEMorphologyElement : SVGElement { + + // 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; +}; + +SVGFEMorphologyElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFEOffsetElement : SVGElement { + readonly attribute SVGAnimatedString in1; + readonly attribute SVGAnimatedNumber dx; + readonly attribute SVGAnimatedNumber dy; +}; + +SVGFEOffsetElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFESpecularLightingElement : SVGElement { + readonly attribute SVGAnimatedString in1; + readonly attribute SVGAnimatedNumber surfaceScale; + readonly attribute SVGAnimatedNumber specularConstant; + readonly attribute SVGAnimatedNumber specularExponent; + readonly attribute SVGAnimatedNumber kernelUnitLengthX; + readonly attribute SVGAnimatedNumber kernelUnitLengthY; +}; + +SVGFESpecularLightingElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFETileElement : SVGElement { + readonly attribute SVGAnimatedString in1; +}; + +SVGFETileElement implements SVGFilterPrimitiveStandardAttributes; + +interface SVGFETurbulenceElement : SVGElement { + + // 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; +}; + +SVGFETurbulenceElement implements SVGFilterPrimitiveStandardAttributes; +</script> +<script> +var svg = document.createElementNS("http://www.w3.org/2000/svg", "svg"); +var g = document.createElementNS("http://www.w3.org/2000/svg", "g"); +var defs = document.createElementNS("http://www.w3.org/2000/svg", "defs"); +var Desc = document.createElementNS("http://www.w3.org/2000/svg", "desc"); +var title = document.createElementNS("http://www.w3.org/2000/svg", "title"); +var symbol = document.createElementNS("http://www.w3.org/2000/svg", "symbol"); +var use = document.createElementNS("http://www.w3.org/2000/svg", "use"); +var image = document.createElementNS("http://www.w3.org/2000/svg", "image"); +var Switch = document.createElementNS("http://www.w3.org/2000/svg", "switch"); +var style = document.createElementNS("http://www.w3.org/2000/svg", "style"); +var path = document.createElementNS("http://www.w3.org/2000/svg", "path"); +var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); +var circle = document.createElementNS("http://www.w3.org/2000/svg", "circle"); +var ellipse = document.createElementNS("http://www.w3.org/2000/svg", "ellipse"); +var line = document.createElementNS("http://www.w3.org/2000/svg", "line"); +var polyline = document.createElementNS("http://www.w3.org/2000/svg", "polyline"); +var polygon = document.createElementNS("http://www.w3.org/2000/svg", "polygon"); +var textContent = document.createElementNS("http://www.w3.org/2000/svg", + "textContent"); +var text = document.createElementNS("http://www.w3.org/2000/svg", "text"); +var tspan = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); +var tref = document.createElementNS("http://www.w3.org/2000/svg", "tref"); +var textPath = document.createElementNS("http://www.w3.org/2000/svg", "textPath"); +var altGlyph = document.createElementNS("http://www.w3.org/2000/svg", "altGlyph"); +var altGlyphDef = document.createElementNS("http://www.w3.org/2000/svg", + "altGlyphDef"); +var altGlyphItem = document.createElementNS("http://www.w3.org/2000/svg", + "altGlyphItem"); +var glyphRef = document.createElementNS("http://www.w3.org/2000/svg", + "glyphRef"); +var marker = document.createElementNS("http://www.w3.org/2000/svg", "marker"); +var colorProfile = document.createElementNS("http://www.w3.org/2000/svg", + "color-profile"); +var linearGradient = document.createElementNS("http://www.w3.org/2000/svg", + "linearGradient"); +var radialGradient = document.createElementNS("http://www.w3.org/2000/svg", + "radialGradient"); +var meshGradient = document.createElementNS("http://www.w3.org/2000/svg", + "meshGradient"); +var stop = document.createElementNS("http://www.w3.org/2000/svg", "stop"); +var pattern = document.createElementNS("http://www.w3.org/2000/svg", "pattern"); +var clipPath = document.createElementNS("http://www.w3.org/2000/svg", "clipPath"); +var mask = document.createElementNS("http://www.w3.org/2000/svg", "mask"); +var cursor = document.createElementNS("http://www.w3.org/2000/svg", "cursor"); +var a = document.createElementNS("http://www.w3.org/2000/svg", "a"); +var view = document.createElementNS("http://www.w3.org/2000/svg", "view"); +var script = document.createElementNS("http://www.w3.org/2000/svg", "script"); +var animate = document.createElementNS("http://www.w3.org/2000/svg", "animate"); +var set = document.createElementNS("http://www.w3.org/2000/svg", "set"); +var animateMotion = document.createElementNS("http://www.w3.org/2000/svg", + "animateMotion"); +var mPath = document.createElementNS("http://www.w3.org/2000/svg", "mPath"); +var animateColor = document.createElementNS("http://www.w3.org/2000/svg", + "animateColor"); +var animateColor = document.createElementNS("http://www.w3.org/2000/svg", + "animateColor"); +var animateTransform = document.createElementNS("http://www.w3.org/2000/svg", + "animateTransform"); +var font = document.createElementNS("http://www.w3.org/2000/svg", "font"); +var glyph = document.createElementNS("http://www.w3.org/2000/svg", "glyph"); +var missingglyph = document.createElementNS("http://www.w3.org/2000/svg", + "missing-glyph"); +var khern = document.createElementNS("http://www.w3.org/2000/svg", "hkern"); +var vkern = document.createElementNS("http://www.w3.org/2000/svg", "vkern"); +var fontface = document.createElementNS("http://www.w3.org/2000/svg", "font-face"); +var fontfacesrc = document.createElementNS("http://www.w3.org/2000/svg", + "font-face-src"); +var fontfaceuri = document.createElementNS("http://www.w3.org/2000/svg", + "font-face-uri"); +var fontfaceformat = document.createElementNS("http://www.w3.org/2000/svg", + "font-face-format"); +var fontfacename = document.createElementNS("http://www.w3.org/2000/svg", + "font-face-name"); +var metadata = document.createElementNS("http://www.w3.org/2000/svg", + "metadata"); +var foreignObject = document.createElementNS("http://www.w3.org/2000/svg", + "foreignObject"); +var filter = document.createElementNS("http://www.w3.org/2000/svg", "filter"); +var feBlend = document.createElementNS("http://www.w3.org/2000/svg", "feBlend"); +var feColorMatrix = document.createElementNS("http://www.w3.org/2000/svg", + "feColorMatrix"); +var feComponentTransfer = document.createElementNS("http://www.w3.org/2000/svg", + "feComponentTransfer"); +var feFuncR = document.createElementNS("http://www.w3.org/2000/svg", "feFuncR"); +var feFuncG = document.createElementNS("http://www.w3.org/2000/svg", "feFuncG"); +var feFuncB = document.createElementNS("http://www.w3.org/2000/svg", "feFuncB"); +var feFuncA = document.createElementNS("http://www.w3.org/2000/svg", "feFuncA"); +var feComposite = document.createElementNS("http://www.w3.org/2000/svg", + "feComposite"); +var feConvolveMatrix = document.createElementNS("http://www.w3.org/2000/svg", + "feConvolveMatrix"); +var feDiffuseLighting = document.createElementNS("http://www.w3.org/2000/svg", + "feDiffuseLighting"); +var fePointLight = document.createElementNS("http://www.w3.org/2000/svg", + "fePointLight"); +var feSpotLight = document.createElementNS("http://www.w3.org/2000/svg", + "feSpotLight"); +var feDisplacementMap = document.createElementNS("http://www.w3.org/2000/svg", + "feDisplacementMap"); +var feDropShadow = document.createElementNS("http://www.w3.org/2000/svg", + "feDropShadow"); +var feFlood = document.createElementNS("http://www.w3.org/2000/svg", "feFlood"); +var feGaussianBlur = document.createElementNS("http://www.w3.org/2000/svg", + "feGaussianBlur"); +var feDisplacementMap = document.createElementNS("http://www.w3.org/2000/svg", + "feDisplacementMap"); +var feDropShadow = document.createElementNS("http://www.w3.org/2000/svg", + "feDropShadow"); +var feImage = document.createElementNS("http://www.w3.org/2000/svg", "feImage"); +var feMerge = document.createElementNS("http://www.w3.org/2000/svg", "feMerge"); +var feMergeNode = document.createElementNS("http://www.w3.org/2000/svg", + "feMergeNode"); +var feMorphology = document.createElementNS("http://www.w3.org/2000/svg", + "feMorphology"); +var feSpecularLighting = document.createElementNS("http://www.w3.org/2000/svg", + "feSpecularLighting"); +var feTile = document.createElementNS("http://www.w3.org/2000/svg", + "feTile"); +var feTurbulence = document.createElementNS("http://www.w3.org/2000/svg", + "feTurbulence"); + + +var idlArray = new IdlArray(); +var idls = document.getElementById("idl").textContent; +var untestedIdls = document.getElementById("untested_idl").textContent; +idlArray.add_untested_idls(untestedIdls); +idlArray.add_idls(idls); +idlArray.add_objects({ + SVGAnimatedBoolean: ['feConvolveMatrix.preserveAlpha'], + SVGAnimatedString: ['a.target'], + SVGStringList: ['a.requiredFeatures'], + SVGAnimatedEnumeration: ['text.lengthAdjust'], + SVGAnimatedInteger: ['feConvolveMatrix.orderX'], + SVGNumber: ['svg.createSVGNumber()'], + SVGAnimatedNumber: ['stop.offset'], + SVGNumberList: ['text.rotate.baseVal'], + SVGAnimatedNumberList: ['text.rotate'], + SVGLength: ['svg.createSVGLength()'], + SVGAnimatedLength: ['svg.x'], + SVGAnimatedLengthList: ['text.x'], + SVGAngle: ['svg.createSVGAngle()'], + SVGAnimatedAngle: ['marker.orientAngle'], + SVGRect: ['svg.createSVGRect()'], + SVGAnimatedRect: ['svg.viewBox'], + SVGSVGElement: ['svg'], + SVGGElement: ['g'], + SVGDefsElement: ['defs'], + SVGDescElement: ['Desc'], + SVGTitleElement: ['title'], + SVGSymbolElement: ['symbol'], + SVGUseElement: ['use'], + SVGImageElement: ['image'], + SVGSwitchElement: ['Switch'], + SVGStyleElement: ['style'], + SVGPoint: ['svg.createSVGPoint()'], + SVGPointList: ['polygon.points'], + SVGMatrix: ['svg.createSVGMatrix()'], + SVGTransform: ['svg.createSVGTransform()'], + SVGTransformList: ['pattern.patternTransform.baseVal'], + SVGAnimatedTransformList: ['pattern.patternTransform'], + SVGPreserveAspectRatio: ['image.preserveAspectRatio.baseVal'], + SVGAnimatedPreserveAspectRatio: ['image.preserveAspectRatio'], + SVGPathSegClosePath: ['path.createSVGPathSegClosePath()'], + SVGPathSegMovetoAbs: ['path.createSVGPathSegMovetoAbs(0,0)'], + SVGPathSegMovetoRel: ['path.createSVGPathSegMovetoRel(0,0)'], + SVGPathSegLinetoAbs: ['path.createSVGPathSegLinetoAbs(0,0)'], + SVGPathSegLinetoRel: ['path.createSVGPathSegLinetoRel(0,0)'], + SVGPathSegCurvetoCubicAbs: ['path.createSVGPathSegCurvetoCubicAbs(0,0,0,0,0,0)'], + SVGPathSegCurvetoCubicRel: ['path.createSVGPathSegCurvetoCubicRel(0,0,0,0,0,0)'], + SVGPathSegCurvetoQuadraticAbs: ['path.createSVGPathSegCurvetoQuadraticAbs(0,0,0,0)'], + SVGPathSegCurvetoQuadraticRel: ['path.createSVGPathSegCurvetoQuadraticRel(0,0,0,0)'], + SVGPathSegArcAbs: ['path.createSVGPathSegArcAbs(0,0,0,0,0,true,true)'], + SVGPathSegArcRel: ['path.createSVGPathSegArcRel(0,0,0,0,0,true,true)'], + SVGPathSegLinetoHorizontalAbs: ['path.createSVGPathSegLinetoHorizontalAbs(0)'], + SVGPathSegLinetoHorizontalRel: ['path.createSVGPathSegLinetoHorizontalRel(0)'], + SVGPathSegLinetoVerticalAbs: ['path.createSVGPathSegLinetoVerticalAbs(0)'], + SVGPathSegLinetoVerticalRel: ['path.createSVGPathSegLinetoVerticalRel(0)'], + SVGPathSegCurvetoCubicSmoothAbs: ['path.createSVGPathSegCurvetoCubicSmoothAbs(0,0,0,0)'], + SVGPathSegCurvetoCubicSmoothRel: ['path.createSVGPathSegCurvetoCubicSmoothRel(0,0,0,0)'], + SVGPathSegCurvetoQuadraticSmoothAbs: ['path.createSVGPathSegCurvetoQuadraticSmoothAbs(0,0)'], + SVGPathSegCurvetoQuadraticSmoothRel: ['path.createSVGPathSegCurvetoQuadraticSmoothRel(0,0)'], + SVGPathSegList: ['path.pathSegList'], + SVGPathElement: ['path'], + SVGRectElement: ['rect'], + SVGCircleElement: ['circle'], + SVGEllipseElement: ['ellipse'], + SVGLineElement: ['line'], + SVGPolylineElement: ['polyline'], + SVGPolygonElement: ['polygon'], + SVGTextContentElement: ['textContent'], + SVGTextElement: ['text'], + SVGTSpanElement: ['tspan'], + SVGTRefElement: ['tref'], + SVGTextPathElement: ['textPath'], + SVGAltGlyphElement: ['altGlyph'], + SVGAltGlyphDefElement: ['altGlyphDef'], + SVGAltGlyphItemElement: ['altGlyphItem'], + SVGGlyphRefElement: ['glyphRef'], + SVGMarkerElement: ['marker'], + SVGColorProfileElement: ['colorProfile'], + SVGLinearGradientElement: ['linearGradient'], + SVGRadialGradientElement: ['radialGradient'], + SVGMeshGradientElement: ['meshGradient'], + SVGStopElement: ['stop'], + SVGPatternElement: ['pattern'], + SVGClipPathElement: ['clipPath'], + SVGMaskElement: ['mask'], + SVGCursorElement: ['cursor'], + SVGAElement: ['a'], + SVGViewElement: ['view'], + SVGScriptElement: ['script'], + SVGAnimateElement: ['animate'], + SVGSetElement: ['set'], + SVGAnimateMotionElement: ['animateMotion'], + SVGMPathElement: ['mPath'], + SVGAnimateColorElement: ['animateColor'], + SVGAnimateTransformElement: ['animateTransform'], + SVGFontElement: ['font'], + SVGGlyphElement: ['glyph'], + SVGMissingGlyphElement: ['missingglyph'], + SVGHKernElement: ['hkern'], + SVGVKernElement: ['vkern'], + SVGFontFaceElement: ['fontface'], + SVGFontFaceSrcElement: ['fontfacesrc'], + SVGFontFaceUriElement: ['fontfaceuri'], + SVGFontFaceFormatElement: ['fontfaceformat'], + SVGMetadataElement: ['metadata'], + SVGForeignObjectElement: ['foreignObject'], + SVGFilterElement: ['filter'], + SVGFEBlendElement: ['feBlend'], + SVGFEColorMatrixElement: ['feColorMatrix'], + SVGFEComponentTransferElement: ['feComponentTransfer'], + SVGFEFuncRElement: ['feFuncR'], + SVGFEFuncGElement: ['feFuncG'], + SVGFEFuncBElement: ['feFuncB'], + SVGFEFuncAElement: ['feFuncA'], + SVGFECompositeElement: ['feComposite'], + SVGFEConvolveMatrixElement: ['feConvolveMatrix'], + SVGFEDiffuseLightingElement: ['feDiffuseLighting'], + SVGFEPointLightElement: ['fePointLight'], + SVGFESpotLightElement: ['feSpotLight'], + SVGFEDisplacementMapElement: ['feDisplacementMap'], + SVGFEDropShadowElement: ['feDropShadow'], + SVGFEFloodElement: ['feFlood'], + SVGFEGaussianBlurElement: ['feGaussianBlur'], + SVGFEImageElement: ['feImage'], + SVGFEMergeElement: ['feMerge'], + SVGFEMergeNodeElement: ['feMergeNode'], + SVGFEMorphologyElement: ['feMorphology'], + SVGFESpecularLightingElement: ['feSpecularLighting'], + SVGFETileElement: ['feTile'], + SVGFETurbulenceElement: ['feTurbulence'] +}); +idlArray.test(); +</script> + |