Chapter 3. XUL Elements and Features- P6

3.11. Overlays
An overlay is a separate file in which additional XUL content can be defined
and loaded at runtime. Overlays are often used to define things like menus
that appear in different components or parts of the application.
If you are creating a large application or a UI with many elements as a part
of your design, the files can easily become large. The size in itself does not
render it ineffective, but it does make the job of the developer a little
difficult when tracking down and changing features. The best way to
overcome this size problem is to use overlays. Another reason to use
overlays is to extract information from a certain logical portion of the UI and
contain it in a file of its own. This extraction and containment promotes
modularization and reusability.
3.11.1. How to Use Overlays
The following declaration is the principal method for including reusable
content in a XUL window.
<?xul-overlay
href="chrome://global/content/globalOverlay.xul"?>
This declaration follows the same syntax as CSS processing instructions.
Like other XML processing instructions, it uses a ? at the beginning and
end, just inside the braces. The href attribute points to the overlay and uses
Mozilla's chrome:// type URL.
To insert content from an overlay, use the same id of an element in the
"base file" for a similar element in your overlay content, and the overlay will
replace the base file at runtime (or be merged with it, as described later in
this chapter in the Section 3.11.2
section).
When the base element is empty, it is replaced with the corresponding
overlay element and any child subcontent. The following toolbar snippet
shows a reference placed in a base file:

When a new package or component is registered,
the overlays that come with it are loaded automatically.
Dynamic overlays are commonly used to extend certain parts of the Mozilla
application itself when new packages are installed that need access points, as
do new language packages and themes, for instance. Certain menus in the
UI, for example, are open for third-party authors to add items. Adding the
name of your package to Mozilla's Tasks menu, for example, provides a
convenient launching point and is handled with dynamic overlays. Chapter 6

provides more information on this topic, in the section Section 6.2.3.3
.
3.11.2. Content Positioning
Content positioning is the order in which widgets appear in the UI. Usually
content is laid out in the order elements are defined in the XUL file.
However, there are a couple of ways to override this ordering in XUL.
Continuing with the example of the overlaid toolbar in the previous section,
it is possible for both the base definition and the overlaid definition to have
children. In this instance, the content is merged, with the original content
appearing before the overlaid content by default:
<toolbar id="main-toolbar">
<toolbarbutton id="print-button" label="Print"
observes="cmd_print"/>
</toolbar>
If the toolbarbutton above is in the base XUL, then the ordering of the
buttons would be Print, New, Open, and Save. It is possible to change this
ordering by using insertbefore, however, as shown in Example 3-21
.
Example 3-21. Positioning attributes
<toolbar id="main-toolbar" persist="collapsed">
<toolbarbutton id="new-button" label="New"

obscured in the UI. In the Mozilla application, the most common places
where they are used are on toolbar buttons and splitter grippies that divide
panels in the window.
To invoke a tooltip, add a tooltiptext attribute to the widget that needs
it:
<button id="printButton" label="Print"
tooltiptext="Print this page" />
Defining this attribute is enough to ensure that the generic Mozilla tip box
appears with the specified text when you place the cursor over the element.
Tooltips are actually implemented as an XBL binding. Underneath, a tooltip
is essentially a pop up with a description element within that holds text.
You can also create your own tooltips.
To create your own content and customized appearance for a tooltip:
1. Create the content.
2. Attach it to the pop-up element you will be using.
3. Give the pop up a unique ID.
The following snippet shows the kind of tooltip you can create and then
reuse in your application code:
<popupset id="aTooltipSet">
<popup id="myTooltip"
class="tooltip"
onpopupshowing="return
FillInTooltip(document.tooltipNode);" >
<description id="TOOLTIP-tooltipText"
class="my-tooltip-label" flex="1"/>
</popup>
</popupset>
Use your newly created widget by adding its id value to the tooltip
attribute to the UI element that wants it:
<treeitem id="FlyDescription" tooltip="myTooltip"