The charter of the Web Application Formats (WAF) Working Group includes a specification for an XML Binding Language (XBL). This document describes use cases and high-level requirements for this declarative language and thus will be a useful input when creating a specification for an XML Binding Language. Additionally, this document provides some useful information regarding the scope of an XML Binding Language and thus may be useful to others (e.g. other Working Groups, etc.).
The requirements in this document have been derived from several sources including American Online's XBL version 1.0 [XBL1.0], the SVG Working Group's XML Binding Language for SVG [SXBL] and Mozilla Foundation's XBL version 2.0 [XBL2.0].
This document is purely informational and contains no conformance statements or testable assertions.
The WAF Working Group provides these requirements for general information and as of the date of its publication makes no commitment that any of the requirements will be satisfied in a follow-on specification for an XML Binding Language.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is the first publication of the XML Binding Language Use Cases and Requirements 1.0 document. It has been produced by the Web Application Formats Working Group, which is part of the Rich Web Clients Activity.
Comments and discussion on this document should be sent to firstname.lastname@example.org (public archives).
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
2 Use Cases
2.1 UC1 - Extension Mechanisms
2.2 UC2 - Presentation and Behavior Encapsulation
2.3 UC3 - Presentation and Behavior Inheritance
3.5 Error Handling
An XML Binding Language is a declarative language that defines generic mechanisms to bind an arbitrary XML element to a binding element that defines the behavior and/or presentation of the arbitrary element. This mechanism can be used to separate or hide elements of an XML vocabulary from its presentation or behavior. Such mechanisms facilitate re-use of a binding by different applications.
A declarative language is characterized by its focus on describing a problem space via a set of conditions/constraints rather than defining a specific solution to a problem. This abstraction provides several advantages for an XML Binding Language as illustrated by the Use Cases in this document.
A binding is the definition of behavior that can be applied to an arbitrary XML element so as to define its presentation.
An XBL subtree is a subtree in an XBL
document fragment, the subtree having as its root
xbl element in the XBL namespace,
that is used to define bindings.
The term binding document is used to mean a document containing an XBL fragment that itself contains XBL subtrees.
A bound element is an element in an arbitrary XML namespace, to which a binding has been applied.
A bound document is a document containing an XBL fragment with one or more bound elements.
The shadow tree for a bound element is the
subtree of nodes that are attached to a bound element as a result of XBL
processing. The contents of the shadow tree augment the bound element's standard
presentation and interactive behavior with alternate behavior.
However, the shadow
tree is hidden from normal DOM processing (hence the name "shadow"). The
shadow tree is attached to the bound element. Once attached, the shadow
tree can be accessed only via XBL-specific DOM extensions and therefore is
not accessible via Core DOM navigation facilities such as
The term shadow content refers to the various nodes in the shadow tree of a bound element. Shadow content is created by cloning a shadow content template during binding attachment.
An XBL application is an application that can interpret XBL i.e. apply the semantics as defined in an XBL specification. In this document, an XBL application is said to interpret an XBL document fragment i.e. process the XBL fragment.
This section describes several Use Cases for an XML Binding Language.
A major use of the XBL declarative language is to extend an XML vocabulary. For example an XBL binding element can define an event handler that will be added to a bound element (when the bound element is interpreted). Additionally, an XBL binding element can be used to change the behavior of an XML element e.g. adding a menu to a button, changing how a scroll bar functions, adding a new menu option to a pulldown menu, etc.
An XBL binding can also specify the arbitrary content i.e. the child elements that is added to a bound element (when the bound element is interpreted).
Additionally, XBL can be used to define a new element i.e. a custom element that can then be used by an XBL application.
The XML Binding Language can be used to define an arbitrarily complex binding (e.g. the behavior of an element, the presentation of an element, etc.). That binding can then be used by any XBL user agent either directly (i.e. embedding the binding) or indirectly (i.e. refer to the externally defined binding). This encapsulation functionality facilitates reuse and thus has several positive side-effects such as reduced maintenance, reduced testing, etc.
By re-using existing bindings (particularly external references), a document can be simplified i.e. a complex binding can be attached to the document by a single reference to a binding. This is especially useful when an XBL application needs to make multiple references to a single binding. Additionally, smaller document size may be useful in scenarios where there is low network bandwidth.
The content in a binding can be defined such that it inherits its values from the hosting XBL application or any arbitrary XML vocabulary. This usage facilitates customization of behavior and presentation of the XBL application. As a further convenience for the author of an XBL binding, a binding's definition may include a default value that will be used if no value is inherited.
This section defines high-level requirements for an XML Binding Language. The requirements are derived from the above Use Cases, [SXBL], [XBL1.0] and [XBL2.0]. The categories are provided for the convenience of the reader. Although some of the requirements could be placed in multiple categories they are only listed in one.
The XML Binding Language's general requirements are:
The requirements for a binding are:
The requirements for a binding's content are:
The requirements regarding events are:
The error handling requirements are:
The editors acknowledge the following contributors:
The WAF Working Group also acknowledges the Editors of the following documents:
XBL version 1.0 - David Hyatt
SVG's XML Binding Language - Jon Ferraiolo, Ian Hickson, David Hyatt
XBL version 2.0 - Mozilla Foundation