<?xml version="1.0" encoding="UTF-8"?>
<!-- $Id: glossary.xml 225913 2001-06-01 11:15:37Z dims $ -->
<!--
 *************************************************************************
 * BEGINNING OF DOM GLOSSARY                                             *
 *************************************************************************
-->
<div1 role="glossary" id="glossary"> 
  <head>Glossary</head> 
  <orglist role="editors"> 
	 <member> 
		<name>Arnaud Le Hors</name> 
		<affiliation>IBM</affiliation> 
	 </member> 
	 <member> 
		<name>Lauren Wood</name> 
		<affiliation>SoftQuad Software Inc.</affiliation> 
	 </member> 
	 <member> 
		<name>Robert S. Sutor</name> 
		<affiliation>IBM (for DOM Level 1)</affiliation> 
	 </member> 
  </orglist> 
  <p>Several of the following term definitions have been borrowed or modified
	 from similar definitions in other W3C or standards documents. See the links
	 within the definitions for more information.</p> 
  <glist><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-16-bit-unit">16-bit unit</label> 
		<def> 
		  <p>The base unit of a <code>DOMString</code>. This indicates that indexing on a <code>DOMString</code> occurs in units of 16 bits. This must not be misunderstood to mean that
			 a <code>DOMString</code> can store arbitrary 16-bit units. A <code>DOMString</code> is a character string encoded in UTF-16; this means that the
			 restrictions of UTF-16 as well as the other relevant restrictions on character
			 strings must be maintained. A single character, for example in the form of a
			 numeric character reference, may correspond to one or two 16-bit units.</p> 
		  <p>For more information, see <bibref ref="Unicode"/> and
			 <bibref ref="ISO10646"/>.</p> 
		</def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-ancestor">ancestor</label> 
		<def> 
		  <p>An <term>ancestor</term> node of any node A is any node above A in a
			 tree model of a document, where "above" means "toward the root." </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-API">API</label> 
		<def> 
		  <p>An <term>API</term> is an application programming interface, a set
			 of functions or <term>methods</term> used to access some
			 functionality.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-child">child</label> 
		<def> 
		  <p>A <term>child</term> is an immediate <term>descendant</term> node of
			 a node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-application">client application</label> 
		<def> 
		  <p>A [client] application is any software that uses the Document Object
			 Model programming interfaces provided by the hosting implementation to
			 accomplish useful work. Some examples of client applications are scripts within
			 an HTML or XML document.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-COM">COM</label> 
		<def> 
		  <p><term>COM</term> is Microsoft's Component Object Model
			 <bibref ref="COM"/>, a technology for building applications from binary
			 software components.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-content-model">content model</label> 
		<def> 
		  <p>The <term>content model</term> is a simple grammar governing the
			 allowed types of the <term>child</term> elements and the order in which they
			 appear. See <xspecref href="&xml-spec;#sec-element-content">Element
			 Content</xspecref> in XML <bibref ref="XML"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-context">context</label> 
		<def> 
		  <p>A <term>context</term> specifies an access pattern (or path): a set
			 of interfaces which give you a way to interact with a model. For example,
			 imagine a model with different colored arcs connecting data nodes. A context
			 might be a sheet of colored acetate that is placed over the model allowing you
			 a partial view of the total information in the model.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-convenience">convenience</label> 
		<def> 
		  <p>A <term>convenience method</term> is an operation on an object that
			 could be accomplished by a program consisting of more basic operations on the
			 object. Convenience <term>methods</term> are usually provided to make the API
			 easier and simpler to use or to allow specific programs to create more
			 optimized implementations for common operations. A similar definition holds for
			 a <term>convenience property</term>. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-cooked">cooked model</label> 
		<def> 
		  <p>A model for a document that represents the document after it has
			 been manipulated in some way. For example, any combination of any of the
			 following transformations would create a cooked model: 
			 <olist> 
				<item> 
				  <p>Expansion of internal text entities.</p> 
				</item> 
				<item> 
				  <p>Expansion of external entities.</p> 
				</item> 
				<item> 
				  <p>Model augmentation with style-specified generated text.</p> 
				</item> 
				<item> 
				  <p>Execution of style-specified reordering.</p> 
				</item> 
				<item> 
				  <p>Execution of scripts.</p> 
				</item> 
			 </olist> A browser might only be able to provide access to a cooked
			 model, while an editor might provide access to a cooked or the initial
			 structure model (also known as the <term>uncooked model</term>) for a document.
			 </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-CORBA">CORBA</label> 
		<def> 
		  <p><term>CORBA</term> is the <term>Common Object Request Broker
			 Architecture</term> from the 
			 <loc href="&omg;">OMG</loc> <bibref ref="CORBA"/>. This architecture
			 is a collection of objects and libraries that allow the creation of
			 applications containing objects that make and receive requests and responses in
			 a distributed environment.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-cursor">cursor</label> 
		<def> 
		  <p>A <term>cursor</term> is an object representation of a node. It may
			 possess information about context and the path traversed to reach the
			 node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-datamodel">data model</label> 
		<def> 
		  <p>A <term>data model</term> is a collection of descriptions of data
			 structures and their contained fields, together with the operations or
			 functions that manipulate them.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-deepest">deepest</label> 
		<def> 
		  <p>The <term>deepest</term> element is that element which is furthest
			 from the root or document element in a tree model of the document.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-documentorder">document order</label>
		<def> 
                  <p>The term <term>document order</term> has the same meaning as depth 
                     first, pre-order traversal, which is equivalent to the order in 
                     which the start tags occur in the text representation of the document.</p></def> 
	 </gitem><!-- ................................................................ -->

	 <gitem> 
		<label id="dt-deprecation">deprecation</label> 
		<def> 
		  <p>When new releases of specifications are released, some older
			 features may be marked as being <term>deprecated</term>. This means that new
			 work should not use the features and that although they are supported in the
			 current release, they may not be supported or available in future
			 releases.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-descendant">descendant</label> 
		<def> 
		  <p>A <term>descendant</term> node of any node A is any node below A in
			 a tree model of a document, where "above" means "toward the root."</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-DOM-Level-0">DOM Level 0</label> 
		<def> 
		  <p>The term "<term>DOM Level 0</term>" refers to a mix (not formally
			 specified) of HTML document functionalities offered by Netscape Navigator
			 version 3.0 and Microsoft Internet Explorer version 3.0. In some cases,
			 attributes or <term>methods</term> have been included for reasons of backward
			 compatibility with "DOM Level 0".</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-ECMAScript">ECMAScript</label> 
		<def> 
		  <p>The programming language defined by the ECMA-262 standard
			 <bibref ref="ECMAScript"/>. As stated in the standard, the originating
			 technology for ECMAScript was JavaScript <bibref ref="JavaScript"/>. Note that
			 in the ECMAScript Language binding, the word &quot;property&quot; is used in the same
			 sense as the IDL term &quot;attribute.&quot;</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-element">element</label> 
		<def> 
		  <p>Each document contains one or more elements, the boundaries of which
			 are either delimited by start-tags and end-tags, or, for empty elements by an
			 empty-element tag. Each element has a type, identified by name, and may have a
			 set of attributes. Each attribute has a name and a value. See
			 <xspecref href="&xml-spec;#sec-logical-struct">Logical Structures</xspecref> in
			 XML <bibref ref="XML"/>. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-event-propagation">event propagation, also known as event
		  bubbling</label> 
		<def> 
		  <p>This is the idea that an event can affect one object and a set of
			 related objects. Any of the potentially affected objects can block the event or
			 substitute a different one (upward event propagation). The event is broadcast
			 from the node at which it originates to every <term>parent</term>
			 node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-equivalence">equivalence</label> 
		<def> 
		  <p>Two nodes are <term>equivalent</term> if they have the same node
			 type and same node name. Also, if the nodes contain data, that must be the
			 same. Finally, if the nodes have attributes the collection of attribute names
			 must be the same and the attributes corresponding by name must be equivalent as
			 nodes.</p> 
		  <p>Two nodes are <term>deeply equivalent</term> if they are
			 <term>equivalent</term>, their <term>child</term> node lists are equivalent <code>NodeList</code> objects, and their attributes are deeply equivalent.</p> 
		  <p>Two <code>NodeList</code> objects are <term>equivalent</term> if they have the same length, and
			 the nodes corresponding by index are deeply equivalent. </p> 
		  <p>Two <code>NamedNodeMap</code> objects are <term>equivalent</term> if they have the same length, they
			 have same collection of names, and the nodes corresponding by name in the maps
			 are deeply equivalent. </p> 
		  <p>Two <code>DocumentType</code> nodes are <term>equivalent</term> if they are equivalent as nodes, have
			 the same names, and have equivalent entities and attributes <code>NamedNodeMap</code> objects.</p> 
		</def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-infoitem">information item</label> 
		<def> 
		  <p>An information item is an abstract representation of some component
			 of an XML document. See the <bibref ref="InfoSet"/> for details. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-implementation">hosting implementation</label> 
		<def> 
		  <p>A [hosting] implementation is a software module that provides an
			 implementation of the DOM interfaces so that a client application can use them.
			 Some examples of hosting implementations are browsers, editors and document
			 repositories.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-HTML">HTML</label> 
		<def> 
		  <p>The HyperText Markup Language (<term>HTML</term>) is a simple markup
			 language used to create hypertext documents that are portable from one platform
			 to another. HTML documents are SGML documents with generic semantics that are
			 appropriate for representing information from a wide range of applications.
			 <bibref ref="HTML40"/></p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-IDL">IDL</label> 
		<def> 
		  <p>An Interface Definition Language (<term>IDL</term>) is used to
			 define the interfaces for accessing and operating upon objects. Examples of
			 IDLs are the Object Management Group's IDL <bibref ref="CORBA"/>, Microsoft's
			 IDL <bibref ref="MSIDL"/>, and Sun's Java IDL <bibref
			 ref="JavaIDL"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-implementor">implementor</label> 
		<def> 
		  <p>Companies, organizations, and individuals that claim to support the
			 Document Object Model as an API for their products.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-inheritance">inheritance</label> 
		<def> 
		  <p>In object-oriented programming, the ability to create new classes
			 (or interfaces) that contain all the methods and properties of another class
			 (or interface), plus additional methods and properties. If class (or interface)
			 D inherits from class (or interface) B, then D is said to be
			 <term>derived</term> from B. B is said to be a <term>base</term> class (or
			 interface) for D. Some programming languages allow for multiple inheritance,
			 that is, inheritance from more than one class or interface.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-raw-struct">initial structure model</label> 
		<def> 
		  <p>Also known as the <term>raw structure model</term> or the
			 <term>uncooked model</term>, this represents the document before it has been
			 modified by entity expansions, generated text, style-specified reordering, or
			 the execution of scripts. In some implementations, this might correspond to the
			 &quot;initial parse tree&quot; for the document, if it ever exists. Note that a
			 given implementation might not be able to provide access to the initial
			 structure model for a document, though an editor probably would.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-interface">interface</label> 
		<def> 
		  <p>An <term>interface</term> is a declaration of a set of
			 <term>methods</term> with no information given about their implementation. In
			 object systems that support interfaces and inheritance, interfaces can usually
			 inherit from one another. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-lang-binding">language binding</label> 
		<def> 
		  <p>A programming <term>language binding</term> for an IDL specification
			 is an implementation of the interfaces in the specification for the given
			 language. For example, a Java language binding for the Document Object Model
			 IDL specification would implement the concrete Java classes that provide the
			 functionality exposed by the interfaces.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-localname">local name</label> 
		<def> 
		  <p>A <term>local name</term> is the local part of a <term>qualified
			 name</term>. This is called the <xtermref
			 href="&xml-names;/#dt-localname">local part</xtermref> in Namespaces in XML
			 <bibref ref="Namespaces"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-method">method</label> 
		<def> 
		  <p>A <term>method</term> is an operation or function that is associated
			 with an object and is allowed to manipulate the object's data. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-model">model</label> 
		<def> 
		  <p>A <term>model</term> is the actual data representation for the
			 information at hand. Examples are the structural model and the style model
			 representing the parse structure and the style information associated with a
			 document. The model might be a tree, or a directed graph, or something
			 else.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-namespaceprefix">namespace prefix</label> 
		<def> 
		  <p>A <term>namespace prefix</term> is a string that associates an
			 element or attribute name with a <term>namespace URI</term> in XML. See
			 <xtermref href="&xml-names;/#dt-prefix">namespace prefix</xtermref> in
			 Namespaces in XML <bibref ref="Namespaces"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-namespaceURI">namespace URI</label> 
		<def> 
		  <p>A <term>namespace URI</term> is a URI that identifies an <term>XML
			 namespace</term>. Strictly speaking, this actually is a <term>namespace URI
			 reference</term>. This is called the <xtermref
			 href="&xml-names;/#dt-NSName">namespace name</xtermref> in Namespaces in XML
			 <bibref ref="Namespaces"/>.</p>
		</def>
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-object-model">object model</label>
		<def>
		  <p>An <term>object model</term> is a collection of descriptions of
			 classes or interfaces, together with their member data, member functions, and
			 class-static operations. </p></def>
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-parent">parent</label> 
		<def> 
		  <p>A <term>parent</term> is an immediate <term>ancestor</term> node of
			 a node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-qualifiedname">qualified name</label> 
		<def> 
		  <p>A <term>qualified name</term> is the name of an element or attribute
			 defined as the concatenation of a <term>local name</term> (as defined in this
			 specification), optionally preceded by a <term>namespace prefix</term> and
			 colon character. See <xspecref href="&xml-names;/#ns-qualnames">Qualified
			 Names</xspecref> in Namespaces in XML <bibref ref="Namespaces"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-readonly-node">readonly node</label> 
		<def> 
		  <p>A <term>readonly node</term> is a node that is immutable. This means
			 its list of children, its content, and its attributes, when it is an element,
			 cannot be changed in any way. However, a readonly node can possibly be moved,
			 when it is not itself contained in a readonly node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-root-node">root node</label> 
		<def> 
		  <p>The <term>root node</term> is the unique node that is not a
			 <term>child</term> of any other node. All other nodes are children or other
			 descendants of the root node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-sibling">sibling</label> 
		<def> 
		  <p>Two nodes are <term>siblings</term> if and only if they have the
			 same <term>parent</term> node.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-string-compare">string comparison</label> 
		<def> 
		  <p>When string matching is required, it is to occur as though the
			 comparison was between 2 sequences of code points from the Unicode 3.0 standard
			 <bibref ref="Unicode"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-tag-valid">tag valid document</label> 
		<def> 
		  <p>A document is <term>tag valid</term> if all begin and end tags are
			 properly balanced and nested.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem><label id="dt-token">token</label><def>
		  <p>An information item such as an
			 <xtermref href="http://www.w3.org/TR/REC-xml.html#NT-Name">XML Name</xtermref>
			 which has been <termref def="dt-tokenized">tokenized</termref>.</p></def>
	 </gitem><!-- ................................................................ -->
	 <gitem><label id="dt-tokenized">tokenized</label><def>
		  <p>The description given to various information items (for example,
			 attribute values of various types, but not including the StringType CDATA)
			 after having been processed by the XML processor. The process includes
			 stripping leading and trailing white space, and replacing multiple space
			 characters by one. See the definition of
			 <xtermref href="http://www.w3.org/TR/REC-xml.html#NT-TokenizedType">tokenized
			 type</xtermref>.</p></def>
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-type-valid">type valid document</label> 
		<def> 
		  <p>A document is <term>type valid</term> if it conforms to an explicit
			 DTD.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-uncooked">uncooked model</label> 
		<def> 
		  <p>See initial structure model.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-well-formed">well-formed document</label> 
		<def> 
		  <p>A document is <term>well-formed</term> if it is tag valid and
			 entities are limited to single elements (i.e., single sub-trees). See
			 <xspecref href="&xml-spec;#sec-well-formed"> Well-Formed XML
			 Documents</xspecref> in XML <bibref ref="XML"/>.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-XML">XML</label> 
		<def> 
		  <p>Extensible Markup Language (<term>XML</term>) is an extremely simple
			 dialect of SGML. The goal is to enable generic SGML to be served, received, and
			 processed on the Web in the way that is now possible with HTML. XML
			 <bibref ref="XML"/> has been designed for ease of implementation and for
			 interoperability with both SGML and HTML.</p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-XML-name">XML name</label> 
		<def> 
		  <p>See <xspecref href="&xml-spec;#NT-Name">XML name</xspecref> in the
			 XML specification <bibref ref="XML"/>. </p></def> 
	 </gitem><!-- ................................................................ -->
	 <gitem> 
		<label id="dt-XML-namespace">XML namespace</label> 
		<def> 
		  <p>An <term>XML namespace</term> is a collection of names, identified
			 by a URI reference <bibref ref="URIRef"/>, which are used in XML documents as
			 element types and attribute names. <bibref ref="Namespaces"/></p></def> 
	 </gitem><!-- ................................................................ -->
  </glist></div1><!--
 *************************************************************************
 * END OF DOM GLOSSARY                                                   *
 *************************************************************************
-->
