The EBNF grammar is as used in the XML specification, with the addition of ~, a case-insensitive literal: characters in the ASCII range (only) are declared to be case-insensitive. For example, ~"Hello" will match (H|h)(e|E)(l|L)(l|L)(o|O). This makes the productions much easier to read.
| ? | optional, zero or one |
| + | one or more |
| * | zero or more |
| | | alternation |
| "string" | literal |
| ~"string" | case-insensitive literal |
| [] | a character range |
| [^] | excluded character range |
| () | grouping |
We should reference css3-values, and not redefine a bunch of types in this chapter.
This section defines a number of common data types used in the definitions of SVG properties and attributes. Some data types that are not referenced by multiple properties and attributes are defined inline in subsequent chapters.
Note that, as mentioned below, the specification of some types is different for CSS property values in style sheets (in the 'style attribute' attribute, 'style element' element or an external style sheet) than it is for for XML attribute values (including presentation attributes). This is due to restrictions in the CSS grammar. For example, scientific notation is allowed in attributes, including presentation attributes, but not in style sheets.
The basic type <anything> is a sequence of zero or more characters. Specifically:
anything ::= Char*
where Char is the production for a character, as defined in XML 1.0 ([XML10], section 2.2).
White space is defined as one or more of the following consecutive characters: "space" (U+0020), "tab" (U+0009), "line feed" (U+000A), "form feed" (U+000C) and "carriage return" (U+000D).
wsp ::= ( #x9 | #x20 | #xA | #xC | #xD )
A comma-separated list of compound selectors. When used, the scope in which the selectors are evaluated is also defined. Typically only the first matching element in tree order (as defined in [DOM4]) as a result of evaluating the list of selectors is used.
child-selector ::= select(compound selector#)
The basic type <color> is a CSS 2.1 compatible specification for a color in the sRGB color space [SRGB]. <color> applies to SVG's use of the 'color' property and is a component of the definitions of properties 'fill', 'stroke', 'stop-color', 'flood-color' and 'lighting-color', which also offer optional ICC-based color specifications.
SVG supports all of the syntax alternatives for <color> defined in CSS 2.1 syntax and basic data types ([CSS21], section 4.3.6), with the exception that SVG allows an expanded list of recognized color keywords names.
A <color> is either a keyword (see Recognized color keyword names) or a numerical RGB specification.
In addition to these color keywords, users may specify keywords that correspond to the colors used by objects in the user's environment. The normative definition of these keywords is found in System Colors ([CSS21], section 18.2).
The format of an RGB value in hexadecimal notation is a "#" immediately followed by either three or six hexadecimal characters. The three-digit RGB notation (#rgb) is converted into six-digit form (#rrggbb) by replicating digits, not by adding zeros. For example, #fb0 expands to #ffbb00. This ensures that white (#ffffff) can be specified with the short notation (#fff) and removes any dependencies on the color depth of the display.
The format of an RGB value in the functional notation is an RGB start-function followed by a comma-separated list of three numerical values (either three integer values or three percentage values) followed by ")". An RGB start-function is the case-insensitive string "rgb(", for example "RGB(" or "rGb(". For compatibility, the all-lowercase form "rgb(" is preferred.
The integer value 255 corresponds to 100%, and to F or FF in the hexadecimal notation: rgb(255,255,255) = rgb(100%,100%,100%) = #FFF. White space characters are allowed around the numerical values. All RGB colors are specified in the sRGB color space [SRGB]. Using sRGB provides an unambiguous and objectively measurable definition of the color, which can be related to international standards (see [COLORIMETRY]).
color ::= "#" hexdigit hexdigit hexdigit (hexdigit hexdigit hexdigit)? | "rgb(" wsp* integer comma integer comma integer wsp* ")" | "rgb(" wsp* integer "%" comma integer "%" comma integer "%" wsp* ")" | color-keyword hexdigit ::= [0-9A-Fa-f] comma ::= wsp* "," wsp*
where color-keyword matches (case insensitively) one of the color keywords listed in Recognized color keyword names below, or one of the system color keywords listed in System Colors ([CSS21], section 18.2).
The corresponding SVG DOM interface definitions for <color> are defined in Document Object Model CSS; in particular, see RGBColor ([DOM2STYLE], section 2.2).
Frequency values are used with aural properties. As defined in CSS 2.1, a frequency value is a <number> immediately followed by a frequency unit identifier. The frequency unit identifiers are:
Frequency values may not be negative.
In the SVG DOM, <frequency> values are represented using the CSSPrimitiveValue interface defined in Document Object Model CSS ([DOM2STYLE], section 2.2).
A gradient as defined by CSS Level 3 Image Values [CSS3IMAGES] and can be used as paint server for the properties 'fill' and 'stroke'. Percentage values get resolved against the bounding box of the element to which the gradient is applied.
An <icccolor> is an ICC color specification. In SVG 1.1, an ICC color specification is given by a name, which references an @color-profile rule, and one or more color component values. The grammar is as follows:
icccolor ::= "icc-color(" author-ident (comma-wsp number)+ ")"
An image source (including gradients) as defined by CSS Level 4 Image Values ([CSS4IMAGES], section 4.3).
An <integer> is specified as an optional sign character ("+" or "-") followed by one or more digits "0" to "9", optionally surrounded by whitespace:
integer ::= wsp* [+-]? [0-9]+ wsp*
If the sign character is not present, the number is non-negative.
Unless stated otherwise for a particular attribute or property, the range for an <integer> encompasses (at a minimum) -2147483648 to 2147483647.
Within the SVG DOM, an <integer> is represented as a long or an SVGAnimatedInteger.
A length is a distance measurement, given as a number along with a unit which may be optional. Lengths are specified in one of two ways depending upon whether they are used in CSS property syntax or SVG presentation attribute syntax:
When a <length> is used in a style sheet or with a property in a 'style attribute' attribute, the syntax must match the following pattern:
length ::= number (~"em" | ~"ex" | ~"px" | ~"in" | ~"cm" | ~"mm" | ~"pt" | ~"pc")?
See the CSS 2.1 specification for the meanings of the unit identifiers. The unit identifier may be in lower (recommended) or upper case.
For properties defined in CSS 2.1 [CSS21], a length unit identifier must be provided (for non-zero values). For SVG-specific properties, the length unit identifier is optional. If a unit is not provided, the length value represents a distance in the current user coordinate system.
When a <length> is used in an SVG presentation attribute, the syntax must match the following pattern:
length ::= wsp* number ("em" | "ex" | "px" | "in" | "cm" | "mm" | "pt" | "pc" | "%")? wsp*
The unit identifier, if present, must be in lower case; if not present, the length value represents a distance in the current user coordinate system.
Note that the non-property <length> definition also allows a percentage unit identifier. The meaning of a percentage length value depends on the attribute for which the percentage length value has been specified. Two common cases are: (a) when a percentage length value represents a percentage of the viewport width or height (refer to the section that discusses units in general), and (b) when a percentage length value represents a percentage of the bounding box width or height on a given object (refer to the section that describes object bounding box units).
In the SVG DOM, <length> values are represented using SVGLength or SVGAnimatedLength objects.
We should disentangle lengths and percentages.
A <list-of-strings> consists of a white space-separated sequence of <string>s.
The following is an EBNF grammar describing the <list-of-strings> syntax:
list-of-strings ::= string
| string wsp+ list-of-strings
string ::= [^#x9#x20#xA#xC#xD]*
(Where T is a type other than <string> and <family-name>.) A list consists of a separated sequence of values. Unless explicitly described differently, lists within SVG's XML attributes can be either comma-separated, with optional white space before or after the comma, or white space-separated.
The following is a template for an EBNF grammar describing the <list-of-Ts> syntax:
list-of-Ts ::= T | T comma-wsp list-of-Ts comma-wsp ::= (wsp+ ","? wsp*) | ("," wsp*)
Within the SVG DOM, values of a <list-of-Ts> type are represented by an interface specific for the particular type T. For example, a <list-of-lengths> is represented in the SVG DOM using an SVGLengthList or SVGAnimatedLengthList object.
Real numbers are specified in one of two ways. When used in a style sheet, a <number> is defined as follows:
number ::= integer
| [+-]? [0-9]* "." [0-9]+
This syntax is the same as the definition in CSS ([CSS21], section 4.3.1).
When used in an SVG attribute, a <number> is defined differently, to allow numbers with large magnitudes to be specified more concisely:
number ::= wsp* integer ([Ee] integer)?
| [+-]? [0-9]* "." [0-9]+ ([Ee] integer)? wsp*
Within the SVG DOM, a <number> is represented as a float, SVGNumber or a SVGAnimatedNumber.
A pair of <number>s, where the second <number> is optional.
number-optional-number ::= wsp* number wsp*
| wsp* number comma-wsp number wsp*
In the SVG DOM, a <number-optional-number> is represented using a pair of SVGAnimatedInteger or SVGAnimatedNumber objects.
The values for properties 'fill' and 'stroke' are specifications of the type of paint to use when filling or stroking a given graphics element. The available options and syntax for <paint> are described in Specifying paint.
Percentages are specified as a number followed by a "%" character:
percentage ::= wsp* number "%" wsp*
Note that the definition of <number> depends on whether the percentage is specified in a style sheet or in an attribute that is not also a presentation attribute.
Percentage values are always relative to another value, for example a length. Each attribute or property that allows percentages also defines the reference distance measurement to which the percentage refers.
Within the SVG DOM, a <percentage> is represented using an SVGNumber or SVGAnimatedNumber object.
A time value is a <number> immediately followed by a time unit identifier. The time unit identifiers are:
In the SVG DOM, <time> values are represented using the CSSPrimitiveValue interface defined in Document Object Model CSS ([DOM2STYLE], section 2.2).
A <transform-list> is used to specify a list of coordinate system transformations. A detailed description of the possible values for a <transform-list> is given in Modifying the User Coordinate System: the transform property.
Within the SVG DOM, a <transform-list> value is represented using an SVGTransformList or SVGAnimatedTransformList object.
A Uniform Resource Locator (see URL). For the specification of URL references in SVG, see URL references.
An XML name, as defined by the Name production in Extensible Markup Language (XML) 1.0 ([XML10], section 2.3).
Unless stated otherwise for a particular attribute or property, a <number> has the capacity for at least a single-precision floating point number and has a range (at a minimum) of -3.4e+38F to +3.4e+38F.
It is recommended that higher precision floating point storage and computation be performed on operations such as coordinate system transformations to provide the best possible precision and to prevent round-off errors.
Conforming High-Quality SVG Viewers are required to use at least double-precision floating point for intermediate calculations on certain numerical operations.
The following is the list of recognized color keywords that can be used as a keyword value for data type <color>:
|
|
| SVG 2 Requirement: | Make the SVGList* interfaces a bit more like other lists/arrays. |
|---|---|
| Resolution: | Add array style indexing and .length and .item to svg list types. |
| Purpose: | To align with other array types (e.g. NodeList). Already implemented in Opera and Firefox. |
| Owner: | Erik (ACTION-2975) |
All of the SVG DOM interfaces that correspond directly to elements in the SVG language (such as the SVGPathElement interface for the 'path' element) derive from the SVGElement interface.
interface SVGElement : Element {
attribute DOMString xmlbase;
readonly attribute SVGAnimatedString className;
readonly attribute CSSStyleDeclaration style;
attribute DOMString xmllang;
attribute DOMString xmlspace;
readonly attribute SVGSVGElement? ownerSVGElement;
readonly attribute SVGElement? viewportElement;
attribute long tabIndex;
void focus();
void blur();
};
SVGElement implements GlobalEventHandlers;
Do not use this method to hide the focus ring. Do not use any other method that hides the focus ring from keyboard users,in particluar do not use a CSS rule to override the 'outline' property. Removal of the focus ring leads to serious accessibility issues for users who navigate and interact with interactive content using the keyboard.
Used for attributes of type boolean which can be animated.
interface SVGAnimatedBoolean {
attribute boolean baseVal;
readonly attribute boolean animVal;
};Used for attributes of type DOMString which can be animated.
interface SVGAnimatedString {
attribute DOMString baseVal;
readonly attribute DOMString animVal;
};
This interface defines a list of DOMString values.
SVGStringList has the same attributes and methods as other SVGxxxList interfaces. Implementers may consider using a single base class to implement the various SVGxxxList interfaces.
The supported property indices of an SVGStringList object is all non-negative integers less than the length of the list.
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);
};
Used for attributes whose value must be a constant from a particular enumeration and which can be animated.
interface SVGAnimatedEnumeration {
attribute unsigned short baseVal;
readonly attribute unsigned short animVal;
};
Used for attributes of basic type <integer> which can be animated.
interface SVGAnimatedInteger {
attribute long baseVal;
readonly attribute long animVal;
};
Used for attributes of basic type <number>.
[Constructor,
Constructor(float value)]
interface SVGNumber {
attribute float value;
};
Used for attributes of basic type <number> which can be animated.
interface SVGAnimatedNumber {
attribute float baseVal;
readonly attribute float animVal;
};
This interface defines a list of SVGNumber objects.
SVGNumberList has the same attributes and methods as other SVGxxxList interfaces. Implementers may consider using a single base class to implement the various SVGxxxList interfaces.
The supported property indices of an SVGNumberList object is all non-negative integers less than the length of the list.
An SVGNumberList object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below.
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);
};
Used for attributes which take a list of numbers and which can be animated.
interface SVGAnimatedNumberList {
readonly attribute SVGNumberList baseVal;
readonly attribute SVGNumberList animVal;
};The SVGLength interface corresponds to the <length> and <percentage> basic data types, and represents a length or percentage that consists of a numerical factor and a unit, where the unit is one of the set of units described in Units (em, ex, px, pt, pc, cm, mm and in), a percentage, a unitless number (user units), or "unknown".
An SVGLength object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below.
An SVGLength object can be associated with a particular element, as well as being designated with a directionality: horizontal, vertical or unspecified. The associated element and the directionality of the length are used to resolve percentage values to user units. Unless otherwise described, an SVGLength object is not associated with any element and has unspecified directionality.
We need to define the behavior of converting values from/to percentages when the viewport width/height/size is zero.
[Constructor,
Constructor(float value, optional unsigned short unitType),
Constructor(DOMString 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);
};
The length value as a string. On getting, returns a string as follows:
On setting, updates the numeric factor and units type of the SVGLength object according to the result of parsing the assigned string as a <length> or <percentage>.
Sets the unit type of the length value to the type specified by unitType and sets the numeric factor value such that it represents the same absolute length. For example, if the original value were "0.5cm" and the method was invoked to convert to millimeters, then unitType would return SVG_LENGTHTYPE_MM and valueInSpecifiedUnits would return the numeric value 5.
If the old or new unit type is percentage and the SVGLength object has no associated element, then the percentages are considered to resolve against a length of 100 user units. For example, converting an SVGLength whose value is 20px to a percentage will result in the value being 20%.
| SVG 2 Requirement: | Make it easier to read and write to attributes in the SVG DOM. |
|---|---|
| Resolution: | We will make it easier to read and write to attributes in the SVG DOM in SVG2. |
| Purpose: | To avoid the awkward access to the base values of SVGAnimatedLengths. |
| Owner: | Cameron (ACTION-3414) |
Used for attributes of basic type <length> which can be animated.
interface SVGAnimatedLength {
readonly attribute SVGLength baseVal;
readonly attribute SVGLength animVal;
attribute float cm;
attribute float em;
attribute float ex;
attribute float in;
attribute float mm;
attribute float pc;
attribute float pt;
attribute float px;
};
We should add accessors for the ch,
rem, vw, vh, vmin
and vmax units once we support css3-values more fully.
Since SVGAnimatedLength objects can represent percentage values too, what should we name the accessor for that unit?
Should we add a string accessor, perhaps named
asString or value, to avoid having to write for example
rect.x.baseVal.valueAsString?
This interface defines a list of SVGLength objects.
SVGLengthList has the same attributes and methods as other SVGxxxList interfaces. Implementers may consider using a single base class to implement the various SVGxxxList interfaces.
The supported property indices of an SVGLengthList object is all non-negative integers less than the length of the list.
An SVGLengthList object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below.
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);
};
Used for attributes of type SVGLengthList which can be animated.
interface SVGAnimatedLengthList {
readonly attribute SVGLengthList baseVal;
readonly attribute SVGLengthList animVal;
attribute float cm;
attribute float em;
attribute float ex;
attribute float in;
attribute float mm;
attribute float pc;
attribute float pt;
attribute float px;
};
If any changes to the unit accessors are made to SVGAnimatedLength they should be made here too.
The SVGAngle interface corresponds to the <angle> basic data type, and represents an angle that consists of a numerical factor and a unit, where the unit is degrees, radians, grads, unitless numbers or "unknown".
An SVGAngle object can be designated as read only, which means that attempts to modify the object will result in an exception being thrown, as described below.
[Constructor,
Constructor(float value, optional unsigned short unitType),
Constructor(DOMString value)]
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);
};
The angle value as a string. On getting, returns a string as follows:
On setting, updates the numeric factor and units type of the SVGAngle object according to the result of parsing the assigned string as an <angle>.
Sets the unit type of the angle value to the type specified by unitType and sets the numeric factor value such that it represents the same absolute angle. For example, if the original value were "180deg" and the method was invoked to convert to radians, then unitType would return SVG_ANGLETYPE_RAD and valueInSpecifiedUnits would return the numeric value π.
Used for attributes of basic data type <angle> that can be animated.
interface SVGAnimatedAngle {
readonly attribute SVGAngle baseVal;
readonly attribute SVGAngle animVal;
};Used for attributes of type DOMRect which can be animated.
interface SVGAnimatedRect {
readonly attribute DOMRectReadOnly baseVal;
readonly attribute DOMRectReadOnly animVal;
};The SVGUnitTypes interface defines a commonly used set of constants and is a base interface used by SVGGradientElement, SVGPatternElement, SVGClipPathElement, SVGMaskElement and SVGFilterElement.
[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;
};
| SVG 2 Requirement: | Detect if a mouse event is on the fill or stroke of a shape. |
|---|---|
| Resolution: | SVG 2 will make it easier to detect if an mouse event is on the stroke or fill of an element. |
| Purpose: | To allow authors to discriminate between pointer events on the fill and stroke of an element without having to duplicate the element |
| Owner: | Cameron (ACTION-3279) |
Interface SVGGraphicsElement represents SVG elements whose primary purpose is to directly render graphics into a group. The 'transform' property applies to all SVGGraphicsElement. All SVGGraphicsElement have a bounding box in current user space.
dictionary SVGBoundingBoxOptions {
bool fill = true;
bool stroke = false;
bool markers = false;
bool clipped = false;
};
interface SVGGraphicsElement : SVGElement {
readonly attribute SVGAnimatedTransformList transform;
readonly attribute SVGElement? nearestViewportElement;
readonly attribute SVGElement? farthestViewportElement;
DOMRect getBBox(optional SVGBoundingBoxOptions options);
DOMMatrix? getCTM();
DOMMatrix? getScreenCTM();
DOMMatrix getTransformToElement(SVGGraphicsElement element);
};
SVGGraphicsElement implements SVGTests;
This needs to be updated to reflect the value of the 'transform' property.
Returns the result of invoking the bounding box algorithm for the element, with fill, stroke, markers and clipped members of the options dictionary argument used to control which parts of the element are included in the bounding box, using the element's user space as the coordinate system to return the bounding box in.
getClientCTM,
but the name getScreenCTM is kept for historical reasons.
Interface SVGGeometryElement represents SVG elements whose rendering is defined by geometry and which can be filled and stroked. This includes paths, text and the basic shapes.
interface SVGGeometryElement : SVGGraphicsElement { bool isPointInFill(DOMPoint point); bool isPointInStroke(DOMPoint point); };
Interface SVGTests defines an interface which applies to all elements which have attributes 'requiredFeatures', 'requiredExtensions' and 'systemLanguage'.
[NoInterfaceObject]
interface SVGTests {
readonly attribute SVGStringList requiredFeatures;
readonly attribute SVGStringList requiredExtensions;
readonly attribute SVGStringList systemLanguage;
boolean hasExtension(DOMString extension);
};Interface SVGFitToViewBox defines DOM attributes that apply to elements which have XML attributes 'viewBox' and 'preserveAspectRatio'.
[NoInterfaceObject]
interface SVGFitToViewBox {
readonly attribute SVGAnimatedRect viewBox;
readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
};
The SVGZoomAndPan interface defines attribute zoomAndPan and associated constants.
[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;
};
interface SVGViewSpec {
readonly attribute SVGTransformList transform;
readonly attribute SVGElement viewTarget;
readonly attribute DOMString viewBoxString;
readonly attribute DOMString preserveAspectRatioString;
readonly attribute DOMString transformString;
readonly attribute DOMString viewTargetString;
};
SVGViewSpec implements SVGFitToViewBox;
SVGViewSpec implements SVGZoomAndPan;
Interface SVGURIReference defines an interface which applies to all elements which have an 'xlink:href' attribute.
[NoInterfaceObject]
interface SVGURIReference {
readonly attribute SVGAnimatedString href;
};
SVG extends interface CSSRule with interface SVGCSSRule by adding an SVGColorProfileRule rule to allow for specification of ICC-based color.
It is likely that this extension will become part of a future version of CSS and DOM.
interface SVGCSSRule : CSSRule {
const unsigned short COLOR_PROFILE_RULE = 7;
};The SVGRenderingIntent interface defines the enumerated list of possible values for the ‘rendering-intent’ descriptor on an @color-profile rule.
[NoInterfaceObject]
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;
};