Introduction

Quoting from the W3C page about DOM [5]

The Document Object Model (DOM) is a platform and language-neutral interface that will allow programs and scripts to dynamically access and update the content, structure and style of documents.

More concretely, the DOM Level 2 specification defines a hierarchy of abstract interfaces providing an object-oriented API to navigate and operate on valid HTML or well-formed XML documents [1,2]. Interfaces are provided for the management of elements, attributes, text nodes, as well as the other XML element types. When speaking of these entities in general, we will call them document nodes. In fact, Node is one of the fundamental DOM interfaces from which most of the other entities derive. Basic node operations include creation, deletion and retrieval. Beside that, the DOM specification provides also a set of event interface for the implementation of event-driven applications. Events can be triggered by physical user actions (such as GUI events) and by modifications of the document structure and content. A DOM implementation (also called a host implementation) is a piece of software which actually implements all (or a subset of) the interfaces defined in the DOM specification. In other words, it takes a parsed XML document and makes it available for processing via some language-dependent implementation of the DOM interfaces. The Gnome DOM Engine (Gdome2 for short, see http://www.cs.unibo.it/~casarini/gdome2) is a DOM implementation whose aim is to provide an interface to XML documents to Gnome programmers which is:

• efficient;
• easy to use;
• compliant to W3C standards.

Basically, the problem is that in usual DOM implementations there is a considerable overhead: application are forced to use a fairly narrow interface to be able to modify and access their state. Furthermore, there are also bloated memory requirements for the storing of the state itself. So, our primary goal is to make the DOM an attractive interface for Gnome¹ applications. Furthermore, as already pointed out in [4], we are also exploring the possibility of providing a unified framework allowing mixing of components within the same application, each component being responsible for managing a particular subset of markup inside a XML document (typically, markup belonging to a given namespace [12]). This is the so called document centric architecture for applications, where the central structure is given by the document and components are plugged in as needed. Gdome2, whose aim is to address these issues, currently supports ``Core'' and ``XML'' modules from DOM Level 2 Specification² but it is supposed to become a full implementation of all the DOM Level 2 interfaces. However, much of the design issues are decided in this phase, because most of the other modules and levels are built on top of this core interface.

Footnotes

... Gnome¹

http://www.gnome.org

... Specification²

The 2 in the Gdome2 has nothing to do with the Level 2 in the DOM Specification. It is just to distinguish the package from a previous version never released officially.