Free dom software for linux

SVG::DOM is a Perl library with DOM (Document Object Model) methods for SVG objects.

SVG::DOM provides a selection of methods for accessing and manipulating SVG elements through DOM-like methods such as getElements, getChildren, getNextSibling and so on.

Currently only methods that provide read operations are supported. Methods to manipulate SVG elements will be added in a future release.

SYNOPSIS

my $svg=new SVG(id=>"svg_dom_synopsis", width=>"100", height=>"100");
my %attributes=$svg->getAttributes;

my $group=$svg->group(id=>"group_1");
my $name=$group->getElementName;
my $id=$group->getElementID;

$group->circle(id=>"circle_1", cx=>20, cy=>20, r=>5, fill=>"red");
my $rect=$group->rect(id=>"rect_1", x=>10, y=>10, width=>20, height=>30);
my $width=$rect->getAttribute("width");

my $has_children=$group->hasChildren();
my @children=$group->getChildren();

my $kid=$group->getFirstChild();
do {
print $kid->xmlify();
} while ($kid=$kid->getNextSibling);

my @ancestors=$rect->getParents();
my $is_ancestor=$group->isAncestor($rect);
my $is_descendant=$rect->isDescendant($svg);

my @rectangles=$svg->getElements("rect");
my $allelements_arrayref=$svg->getElements();

...and so on...

DOM3K is a fast and rapid development Framework for AJAX. DOM3K uses SPyRO as Web services provider (with the XMLRPC message format) and supports a set of fast and furious javascript functions to manage and create amazing sites.
DOM3K can create standalone applications with the web server included in SPyRO or can be used with monarca web server to get pyew pages support. Support for the Apache Web server is provided too, with all advantages of an Enterprise level Web Server.
Components of dom3k
- dom3k: The HTML DOM Manager.
- db3k: A DB connection object, a wrapper to DBApi2.
- easyform.js: The easyform DOM manager.

DOM Menu allows developers to add dynamic, hierarchical popup menus on their web pages. The direction of the menu can either be horizontal or vertical and the menu can open (or popout) in either direction. It has both screen edge detection and < select > element detection (for browsers that cannot hide these form elements).
The styles for the menu items are contr olled almost entirely through CSS and the menus are created/hidden using the DOM (Document Object M odel).
Menu configuration is done using a custom Hash() class and is very portable from a PHP type array structure. The menus attempt to follow the look and feel of well known GUI toolkit menus.
Version restrictions:
- cannot use opposite direction to open
- opera 7 having difficulty with table (need to work around)
Enhancements:
- added support for IE 5.0
- fixed problem when submenu was deactivated and parent would highlight
- added a converter from phplayersmenu

XML::DOM2 is a DOM controlled, strict XML module for extentable xml objects.
XML::DOM2 is yet _another_ perl XML module.
Main features:
- DOM Level2 Compilence in both document, elements and attributes
- NameSpace control for elements and attributes
- XPath (its just one small method once you have a good DOM)
- Extendability:
- Document, Element or Attribute classes can be used as base class for other kinds of document, element or attribute.
- Element and Attribute Handler allows element specific child elements and attribute objects.
- Element and Attribute serialisation overiding.
- Parsing with SAX (use XML::SAX::PurePerl for low dependancy installs)
- Internal serialisation

XML::DOM::Attr is an XML attribute in XML::DOM.

XML::DOM::Attr extends XML::DOM::Node.

The Attr nodes built by the XML::DOM::Parser always have one child node which is a Text node containing the expanded string value (i.e. EntityReferences are always expanded.) EntityReferences may be added when modifying or creating a new Document.

The Attr interface represents an attribute in an Element object. Typically the allowable values for the attribute are defined in a document type definition.

Attr objects inherit the Node interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the Node attributes parentNode, previousSibling, and nextSibling have a undef value for Attr objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type.

Furthermore, Attr nodes may not be immediate children of a DocumentFragment. However, they can be associated with Element nodes contained within a DocumentFragment. In short, users and implementors of the DOM need to be aware that Attr nodes have some things in common with other objects inheriting the Node interface, but they also are quite distinct.

The attributes effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attributes effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attributes effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the nodeValue attribute on the Attr instance can also be used to retrieve the string version of the attributes value(s).

In XML, where the value of an attribute can contain entity references, the child nodes of the Attr node provide a representation in which entity references are not expanded. These child nodes may be either Text or EntityReference nodes. Because the attribute type may be unknown, there are no tokenized attribute values.

XML::DOM::Text is a piece of XML text in XML::DOM.

XML::DOM::Text extends XML::DOM::CharacterData, which extends XML::DOM::Node.

The Text interface represents the textual content (termed character data in XML) of an Element or Attr. If there is no markup inside an elements content, the text is contained in a single object implementing the Text interface that is the only child of the element. If there is markup, it is parsed into a list of elements and Text nodes that form the list of children of the element.

When a document is first made available via the DOM, there is only one Text node for each block of text. Users may create adjacent Text nodes that represent the contents of a given element without any intervening markup, but should be aware that there is no way to represent the separations between these nodes in XML or HTML, so they will not (in general) persist between DOM editing sessions. The normalize() method on Element merges any such adjacent Text objects into a single node for each block of text; this is recommended before employing operations that depend on a particular document structure, such as navigation with XPointers.

METHODS

splitText (offset)

Breaks this Text node into two Text nodes at the specified offset, keeping both in the tree as siblings. This node then only contains all the content up to the offset point. And a new Text node, which is inserted as the next sibling of this node, contains all the content at and after the offset point.

Parameters: offset The offset at which to split, starting from 0.

Return Value: The new Text node.

DOMExceptions:

INDEX_SIZE_ERR

Raised if the specified offset is negative or greater than the number of characters in data.

NO_MODIFICATION_ALLOWED_ERR

Raised if this node is readonly.

XML::LibXML::DOM is a XML::LibXML DOM Implementation.

XML::LibXML provides an lightwight interface to modify a node of the document tree generated by the XML::LibXML parser. This interface follows as far as possible the DOM Level 3 specification. Additionally to the specified functions the XML::LibXML supports some functions that are more handy to use in the perl environment.

One also has to remember, that XML::LibXML is an interface to libxml2 nodes which actually reside on the C-Level of XML::LibXML. This means each node is a reference to a structure different than a perl hash or array. The only way to access these structures values is through the DOM interface provided by XML::LibXML. This also means, that one cant simply inherit a XML::LibXML node and add new member variables as they were hash keys.

The DOM interface of XML::LibXML does not intend to implement a full DOM interface as it is done by XML::GDOME and used for full featured application. Moreover, it offers an simple way to build or modify documents that are created by XML::LibXMLs parser.

Another target of the XML::LibXML interface is to make the interfaces of libxml2 available to the perl community. This includes also some workarounds to some features where libxml2 assumes more control over the C-Level that most perl users dont have.

One of the most important parts of the XML::LibXML DOM interface is, that the interfaces try do follow the DOM Level 3 specification rather strictly. This means the interface functions are named as the DOM specification says and not what widespread Java interfaces claim to be standard. Although there are several functions that have only a singular interface that conforms to the DOM spec XML::LibXML provides an additional Java style alias interface.

Also there are some function interfaces left over from early stages of XML::LibXML for compatibility reasons. These interfaces are for compatibility reasons only. They might disappear in one of the future versions of XML::LibXML, so a user is requested to switch over to the official functions.

More recent versions of perl (e.g. 5.6.1 or higher) support special flags to disinguish between UTF8 and so called binary data. XML::LibXML provides for these versions functionality to make efficient use of these flags: If a document has set an encoding other than UTF8 all strings that are not already in UTF8 are implicitly encoded from the document encoding to UTF8. On output these strings are commonly returned as UTF8 unless a user does request explicitly the original (aka. document) encoding.
Older version of perl (such as 5.00503 or less) do not support these flags. If XML::LibXML is build for these versions, all strings have to get encoded to UTF8 manualy before they are passed to any DOM functions.

NOTE: XML::LibXMLs magic encoding may not work on all plattforms. Some platforms are known to have a broken iconv(), which is partly used by libxml2. To test if your platform works correctly with your language encoding, build a simple document in the particular encoding and try to parse it with XML::LibXML. If your document gets parsed with out causing any segmentation faults, bus errors or whatever your OS throws. An example for such a test can be found in test 19encoding.t of the distribution.

Namespaces and XML::LibXMLs DOM implementation
XML::LibXMLs DOM implementation follows the DOM implementation of libxml2. This is important to know if namespaces are used. Namespaces cannot be declared on an document node. This is basicly because XPath doesnt know about document nodes. Therefore namespaces have to be declared on element nodes.

This can happen explicitly by using XML::LibXML:Elements setNamespace() function or more or less implicitly by using XML::LibXML::Documents createElementNS() or createAttributeNS() function. If the a namespace is not declared on the documentElement, the namespace will be localy declared for the newly created node. In case of Attributes this may look a bit confusing, since these nodes cannot have namespace declarations itself. In this case the namespace in internally applied to the attribute and later declared on the node the attribute is appended to.

XML::Sablotron::DOM is the DOM interface to Sablotrons internal structures.

SYNOPSIS

use XML::Sablotron::DOM;

my $situa = new XML::Sablotron::Situation();
my $doc = new XML::Sablotron::DOM::Document(SITUATION => $sit);

my $e = $doc->createElement($situa, "foo");
my $t = $doc->createTextNode($situa, "this is my text");

print $doc->toString();

Sablotron uses internally the DOM-like data structures to represent parsed XML trees. In the sdom.h header file is defined a subset of functions allowing the DOM access to these structures.