--- /dev/null
+##############################################################################
+#
+# Zope Public License (ZPL) Version 1.0
+# -------------------------------------
+#
+# Copyright (c) Digital Creations. All rights reserved.
+#
+# This license has been certified as Open Source(tm).
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions in source code must retain the above copyright
+# notice, this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in
+# the documentation and/or other materials provided with the
+# distribution.
+#
+# 3. Digital Creations requests that attribution be given to Zope
+# in any manner possible. Zope includes a "Powered by Zope"
+# button that is installed by default. While it is not a license
+# violation to remove this button, it is requested that the
+# attribution remain. A significant investment has been put
+# into Zope, and this effort will continue if the Zope community
+# continues to grow. This is one way to assure that growth.
+#
+# 4. All advertising materials and documentation mentioning
+# features derived from or use of this software must display
+# the following acknowledgement:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# In the event that the product being advertised includes an
+# intact Zope distribution (with copyright and license included)
+# then this clause is waived.
+#
+# 5. Names associated with Zope or Digital Creations must not be used to
+# endorse or promote products derived from this software without
+# prior written permission from Digital Creations.
+#
+# 6. Modified redistributions of any form whatsoever must retain
+# the following acknowledgment:
+#
+# "This product includes software developed by Digital Creations
+# for use in the Z Object Publishing Environment
+# (http://www.zope.org/)."
+#
+# Intact (re-)distributions of any official Zope release do not
+# require an external acknowledgement.
+#
+# 7. Modifications are encouraged but must be packaged separately as
+# patches to official Zope releases. Distributions that do not
+# clearly separate the patches from the original work must be clearly
+# labeled as unofficial distributions. Modifications which do not
+# carry the name Zope may be packaged in any form, as long as they
+# conform to all of the clauses above.
+#
+#
+# Disclaimer
+#
+# THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS ``AS IS'' AND ANY
+# EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL DIGITAL CREATIONS OR ITS
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+#
+# This software consists of contributions made by Digital Creations and
+# many individuals on behalf of Digital Creations. Specific
+# attributions are listed in the accompanying credits file.
+#
+##############################################################################
+"""
+DOM implementation in StructuredText : Read-Only methods
+
+All standard Zope objects support DOM to a limited extent.
+"""
+import string
+
+
+# Node type codes
+# ---------------
+
+ELEMENT_NODE = 1
+ATTRIBUTE_NODE = 2
+TEXT_NODE = 3
+CDATA_SECTION_NODE = 4
+ENTITY_REFERENCE_NODE = 5
+ENTITY_NODE = 6
+PROCESSING_INSTRUCTION_NODE = 7
+COMMENT_NODE = 8
+DOCUMENT_NODE = 9
+DOCUMENT_TYPE_NODE = 10
+DOCUMENT_FRAGMENT_NODE = 11
+NOTATION_NODE = 12
+
+# Exception codes
+# ---------------
+
+INDEX_SIZE_ERR = 1
+DOMSTRING_SIZE_ERR = 2
+HIERARCHY_REQUEST_ERR = 3
+WRONG_DOCUMENT_ERR = 4
+INVALID_CHARACTER_ERR = 5
+NO_DATA_ALLOWED_ERR = 6
+NO_MODIFICATION_ALLOWED_ERR = 7
+NOT_FOUND_ERR = 8
+NOT_SUPPORTED_ERR = 9
+INUSE_ATTRIBUTE_ERR = 10
+
+# Exceptions
+# ----------
+
+class DOMException(Exception):
+ pass
+class IndexSizeException(DOMException):
+ code = INDEX_SIZE_ERR
+class DOMStringSizeException(DOMException):
+ code = DOMSTRING_SIZE_ERR
+class HierarchyRequestException(DOMException):
+ code = HIERARCHY_REQUEST_ERR
+class WrongDocumentException(DOMException):
+ code = WRONG_DOCUMENT_ERR
+class InvalidCharacterException(DOMException):
+ code = INVALID_CHARACTER_ERR
+class NoDataAllowedException(DOMException):
+ code = NO_DATA_ALLOWED_ERR
+class NoModificationAllowedException(DOMException):
+ code = NO_MODIFICATION_ALLOWED_ERR
+class NotFoundException(DOMException):
+ code = NOT_FOUND_ERR
+class NotSupportedException(DOMException):
+ code = NOT_SUPPORTED_ERR
+class InUseAttributeException(DOMException):
+ code = INUSE_ATTRIBUTE_ERR
+
+# Node classes
+# ------------
+
+class ParentNode:
+ """
+ A node that can have children, or, more precisely, that implements
+ the child access methods of the DOM.
+ """
+
+ def getChildNodes(self, type=type, st=type('')):
+ """
+ Returns a NodeList that contains all children of this node.
+ If there are no children, this is a empty NodeList
+ """
+
+ r=[]
+ for n in self.getChildren():
+ if type(n) is st: n=TextNode(n)
+ r.append(n.__of__(self))
+
+ return NodeList(r)
+
+ def getFirstChild(self, type=type, st=type('')):
+ """
+ The first child of this node. If there is no such node
+ this returns None
+ """
+ children = self.getChildren()
+
+ if not children:
+ return None
+
+ n=chidren[0]
+
+ if type(n) is st:
+ n=TextNode(n)
+
+ return n.__of__(self)
+
+ def getLastChild(self, type=type, st=type('')):
+ """
+ The last child of this node. If there is no such node
+ this returns None.
+ """
+ children = self.getChildren()
+ if not children: return None
+ n=chidren[-1]
+ if type(n) is st: n=TextNode(n)
+ return n.__of__(self)
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_ChildNodes(self, type=type, st=type('')):
+ return self.getChildNodes(type,st)
+
+ def _get_FirstChild(self, type=type, st=type('')):
+ return self.getFirstChild(type,st)
+
+ def _get_LastChild(self, type=type, st=type('')):
+ return self.getLastChild(type,st)
+
+class NodeWrapper(ParentNode):
+ """
+ This is an acquisition-like wrapper that provides parent access for
+ DOM sans circular references!
+ """
+
+ def __init__(self, aq_self, aq_parent):
+ self.aq_self=aq_self
+ self.aq_parent=aq_parent
+
+ def __getattr__(self, name):
+ return getattr(self.aq_self, name)
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+ return self.aq_parent
+
+ def _getDOMIndex(self, children, getattr=getattr):
+ i=0
+ self=self.aq_self
+ for child in children:
+ if getattr(child, 'aq_self', child) is self:
+ self._DOMIndex=i
+ return i
+ i=i+1
+ return None
+
+ def getPreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ children = self.aq_parent.getChildren()
+ if not children:
+ return None
+
+ index=getattr(self, '_DOMIndex', None)
+ if index is None:
+ index=self._getDOMIndex(children)
+ if index is None: return None
+
+ index=index-1
+ if index < 0: return None
+ try: n=children[index]
+ except IndexError: return None
+ else:
+ if type(n) is st:
+ n=TextNode(n)
+ n._DOMIndex=index
+ return n.__of__(self)
+
+
+ def getNextSibling(self, type=type, st=type('')):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+ children = self.aq_parent.getChildren()
+ if not children:
+ return None
+
+ index=getattr(self, '_DOMIndex', None)
+ if index is None:
+ index=self._getDOMIndex(children)
+ if index is None:
+ return None
+
+ index=index+1
+ try: n=children[index]
+ except IndexError:
+ return None
+ else:
+ if type(n) is st:
+ n=TextNode(n)
+ n._DOMIndex=index
+ return n.__of__(self)
+
+ def getOwnerDocument(self):
+ """
+ The Document object associated with this node, if any.
+ """
+ return self.aq_parent.getOwnerDocument()
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_DOMIndex(self, children, getattr=getattr):
+ return self._getDOMIndex(children,getattr)
+
+ def _get_PreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ return self.getPreviousSibling(type,st,getattr,None)
+
+ def _get_NextSibling(self, type=type, st=type('')):
+ return self.getNextSibling(type,st)
+
+ def _get_OwnerDocument(self):
+ return self.getOwnerDocument()
+
+class Node(ParentNode):
+ """
+ Node Interface
+ """
+
+ # Get a DOM wrapper with a parent link
+ def __of__(self, parent):
+ return NodeWrapper(self, parent)
+
+ # DOM attributes
+ # --------------
+
+ def getNodeName(self):
+ """
+ The name of this node, depending on its type
+ """
+
+ def getNodeValue(self):
+ """
+ The value of this node, depending on its type
+ """
+ return None
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+
+ def getChildren(self):
+ """
+ Get a Python sequence of children
+ """
+ return ()
+
+ def getPreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ def getNextSibling(self, type=type, st=type('')):
+ """
+ The node immediately preceding this node. If
+ there is no such node, this returns None.
+ """
+
+ def getAttributes(self):
+ """
+ Returns a NamedNodeMap containing the attributes
+ of this node (if it is an element) or None otherwise.
+ """
+ return None
+
+ def getOwnerDocument(self):
+ """
+ The Document object associated with this node, if any.
+ """
+
+ # DOM Methods
+ # -----------
+
+ def hasChildNodes(self):
+ """
+ Returns true if the node has any children, false
+ if it doesn't.
+ """
+ return len(self.getChildren())
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_Children(self):
+ return self.getChildren()
+
+ def _get_PreviousSibling(self,
+ type=type,
+ st=type(''),
+ getattr=getattr,
+ None=None):
+
+ return self.getPreviousSibling(type,st,getattr,None)
+
+ def _get_NextSibling(self, type=type, st=type('')):
+ return self.getNextSibling()
+
+ def _get_Attributes(self):
+ return self.getAttributes()
+
+ def _get_OwnerDocument(self):
+ return self.getOwnerDocument()
+
+ def _has_ChildNodes(self):
+ return self.hasChildNodes()
+
+
+class TextNode(Node):
+
+ def __init__(self, str): self._value=str
+
+ def getNodeType(self):
+ return TEXT_NODE
+
+ def getNodeName(self):
+ return '#text'
+
+ def getNodeValue(self):
+ return self._value
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+class Element(Node):
+ """
+ Element interface
+ """
+
+ # Element Attributes
+ # ------------------
+
+ def getTagName(self):
+ """The name of the element"""
+ return self.__class__.__name__
+
+ def getNodeName(self):
+ """The name of this node, depending on its type"""
+ return self.__class__.__name__
+
+ def getNodeType(self):
+ """A code representing the type of the node."""
+ return ELEMENT_NODE
+
+ def getNodeValue(self, type=type, st=type('')):
+ r=[]
+ for c in self.getChildren():
+ if type(c) is not st:
+ c=c.getNodeValue()
+ r.append(c)
+ return string.join(r,'')
+
+ def getParentNode(self):
+ """
+ The parent of this node. All nodes except Document
+ DocumentFragment and Attr may have a parent
+ """
+
+ # Element Methods
+ # ---------------
+
+ _attributes=()
+
+ def getAttribute(self, name): return getattr(self, name, None)
+ def getAttributeNode(self, name):
+ if hasattr(self, name):
+ return Attr(name, getattr(self, name))
+
+ def getAttributes(self):
+ d={}
+ for a in self._attributes:
+ d[a]=getattr(self, a, '')
+ return NamedNodeMap(d)
+
+ def getAttribute(self, name):
+ """Retrieves an attribute value by name."""
+ return None
+
+ def getAttributeNode(self, name):
+ """ Retrieves an Attr node by name or None if
+ there is no such attribute. """
+ return None
+
+ def getElementsByTagName(self, tagname):
+ """
+ Returns a NodeList of all the Elements with a given tag
+ name in the order in which they would be encountered in a
+ preorder traversal of the Document tree. Parameter: tagname
+ The name of the tag to match (* = all tags). Return Value: A new
+ NodeList object containing all the matched Elements.
+ """
+ nodeList = []
+ for child in self.getChildren():
+ if (child.getNodeType()==ELEMENT_NODE and \
+ child.getTagName()==tagname or tagname== '*'):
+
+ nodeList.append(child)
+
+ if hasattr(child, 'getElementsByTagName'):
+ n1 = child.getElementsByTagName(tagname)
+ nodeList = nodeList + n1._data
+ return NodeList(nodeList)
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_TagName(self):
+ return self.getTagName()
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_NodeValue(self, type=type, st=type('')):
+ return self.GetNodeValue(type,st)
+
+ def _get_ParentNode(self):
+ return self.getParentNode()
+
+ def _get_Attribute(self, name):
+ return self.getAttribute(name)
+
+ def _get_AttributeNode(self, name):
+ return self.getAttributeNode(name)
+
+ def _get_Attributes(self):
+ return self.getAttributes()
+
+ def _get_Attribute(self, name):
+ return self.getAttribute(name)
+
+ def _get_AttributeNode(self, name):
+ return self.getAttributeNode(name)
+
+ def _get_ElementsByTagName(self, tagname):
+ return self.getElementsByTagName(tagname)
+
+
+class NodeList:
+ """
+ NodeList interface - Provides the abstraction of an ordered
+ collection of nodes.
+
+ Python extensions: can use sequence-style 'len', 'getitem', and
+ 'for..in' constructs.
+ """
+
+ def __init__(self,list=None):
+ self._data = list or []
+
+ def __getitem__(self, index, type=type, st=type('')):
+ return self._data[index]
+
+ def __getslice__(self, i, j):
+ return self._data[i:j]
+
+ def item(self, index):
+ """
+ Returns the index-th item in the collection
+ """
+ try: return self._data[index]
+ except IndexError: return None
+
+ def getLength(self):
+ """
+ The length of the NodeList
+ """
+ return len(self._data)
+
+ __len__=getLength
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_Length(self):
+ return self.getLength()
+
+class NamedNodeMap:
+ """
+ NamedNodeMap interface - Is used to represent collections
+ of nodes that can be accessed by name. NamedNodeMaps are not
+ maintained in any particular order.
+
+ Python extensions: can use sequence-style 'len', 'getitem', and
+ 'for..in' constructs, and mapping-style 'getitem'.
+ """
+
+ def __init__(self, data=None):
+ if data is None:
+ data = {}
+ self._data = data
+
+ def item(self, index):
+ """
+ Returns the index-th item in the map
+ """
+ try: return self._data.values()[index]
+ except IndexError: return None
+
+ def __getitem__(self, key):
+ if type(key)==type(1):
+ return self._data.values()[key]
+ else:
+ return self._data[key]
+
+ def getLength(self):
+ """
+ The length of the NodeList
+ """
+ return len(self._data)
+
+ __len__ = getLength
+
+ def getNamedItem(self, name):
+ """
+ Retrieves a node specified by name. Parameters:
+ name Name of a node to retrieve. Return Value A Node (of any
+ type) with the specified name, or None if the specified name
+ did not identify any node in the map.
+ """
+ if self._data.has_key(name):
+ return self._data[name]
+ return None
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+ def _get_Length(self):
+ return self.getLength()
+
+ def _get_NamedItem(self, name):
+ return self.getNamedItem(name)
+
+class Attr(Node):
+ """
+ Attr interface - The Attr interface represents an attriubte in an
+ Element object. Attr objects inherit the Node Interface
+ """
+
+ def __init__(self, name, value, specified=1):
+ self.name = name
+ self.value = value
+ self.specified = specified
+
+ def getNodeName(self):
+ """
+ The name of this node, depending on its type
+ """
+ return self.name
+
+ def getName(self):
+ """
+ Returns the name of this attribute.
+ """
+ return self.name
+
+ def getNodeValue(self):
+ """
+ The value of this node, depending on its type
+ """
+ return self.value
+
+ def getNodeType(self):
+ """
+ A code representing the type of the node.
+ """
+ return ATTRIBUTE_NODE
+
+ def getSpecified(self):
+ """
+ If this attribute was explicitly given a value in the
+ original document, this is true; otherwise, it is false.
+ """
+ return self.specified
+
+ """
+ create aliases for all above functions in the pythony way.
+ """
+
+ def _get_NodeName(self):
+ return self.getNodeName()
+
+ def _get_Name(self):
+ return self.getName()
+
+ def _get_NodeValue(self):
+ return self.getNodeValue()
+
+ def _get_NodeType(self):
+ return self.getNodeType()
+
+ def _get_Specified(self):
+ return self.getSpecified()
projects / wxWidgets.git / blobdiff