Chapter 7. Extending the UI with XBL- P1
You now know that XUL is the basic tool set for creating your application
interface, but even it has limitations. It is just a finite set of widgets that your
programming needs may transcend. If you find that you reimplement many
of the same groups of widgets in different applications, or if you want to
extend your application's interface in some other way, you will find the
eXtensible Binding Language (XBL) an invaluable tool.
This chapter describes what XBL is and how it is used. Basically, XBL
provides a way to attach new content or behavior to your application by
using XBL bindings. XBL can extend, add to, and reorganize user interfaces.
XBL can also help you organize scattered XUL code into a set of self-
contained widgets that make building and maintaining your Mozilla
application much easier. Appendix C
provides a reference for the XBL
element set, with which new elements can be created.
7.1. What Is XBL?
XBL is an XML markup language invented specifically for creating widgets.
XBL looks similar to XUL, and may even contain XUL or HTML and other
markup (see the Section 7.1.3
section later in this chapter for more
information about how other markup is used in XBL bindings), but its
purpose is different. Flexibility and interoperability are the point of XBL.
If the XUL textbox is inadequate, for example, you can use XBL to create
and attach a new widget called <datafield/>, possibly based on
textbox, that provides special attributes and functionality for validating
input data against a database.
A binding is a single XBL language entity that can contain content as other
markup (such as XUL) behavior that is represented as methods and
properties, and event-handling capabilities. Bindings can be anything from
small widget objects to large, complex blocks of code with extensive
functionality. Figure 7-1

to it as content.
Bound element
A bound element is a widget or element that uses a particular binding.
It can be an existing element in the XUL or HTML set or a newly
invented one.
Anonymous content
Content (e.g., XUL elements) contained in a binding that is hidden
from the document object (DOM). Refer to the section Section 7.4
,
later in this chapter, for a more detailed discussion of its
characteristics and how to programmatically gain access to the
content.
Attachment and detachment
Attachment is the process through which a binding is associated with
a bound element. It is essentially a way of telling the element which
binding to use. Detachment is the process of removing that link and
with it, the binding display.
Insertion point
The point in anonymous content at which children of the bound
element are inserted. The section Section 7.4.4
, later in this chapter,
details the insertion process.
Inheritance
During inheritance, characteristics of one object are passed on to
another object. In XBL, this process is multifaceted. Bindings can
inherit from other bindings, anonymous content can inherit attributes
from the bound element, and a binding implementation can inherit the
behavior of another widget. All concepts are explained in the section
Section 7.5
, later in this chapter.

7.1.3. Namespaces and XBL
Because XBL is a binding language for other markup, remember to
distinguish between the XBL markup (such as <binding> and
<handler>) and markup from another language (such as XUL).
Namespaces are a feature of the XML language that was invented to handle
this separation of intermingled markup, and XBL uses namespaces. For
more information on namespaces, refer to the W3C at

Namespaces are declared in the root element of an XML document. The
most common implementation is the declaration of two namespaces: a
default namespace for XBL and a namespace for the other markup. This
code shows the root of a bindings document in which the XUL namespace
declaration (xmlns:xul) and the XBL default namespace are declared:
<bindings id="dataBindings"
xmlns=
xmlns:xul=

/>s.only.xul>
An NCName is the part of a namespace declaration that qualifies the markup
type for that particular namespace. It is placed after a colon, and in many
XPFE documents, is the markup language name (xul, xbl, or rdf). The
XBL namespace is the default in this instance because it does not declare a
namespace prefix (NCName).