During the later stages of the SVG Mobile 1.1 specification it became obvious that there was a requirement to subset the SVG and XML DOM in order to reduce the burden on implementations. SVGT 1.2 adds new features to the uDOM, allowing for as much necessary functionality as possible, still being suitable for SVG Tiny implementations.
Furthermore, it should be possible to implement the uDOM on devices that support SVG Tiny 1.1 although, in this case, the scripting would be external to the SVG document (since SVG Tiny 1.1 does not support inline scripting).
The goal of the uDOM definition is to provide an API that allows access to initial and computed attribute and property values, to reduce the number of interfaces compared to the traditional SVG DOM, to reduce run-time memory footprint using necessary features of the core XML DOM, as well as the most useful SVG features (such as transformation matrices). A subset of the uDOM (corresponding to SVG Tiny 1.1) is already successfully implemented by various implementations of JSR-226. One goal of the uDOM is to keep compatibility with the JSR-226 uDOM subset.
The IDL definition for the uDOM is provided.
This appendix consists of the following parts:
The following sections provides an informative overview of the SVG uDOM's key features and constraints.
Note: Like other W3C DOM definitions, the SVG uDOM is programming-language independent. Although this appendix only contain ECMAScript and Javatm language examples, the SVG uDOM is compatible with other programming languages.
The SVG uDOM offers access to a
Document object which is the root for accessing other features. The way the
Document object becomes available depends on
the usage context. One way to gain access to the
Document object is to implement the
EventListenerInitializer2 interface. The SVG Tiny user agent will invoke the implementation's initializeEventListeners method once the programming logic has been loaded and is ready to bind to the
document. The Document object
is sometimes accessible through other means, for example as the
global document variable in ECMAScript.
SVG uDOM only allows navigation of the element nodes in the DOM tree. Two options are available for navigating the hierarchy of elements:
getElementById method on the Document interface.
parentNode attribute on the Node interface.
The ElementTraversal interface provides
firstElementChild,
lastElementChild, previousElementSibling and
nextElementSibling, which are particularly suitable for constrained devices. These traversal mechanisms skip over intervening nodes between element nodes, such as text nodes which might only contain spaces, tabs and newlines.
SVG uDOM allows creation of new Elements.
String svgNS = "http://www.w3.org/2000/svg"; Element myRect = document.createElementNS(svgNS, "rect");
Element insertion is the ability to insert new elements to a document tree.
SVG uDOM allows the insertion of an Element.
var svgNS = "http://www.w3.org/2000/svg"; // Create a new <rect> element var myRect = document.createElementNS(svgNS, "rect"); // Set the various <rect> properties before appending ... // Add element to the root of the document var svgRoot = document.documentElement; svgRoot.appendChild(myRect); // Create a new <ellipse> element var myEllipse = document.createElementNS(svgNS, "ellipse"); // Set the various <ellipse> properties before insertion ... // Insert the ellipse before the rectangle svgRoot.insertBefore(myEllipse, myRect);
Element removal is the ability to remove an element from a document tree. SVG uDOM allows removal of Elements.
var myRect = ...; // See Element creation
var myGroup = document.getElementById("myGroup");
myGroup.appendChild(myRect);
...
myGroup.removeChild(myRect);
SVGT 1.2 uDOM supports two ways of accessing XML attributes and CSS properties; the standard way via getAttributeNS
and setAttributeNS on the Element interface and via a new concept called Traits.
A trait is the typed value (e.g. a number, not just a string), associated with an element by an XML attribute or a CSS property.
The trait facilities in the SVG uDOM allow for strongly-typed access to
certain attribute and property values. For example, there is a
getFloatTrait(...) method for getting an attribute or property value
directly as a float. This contrasts the getAttributeNS method which always returns a string. The trait facilities in the SVG uDOM are available on the
TraitAccess interface.
float width = myRect.getFloatTrait('width');
width += 10;
myRect.setFloatTrait('width', width);
An important difference between getTraitNS (and all other variants of getTrait methods) and getAttributeNS is that
getTraitNS returns the computed attribute value but getAttributeNS
returns the specified attribute value (which might not exactly match the original specified value due to the possibility of user agent value normalization as described in Attribute Normalization).
<g fill="red">
<rect id="r1" x="1" y="1" width="5" height="5"/>
<rect id="r2" fill="inherit" x="1" y="1" width="5" height="5"/>
</g>
r1.getTraitNS(null, "fill") returns "red" (or equivalent normalized form, see Attribute/Property Normalization).
r2.getTraitNS(null, "fill") returns "red" (or equivalent normalized form, see Attribute/Property Normalization).
r1.getAttributeNS(null, "fill") returns "".
r2.getAttributeNS(null, "fill") returns "inherit".
A trait may be animated. To access the animated value, use getPresentationTrait.
Event Listener Registration and Removal is the ability to add and remove new event listeners from a Document. SVG uDOM allows adding and removing EventListeners.
class MyEventListener implements EventListener {
public void handleEvent(Event evt) {
// Do whatever is needed here
}
}
...
EventListener l = new MyEventListener();
SVGElement myRect = (SVGElement)document.getElementById("myRect");
//Listen to click events, during the bubbling phase
myRect.addEventListenerNS("http://www.w3.org/2001/xml-events", "click", l, false, null);
...
// Remove the click listener
myRect.removeEventListenerNS("http://www.w3.org/2001/xml-events","click", l, false);
SVG uDOM allows code to start or end timed elements (i.e. elements implementing SVGTimedElement).
var animateColor = document.getElementById("myAnimation");
// Start the animation 2.5 seconds from now.
animateColor.beginElementAt(2.5);
The SVG uDOM will use the same Java package names as the upcoming SVG 1.2 Full DOM (e.g. org.w3c.dom,org.w3c.dom.events, org.w3c.dom.svg). This allows Java applications which restrict themselves to the features in the SVG uDOM to also run in implementations that support the SVG 1.2 Full DOM.
A viewer implementing the uDOM is allowed to return normalized attribute values (defined in DOM 3) from getAttributeNS and the various getTrait methods (getTrait, getTraitNS, getFloatTrait, ...) and getPresentationTrait methods (getPresentationTrait, getPresentationTraitNS, getFloatPresentationTrait, ...). Following is a list of possible attribute normalizations:
In the SVG uDOM, there are two alternative ways to access an element's
textual content. Text access via the TraitAccess interface is
available on all SVGElements. This was available in the SVG Tiny 1.1 uDOM (used in the JSR-226 specification) and is still available in order to keep backward compability. The SVG Tiny 1.2 uDOM specification introduces the textContent attribute on the
Node interface as a more generic text access mechanism.
To access or set the text string value for an element via traits you
invoke getTrait() or
setTrait() on that element and pass #text as
the name of the trait you want to get or set. For example,
MyTextElement.setTrait("#text", "Hello");
Text access via the #text mechanism must be supported on
Text Content,
'desc',
'title'
and 'metadata' elements. Text access
to other elements defined within this specification (see list of elements) is not
supported and an implementation should ignore any text on these elements.
The result of getting and setting text content via the #text mechanism is exactly the same
as when using the textContent attribute. Therefore the user should
be aware of the fact that styling by child
'tspan' elements (i.e. 'tspan' elements that are children of the element which text content is retrieved) will be lost if a text string is retrieved from an element and then set back again.
The #text trait is included for compatibility with
JSR-226. It is recommended
that where compatibility with JSR-226 implementations is not required
content developers use textContent instead as it is
more generally applicable and supports better compatibility with
DOM Level 3 Core [DOM3].
exception DOMException
{
unsigned short code;
};
// ExceptionCode
const unsigned short INDEX_SIZE_ERR = 1;
const unsigned short DOMSTRING_SIZE_ERR = 2;
const unsigned short HIERARCHY_REQUEST_ERR = 3;
const unsigned short WRONG_DOCUMENT_ERR = 4;
const unsigned short INVALID_CHARACTER_ERR = 5;
const unsigned short NO_DATA_ALLOWED_ERR = 6;
const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7;
const unsigned short NOT_FOUND_ERR = 8;
const unsigned short NOT_SUPPORTED_ERR = 9;
const unsigned short INUSE_ATTRIBUTE_ERR = 10;
const unsigned short INVALID_STATE_ERR = 11;
const unsigned short SYNTAX_ERR = 12;
const unsigned short INVALID_MODIFICATION_ERR = 13;
const unsigned short NAMESPACE_ERR = 14;
const unsigned short INVALID_ACCESS_ERR = 15;
const unsigned short VALIDATION_ERR = 16;
const unsigned short TYPE_MISMATCH_ERR = 17;
This interface is a subset of the Node interface defined in DOM Level 3 Core. Node types that must be supported in the uDOM are Element nodes and Document nodes.
This subset does not support the NodeType and DocumentPosition definition groups, since the nodeType field and the compareDocumentPosition are not members of the subsetted interface.
Concerning textContent, there is no requirement to create a Text node
on setting since this subset has no interface representing Text nodes. However, the
behaviour of textContent must be as if the Text node described in the
the definition of textContent
had indeed been created.
An alternate way of accessing text content on elements defined within
the SVG specification is via the
getTrait("#text") syntax.
interface Node
{
readonly attribute DOMString namespaceURI;
readonly attribute DOMString localName;
readonly attribute Node parentNode;
readonly attribute Document ownerDocument;
attribute DOMString textContent;
Node appendChild(in Node newChild)
raises(DOMException);
Node insertBefore(in Node newChild, in Node refChild)
raises(DOMException);
Node removeChild(in Node oldChild)
raises(DOMException);
Node cloneNode(in boolean deep);
};
namespaceURI
localName
parentNode
ownerDocument
textContent
appendChild
insertBefore
removeChild
cloneNode
This interface is a subset of the Element interface defined in DOM Level 3 Core.
Concerning setAttributeNS, there is no requirement to take
the prefix into account since neither the prefix field
nor the Attr interface are supported.
interface Element : Node
{
DOMString getAttributeNS(in DOMString namespaceURI, in DOMString localName)
raises(DOMException);
void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value)
raises(DOMException);
};
getAttributeNS
setAttributeNS
This interface is a subset of the Document interface defined in DOM Level 3 Core.
interface Document : Node
{
readonly attribute DOMImplementation implementation;
Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName)
raises(DOMException);
readonly attribute Element documentElement;
Element getElementById(in DOMString elementId);
};
implementation
documentElement
createElementNS
getElementById
This interface is a subset of the DOMImplementation interface defined in DOM Level 3 Core.
interface DOMImplementation
{
};
This interface is a subset of the EventTarget interface defined in DOM Level 3 Events.
Please note that SVG Tiny 1.2 user-agents are not required
to support the capture phase, conformant SVG Tiny 1.2 content must not
make use of it. If an attempt to specify event operations on the capture
phase is made an SVG Tiny user-agent that does not support it must
ignore them as if addEventListener had not been called.
Refer to the DOM Events Level 3 specification or the XML Events specification introduction for an explanation of the SVG event flow and the meaning of event targets, event current target, bubble and capture.
interface EventTarget
{
void addEventListener(in DOMString type, in EventListener listener, in boolean useCapture);
void removeEventListener(in DOMString type, in EventListener listener, in boolean useCapture);
void addEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener,
in boolean useCapture, in DOMObject evtGroup);
void removeEventListenerNS(in DOMString namespaceURI, in DOMString type, in EventListener listener,
in boolean useCapture);
};
addEventListener
removeEventListener
addEventListenerNS
removeEventListenerNS
This interface is identical to the EventListener interface defined in DOM Level 3 Events.
interface EventListener
{
void handleEvent(in Event evt);
};
handleEvent
This interface is a subset of the Event interface defined in DOM Level 3 Events. This subset does not support the PhaseType definition group.
For a list of supported event types see the Supported Events chapter.
interface Event
{
readonly attribute EventTarget target;
readonly attribute EventTarget currentTarget;
readonly attribute DOMString type;
readonly attribute DOMString namespaceURI;
readonly attribute boolean cancelable;
readonly attribute boolean defaultPrevented;
void stopPropagation();
void preventDefault();
};
target
currentTarget
type
namespaceURI
cancelable
defaultPrevented
stopPropagation
preventDefault
Event types that are MouseEvents: click, mousedown, mouseup, mouseover, mousemove, mouseout, WheelEvent.
This interface is a subset of the MouseEvent interface defined in DOM Level 3 Events.
interface MouseEvent : UIEvent
{
readonly attribute long screenX;
readonly attribute long screenY;
readonly attribute long clientX;
readonly attribute long clientY;
readonly attribute unsigned short button;
};
screenX
screenY
clientX
clientY
button
Many devices today have a rotational input method, such as the wheel on a mouse or the "jog dial" of a phone or PDA.
The SVGMousewheel event is triggered
when the user rotates the rotational input device. Listeners for this event may
only be attached to the Element
node that is the Document
node's documentElement.
If a listener for this event is attached to another node in the document, the user
agent must not trigger it when the event occurs.
Event type that is a
WheelEvent:
SVGMousewheel.
interface WheelEvent : MouseEvent
{
readonly attribute long wheelDelta;
};
A "click" is defined to be a unit of rotation. On some devices this is a finite physical step. On devices with smooth rotation, a "click" becomes the smallest measurable amount of rotation.
textInput.
This interface is a subset of the TextEvent interface defined in DOM Level 3 Events.
interface TextEvent : UIEvent
{
readonly attribute DOMString data;
};
data
Event types that
are KeyboardEvents:
keydown, keyup.
This interface is a subset of the KeyboardEvent interface defined in DOM Level 3 Events.
interface KeyboardEvent : UIEvent
{
readonly attribute DOMString keyIdentifier;
};
keyIdentifier
This interface is a subset of the TimeEvent interface defined in smil animation.
Event that is fired by all Timed Elements.Event types that are TimeEvents: beginEvent, endEvent, repeatEvent.
interface TimeEvent : Event
{
readonly attribute long detail;
};
beginEvent and endEvent the detail field is not used. For repeatEvent the detail field contains the current repeat iteration.
Event types that are
UIEvents:
DOMFocusIn,
DOMFocusOut,
DOMActivate,
MouseEvent,
TextEvent,
KeyboardEvent,
This interface is a subset of the UIEvent interface defined in DOM Level 3 Events.
interface UIEvent : Event
{
readonly attribute long detail;
};
detail
Many resources, such as raster images, movies and complex SVG content can take a substantial amount of time to download. In some use cases the author would prefer to delay the display of content or the beginning of an animation until the entire content of a file has been downloaded. In other cases, the author may wish to give the viewer some feedback that a download is in progress (e.g. a loading progress screen).
The ProgressEvent occurs when the user agent makes progress loading a resource (local or external) referenced by an xlink:href attribute.
The user agent must dispatch a
ProgressEvent at
the beginning of a load operation (i.e. just before starting to access the resource).
This event is of type SVGPreload.
The user agent must dispatch a
ProgressEvent at
the end of a load operation (i.e. after load is complete and the user agent is
ready to render the corresponding resource). This event is of type
SVGPostload.
The user agent may dispatch
ProgressEvents
between the SVGPreload event
and the SVGPostload events.
Such events are of type SVGLoadProgress.
Event types
that are ProgressEvents:
SVGLoadProgress,
SVGPreload,
SVGPostload.
interface ProgressEvent : Event
{
readonly attribute boolean lengthComputable;
readonly attribute unsigned long loaded;
readonly attribute unsigned long total;
};
SVGPreload
or SVGPostload event.
SVGLoadProgress event,
it should specify the total number of bytes expected.
<svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny"
xmlns:xlink="http://www.w3.org/1999/xlink">
<script type="application/ecmascript"><![CDATA[
function showImage(imageHref) {
var image = document.getElementById('myImage');
image.setTraitNS("http://www.w3.org/1999/xlink", "href", imageHref);
}
function imageLoadStart (evt) {
progressBar.setFloatTrait("width", 0);
var loadingAnimation = document.getElementById('loadingAnimation');
loadingAnimation.beginElement();
}
function imageLoadProgress (evt) {
if ( evt.lengthComputable )
{
var progressBar = document.getElementById('progressBar');
progressBar.setFloatTrait("width", 100*(evt.loaded/evt.total));
progressBar.setTrait( "visibility", "visible" );
}
}
function imageLoadComplete (evt) {
var progressBar = document.getElementById('progressBar');
progressBar.setTrait( "visibility", "hidden" );
var loadingAnimation = document.getElementById('loadingAnimation');
loadingAnimation.endElement();
}
]]></script>
<image xml:id="myImage" xlink:href="imageA.png" width="300" height="400">
<handler type="application/ecmascript" ev:event="preload">
imageLoadStart(evt);
</handler>
<handler type="application/ecmascript" ev:event="loadProgress">
imageLoadProgress(evt);
</handler>
<handler type="application/ecmascript" ev:event="postload">
imageLoadComplete(evt);
</handler>
</image>
<rect width="120" height="30" y="400">
<handler type="application/ecmascript" ev:event="click">
showImage('imageB.png');
</handler>
</rect>
<animate xml:id="loadingAnimation" ... />
<rect visibility="hidden" xml:id="progressBar" ... />
</svg>
The ConnectionEvent is used to represent all events that may occur during the processing of connections, as described in the Connection interface. These events represent not only data received through a connection, but also the establishment and closing of a connection, as well as error conditions that may occur.
Event types that are
ConnectionEvents:
SVGConnectionConnected,
SVGConnectionDataSent,
SVGConnectionDataReceived,
SVGConnectionClosed,
SVGConnectionError.
interface ConnectionEvent : Event
{
const unsigned short NO_ERR = 0;
const unsigned short NETWORK_ERR = 1;
readonly attribute unsigned short errorCode;
readonly attribute sequence<octet> receivedData;
};
errorCode
field is set to this value so that it can be distinguished from error related events.
errorCode field set to this value.
null.
interface ElementTimeControl
{
void beginElementAt(in float offset);
void beginElement();
void endElementAt(in float offset);
void endElement();
};
| in float offset | The offset in seconds at which to begin the element. |
beginElementAt(0).
| in float offset | The offset in seconds at which to end the element. |
endElementAt(0).
interface TimeEvent : Event
{
readonly attribute long detail;
};
interface Global
{
};
exception GlobalException
{
unsigned short code;
};
// ExceptionCode
const unsigned short NOT_CONNECTED_ERR = 1;
const unsigned short ENCODING_ERR = 2;
const unsigned short DENIED_ERR = 3;
const unsigned short UNKNOWN_ERR = 4;
The Connection
interface provides an API for socket-level
communication. The socket must be set up to use the TCP
protocol. A Connection object is created using the
SVGGlobal
interface method createConnection().
Since it inherits from the EventTarget interface, it is possible to register event listeners on the Connection interface in order to handle the various types of ConnectionEvent that are dispatched during the processing of connections.
After a connection has been established the Connection object
must dispatch a ConnectionEvent with the type SVGConnectionConnected to event handlers
registered on that Connection object.
After data has been successfully sent, the Connection object
must dispatch a ConnectionEvent with the type SVGConnectionDataSent to event handlers
registered on that Connection object. The event is
dispatched exactly once for each call to send().
When data has been received, the Connection object must
dispatch a ConnectionEvent with the type SVGConnectionDataReceived to event handlers
registered on that Connection object.
In the circumstance that the connection is closed by any
peer, a ConnectionEvent with the type SVGConnectionClosed must be dispatched to event handlers
registered on that Connection object.
If an error occurs, a ConnectionEvent with the type SVGConnectionError must be
dispatched to event handlers
registered on that Connection object. This must cause the connection
to be closed.
Data must be sent and received over the connection as a binary stream of octets.
The connect() and send() methods work asynchronously
(non-blocking). Multiple calls to send() can be made in
sequence without waiting for the SVGConnectionDataSent event
to have been dispatched.
Each set of data must be queued and sent, in FIFO order, by
the UA. Each send() will result in a SVGConnectionDataSent
event except when an error occurs. A user-agent may arbitrary limit the size of the queue
of events that it can hold at any one time. Should more events require to be queued than
the user-agent's limit a GlobalException
of type DENIED_ERR must be raised, the entirety of the queue discarded, and the connection closed.
The send() method must raise an GlobalException of type NOT_CONNECTED_ERR exception if the connection
is not open at the time the call is made. All other errors are treated asynchronously, in
the form of connectionError events.
interface Connection : EventTarget
{
readonly attribute boolean connected;
void connect(in DOMString host, in unsigned short port)
raises(GlobalException);
void send(in sequence<octet> data)
raises(GlobalException);
void close();
};
true if a connection is currently open,
and false otherwise.
Cause a connection to be open to the provided host and port, where the host
may be either a domain name or an IP address. If the connection fails to be
established, a GlobalException of type NOT_CONNECTED_ERR MUST be raised.
Once the connection is established, the connected field must be set to true.
For security reasons, user-agents are strongly encouraged to restrict the ways in which a connection can be established both for both host and ports. If the user-agent elects to deny the connection based on these restrictions, a GlobalException of type DENIED_ERR MUST be raised.
| in DOMString host | A domain name or IP address that the TCP connection is to be established to. |
| in unsigned short port | The port to which the TCP connection is being established. |
| GlobalException |
NOT_CONNECTED_ERR: Raised if the connection fails.
|
This method sends the data over the connection. It transmits a sequence of octets
without modifying it in any way. A string can be transmitted after having been
converted to a sequence of octets using the stringToBinary method on the
SVGGlobal interface.
| in sequence<octet> data data | The data to send. |
| GlobalException |
NOT_CONNECTED_ERR: Raised if the connection is not open when send is called.
|
This method causes the connection to be closed. It is asynchronous
and any data queued for transmission using the send() method but not
yet successfully transmitted must be sent before the connection is
effectively closed. However, any call to send() occurring after
close() has been called will raise an exception as if the connection
had already been closed, and the connected field must be set to
false immediately.
The Timer interface provides an API for scheduling a one time or repetitive event. A Timer object is always either in the running (attribute running is true) or waiting (attribute running is false) state. After each interval of the timer, an Event of type SVGTimer is triggered.
SVGTimer events are triggered only when the timer is in the running state. The SVGTimer event is limited to the target phase. Since Timer is an EventTarget, EventListeners can be registered on it using addEventListener with SVGTimer as the event type. Event listeners can access their corresponding Timer object through the event object's target property.
Timer instances are created using the createTimer method of the SVGGlobalinterface.
interface Timer : events::EventTarget
{
attribute long delay;
attribute long repeatInterval;
readonly attribute boolean running;
void start();
void stop();
};
This attribute specifies the time remaining in milliseconds until the next event is fired. When the Timer is in the running state this attribute is dynamically updated to reflect the remaining time in the current interval. When the Timer is waiting the delay reflects the time that remained when stopped. Getting the delay attribute returns the current value, i.e. a snapshot value of the remaining delay. After delay period has passed while the object is in the running state, the Timer object will trigger an Event of type SVGTimer. The delay will then be updated with the repeatInterval value and a new count down will start. Setting the delay resets the current interval to the new value. If this attribute is 0, it means that the event will be triggered as soon as possible. Assigning a negative value is equivalent to calling the stop() method. The initial value is set through the initialInterval parameter in the createTimer method on the SVGGlobalinterface, and defines the first interval of the Timer.
This attribute specifies in milliseconds the interval for each repeat of the Timer, i.e. each timer interval subsequent to the initial interval. The initial value of this attribute is set through the repeatInterval parameter in the createTimer method on the SVGGlobal interface. Assigning a negative value disables the repetitive triggering of the event making it a one time timer which triggers an event after the delay.
Timer state. Value is true if the timer is running, false if the timer is waiting. Note that the repeatInterval and delay properties can be non-negative if the timer is stopped (but if delay is negative, the timer is stopped).
Changes the Timer state into running. If the timer is already in the running state, it has no effect. Initially the timer is waiting, and must be started with this method. If the timer delay had a negative value when started, for example if the time had been stopped by setting the delay to a negative value, the delay value is reset to repeatInterval when the this method is called.
This interface is identical to SVGException interface defined in SVG 1.1.
exception SVGException
{
unsigned short code;
};
// ExceptionCode
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 SVGDocument : Document, EventTarget
{
readonly attribute SVGGlobal global;
};
This interface is a subset of the SVGElementInstance interface defined in SVG 1.1.
interface SVGElementInstance : EventTarget
{
readonly attribute SVGElement correspondingElement;
readonly attribute SVGElement correspondingUseElement;
};
correspondingElement
correspondingUseElement
<svg version="1.2" baseProfile="tiny" width="640" height="480"
viewBox="0 0 640 480" xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:ev="http://www.w3.org/2001/xml-events">
<defs>
<rect xml:id="r1" width="90" height="65"/>
</defs>
<use xlink:href="#r1" x="50" y="200" fill="red"/>
<use xlink:href="#r1" x="250" y="200" fill="blue"/>
<use xlink:href="#r1" x="450" y="200" fill="green"/>
<rect xml:id="r2" x="250" y="50" width="90" height="65"/>
<ev:listener observer="r1" event="ev:click" handler="#handler"/>
<handler xml:id="handler" type="application/ecmascript">changeColor(evt);</handler>
<script type="application/ecmascript">
<![CDATA[
var target = document.getElementById("r2");
function changeColor(evt)
{
var useElement = evt.currentTarget.correspondingUseElement;
target.setRGBColorTrait("fill", useElement.getRGBColorTrait("fill"));
}
]]>
</script>
</svg>
This interface represents the 'svg' element in the (SVG) document tree.
The uDOM attributes currentScale,
currentRotate and
currentTranslate
are combined to form a user agent transformation which is applied at the outermost
level on the SVG document (i.e. outside the
'svg' element) if
"magnification" is enabled (i.e.
'zoomAndPan'
attribute is set to magnify). Their values
can potentially be modified through user-agent specific UI. User agent transformation
can be obtained by multiplying the matrix
[currentScale 0 currentTranslate.x] [cos(currentRotate) -sin(currentRotate 0] [ 0 currentScale currentTranslate.y] by [sin(currentRotate) cos(currentRotate) 0] [ 0 0 1 ] [ 0 0 1]
i.e. (translate, then scale, then rotate the coordinate system). The reference point for scale and rotate operations is the origin (0, 0).
interface SVGSVGElement : SVGLocatableElement, SVGTimedElement
{
const unsigned short NAV_AUTO = 1;
const unsigned short NAV_NEXT = 2;
const unsigned short NAV_PREV = 3;
const unsigned short NAV_UP = 4;
const unsigned short NAV_UP_RIGHT = 5;
const unsigned short NAV_RIGHT = 6;
const unsigned short NAV_DOWN_RIGHT = 7;
const unsigned short NAV_DOWN = 8;
const unsigned short NAV_DOWN_LEFT = 9;
const unsigned short NAV_LEFT = 10;
const unsigned short NAV_UP_LEFT = 11;
attribute float currentScale;
attribute float currentRotate;
readonly attribute SVGPoint currentTranslate;
readonly attribute SVGRect viewport;
float getCurrentTime();
void setCurrentTime( in float seconds );
SVGMatrix createSVGMatrixComponents(in float a, in float b, in float c, in float d, in float e,
in float f);
SVGRect createSVGRect();
SVGPath createSVGPath();
SVGRGBColor createSVGRGBColor(in long red, in long green, in long blue)
raises(SVGException);
void moveFocus(in unsigned short motionType)
raises(DOMException);
void setFocus(in DOMObject object)
raises(DOMException);
EventTarget getCurrentFocusedObject();
};
nav-next value.
nav-prev value.
currentScale is 1.| DOMException |
INVALID_ACCESS_ERR: Raised if the scale value is set to zero.
|
currentRotate is 0.currentTranslate is SVGPoint(0,0).
The position and size of the viewport (implicit or explicit) that corresponds to this 'svg' element. When the user agent is actually rendering the content, then the position and size values represent the actual values when rendering.
If this SVG document is embedded as part of another document (e.g., via the HTML 'object' element), then the position and size are unitless values in the coordinate system of the parent document. (If the parent uses CSS or XSL layout, then unitless values represent pixel units for the current CSS or XSL viewport, as described in the CSS2 specification.) If the parent element does not have a coordinate system, then the user agent should provide reasonable default values for this attribute.
For stand-alone SVG documents, both 'x' and 'y' must be zero, the 'width' must be the width of the viewport which the host environment provides to the SVG user agent into which it can render its content, and the 'height' must be the height of the viewport, with all values expressed in the pixel coordinate system from the host environment, preferably such that this pixel coordinate system matches the same pixel coordinate system presented to HTML and matches the model for pixel coordinates described in the CSS2 specification.
Note that "pixel coordinate systems" are host-specific. Two possible
approaches that hosts might use for pixel coordinate systems are
actual device pixels or (particularly for high-resolution devices)
pseudo device pixels which exactly match SVG and CSS's "px"
coordinates.
The object itself and its contents are both readonly. A DOMException with error code NO_MODIFICATION_ALLOWED_ERR
is raised if attempt is made to modify it. The returned SVGRect object is "live", i.e. its x, y, width, height is
automatically updated if viewport size or position changes.
setMatrixTrait method. The internal representation of the matrix is as follows:
[ a c e ] [ b d f ] [ 0 0 1 ]
| in float a | The 'a' component of the matrix to be set. |
| in float b | The 'b' component of the matrix to be set. |
| in float c | The 'c' component of the matrix to be set. |
| in float d | The 'd' component of the matrix to be set. |
| in float e | The 'e' component of the matrix to be set. |
| in float f | The 'f' component of the matrix to be set. |
setRectTrait method. The initial values for x, y, width, height of this new SVGRect are zero.
setPathTrait method.
setRGBColorTrait method. The parameters are floats, one per color component. 0.0 represents zero intensity and 255.0 represents full intensity of a given color component. Colors originally in the rgb(%,%,%) syntax may have fractional components. Out of gamut colors may have component values less than 0.0 or greater than 255.0.
| in float red | The red component of the SVGRGBColor. |
| in float green | The green component of the SVGRGBColor. |
| in float blue | The blue component of the SVGRGBColor. |
| SVGRGBColor | The created SVGRGBColor. |
motionType. The User Agent must take into account the
currently focused object in the document in order to find the new focused object.DOMFocusOut event must be dispatched which has the previously focused object as the event target.DOMFocusIn event must dispatched which has the the new focused object as the event target.DOMFocusIn event.DOMFocusOut/DOMFocusIn event is dispatched.| in short motionType | The type of motion. |
| DOMException |
NOT_SUPPORTED_ERROR: Raised if the requested motion type is not supported (i.e. not one of the interface constants).
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the currently focused object doesn't have a
nav-* value corresponding to the requested motion type. For instance, if a moveFocus(NAV_UP) is called on an element which has no 'nav-up' attribute.
|
|
| DOMException |
INVALID_STATE_ERR: Raised if the currently focused object has a
nav-* value corresponding to the requested motion type but the target indicated in this attribute can not be found or is not a focusable object. For instance, if a moveFocus(NAV_UP) is called on an object which has a 'nav-up' attribute but the value of this attribute references an element which is not focusable.
|
DOMFocusOut event must be dispatched which has the previously focused object as the event target.DOMFocusIn event must be dispatched which has the the new focused object as the event target.DOMFocusIn event.DOMFocusOut/DOMFocusIn event is dispatched.
| in DOMObject object | The object which should receive focus. |
| DOMException |
NOT_SUPPORTED_ERROR: Raised if the requested element is not focusable (i.e. its ''focusable' attribute does not evaluate to
true).
|
| EventTarget | The currently focused object. |
getRGBColorTrait)
such as 'fill', 'stroke', and 'color'.
interface SVGRGBColor
{
attribute unsigned long red;
attribute unsigned long green;
attribute unsigned long blue;
};
This interface is identical to SVGRect interface defined in SVG 1.1.
interface SVGRect
{
attribute float x;
attribute float y;
attribute float width;
attribute float height;
};
This interface is a subset of the SVGPoint interface defined in SVG 1.1.
interface SVGPoint
{
attribute float x;
attribute float y;
};
Path data created or modified using this interface must be normalized as per the rules given in Path Normalization.
interface SVGPath
{
const unsigned short MOVE_TO = 77;
const unsigned short LINE_TO = 76;
const unsigned short CURVE_TO = 67;
const unsigned short QUAD_TO = 81;
const unsigned short CLOSE = 90;
readonly attribute unsigned long numberOfSegments;
unsigned short getSegment(in unsigned long cmdIndex)
raises(DOMException);
float getSegmentParam(in unsigned long cmdIndex, in unsigned long paramIndex)
raises(DOMException);
void moveTo(in float x, in float y);
void lineTo(in float x, in float y);
void quadTo(in float x1, in float y1, in float x2, in float y2);
void curveTo(in float x1, in float y1, in float x2, in float y2, in float x3, in float y3);
void close();
};
| in unsigned long cmdIndex | The command index for the segment command to retrieve. |
| unsigned short | The segment command. One of MOVE_TO, LINE_TO, CURVE_TO, QUAD_TO or CLOSE |
| DOMException |
INDEX_SIZE_ERR: Raised if segment index is out of bounds or param index is out of bounds for this segment's type.
|
| in float cmdIndex | The command index for the segment command. |
| in float paramIndex | The parameter index to retrieve. |
| float | The segment parameter. |
| DOMException |
INDEX_SIZE_ERR: Raised if segment index out of bounds or param index out of bounds for this segment's type.
|
| in float x | The x-axis coordinate for the specified point. |
| in float y | The y-axis coordinate for the specified point. |
| in float x | The x-axis coordinate for the specified point. |
| in float y | The y-axis coordinate for the specified point. |
| in float x1 | The x-axis coordinate of the first control point. |
| in float y1 | The y-axis coordinate of the first control point. |
| in float x2 | The x-axis coordinate of the final end point. |
| in float y2 | The y-axis coordinate of the final end point. |
| in float x1 | The x-axis coordinate of the first control point. |
| in float y1 | The y-axis coordinate of the first control point. |
| in float x2 | The x-axis coordinate of the second end point. |
| in float y2 | The y-axis coordinate of the second end point. |
| in float x3 | The x-axis coordinate of the final end point. |
| in float y3 | The y-axis coordinate of the final end point. |
mTranslate, inverse, mMultiply, mScale and mRotate methods in this interface
mutate the SVGMatrix object and return a reference to the SVGMatrix instance itself, after
performing the necessary matrix operation.
This matrix transforms source coordinates (x, y) into destination coordinates (x', y') by considering them to be a column vector and multiplying the coordinate vector by the matrix according to the following process:
[ x' ] [ a c e ] [ x ] [ a.x + c.y + e ] [ y' ] = [ b d f ] [ y ] = [ b.x + d.y + f ] [ 1 ] [ 0 0 1 ] [ 1 ] [ 1 ]
interface SVGMatrix
{
float getComponent(in unsigned long index)
raises(DOMException);
SVGMatrix mMultiply(in SVGMatrix secondMatrix);
SVGMatrix inverse()
raises(SVGException);
SVGMatrix mTranslate(in float x, in float y);
SVGMatrix mScale(in float scaleFactor);
SVGMatrix mRotate(in float angle);
};
getComponent(0) is a, getComponent(1) is b, etc.
| in unsigned long index | The index of the matrix component to retrieve. |
| float | The matrix component. |
| DOMException |
INDEX_SIZE_ERR: Raised if the
index is invalid.
|
| in SVGMatrix secondMatrix | The matrix to post-multiply with. |
| SVGMatrix | The resulting current matrix. |
| SVGMatrix | The inverse of the current matrix. |
| SVGException |
SVG_MATRIX_NOT_INVERTABLE: Raised when determinant of this matrix is zero.
|
mMultiply(T), where T is an
SVGMatrix object represented by the following
matrix:
[ 1 0 x ] [ 0 1 y ] [ 0 0 1 ]
| in float x | The distance by which coordinates are translated in the X axis direction. |
| in float y | The distance by which coordinates are translated in the Y axis direction. |
| SVGMatrix | The resulting current matrix. |
mMultiply(S), where S is an SVGMatrix
object represented by the following matrix:
[ scaleFactor 0 0 ] [ 0 scaleFactor 0 ] [ 0 0 1 ]
| in float scaleFactor | The factor by which coordinates are scaled along the X and Y axis. |
| SVGMatrix | The resulting current matrix. |
mMultiply(R), where R is an
SVGMatrix object represented by the following matrix:
[ cos(angle) -sin(angle) 0 ] [ sin(angle) cos(angle) 0 ] [ 0 0 1 ]
| in float angle | The angle of rotation in degrees. |
| SVGMatrix | The resulting current matrix. |
interface SVGLocatable
{
SVGRect getBBox();
SVGMatrix getScreenCTM();
SVGRect getScreenBBox();
};
null is returned if this element is not hooked into the document tree.
| SVGRect | The bounding box. The returned object is a copy of the current bounding box value and will not change if the corresponding bounding box changes. |
getClientCTM, but the name getScreenCTM is kept for historical reasons.
| SVGMatrix | The transformation matrix. The returned object is a copy of the current screen CTM value and will not change if the corresponding screen CTM changes. |
SVGLocatable::getScreenCTM method.null is returned if this element is not hooked into the document tree.
| SVGRect | The bounding box in screen coordinate space. The returned object is a copy of the current screen bounding box value and will not change if the corresponding screen bounding box changes. |
The following examples further clarify the behavior of the getBBox()
method. The examples have a short explanation, an SVG fragment and are
followed by a set of bounding box values which have the following
format:
[elementId] : {x, y, width, height} | {null}
where x, y, width and height define the values of the SVGRect object's
returned from a getBBox call on the element with the specified id.
There are a few cases where the bounding box may be null (see example
6).
getBBox method for
various simple basic shapes and groups. In particular, it shows that
the transform, on an element, does not change the value of its user
space bounding box.
<g xml:id="group1" transform="translate(10, 20)" fill="red"> <rect xml:id="rect1" transform="scale(2)" x="10" y="10" width="50" height="50"/> <rect xml:id="rect2" x="10" y="10" width="100" height="100"/> <g xml:id="group2" transform="translate(10, 20)"> <rect xml:id="rect3" x="0" y="10" width="150" height="50"/> <circle xml:id="circle1" cx="20" cy="20" r="100" /> </g> </g>
Result:
[group1] : {-70.0, -60.0, 230.0, 200.0}
[rect1] : {10.0, 10.0, 50.0, 50.0}
[rect2] : {10.0, 10.0, 100.0, 100.0}
[group2] : {-80.0, -80.0, 230.0, 200.0}
[rect3] : {0.0, 10.0, 150.0, 50.0}
[circle1] : {-80.0, -80.0, 200.0, 200.0}
<g xml:id="group1" transform="translate(10, 20)" fill="red"> <rect xml:id="rect2" x="10" y="10" width="400" height="0"/> <g xml:id="group2" transform="translate(10, 20)"> <rect xml:id="rect3" x="0" y="10" width="150" height="50"/> </g> </g>
Result:
[group1] : {10.0, 10.0, 400.0, 70.0}
[rect2] : {10.0, 10.0, 400.0, 0.0}
[group2] : {0.0, 10.0, 150.0, 50.0}
[rect3] : {0.0, 10.0, 150.0, 50.0}
<svg xml:id="mySVG" version="1.2" baseProfile="tiny" width="10" height="20"> <g xml:id="group1" transform="translate(10, 20)" fill="red"> <rect xml:id="rect1" x="10" y="10" width="100" height="100"/> <ellipse xml:id="ellipse1" cx="20" cy="20" rx="0" ry="70" /> </g> </svg>
Result:
[mySVG] : {20.0, -30.0, 100.0, 160.0}
[group1] : {10.0, -50.0, 100.0, 160.0}
[rect1] : {10.0, 10.0, 100.0, 100.0}
[ellipse1] : {20.0, -50.0, 0.0, 140.0}
<svg xml:id="mySVG" version="1.2" baseProfile="tiny" width="0" height="50"> <g xml:id="group1" transform="translate(10, 20)" fill="red" > <rect xml:id="rect1" x="10" y="10" width="50" height="50"/> <g xml:id="group2" transform="translate(10, 20)"> <rect xml:id="rect2" x="0" y="10" width="150" height="0"/> <circle xml:id="circle1" cx="20" cy="20" r="500"/> </g> </g> </svg>
Result:
[mySVG] : {-460.0, -440.0, 1000.0, 1000.0}
[group1] : {-470.0, -460.0, 1000.0, 1000.0}
[rect1] : {10.0, 10.0, 50.0, 50.0}
[group2] : {-480.0, -480.0, 1000.0, 1000.0}
[rect2] : {0.0, 10.0, 150.0, 0.0}
[circle1] : {-480.0, -480.0, 1000.0, 1000.0}
<svg version="1.2" baseProfile="tiny"> <defs> <rect xml:id="myRect" x="0" y="0" width="60" height="40"/> </defs> <use xml:id="myUse" xlink:href="#myRect" x="-30" y="-20"/> </svg>
Result:
[myRect] : {0.0, 0.0, 60.0, 40.0}
[myUse] : {-30.0, -20.0, 60.0, 40.0}
createElementNS
call) is also null.
<g xml:id="emptyG"/>
Result:
[emptyG] : {null}
display='none'
are not accounted for in the computation of their parent's bounding
box. This reflects the definition of the 'display' property and its
impact on rendering and bounding box computation. The example also
shows that elements with a 'hidden' 'visibility' still contribute to
their parent's bounding box computation.
<g xml:id="g1"> <g xml:id="g1.1.display.none" display="none"> <rect xml:id="rect1" x="10" y="10" width="40" height="40"/> </g> <rect xml:id="rect2.visibility.hidden" visibility="hidden" x="30" y="60" width="10" height="20"/> </g>
Result:
[g1] : {30.0, 60.0, 10.0, 20.0}
[g1.1.display.none] : {10.0, 10.0, 40.0, 40.0}
[rect1] : {10.0, 10.0, 40.0, 40.0}
[rec2.visibility.hidden] : {30.0, 60.0, 10.0, 20.0}
<g xml:id="g1"> <line xml:id="line1" x2="100" y2="100" transform="rotate(-45)"/> </g>
Result:
[g1] : {0.0, 0.0, 141.42136, 0}
[line1] : {0.0, 0.0, 100.0, 100.0}
<g> <line xml:id="thickLine" stroke-width="10" x2="100" y2="0"/> </g>
Result:
[thickLine] : {0.0, 0.0, 100.0, 0.0}
<svg xml:id="rootSvg" version="1.2" baseProfile="tiny" width="500" height="300" viewBox="0 0 200 100"> <rect x="-100" y="-200" width="500" height="100"/> </svg>
Result:
[rootSVG] : {-100, -200, 500, 100}
This interface represents an element that has a physical location on the screen.
This interface is implemented by: 'rect', 'circle', 'ellipse', 'line', 'path', 'use', 'image', 'text', 'textArea', 'tspan', 'svg', 'a', 'video', 'animation', 'switch', 'foreignObject', 'polygon', 'polyline' and 'g'.
interface SVGLocatableElement : SVGElement, SVGLocatable
{
};
Trait manipulation interface. This interface is used read and manipulate the value of "traits" associated with an SVGElement. Each trait corresponds to an attribute or property, which is parsed and understood by the element and in most cases animatable. Unlike attributes, each element has a well-defined set of traits and attempting to access an undefined trait may throw an exception. Also unlike attributes traits are typed and their values are normalized; for instance SVG 'path' specification is parsed and all path commands are converted to their absolute variants, it is not possible to say through the value of the trait if a path command was absolute or relative. When getting and setting trait values, accessor of the correct type must be used or exception will be thrown.
For a trait corresponding to a property, the computed value is used: if the value of a given property is not specified on that element, then for inherited properties the value on the parent is used. For non-inherited values, or on the root element, the initial value of the property is used.
For a trait corresponding to a non-property attribute, if the attribute is inherited (eg xml:lang) the value of the parent is used. If the attribute is not inherited, or on the root element, the default value for the attribute is used, if known. If not known (for example, for an unknown attribute, or a known attribute with no specified default), 'null' is returned.
The different getTrait methods (getTrait, getTraitNS, getFloatTrait, ...) return base values (i.e. before animation is applied), and this is true for both static and animated content. Note however that if the attribute is inherited from an animated parent value, it will inherit the animated value.
The different getPresentationTrait methods (getPresentationTrait, getPresentationTraitNS, getFloatPresentationTrait, ...) return either the current animated value if the given trait is currently being animated (per the SMIL specification) or the base value if the given trait is not currently being animated.
Not all attributes are accessible by traits - see the table of supported attributes.
Setting a trait value has the same effect as changing a corresponding attribute, but trait setters can operate on typed values. The value which is modified is always a base value. For inheritable traits the trait value can always be set to 'inherit' (but querying the value will always return the actual inherited value as explained above).
Note about invalid/unsupported trait values:
There are two situations where the various trait setter methods (such as setTrait, setFloatTrait
or setPathTrait methods) consider a value invalid and throw a DOMException with the INVALID_ACCESS_ERR code.
The trait methods will consider the value to be invalid if its in error.
The second situation is when the trait value is invalid with regards to animations currently applied to the trait. The value is considered invalid because it would put the animation, and therefore the document, in an error state. For example, if a 'path' element has animations on its 'd' attribute, trying to change the 'd' attribute to a value incompatible with the animations will cause the exception to happen.
User Agents must implement the trait setter methods such that trait values which represent unsupported values result in a DOMException with the NOT_SUPPORTED_ERR code.
For example, trying to set the
'stroke-linejoin' trait to 'foo' would cause this exception.
interface TraitAccess
{
DOMString getTrait(in DOMString name)
raises(DOMException);
DOMString getTraitNS(in DOMString namespaceURI, in DOMString name)
raises(DOMException);
float getFloatTrait(in DOMString name)
raises(DOMException);
SVGMatrix getMatrixTrait(in DOMString name)
raises(DOMException);
SVGRect getRectTrait(in DOMString name)
raises(DOMException);
SVGPath getPathTrait(in DOMString name)
raises(DOMException);
SVGRGBColor getRGBColorTrait(in DOMString name)
raises(DOMException);
DOMString getPresentationTrait(in DOMString name)
raises(DOMException);
DOMString getPresentationTraitNS(in DOMString namespaceURI, in DOMString name)
raises(DOMException);
float getFloatPresentationTrait(in DOMString name)
raises(DOMException);
SVGMatrix getMatrixPresentationTrait(in DOMString name)
raises(DOMException);
SVGRect getRectPresentationTrait(in DOMString name)
raises(DOMException);
SVGPath getPathPresentationTrait(in DOMString name)
raises(DOMException);
SVGRGBColor getRGBColorPresentationTrait(in DOMString name)
raises(DOMException);
void setTrait(in DOMString name, in DOMString value)
raises(DOMException);
void setTraitNS(in DOMString namespaceURI, in DOMString name, in DOMString value)
raises(DOMException);
void setFloatTrait(in DOMString name, in float value)
raises(DOMException);
void setMatrixTrait(in DOMString name, in SVGMatrix matrix)
raises(DOMException);
void setRectTrait(in DOMString name, in SVGRect rect)
raises(DOMException);
void setPathTrait(in DOMString name, in SVGPath path)
raises(DOMException);
void setRGBColorTrait(in DOMString name, in SVGRGBColor color)
raises(DOMException);
};
getTraitNS
with namespaceURI set to null.
| in DOMString name | The name of the trait to retrieve. |
| DOMString | The trait value. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a DOMString (SVG Tiny only).
|
getTrait, but for namespaced traits. Parameter name must be a non-qualified trait name, i.e. without prefix.
| in DOMString namespaceURI | The namespace of the trait to retrieve. |
| in DOMString name | The name of the trait to retrieve. |
| DOMString | The trait value. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a DOMString (SVG Tiny only).
|
float.
| in DOMString name | The name of the trait to retrieve. |
float |
The trait value as a float. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a
float.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGMatrix.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGRect.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGPath.
|
| in DOMString name | The name of the trait to retrieve. |
| SVGRGBColor | The trait value as an SVGRGBColor. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGRGBColor.
|
getPresentationTraitNS with namespaceURI set to null.
| in DOMString name | The name of the trait to retrieve. |
| DOMString | The trait presentation value. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a DOMString (SVG Tiny only).
|
getPresentationTrait, but for namespaced traits. The parameter name must be a non-qualified trait name, i.e. without prefix.
| in DOMString namespaceURI | The namespace of the trait to retrieve. |
| in DOMString name | The name of the trait to retrieve. |
| DOMString | The trait presentation value. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a DOMString (SVG Tiny only).
|
float.
| in DOMString name | The name of the trait to retrieve. |
float |
The trait presentation value as a float. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to a
float.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGMatrix.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGRect.
|
| in DOMString name | The name of the trait to retrieve. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGPath.
|
null.
| in DOMString name | The name of the trait to retrieve. |
| SVGRGBColor | The trait presentation value as an SVGRGBColor. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or
null.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if requested trait's computed value cannot be converted to an SVGRGBColor.
|
setTraitNS with the namespaceURI attribute set to null.
| in DOMString name | The name of the trait to be set. |
| in DOMString value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or an attempt has been made to set an unsupported value.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as a DOMString.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is an invalid value for the given trait or
null is specified.
|
|
| DOMException |
NO_MODIFICATION_ALLOWED_ERR: Raised if attempt is made to change a readonly trait.
|
setTrait, but for namespaced traits. The parameter name must be a non-qualified trait name, i.e. without prefix.
| in DOMString namespaceURI | The namespace of the trait to be set. |
| in DOMString name | The name of the trait to be set. |
| in DOMString value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element or an attempt has been made to set an unsupported value.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as a DOMString.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is an invalid value for the given trait or
null is specified. This error is also thrown when the 'use' element is hooked into the document tree and the the value of 'xlink:href' is set invalid.
|
|
| DOMException |
NO_MODIFICATION_ALLOWED_ERR: Raised if attempt is made to change a readonly trait.
|
float.
| in DOMString name | The name of the trait to be set. |
in float
value |
The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as a
float.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is an invalid value for the given trait or
null is specified.
|
| in DOMString name | The name of the trait to be set. |
| in SVGMatrix value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as an SVGMatrix.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is
null.
|
| in DOMString name | The name of the trait to be set. |
| in SVGRect value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as an SVGRect.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is an invalid value for the given trait or
null is specified. An SVGRect is invalid if the width or height values are set to negative..
|
| in DOMString name | The name of the trait to be set. |
| in SVGPath value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as an SVGPath.
|
|
| DOMException |
| in DOMString name | The name of the trait to be set. |
| in SVGRGBColor value | The value of the trait. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the requested trait is not supported on this element.
|
|
| DOMException |
TYPE_MISMATCH_ERR: Raised if the requested trait's value cannot be specified as an SVGRGBColor.
|
|
| DOMException |
INVALID_ACCESS_ERR: Raised if the input value is
null.
|
Trait access is not required on all of the SVG Tiny attributes and properties. The table below shows the attributes and properties that SVG Tiny DOM 1.2 implementations must support trait access to. Each attribute row lists the allowed getter and setter(s). The 'Default Values' column specifies the default values that must be used for each attribute or property. If a 'Default Values' column entry is empty, there is no default value. Unless explicitly stated in the 'Comments' column, a supported attribute is accessible on all elements it can belong to. See the attribute section for a list of attributes and which elements they belong to.
Implementations that support multiple versions of svg must allow trait access to the most extensive set and support the types supported by each trait in the most extensive set. However, content relying on traits or trait types available in future versions may not work in all conformant SVG Tiny 1.2 uDOM implementations.
For 'REQUIRED' attributes, there are two cases:
The User Agent must raise a NOT_SUPPORTED_ERR whenever there is an attempt to use trait methods for traits which are not supported by the UA.
Note: For some of the attributes and data types additional rules apply. These rules are defined below the table.
Note: In the table below:
getTrait method, it must also support the getTraitNS, getPresentationTrait, and getPresentationTraitNS methods.getFloatTrait), it must also support the corresponding get***PresentationTrait method (e.g.,
getFloatPresentationTrait).setTrait method, it must also support the setTraitNS method.| Attribute | Trait Getter | Trait Setter | Default Values | Comments |
|---|---|---|---|---|
| accumulate | getTrait [none | sum] | setTrait [none | sum] | none | |
| additive | getTrait [replace | sum] | setTrait [replace | sum] | replace | |
| attributeName | getTrait | setTrait | ||
| audio-level | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait [inherit] |
1.0f | |
| baseProfile | getTrait | setTrait | "tiny" | |
| begin | N/A | setTrait | ||
| calcMode | getTrait [discrete | linear | paced | spline] | setTrait [discrete | linear | paced | spline] | linear (except for animateMotion) paced (for animateMotion) |
|
| color | getRGBColorTrait [SVGRGBColor] getTrait [SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait [inherit | SVGRGBColor] |
rgb(0,0,0) | -See RGB access rule. |
| cx | getFloatTrait | setFloatTrait | 0.0f | |
| cy | getFloatTrait | setFloatTrait | 0.0f | |
| d | getPathTrait [SVGPath] | setPathTrait [SVGPath] | REQUIRED(Empty SVGPath) | |
| display | getTrait [inline | none ] | setTrait [inline | none | inherit ] | "inline" | -See Display access rule. |
| dur | N/A | setTrait | ||
| editable | getTrait [simple | none] | setTrait [simple | none] | "none" | |
| fill | getRGBColorTrait [SVGRGBColor] getTrait [none | SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait [none | currentColor | inherit | SVGRGBColor] |
rgb(0,0,0) | -See RGB access rule. -Attribute defining the fill-color. |
| fill | getTrait[freeze | remove] | setTrait[freeze | remove] | "remove" | -Attribute defining the fill behavior of a smil animation element. |
| fill-opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait[inherit] |
1.0f | |
| fill-rule | getTrait [nonzero | evenodd] | setTrait [nonzero | evenodd | inherit] | "nonzero" | |
| focusable | getTrait [true | false] | setTrait [true | false | auto] | ||
| nav-right | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-next | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-up | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-up-right | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-up-left | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-prev | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-down | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-down-right | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-down-left | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| nav-left | getTrait [auto | url(<Local IRI Reference>) | self] | setTrait [url(<Local IRI Reference>) | auto | self] | "auto" | |
| focusHighlight | getTrait [auto| none] | setTrait [auto| none] | "auto" | |
| font-family | getTrait [the font-family computed value listed in the same syntax as the font-family property] | setTrait [same syntax as font-family attribute] | User-Agent | |
| font-size | getFloatTrait [value >= 0] | setFloatTrait [value >= 0] setTrait [inherit | xx-small | x-small | small | medium | large | x-large | xx-large | larger | smaller] |
User-Agent | |
| font-style | getTrait [normal | italic | oblique ] | setTrait [normal | italic | oblique | inherit] | "normal" | |
| font-weight | getTrait [100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 ] | setTrait [normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit] | "normal" | |
| gradientUnits | getTrait [userSpaceOnUse | objectBoundingBox] | setTrait [userSpaceOnUse | objectBoundingBox] | "objectBoundingBox" | |
| height | getFloatTrait [value >= 0] | setFloatTrait [value >= 0] | REQUIRED(0.0f) | If the height is specified as a percentage or unit value (only possible for the 'svg' 'height'), a DOMException with error code TYPE_MISMATCH_ERR is raised since the requested trait's computed value cannot be converted to a float. |
| id | getTrait | setTrait | ||
| keyPoints | N/A | setTrait | ||
| keySplines | N/A | setTrait | ||
| keyTimes | N/A | setTrait | ||
| max | N/A | setTrait | ||
| min | N/A | setTrait | ||
| offset | getFloatTrait[value >= 0 && value <= 1] | setFloatTrait[value >= 0 && value <= 1] | ||
| opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait[inherit] |
||
| path | getPathTrait [SVGPath] | setPathTrait [SVGPath] | REQUIRED(Empty SVGPath) | |
| r | getFloatTrait [ value >= 0] | setFloatTrait [value >= 0] | REQUIRED (0.0f) | |
| repeatCount | N/A | setTrait | ||
| repeatDur | N/A | setTrait | ||
| restart | getTrait [always | whenNotActive | never] | setTrait [always | whenNotActive | never] | always | |
| rx | getFloatTrait [value >= 0] | setFloatTrait [value >= 0] | 0.0f | |
| ry | getFloatTrait [value >= 0] | setFloatTrait [value >= 0] | 0.0f | |
| snapshotTime | getFloatTrait [value >= 0] | setFloatTrait [value >= 0] | 0.0f | |
| solid-color | getRGBColorTrait [SVGRGBColor] getTrait [SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait [SVGRGBColor | inherit] |
rgb(0,0,0) | -See RGB access rule. |
| solid-opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait [inherit] |
1.0f | |
| stop-color | getRGBColorTrait [SVGRGBColor] getTrait [none | SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait(none | currentColor | inherit | SVGRGBColor] |
rgb(0,0,0) | -See RGB access rule. |
| stop-opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait[inherit] |
1.0f | |
| stroke | getRGBColorTrait [SVGRGBColor] getTrait [none | SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait [none | currentColor | inherit | SVGRGBColor] |
"none" | -See RGB access rule. |
| stroke-dashoffset | getFloatTrait | setTrait [inherit] setFloatTrait |
0.0f | |
| stroke-linecap | getTrait [butt | round | square] | setTrait [butt | round | square | inherit] | "butt" | |
| stroke-linejoin | getTrait [miter | round | bevel ] | setTrait [miter | round | bevel | inherit] | "miter" | |
| stroke-miterlimit | getFloatTrait [ value >= 1] | setTrait [inherit] setFloatTrait [value >= 1] |
4.0f | |
| stroke-opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait[inherit] |
1.0f | |
| stroke-width | getFloatTrait [value >= 0] | setTrait [inherit] setFloatTrait [value >= 0] |
1.0f | |
| target | getTrait | setTrait | "_self" | |
| "text" | getTrait("#text") ["text content"] | setTrait("#text", "text content") | -See Text Node Access for details. | |
| text-anchor | getTrait [start | middle | end] | setTrait [start | middle | end | inherit ] | "start" | |
| transform | getMatrixTrait [SVGMatrix] getTrait |
setMatrixTrait [SVGMatrix] setTrait |
Identity matrix (1,0,0,1,0,0) | -See Transform access rule. |
| type | For animateTransform: getTrait [translate | scale | rotate | skewX | skewY] | For animateTransform: setTrait [translate | scale | rotate | skewX | skewY] | ||
| values | N/A | setTrait | ||
| vector-effect | getTrait [none | non-scaling-stroke] | setTrait [none | non-scaling-stroke | inherit] | "none" | |
| version | getTrait | setTrait | "1.2" | |
| viewBox | getRectTrait [null, SVGRect] | setRectTrait [SVGRect] setTrait [none] |
null | If the actual trait value is not an SVGRect (i.e. "none"), the getRectTrait
method will return null. |
| viewport-fill | getRGBColorTrait [SVGRGBColor] getTrait [none | SVGRGBColor] |
setRGBColorTrait [SVGRGBColor] setTrait [none | currentColor | SVGRGBColor | inherit] |
"none" | -See RGB access rule. |
| viewport-fill-opacity | getFloatTrait [value >= 0 && value <= 1] | setFloatTrait [value >= 0 && value <= 1] setTrait [inherit] |
1.0f | |
| visibility | getTrait [visible | hidden] | setTrait [visible | hidden | inherit] | "visible" | |
| width | getFloatTrait [ value >= 0] | setFloatTrait [ value >= 0] | REQUIRED (0.0f) | If the width is specified as a percentage or unit value (only possible for the 'svg' 'width'), a DOMException with error code TYPE_MISMATCH_ERR is raised since the requested trait's computed value cannot be converted to a float. |
| x | getFloatTrait (array of x-values not supported) |
setFloatTrait (array of x-values not supported) |
0.0f | |
| x1 | getFloatTrait | setFloatTrait | 0.0f | |
| x2 | getFloatTrait | setFloatTrait | 0.0f | |
| xlink:href | getTraitNS [absolute IRI or null] |
setTraitNS | "" | |
| y | getFloatTrait (array of y-values not supported) |
setFloatTrait (array of y-values not supported) |
0.0f | |
| y1 | getFloatTrait | setFloatTrait | 0.0f | |
| y2 | getFloatTrait | setFloatTrait | 0.0f | |
| zoomAndPan | getTrait [disable | magnify] | setTrait [disable | magnify] | "magnify" |
The getRGBColorTrait is used to get the SVGRGBColor color.
If the actual trait value is not an SVGRGBColor, i.e. 'none' or a paint server
(e.g. a gradient, system paint, or solid-color), this method must raise a DOMException with error
code TYPE_MISMATCH_ERR and getTrait
should be used instead. setTrait must be used to
set a color type that is not an SVGRGBColor.
The 'transform' attribute in SVGT1.2 can have three types of values.
The "normal" transformation list (e.g. scale, translate, rotate, matrix etc),
the newly introduced 'ref(svg)' type or 'none'. getMatrixTrait
returns the current evaluated matrix in
all cases. If the user needs to know that the 'transform' attribute value was a 'ref' or a 'none' getTrait must be used. By using setTrait the user can set the 'transform' attribute to 'ref(svg)' or 'none'.
Due to backward compatibility reasons the 'display' values accessible via the trait mechanism are limited to 'none' and 'inline', all other values are translated into 'none' or 'inline'. (For a list of all possible 'display' values, see Controlling visibility.) If other 'display' values are of interest, e.g. the user want to set display to 'block', the more generic getAttributeNS/setAttributeNS must be used. Note however that an SVGT1.2 user agent is allowed to normalize its attribute data as described in Display Normalization.
The following rule applies to SMIL-animation elements ('animate', 'animateTransform', 'animateColor', 'animateMotion', 'set') and font element with its children ('font', 'font-face', 'missing-glyph', 'glyph', 'hkern', 'font-face-src', 'font-face-uri' ).
These elements can be inserted and removed from the tree but they cannot be modified once inserted into the tree. Manipulating animations while they are in the uDOM tree and possibly active would result in undefined behaviour. This may also have an effect on past resolved times. This restriction means that if the author wishes to add animations via script, the element must be modified when it is not attached to the tree. A similar reasoning applies to the different font elements, modifying them while attached to the tree might lead to unpredictable result. Following is an example of adding animation to the tree including setting the properties prior to insertion.
<svg version="1.2" baseProfile="tiny" xmlns="http://www.w3.org/2000/svg" xml:id="svg-root" width="100%" height="100%" viewBox="0 0 480 360"> <rect xml:id="myRect" fill="green" x="10" y="10" width="200" height="100" stroke="black" stroke-width="2"/> </svg>
SVGElement newAnimate = (SVGElement)document.createElementNS(svgNS, "animate");
newAnimate.setTrait("attributeName", "fill");
newAnimate.setTrait("from", "red");
newAnimate.setTrait("to", "blue");
newAnimate.setTrait("dur", "5");
newAnimate.setTrait("repeatCount", "10");
Element myRect = document.getElementById("myRect");
myRect.appendChild(newAnimate);
interface ElementTraversal
{
readonly attribute Element firstElementChild;
readonly attribute Element lastElementChild;
readonly attribute Element nextElementSibling;
readonly attribute Element previousElementSibling;
};
null if this element has no child elements.
null if this element has no child elements.
null if this element has no element sibling
nodes that come after this one in the document tree.
null if this element has no element sibling nodes that come before
this one in the document tree.
This interface represents an SVG element in the document tree.
It provides methods to traverse elements in the uDOM tree and allows setting and getting the id of an element.
Note: See the definition of id and xml:id for the rules of how to treat id and xml:id.
interface SVGElement : Element, EventTarget, TraitAccess, ElementTraversal
{
attribute DOMString id;
};
null if no id specified.
interface SVGTimedElement : SVGElement, smil::ElementTimeControl
{
void pauseElement();
void resumeElement();
readonly attribute boolean isPaused;
};
true if the animation is paused. false otherwise. See Paused element and the active duration.
interface SVGVisualMediaElement : SVGLocatableElement, SVGTimedElement
{
};
EventListenerInitializer2 allows event listeners to be initialized. In
typical usage with Java, a 'script' element references a JAR file which
contains a manifest entry (SVG-Handler-Class) which identifies the class responsible for creating the
event listeners.
Further information about EventListenerInitializer2 can be found in the Scripting chapter.
Note: Script code must not invoke the EventListenerInitializer2 methods directly (they are are only called by the User Agent implementation during the parsing or execution of 'script', 'listener' or 'handler' elements). User Agents must prevent user scripts from invoking the methods.
interface EventListenerInitializer2
{
void initializeEventListeners( in Element scriptElement );
EventListener createEventListener( in Element handlerElement );
};
initializeEventListeners method, which allows the scripting code to register event listeners.
For each <handler> element, at load time for that element, the user
agent finds the appropriate object which implements the
EventListenerInitializer2 interface.
(For Java, it is the class identified by the
SVG-Handler-Class manifest entry). The user agent then invokes the
createEventListener method, which allows the scripting code to register an
appropriate event listener.
This method returns the event listener that will handle events. The user agent must register this event listener with the event target identified by the 'handler' element.
| EventListener | The created EventListener. |
Example #1: The usage of java together with the 'script' element
The example rely on the fact the 'exclasses.jar' JAR file
contains a MANIFEST file with the following entry:
SVG-Handler-Class: org.example.SVGHandler
<svg xmlns:svg="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 500 500"> <script type="application/java-archive" xlink:href="exclasses.jar"/> <rect xml:id="therect" x="0" y="0" width="100" height="100"/> </svg>
'exclasses.jar' JAR
file is the following:
package org.example;
import org.w3c.dom.*;
import org.w3c.dom.svg.*;
public class SVGHandler implements EventListenerInitializer2 {
public void initializeEventListeners (Element scriptElement) {
Document document = scriptElement.getOwnerDocument();
EventTarget rect = (EventTarget) document.getElementById("therect");
rect.addEventListenerNS("http://www.w3.org/2001/xml-events", "click", new SVGHandler(), null, false, null);
}
public EventListener createEventListener (Element handlerElement) {}
}
An instance of "SVGHandler" listener will be called when a 'click' event will
occur on the 'rect' element.
Example #2: The usage of java together with the 'handler' element
The example rely on the fact the 'exclasses.jar' JAR file
contains a MANIFEST file with the following entry:
SVG-Handler-Class: org.example.SVGHandler
<svg xmlns:svg="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 500 500" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:exns="http://example.org/exNS"> <script xml:id="init" type="application/java-archive" xlink:href="exclasses.jar"/> <rect xml:id="therect" x="0" y="0" width="100" height="100"> <handler type="application/java" ev:event="click" xlink:href="#init" exns:listenerClass="SVGHandler"/> </rect> </svg>
'exclasses.jar' JAR
file is the following:
package org.example;
import org.w3c.dom.*;
import org.w3c.dom.svg.*;
public class SVGHandler implements EventListenerInitializer2 {
public void initializeEventListeners (Element scriptElement) {}
public EventListener createEventListener (Element handlerElement) {
EventListener listenerInstance = null;
try {
String listenerClass = handlerElement.getAttributeNS("http://example.org/exNS", "listenerClass");
listenerInstance = Class.forName(listenerClass).newInstance();
}
catch (Exception e) {}
return listenerInstance;
}
}
An instance of "SVGHandler" listener will be called when a 'click' event will
occur on the 'rect' element. What createEventListener does is totally in the
hand of the developer, the listener instance can be hardcoded or fully
configured from information put on the 'handler' element as shown here.
The majority of scripted SVG documents in existence make use of the browser specific Window interface. SVGT 1.2 specifies an SVGGlobal interface, taking into account the de-facto standard that already exists, as well as adding the new features present in SVGT 1.2. SVGGlobal inherits from the Global interface, which is currently defined to be empty. The Global interface is designed to be the parent interface for language specific window objects. In scripting implementations, the methods and attributes defined by the Global object are normally part of the global execution context.
Interface SVGGlobal provides a global object for scripts embedded in an SVG document.
interface SVGGlobal : Global, EventListenerInitializer2
{
Connection createConnection();
Timer createTimer(in long initialInterval, in long repeatInterval)
raises(GlobalException);
void gotoLocation(in DOMString newIRI);
readonly attribute Document document;
readonly attribute Global parent;
DOMString binaryToString(in sequence<octet> octets, in DOMString encoding)
raises(GlobalException);
sequence<octet> stringToBinary(in DOMString data, in DOMString encoding)
raises(GlobalException);
void getURL(in DOMString iri, in AsyncStatusCallback callback);
void postURL(in DOMString iri, in DOMString data, in AsyncStatusCallback callback,
in DOMString type, in DOMString encoding);
Node parseXML(in DOMString data, in Document contextDoc);
};
null.
| Connection | The created Connection. |
waiting state.
| in long initialInterval | Specifies the first interval in milliseconds for a repetitive Timer, i.e. sets the initial value of the delay attribute on Timer. Or in the case the Timer is not repetitive it specifies the interval for the one time timer. This parameter corresponds to the delay attribute on the Timer. Setting this parameter with a negative value will create a Timer which is in the waiting state. |
| in long repeatInterval | Specifies the time interval on which the Timer repeats subsequent to the initial interval. A negative value will make the Timer a one time timer. |
| GlobalException |
DENIED_ERR: Raised if the values for the parameters initialInterval and repeatInterval are not given.
|
gotoLocation is activated from script. If the IRI is invalid or unresolvable, the current document remains loaded.
"" means that the current document is reloaded. The current document location is the IRI of the Document object pointed to by the SVGGlobal.document field.
Relative IRI references are resolved based on the current base IRI of the current document. The current document is discarded, reloaded, and reparsed. The timeline is restarted and a new load event is fired.
Note: For HTTP, a pragma:no-cache is not issued and thus a fresh copy from the server is not forced if there is a cache.
Given a sequence of octets such as can be obtained through a Connection object and a character encoding identifier, this method returns the string produced by interpreting the sequence of octets using that character encoding. Both the UTF-8 and UTF-16 (BE and LE) encodings must be supported, implementations may support other encodings as well.
| in sequence<octet> data | A character encoding identifier. The values "UTF-8", "UTF-16", "ISO-10646-UCS-2", and "ISO-10646-UCS-4" should be used for the various encodings and transformations of Unicode / ISO/IEC 10646. It is recommended that character encodings registered (as charsets) with the Internet Assigned Numbers Authority, other than those just listed, be referred to using their registered names; other encodings should use names starting with an "x-" prefix. |
| in DOMString encoding | A character encoding identifier. |
| DOMString | The string resulting from decoding the sequence of octets. |
| GlobalException |
ENCODING_ERR: Raised if it is impossible to decode the given sequence of octets
with the provided encoding (e.g. because of poorly formed data).
|
Given a string and a character encoding identifier, this method returns a sequence of octets representing the string encoded using the specified encoding as can be used to transmit data using the Connection interface. Both the UTF-8 and UTF-16 (BE and LE) encodings must be supported, implementations may support other encodings as well.
| in DOMString data | A string to be encoded using the specified encoding. |
| in DOMString encoding | A character encoding identifier. The values "UTF-8", "UTF-16", "ISO-10646-UCS-2", and "ISO-10646-UCS-4" should be used for the various encodings and transformations of Unicode / ISO/IEC 10646. It is recommended that character encodings registered (as charsets) with the Internet Assigned Numbers Authority, other than those just listed, be referred to using their registered names; other encodings should use names starting with an "x-" prefix. |
| sequence<octet> | The sequence of octets resulting from encoding the string. |
| GlobalException |
ENCODING_ERR: Raised if it is impossible to encode the given string
with the provided encoding (e.g. because the target encoding
cannot capture all characters in the string).
|
Given an IRI and an AsyncStatusCallback object on which to operate a callback, this method will attempt to fetch the resource at that IRI using the HTTP GET method. Once the request has been completed the callback is called as described in the AsyncStatusCallback interface.
This method call must take place asynchronously. When called, control returns immediately to the calling context, and once the request is completed the callback is called. Multiple calls to this method must be executed in FIFO order.
User-agents are required to support the gzip content coding and must decode it before passing it on to the callback. User-agents are not required to support encoding content that they send, though they are encouraged to. Cookies should be supported so that state can be maintained across requests. User Agents may provide the user with means to interact with the request (e.g. to enter authentication information) but is not required to.
It is important to note that for security reasons, user-agents are strongly encouraged to restrict these requests by origin.
When enforcing such restrictions, the callback is called immediately with its AsyncURLStatus object's success field set to false and other fields
set to null. Redirection responses (3xx HTTP codes) must not be exposed through the
API but rather they must be processed internally according to the HTTP specification.
| in DOMString iri | The IRI of the resource that is being requested. |
| in AsyncStatusCallback callback | The object on which the callback will be called upon completion of the request. |
Given an IRI, data to be transmitted, an AsyncStatusCallback object on which to operate a callback, a media type, and a content coding, this method will send the data to the specified IRI as the body of an HTTP POST request using the requested media type and content coding. Once the request has been completed the callback is called as described in the AsyncStatusCallback interface.
Processing requirements are the same as for getURL, with the following notes and additions.
text/plain.
identity.
| in DOMString iri | The IRI of the resource that is being requested. |
| in DOMString data | The data that will be the body of the POST request. |
| in AsyncStatusCallback callback | The object on which the callback will be called upon completion of the request. |
| in DOMString type | The content type of the POST request. |
| in DOMString encoding | The encoding of the POST request. |
Given a string and a Document object, parse the string as an XML document and return
a Node representing it. If the XML in the string is not well-formed according to
either XML 1.0 or XML 1.1 or not namespace-well-formed according to Namespaces in
XML 1.0 or Namespaces in
XML 1.1 respectively, this method must return a null value.
When parsing the input string, the contextDoc parameter is used only for setting
the ownerDocument field in the parsed nodes.
If during parsing a 'script' element is encountered, it must not be executed at that time.
Script execution is deferred until the returned Document
(or applicable parts thereof) is inserted into the contextDoc document.
There is no requirement to load any external resources, e.g. external entities, stylesheets, scripts, raster images, video, audio etc, for the parsing to complete. XSL stylesheets must not be applied.
If the contextDoc parameter is
defined, this method returns an Element object the ownerDocument
field of which must be set to be the provided Document object. In effect when
the contextDoc parameter is specified the processing must be equivalent to applying the following steps:
documentElement elementimportNode on the Document object passed to parseXML
with the Element from the previous step as its first parameter and the
deep parameter set to true. (Please note that importNode is part of DOM 3 Core but not of the uDOM. It is mentioned here to indicate that the effect must be as if importNode had been used, but not to require that it be supported in implementations)
| in DOMString data | The data that is to be parsed as XML. |
| in Document contextDoc | The Document object in the context of which to perform the parsing. |
| Node | A Node (either a Document or an Element) representing the content that was parsed. |
| DOMException |
NOT_SUPPORTED_ERR: Raised if the XML contains unsupported node types.
|
|
| DOMException |
INVALID_CHARACTER_ERR: Raised if one of the parsed XML names is not an XML name according to the XML version in use specified in the Document.xmlVersion attribute of the
contextDoc.
|
primary.svg
<svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" xmlns:xlink="http://www.w3.org/1999/xlink"> <use xlink:href="resource.svg#g"/> </svg>
resource.svg
<svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny"
xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="g">
<script type="application/ecmascript">
gotoLocation("somewhere.svg");
</script>
</g>
</svg>
anchor.svg
<svg xmlns="http://www.w3.org/2000/svg" version="1.2" baseProfile="tiny" xmlns:xlink="http://www.w3.org/1999/xlink"> <a xlink:href="somewhere.svg" target="_replace"><text>Click me!</text></a> </svg>
This interface is implemented by code that intends to process content retrieved through
getURL or postURL, both of which take an instance of this
interface as a parameter, and call its operationComplete method upon completion of the request.
interface AsyncStatusCallback
{
void operationComplete(in AsyncURLStatus status);
};
This method is implemented by code in order to be notified of the result of HTTP requests. Upon request completion, it receives an AsyncURLStatus object that captures the details of what was returned.
| in AsyncURLStatus status | An object representing the HTTP response. |
This interface captures several aspects of an HTTP response in order to be
passed to the operationComplete method upon completion of
an HTTP request.
interface AsyncURLStatus
{
readonly attribute boolean success;
readonly attribute DOMString contentType;
readonly attribute DOMString content;
};
A boolean field indicating whether the request succeeded or not. For response
codes in the 200 range, it must be set to true, and for responses in the
400 and 500 ranges it must be set to false. Responses in the 100 range must be
ignored and responses in the 300 range must be processed as indicated in getURL's
processing requirements.
A string containing the media type of the response, which must be that set in the Content-Type
HTTP header. If there was no Content-Type header, its value is null.
A string containing the body of the HTTP response. Binary HTTP bodies must not be
used and implementations must set this field to null when they receive one. If the
body was in the text/* hierarchy and specified a charset
parameter, then the text must be converted into the host programming language's
native form if the encoding is supported. If the encoding is not supported, the
value of this field must be null. The only required encodings are UTF-8 and UTF-16
(BE and LE). If the HTTP body had one or more content codings applied to it then
it must be fully decoded before setting this field. If the HTTP response code
was an error code but carried a body, the content of that body must still be exposed.