o'reilly - creating applications with mozilla

Creating Applications with Mozilla
Table of Contents
Copyright
Preface
1. Mozilla Background
2. The State of Mozilla
3. Who Should Read This Book
4. Platform and Applications
5. Structure of the Book
6. How This Book Was Written
7. Mozilla Licensing Information
8. Conventions
9. Comments and Questions
10. Acknowledgments
1. Mozilla as Platform
1.1. Visualizing Mozilla's Front End
1.1.1. XPFE Framework
1.1.2. Comparing XPFE and DHTML
1.1.3. Components of a Mozilla Application
1.2. Setting Up Your System
1.3. Mozilla Applications
1.3.1. Applications as Web Pages
2. Getting Started
2.1. Simple XUL Example
2.2. Basic XUL Concepts
2.2.1. The XUL File Format
2.2.2. Conventions
2.2.3. The XUL Namespace
2.2.4. Basic XUL Layout
2.2.5. Using XUL Windows
2.3. Making Mozilla Work for You

2.3.1. Importing Resources from Mozilla
2.4. Displaying XUL Files as Chrome
2.5. Creating a Package
2.5.1. Architecture of a Chrome Package
2.5.2. Package Components
2.5.3. Directory Structure
2.5.4. Package Manifests
2.5.5. Separating the Files
2.5.6. Registering a Package
2.6. Launching the Application
2.6.1. Windows launch
3. XUL Elements and Features
3.1. The XUL Document Object
3.1.1. XUL Parsing and the Document Object Model
3.2. Application Windows
3.2.1. Dialogs
3.2.2. Pages
3.2.3. Wizards
3.3. Application Widgets
3.3.1. The Toolbox
3.3.2. Selection Lists
3.4. Tabular and Hierarchical Information
3.4.1. List Boxes
3.4.2. High Performance Trees
3.4.3. Grid
3.5. Words and Pictures
3.5.1. Text Input
3.5.2. Text Display
3.5.3. Images
3.6. Form Controls

3.6.1. Radio
3.6.2. Checkbox
3.6.3. Buttons
3.7. Widget Interaction
3.7.1. Broadcaster and Observers
3.7.2. Commands
3.8. Content Panels
3.8.1. Browser and IFrame
3.8.2. Editor
3.9. The Box Model
3.9.1. Box Attributes
3.9.2. Box-Like Containers
3.9.3. Additional Box Features
3.9.4. Stacks and Decks
3.10. XUL Attributes
3.10.1. Stretchiness
3.10.2. Style
3.10.3. Persistence
3.10.4. The debug Attribute
3.11. Overlays
3.11.1. How to Use Overlays
3.11.2. Content Positioning
3.12. The Extras
3.12.1. Tooltips
3.12.2. Progress Meter
3.12.3. Links
3.13. Building the Application Shell
4. CSS in Mozilla Applications
4.1. Interface Basics
4.1.1. Skins Versus Themes

4.1.2. Limitations of a Skin
4.1.3. Theme Abstraction (or Building Good Skins)
4.1.4. Cross-Platform Interface Considerations
4.2. Introduction to CSS in Mozilla
4.2.1. Basic XUL + CSS Interaction
4.2.2. Stylesheet Syntax
4.2.3. Special Mozilla Extensions
4.2.4. Referencing Images in CSS
4.2.5. Menu Skinning
4.3. Mozilla Skins
4.3.1. CSS and Skin Hierarchies
4.3.2. Basic Skin Structure
4.3.3. The Modern and Classic Themes
4.3.4. Skin Files
4.4. Creating New Skins
4.4.1. Importing the Global Skin
4.4.2. Getting Started with Custom Styles
4.4.3. Creating Styles for the xFly Buttons
4.4.4. Describing the Skin in RDF
4.5. What Is Possible in a Skin?
4.5.1. Binding New Widgets to the Interface Using XBL
4.5.2. User Stylesheets
4.5.3. Theme Security Restrictions
5. Scripting Mozilla
5.1. Faces of JavaScript in Mozilla
5.2. JavaScript and the DOM
5.2.1. What Is the DOM?
5.2.2. The DOM Standards and Mozilla
5.2.3. DOM Methods and Properties
5.3. Adding Scripts to the UI

5.3.1. Handling Events from a XUL Element
5.3.2. Events and the Mozilla Event Model
5.3.3. Changing an Element's CSS Style Using JavaScript
5.3.4. Creating Elements Dynamically
5.3.5. Sharing Data Between Documents
5.4. XPConnect and Scriptable Components
5.4.1. What Is XPConnect?
5.5. JavaScript Application Code
5.5.1. JavaScript Libraries
6. Packaging and Installing Applications
6.1. Packaging and Installing Overview
6.2. Packaging Mozilla Applications
6.2.1. Package Manifests
6.2.2. Registering Packages
6.2.3. Creating a Package
6.2.4. The Chrome Registry
6.3. Installing Mozilla Applications
6.3.1. The XPI File Format
6.3.2. Installation Scripts
6.3.3. XPInstall
6.3.4. Uninstalling Applications
6.4. Finishing Things Up
6.4.1. Creating the xFly XPI
6.4.2. Adding the Installation Script
6.4.3. Web Page Installer
6.5. Extra Tricks for Customizing an Application
6.5.1. Icons
6.5.2. Splash Screen
7. Extending the UI with XBL
7.1. What Is XBL?

7.1.1. XBL Terminology
7.1.2. An XBL Document
7.1.3. Namespaces and XBL
7.1.4. XBL and HTML
7.2. Anatomy of a Binding
7.2.1. CSS Attachment
7.2.2. The XBL Content Element
7.2.3. The Implementation Element
7.2.4. Handlers
7.2.5. Style
7.3. Adding Behavior to Bindings
7.3.1. Binding Methods
7.3.2. Binding Properties
7.4. XBL and the DOM
7.4.1. The XBL DOM Interfaces
7.4.2. Binding Parents
7.4.3. Accessing Anonymous Nodes
7.4.4. Extra Binding Content and Insertion Points
7.5. Inheritance
7.5.1. Binding Inheritance
7.5.2. Attribute Inheritance
7.5.3. Implementation Inheritance
7.6. Event Handling
7.6.1. The Time and Venue
7.7. Resources for Bindings
7.7.1. Stylesheets in XBL
8. XPCOM
8.1. What Is XPCOM?
8.1.1. What Is a Component?
8.1.2. XPConnect and the Component Object

8.1.3. XPCOM Interfaces and the IDL
8.1.4. XPCOM Type Libraries
8.1.5. XPCOM Identifiers
8.1.6. Component Manager
8.1.7. Getting and Using XPCOM
8.2. Creating XPCOM Components
8.2.1. Creating a JavaScript XPCOM Component
8.2.2. Compiling the Component
8.2.3. Testing the Component
8.2.4. Useful C++ Macros and Types
8.2.5. C++ Implementation of nsISimple
8.2.6. The nsSimple module code
8.2.7. Other Languages for XPCOM
8.2.8. XPCOM as an Open Cross-Platform Solution
9. XUL Templates
9.1. Understanding XUL Templates
9.1.1. Basic template structure
9.2. Enhancing XUL Templates
9.2.1. Nested Content Sample
9.2.2. Using Data for Style
9.2.3. Tree Template
9.2.4. Multiple Rules Tree
9.2.5. Multiple Rules Menubar
9.3. Using Other XUL Tags for Templates
10. RDF, RDF Tools, and the Content Model
10.1. RDF Basics
10.1.1. RDF Data Model
10.1.2. RDF Syntax
10.1.3. Building an RDF File from Scratch
10.2. The Mozilla Content Model

10.2.1. Datasources
10.3. RDF Components and Interfaces
10.3.1. What Is an RDF Component?
10.3.2. What Are RDF Interfaces?
10.3.3. nsIRDFService
10.3.4. nsIRDFCompositeDataSource
10.3.5. nsIRDFDataSource
10.3.6. nsIRDFRemoteDataSource
10.3.7. nsIRDFPurgeableDataSource
10.3.8. nsIRDFNode, nsIRDFResource, and nsIRDFLiteral
10.3.9. nsIRDFContainerUtils
10.3.10. nsIRDFContainer
10.3.11. nsIRDFXML Interfaces
10.4. Template Dynamics
10.4.1. Template Dynamics in XBL
10.5. JSLib RDF Files
10.6. Manifests
10.6.1. RDF and Dynamic Overlays
11. Localization
11.1. Localization Basics
11.1.1. For the Developer
11.1.2. Files and File Formats
11.1.3. UI Aesthetics and Principles
11.2. DTD Entities
11.2.1. Inserting Entities
11.2.2. External and Inline Entities
11.3. String Bundles
11.3.1. Inside a Bundle
11.3.2. String Bundle Methods and Properties
11.3.3. Creating Your Own Bundle

11.4. Programming and Localization
11.4.1. Naming Conventions
11.4.2. Breaking Up the Text
11.4.3. Anonymous Content and Locale
11.4.4. Localizable Resources in HTML
11.4.5. Localizable Resources in RDF
11.5. The Chrome Registry and Locale
11.5.1. The Directory Structure
11.5.2. Interaction with the Chrome Registry
11.5.3. Distribution
11.6. Localization Issues
11.6.1. XPFE and Unicode
11.6.2. Language Quirks
12. Remote Applications
12.1. Directions in Remote Application Development
12.2. Basic Remote Application Example
12.2.1. Case Study: Snake (a.k.a. Hiss-zilla)
12.3. Setting Up XPFE for Remote Applications
12.3.1. Server Configuration
12.4. Generated Content
12.4.1. Generating Content with Scripting Languages
12.4.2. Generating Content from a Database
12.4.3. Localizing Remote Applications
12.5. Certificate Authorities and Digital Signatures
12.5.1. Mozilla Network Security Services (NSS)
12.5.2. CA Certificates, Signing Certificates, and the Certificate Chain
12.5.3. Setting Up a Certificate Authority
12.5.4. Issuing Signing Certificates
12.5.5. Distributing Distribution Certificates
12.6. Creating Signed Remote Applications

12.6.1. certs.mozdev.org CA Certificate
12.6.2. Signing Certificates
12.6.3. Creating and Signing the Application
12.6.4. Receiving a Signed Application
12.7. Expanded Privileges in Mozilla
12.8. Signed Remote Snake Game
12.8.1. How to Expand Mozilla to Full Screen
12.9. Mozilla's XML Extras and SOAP
12.9.1. Mozilla, SOAP, and .NET
12.9.2. Setting Up a .NET Web Service
12.9.3. .NET WSDL
12.9.4. SOAP Call XML Formats
12.9.5. Adding SnakeService SOAP to Snake
12.9.6. Make SOAP Functions Work in XUL Documents
12.9.7. Examining SOAP Functions for Snake
12.10. Looking Forward
A. Getting and Building the Mozilla Source
A.1. Getting the Source Code
A.1.1. Downloading the Source with FTP
A.1.2. Downloading the Source with CVS
A.1.3. Working with Branching
A.2. Building the Source Code
A.2.1. Unix Environment
A.2.2. Windows Environment
A.2.3. Macintosh Environment
B. Development Tools
B.1. XULKit
B.1.1. new-from-template.pl Script
B.1.2. makexpi.pl Script
B.1.3. Using XULKit

B.2. Patch Maker 2.0
B.2.1. CVS Mode
B.2.2. Build Mode
B.3. The DOM Inspector
B.4. The Component Viewer
B.5. Venkman: The JavaScript Debugger
B.6. MozillaTranslator
B.7. Missing Parts
B.7.1. Visual XUL Editors
B.7.2. Toolkits and Libraries
B.7.3. Integrating the Pieces
C. Programmer's Reference
C.1. XUL Element Set
action Child element in a XUL template structure that draws content for matched data
arrowscrollbox Container box for scrolling contents
autorepeatbutton Provides arrows for a scrolling area
binding Child element in a XUL template that optionally matches in the data
bindings Substructure in a XUL template that collects the optional binding rules
box Generic container and layout element
broadcaster Notifies elements when a change occurs in the UI
broadcasterset Container for broadcaster elements
browser Web-content container
button A widget that activates some functionality when pressed
caption Provides heading for a groupbox element
checkbox Indicates a specified feature's on/off state
colorpicker Widget used to choose a color
column A column in a grid
columns Container for the number of columns in a grid
command Defines functionality that can be called from multiple sources
commands Container for a group of command sets

commandset A container for multiple command elements
conditions Defines the conditions within a template rule
content Binds variables in a template
deck Box container that displays one child element at a time
description Holder for block of text that can wrap to multiple lines
dialog Root element for secondary XUL window
dialogheader Styled text heading for UI panel
editor Content area for editable web content
grid Widget for laying out content in a structured tabular fashion
grippy Visible widget used on a grippy bar to expand or collapse a UI region
groupbox Box with frame surrounding it
hbox Box container whose children are laid out horizontally
iframe Web content area
image Display of a supported type image
key Definition for a keyboard shortcut
keybinding Container for a keyset or group of keysets
keyset Container for one or more key elements
label Simple text display element and label for a control element
listbox Used for display of a flat list of items
listcell Single cell of a listbox
listcol Listbox column definition
listcols Container for listbox columns (listcol)
listhead Container for column header in list boxes (listheader)
listheader Text header for listbox column
listitem Listbox row definition
member Matches container relationships in which the parent element is given by a container element
and the child by a child element
menu A menu element for containing menu items
menubar Containing element for one or more menus
menuitem Single selectable choice in a menu

menulist Drop-down list of selectable items
menupopup Pop-up container for menu items
menuseparator Line separating menu items
observes Broadcast event and attribute listener
overlay Root element in a separate file that contains reusable XUL content
page Root element of XUL file loaded in a content frame
popup Box container as child window
popupset Container for popup elements
progressmeter Visual progress indicator of a time-consuming operation
radio Single on/off choice represented as selectable circle
radiogroup Framed box for containing radio elements
resizer Window-resizing element
row Container for grid cells laid out consecutively
rows Definition for grid rows
rule Defines rules for rendering data as XUL
script Declaration of script used in XUL file
scrollbar Widget for scrolling in a container
scrollbarbutton Button used to move position of scrollbar thumb
scrollbox Box for scrolling content
separator Bar between elements
slider A scrollbar without buttons
spacer Blank space separating element
splitter Element for dragging and resizing associated elements
stack Shows children one on top of one another, all at the same time
statusbar Box container for status elements
statusbarpanel Single unit of a statusbar
stringbundle Holder of localized properties for use in script
stringbundleset Container for stringbundle elements
tab A single selectable tab of a tabbox
tabbox Box container for tab panels

tabbrowser Tabbed holder for a set of web content views
tabpanel A single panel of a tabbox
tabpanels Container for tabpanel elements
tabs Container for tab elements
template A high-level widget used to build content dynamically from data
textbox Accepts text input from user
thumb Object used to move content in scrollable area
toolbar Holder of buttons for quick-access UI functionality
toolbarbutton Specially adapted button for use in a toolbar
toolbarseparator Visible separator for elements contained in a toolbar
toolbox Optional container for menu bars and toolbars
tooltip Pop-up window for context-sensitive help
tree Hierarchical holder of information represented as rows
treecell A single cell in a tree
treechildren The main body of a tree; a container for treeitems
treecol A single column of a tree
treecols Container for tree columns
treeitem A treerow container
treerow A single row of a tree
triple Substructure of a template that matches RDF statements in the data
vbox Box container with vertically laid out children
window Root element of a top-level XUL window document
wizard Window used to step though a task
wizardpage A single panel (step) of a wizard
C.2. XBL Element Set
binding A single XBL binding
bindings An XBL document's root element
body Container for JavaScript code to be executed by an XBL method
children Insertion point for children of a bound element, or inherited binding
constructor Container for code to be executed when a binding is created

content Container for anonymous content to be inserted into a bound document
destructor Container for code to be executed when a binding is destroyed
element Insertion point for bound elements in anonymous content
field Holder property for simple data
getter Script access point for an element's property
handler Single event handler for an XBL element
handlers Container for event-handler elements
image An image resource in a binding
implementation Container for binding methods and properties
method Script function to be accessed on a binding object
parameter Single paramter declaration for a method
property Definition of a single binding object property
resources Container for list of resources that can be used by a binding
setter Change a binding property's value
stylesheet Captures an external stylesheet for use by anonymous content
C.3. Event Attributes
onblur //FIXME purpose should go here
onbroadcast //FIXME purpose should go here
onchange //FIXME purpose should go here
onclick //FIXME purpose should go here
onclose //FIXME purpose should go here
oncommand //FIXME purpose should go here
oncommandupdate //FIXME purpose should go here
oncontextmenu //FIXME purpose should go here
oncreate //FIXME purpose should go here
ondblclick //FIXME purpose should go here
ondestroy //FIXME purpose should go here
ondragdrop //FIXME purpose should go here
ondragenter //FIXME purpose should go here
ondragexit //FIXME purpose should go here

ondraggesture //FIXME purpose should go here
ondragover //FIXME purpose should go here
onfocus //FIXME purpose should go here
oninput //FIXME purpose should go here
onkeydown //FIXME purpose should go here
onkeypress //FIXME purpose should go here
onkeyup //FIXME purpose should go here
onload //FIXME purpose should go here
onmousedown //FIXME purpose should go here
onmousemove //FIXME purpose should go here
onmouseout //FIXME purpose should go here
onmouseover //FIXME purpose should go here
onmouseup //FIXME purpose should go here
onoverflow //FIXME purpose should go here
onoverflowchanged //FIXME purpose should go here
onpopuphidden //FIXME purpose should go here
onpopuphiding //FIXME purpose should go here
onpopupshowing //FIXME purpose should go here
onpopupshown //FIXME purpose should go here
onselect //FIXME purpose should go here
onunderflow //FIXME purpose should go here
onunload //FIXME purpose should go here
Colophon
List of Tables
3-1. Main features of the tree
3-2. Tree views
3-3. Button types
3-4. Common box attributes
4-1. Relational selectors
4-2. CSS spacing and layout properties

4-3. The position property
4-4. Mozilla CSS extensions
5-1. JSLib classes
6-1. Install object methods
6-2. InstallTrigger interface showing the role of the InstallTrigger object in the overall installation process
8-1. The IUnknown interface
8-2. The nsISupports interface
8-3. Special XPCOM attributes in Python
9-1. Output of each template iteration
9-2. Scenarios used for building template rules
10-1. Synonyms in RDF
10-2. Types of datasources
10-3. Mozilla's built-in RDF interfaces
11-1. Entity definitions for the XUL menu
12-1. Expanded privileges available to signed scripts
12-2. Expanded privileges available to signed scripts
A-1. Platform tools used to build the Mozilla source code
A-2. Windows environment variables used to build Mozilla
A-3. Make flags
B-1. Options for the new-from-template.pl script
B-2. Options for the makexpi.pl script
B-3. Patch Maker's CVS mode commands
C-1. Common XUL element attributes
List of Figures
1-1. XPFE framework
1-2. Comparison of DHTML and XPFE
1-3. ChatZilla, an IRC chat client created by using Mozilla
1-4. The Mozilla browser rendering itself
2-1. The first Hello xFly example
2-2. The second Hello xFly example loaded in the browser

2-3. The second Hello xFly example launched in its own window
2-4. A sample package layout in the directory system
2-5. xFly package directory structure
2-6. Modified shortcut properties
3-1. Preferences panel loaded as a page
3-2. Application menu bar
3-3. Visual comparison of menu widgets
3-4. Listbox
3-5. Multilevel tree hierarchy
3-6. Autocomplete for Open Web Location
3-7. Checkbox widget
3-8. menu-button for browser's back functionality
3-9. Default box positioning
3-10. Box packing and alignment effects
3-11. Text stacked on an image
3-12. xFly example viewing application
4-1. Scrollbars on Windows and on the Macintosh
4-2. The Open Web Location dialog in Windows and the Macintosh
4-3. The different states for buttons in the Modern theme
4-4. Composite styles for the reload button
4-5. The contents of the modern.jar file
4-6. XUL file and skin loading
4-7. Classic and Modern Navigation toolbars
4-8. Stylesheet additions to a XUL file
4-9. XUL button with no style
4-10. Modern menu button
5-1. Scripting in Mozilla
5-2. Toggling the state of menu items in xFly
5-3. Event capturing
5-4. How XPConnect fits into the application model

6-1. Mozilla packaging components
6-2. Package interaction overview
6-3. xFly item in Tools menu
6-4. Installation process overview
6-5. Simplest XPI archive
6-6. Windows taskbar with Mozilla icon
6-7. Mozilla's splash screen
7-1. Mozilla XBL binding structure
7-2. CSS binding attachment components
7-3. The inputfield alone in the XUL document
9-1. DOM representation of XUL template generation
9-2. View of XUL tree in Mozilla
9-3. Listbox and tree template
9-4. Tree template with hyphen rule
9-5. Menubar template with menus
10-1. Simple labeled-directed graph
10-2. Resource to literal relationship
10-3. RDF Graph with five nodes
10-4. Namespaces applied to Figure 10-3
10-5. The first statement of the graph, with labeled parts
10-6. The second statement of the graph, with labeled parts
10-7. The third statement of the graph, with labeled parts
10-8. The full graph
10-9. Diagram of Mozilla's content model
11-1. Localized menus in English and Spanish
11-2. Locale's placement in typical chrome layout
12-1. Distributed remote Mozilla application
12-2. Remote XUL file-accessing skin
12-3. Hiss-zilla, a remote game
12-4. A Netscape Object Signing certificate chain

12-5. Downloading a certificate window
12-6. Certificate manager with a certs.mozdev.org CA certificate
12-7. SignTool's processes for creating a signed application
12-8. Receiving a signed application
12-9. Snake game in full-screen mode on Windows
12-10. Result of using the GetScore function
A-1. Mozilla Cross Reference code browsing tool
B-1. The DOM inspector interface
B-2. An interface displayed in the Component Viewer
B-3. The JavaScript Debugger
B-4. Chrome view in MozillaTranslator
List of Examples
2-1. Hello xFly
2-2. The XUL namespace declaration
2-3. Mixed namespaces in an XML document
2-4. Sample XUL window
2-5. chrome/xfly/content/contents.rdf file
2-6. chrome/xfly/skin/contents.rdf file
2-7. chrome/xfly/locale/contents.rdf file
2-8. The contents of the xfly.css file
2-9. XUL using external style data
2-10. XUL using an external script
2-11. The contents of the xfly.js file
2-12. The contents of the xfly.dtd file
2-13. XUL using an external DTD file
2-14. Tree structure of a completed sample xFly package
2-15. Additions to the installed-chrome.txt file
3-1. XUL dialog
3-2. XUL page
3-3. A XUL wizard

3-4. Toolbar with buttons and spacing
3-5. Application menu bar
3-6. A sample menu
3-7. Context menu using pop up
3-8. XUL menu list
3-9. Listbox widget
3-10. Tree base model
3-11. Multilevel tree content view
3-12. XUL grid
3-13. Text autocomplete
3-14. A radio group choice of options
3-15. Shortcut keys with command observers
3-16. Tabbed panels
3-17. A deck with three image layers
3-18. Deck layer switching
3-19. Content positioning in a stack
3-20. Flexible buttons
3-21. Positioning attributes
3-22. xFly application main workspace
3-23. Example tree in the xFly application
4-1. Class selector in CSS
4-2. Attribute selector in CSS
4-3. !important keyword in CSS
4-4. Image in CSS
4-5. Mixing CSS and XUL
4-6. CSS for print button in navigator skin
4-7. CSS Import statements in global skin
4-8. CSS information from communicator.css
4-9. CSS rules for xFly window
4-10. Custom styles for buttons

4-11. Skin manifest for the xFly sample
4-12. Manifest for the communicator package of the modern skin in Mozilla
4-13. CSS and XBL example
4-14. userChrome.css style rules
5-1. Printing element properties to the console
5-2. Printing the window properties
5-3. Adding toggle functionality to xFly
5-4. Adding Toggle menus to xFly
5-5. Basic event handler attributes
5-6. Getting event handler attributes from an element
5-7. Event propagation
5-8. stopPropagation( ) event function
5-9. Dynamic menu generation
5-10. Scriptable component example
5-11. Scripting components from HTML
6-1. Package installation script
6-2. Simple theme package manifest
6-3. Locale package manifest
6-4. manifest.rdf describing the XMLTerm extension
6-5. The xFly overlay
6-6. Overlay information in the manifest
6-7. Overlays in navigator.xul
6-8. Top level of the browser.xpi archive
6-9. Simple install script
6-10. Script that explicitly prefixes the Install object
6-11. A more complicated install script
6-12. Trigger script on a web page
6-13. Scriptless install of a JAR
6-14. Getting the operating system in an install script
6-15. install.log

6-16. Common XPInstall functions
6-17. Install script callback
6-18. Non-Mozilla software installation script
6-19. Package metadata in the xFly manifest
6-20. xFly installation script
6-21. Web page trigger
7-1. XBL implementation element
7-2. An XBL property setting and getting a value
7-3. Performing a Google search when setting a property
7-4. Accessing a bound document from a binding
7-5. Selective inclusion of child content in a binding
7-6. Binding inheritance
7-7. Inheriting XUL widget characteristics using extends
7-8. XBL attribute inheritance
7-9. Inheritance of behavior between bindings
8-1. Using an XPCOM object in script
8-2. progIDs
8-3. QueryInterface method for nsISimple interface
8-4. JavaScript implementation of nsISimple
8-5. Scripting the "simple" component in xpcshell
8-6. Reference implementation of QueryInterface
8-7. Platform macros in xpcom/base/nscore.h
8-8. NS_IMETHOD macro
8-9. Manual reference counting using raw pointers
8-10. Using nsCOMPtr in your code
8-11. nsISimple header file generated by xpidl compiler
8-12. The component header file nsSimple.h
8-13. nsSimple.cpp
8-14. nsSimpleModule.cpp
8-15. Sample Makefile

8-16. Sample use of component in xpcshell
8-17. Example 8-17: Testing for nsresults from component methods
8-18. Sample Python component implementation
8-19. IDL for the Python component
8-20. Using the Python component in script
9-1. Simple XUL template in a listbox element
9-2. Basic structure of a XUL template
9-3. Hardcoded representation of generated XUL
9-4. XUL tree template in Figure 9-3
9-5. Simplified version of 10-4 RDF data
9-6. Tree template code of Figure 9-3
9-7. Tree template with rules
9-8. Menubar template with three rules
9-9. Template implemented in a box with buttons as content
10-1. Simple RDF file with "fly" namespace
10-2. RDF root sequence
10-3. The Horse sequence
10-4. Entire RDF file
10-5. Content model of email datasources
10-6. RDF-specific components built into Mozilla
10-7. Creating a root node
10-8. Manipulating datasources
10-9. Parse an RDF/XML string into a datasource
10-10. Setup nsIRDFXMLSink with event handlers
10-11. Binding with in-memory datasource and <listbox> template
10-12. Creating and modifying an RDF file using JSLib
10-13. Initialization
10-14. Data updating
10-15. Skin manifest
10-16. Overlay for a sample application menu

10-17. Overlay for an xFly menu item in the browser
11-1. XUL menu with entity references for text and accesskeys
11-2. The Editor's Doctype definitions
11-3. String bundles used by the Mozilla browser
11-4. Creating the bundle via XPConnect
11-5. Using multiple <description> elements
11-6. Using the HTML break tag
11-7. Binding with attribute inheritance
11-8. RDF Description node with localizable text
11-9. The locale XPI install script, install.js
11-10. Locale-switching script
12-1. Remote XUL example
12-2. Enabling universal XPConnect
12-3. A sample static XUL file
12-4. Using PHP to generate the correct XUL MIME type
12-5. A simple Perl-generated XUL file
12-6. A Python-generated dynamically updated form
12-7. SQL script with User and Project data
12-8. XUL generated from database
12-9. Creating a root certificate
12-10. Creating a distribution certificate
12-11. Create a signing certificate
12-12. Sample redirect into a signed application
12-13. Function for switching screen modes
12-14. Minimal .NET web service
12-15. Abbreviated WSDL as produced by .NET web service.
12-16. XML format for SOAP calls of Mozilla
12-17. .NET format for SOAP calls of Mozilla
12-18. Preloading scores.js into cache with an HTML association
12-19. SaveScore SOAP function

12-20. Code for GetScore and GetHighScores
B-1. Sample application template
B-2. Sample XPCOM component template
B-3. makexpi.conf file
Next
Copyright
Creating Applications with Mozilla
Prev Next
Copyright
Copyright © 2002 O'Reilly & Associates, Inc.
Printed in the United States of America.
Published by O'Reilly & Associates, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O'Reilly & Associates books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (). For more information, contact our corporate/institutional sales
department: (800) 998-9938 or <
>.
Nutshell Handbook, the Nutshell Handbook logo, and the O'Reilly logo are registered trademarks of O'Reilly &
Associates, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O'Reilly & Associates, Inc. was aware of a trademark
claim, the designations have been printed in caps or initial caps. The association between the image of a frilled lizard and
the topic of Mozilla is a trademark of O'Reilly & Associates, Inc.
While every precaution has been taken in the preparation of this book, the publisher and authors assume no responsibility
for errors or omissions, or for damages resulting from the use of the information contained herein.
Prev Home Next
Creating Applications with Mozilla Preface
Creating Applications with Mozilla
Prev Next
Preface
Mozilla is not just a web browser. It is also a framework for building cross-platform applications using standards such as
Cascading Style Sheets (CSS), XML languages such as the XML-based User-interface Language (XUL), eXtensible

Binding Language (XBL), and Resource Description Framework (RDF).
Gecko, Mozilla's rendering engine, is used as part of the framework, along with other technologies such as XPConnect
and XPCOM, Mozilla's component model. The Mozilla development framework also uses programming languages such
as JavaScript, C++, C, Python, and Interface Definition Language (IDL).
The Mozilla framework is used to create Netscape's Mozilla-based browsers (Netscape 6.x and 7.x), other browsers such
as Galeon and Camino, and chat clients like ChatZilla and JabberZilla. Developers also use Mozilla to create
development tools, browser enhancements, games, and other types of add-ons and applications.
This book explains how applications are created with Mozilla and provides step-by-step information that shows how to
create your own programs using Mozilla's powerful cross-platform development framework. It also includes examples of
different existing applications to demonstrate the possibilities of Mozilla development.
1. Mozilla Background
When Netscape Communications Corporation was founded, it planned to create a better version of NCSA's Mosaic
browser, the first application that made accessing the Internet possible for ordinary users. This new application would be
a Mosaic Killer. In time, the word "Mozilla" became the shortened version of this phrase and the code word for
Netscape's browsers.
Mozilla has become more than a reference to one of Netscape's products. On March 31, 1998,
was launched as the site where the development of Netscape's next-generation Communicator 5.0 browser suite would
take place. At that point, Mozilla became an open source project and began to take on a life of its own beyond its origins
at Netscape.
When Netscape released its Communicator code to the open source community, it did something that was never done
before: no other major software company had given away the source code to a proprietary product. At the time, many
people in the software industry and the press debated the wisdom of this decision.
Many other companies have followed Netscape's lead and released their own products to the open source community.
Sun Microsystems sponsors several projects, including and Apple
also bases the core of its new operating system on an open source project called Darwin, hosted at le.
com/darwin/.
A year after the Mozilla source code was released, Mike Homer, a senior executive at Netscape, made the following
comments: "Mozilla is larger than Netscape, and that was its intention. Mozilla is essentially a collaborative project that
was sponsored by a commercial entity. Some of the people that staff mozilla.org are Netscape employees, and the code
that was contributed was code previously owned by Netscape. However, it's also true that the code base will take on a life

of its own someday."
Since the project's launch, many people outside Netscape have joined the community, although many Netscape (now
AOL) employees still contribute to its advancement. The Mozilla community is growing beyond the original home of
mozilla.org. Other community resources worth examining include an advocacy and news
site, and a project-hosting site for Mozilla applications.
Several companies, including IBM, Red Hat, ActiveState, and Sun Microsystems have also contributed to the Mozilla
community. For instance, Red Hat has provided support for Mozilla because it wants to help drive development of an
open source alternative to the closed source Netscape 4.x browser suite that they had included in their Linux distribution.
AOL has also explored the use of Mozilla in its latest CompuServe and AOL clients.
Because all Mozilla source code is made available to anyone who is interested, the community benefits from an increase
in the number of suggestions, bug reports, patches, and new developers. Along with the people who were involved with
the project when it was first released as open source, the new people and companies that joined the community have
helped shape the direction and outcome of the Mozilla project.
Prev Home Next
Copyright The State of Mozilla
Creating Applications with Mozilla
Prev
Preface
Next
2. The State of Mozilla
Mozilla 1.0 was released on June 5, 2002, after more than four years of development as an open source project. This book
was written so that all examples will work with this release and any 1.0.x maintenance release.
After the 1.0 release, two main development branches of Mozilla were created. The stable, long-lived 1.0 branch is
dedicated to fixing bugs in the code of the 1.0 release. From this branch, periodic maintenance releases are labeled as
Version 1.0.x. Every 1.0.x release is designed to be fully compatible with (though less buggy than) the original 1.0
release.
The other development branch is from the Mozilla CVS trunk. New releases from this development effort are labeled as 1.
x and may include new features, changes to architecture, or other additions that help Mozilla evolve as a project.
These new 1.x releases may not be fully compatible with applications created to work with Mozilla 1.0 and the 1.0.x
releases, but mozilla.org made a commitment to preserve frozen API compatibility (including XUL and XBL syntax)

throughout the 1.x series until a future 2.0 release. See for details.
Because Mozilla itself is under active development, applications built on the framework may be affected when new
versions of Mozilla are released. We recommend that you refer to mozilla.org's development road map for the latest
information about the state of Mozilla; see
We also recommend that you use Mozilla 1.0.x versions when working with examples in this book. We encourage you to
use the latest 1.x release as well so you can stay involved with the latest and greatest that Mozilla has to offer.
Prev Home Next
Preface Up Who Should Read This Book
Creating Applications with Mozilla
Prev
Preface
Next
3. Who Should Read This Book
This book is primarily aimed at programmers (and would-be programmers) interested in exploring this brand-new
platform the Mozilla development framework. However, you do not need to be a professional programmer to create
your own cross-platform Mozilla-based applications.
As shown in the coming chapters, all you need to get started is a basic understanding of a few technologies that are
already familiar to most web developers: CSS, XML, and JavaScript. In fact, this is one of the great advantages to
developing a Mozilla-based application: the learning curve isn't as steep as most alternatives, such as C, C++, or even
Java.
Your applications will be cross-platform automatically (although you can create platform-specific applications as well)
and easily installable over the Internet by anyone running Mozilla on their computer. What more could you ask for in a
development platform?
This book assumes that the reader has some level of familiarity with JavaScript, CSS, HTML, and XML. Reading this
book in conjunction with other books that are devoted specifically to these topics may be useful if you are not already
comfortable using these technologies. Some useful O'Reilly & Associates titles include JavaScript: The Definitive Guide,
Cascading Style Sheets: The Definitive Guide, HTML & DHTML: The Definitive Guide, Learning XML, and XML in a
Nutshell, Second Edition. Concepts and technologies that are new to Mozilla or used with Mozilla in a new way are
explained in detail throughout the book.
This book also assumes that the reader has access to a computer with Mozilla 1.0 or later installed on it, plus any text

editor or word processor. Mozilla runs on almost any type of personal computer available today, so finding a compatible
platform shouldn't be difficult. The full system requirements for any Mozilla release can be found on the mozilla.org site.
Prev Home Next
The State of Mozilla Up Platform and Applications
Creating Applications with Mozilla
Prev
Preface
Next
4. Platform and Applications
Some developers work on Mozilla to improve the way it functions and other developers use Mozilla to create new
applications. These two approaches reflect the dual nature of Mozilla as a development project and a framework for
creating applications, but the line between the two isn't always clear.
People often start developing an application with Mozilla and then notice a way to make Mozilla itself work better, which
will in turn make their application work better. In these cases, the developer works on both Mozilla applications and the
Mozilla development framework that provides the plumbing those applications run on top of.
This distinction between platform and applications is important. This book provides in-depth information about
application development using Mozilla, but it does not directly describe anything relating to the development of Mozilla
itself.
If you are interested in learning how to become a Mozilla developer (and actually hacking the code), we can suggest a
couple of starting points. Getting Your Work Into Mozilla is an article written by two authors who chronicled their own
experiences about becoming a part of the Mozilla community, and is available at />mozilla/2000/09/29/keys.html. There is also great information about getting started with development on Mozilla from
the mozilla.org site at
Prev Home Next
Who Should Read This Book Up Structure of the Book
Creating Applications with Mozilla
Prev
Preface
Next
5. Structure of the Book
This book is structured so you can create and distribute a simple Mozilla application after reading through Chapter 6. You

should read Chapters 1-6 in order and work through the examples. The later chapters provide information about advanced
aspects of application development that allow you to take full advantage of what Mozilla has to offer. If you wish, you
can read Chapters 7-12 out of order, depending on your needs and interests.
Chapter 1, provides an introduction to Mozilla and its advantages as a development framework. Conceptually, the chapter
gives you a thorough understanding of how JavaScript, CSS, and XUL are used to create cross-platform applications.
Chapter 2, goes into the initial technical details about creating Mozilla applications. Two "Hello World" examples are
presented to show you how to build an application shell.
Chapter 3, introduces the XML-based User-interface Language, shows you how to create custom XUL documents, and
explains how to use the XUL tag set to build out your application shell.
Chapter 4, shows how Cascading Style Sheets are used to create the look and feel of an application and how custom CSS
files work together with XUL files in your application shell.
Chapter 5, describes how to add functionality to your application by using JavaScript and how custom JS files added to
your application shell interact with existing XUL and CSS files.
Chapter 6, explains how to package an application so it can be installed on different computers. Once you create your
custom XUL, CSS, and JS files, you can package and distribute them to users as your Mozilla application after reading
this chapter.
Chapter 7, is the first of the more advanced chapters that show you how to extend the basic application framework
described in Chapters 1-6. This chapter explains how to use the eXtensible Binding Language to create reusable widgets
that will help organize a complicated application.
Chapter 8, examines Mozilla's cross-platform component object model. After reading this chapter, you should be able to
find and use existing scriptable components in your own application and create a simple XPCOM component using
JavaScript or C++.
Chapter 9, explains how to include dynamic information in your application that can be updated from a database, user
input, or other sources. XUL templates rely on RDF, but it is not necessary to fully understand RDF to be able to use
XUL templates.
Chapter 10, looks more closely at how Mozilla configures and uses datasources with the Resource Description
Framework. RDF is used in XUL templates, but it is also used throughout Mozilla and Mozilla applications. Although it
is considered to be one of the most difficult technologies to learn and use, RDF is worth the effort.
Chapter 11, shows how to make your application more accessible by localizing it into any number of different languages.
This chapter shows you how to use Document Type Definitions and string bundles to provide translations of your

application's interface and other content, such as the Help documents you may provide in your application.
Chapter 12, explores an alternate distribution method that has several advantages over the direct installation method
discussed in
Chapter 6. By serving your application from a server, you may be able to add extra features that wouldn't be
possible otherwise.
The book's three appendixes contain supplemental information not directly applicable to any of the different chapters.
Appendix A, explains how to start using the Mozilla source code. Appendix B, describes projects that will assist you with
your application development.
Appendix C, provides a convenient reference useful for quickly locating specific XUL and
XBL elements and event attributes.
This book was written so that a reader who does not want to read about each aspect of application creation can read just
the chapters that interest them and still get useful information. For instance, a graphic designer can read the chapters
about XUL and CSS and learn how to create an application interface to which a programmer can then add functionality.
Prev Home Next
Platform and Applications Up How This Book Was Written