Viewing file:  Document.py (11.67 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
########################################################################
#
# File Name: Document.py
#
#
"""
WWW: http://4suite.com/4DOM e-mail: support@4suite.com
Copyright (c) 2000 Fourthought Inc, USA. All Rights Reserved.
See http://4suite.com/COPYRIGHT for license and copyright information
"""
import re, string
from DOMImplementation import implementation
from FtNode import FtNode, get_name_pattern
from ext import SplitQName
from xml.dom import Node
from xml.dom import XML_NAMESPACE
from xml.dom import XMLNS_NAMESPACE
from xml.dom import EMPTY_NAMESPACE
from xml.dom import HierarchyRequestErr
from xml.dom import InvalidCharacterErr
from xml.dom import NotSupportedErr
from xml.dom import NamespaceErr
class Document(FtNode):
#Base node type for this class
nodeType = Node.DOCUMENT_NODE
nodeName = "#document"
#This is for validation that the proper nodes are added
_allowedChildren = [Node.PROCESSING_INSTRUCTION_NODE,
Node.COMMENT_NODE,
Node.ELEMENT_NODE,
Node.DOCUMENT_TYPE_NODE
]
def __init__(self, doctype):
FtNode.__init__(self, None)
self.__dict__['__doctype'] = None
self.__dict__['__implementation'] = implementation
self.__dict__['__documentElement'] = None
self.__dict__['_singleChildren'] = {Node.ELEMENT_NODE:'__documentElement',
Node.DOCUMENT_TYPE_NODE:'__doctype'
}
self._4dom_setDocumentType(doctype)
### Attribute Methods ###
def _get_doctype(self):
return self.__dict__['__doctype']
def _get_implementation(self):
return self.__dict__['__implementation']
def _get_documentElement(self):
return self.__dict__['__documentElement']
def _get_ownerDocument(self):
return self
### Methods ###
def createAttribute(self, name):
if not get_name_pattern().match(name):
raise InvalidCharacterErr()
import Attr
return Attr.Attr(self, name, EMPTY_NAMESPACE, None, None)
def createCDATASection(self, data):
from CDATASection import CDATASection
return CDATASection(self, data)
def createComment(self, data):
from Comment import Comment
return Comment(self, data)
def createDocumentFragment(self):
from DocumentFragment import DocumentFragment
return DocumentFragment(self)
def createElement(self, tagname):
if not get_name_pattern().match(tagname):
raise InvalidCharacterErr()
from Element import Element
return Element(self, tagname, EMPTY_NAMESPACE, None, None)
def createEntityReference(self, name):
if not get_name_pattern().match(name):
raise InvalidCharacterErr()
from EntityReference import EntityReference
return EntityReference(self, name)
def createProcessingInstruction(self, target, data):
if not get_name_pattern().match(target):
raise InvalidCharacterErr()
#FIXME: Unicode support
# Technically, chacters from the unicode surrogate blocks are illegal.
#for c in target:
# if c in unicode_surrogate_blocks:
# raise InvalidCharacterErr()
from ProcessingInstruction import ProcessingInstruction
return ProcessingInstruction(self, target, data);
def createTextNode(self, data):
from Text import Text
return Text(self, data)
def getElementById(self, elementId):
#FIXME: Must be implemented in the parser first
return None
def getElementsByTagName(self, tagName):
nodeList = implementation._4dom_createNodeList([])
root = self.documentElement
if root:
if tagName == '*' or root.tagName == tagName:
nodeList.append(root)
nodeList.extend(list(root.getElementsByTagName(tagName)))
return nodeList
### DOM Level 2 Methods ###
def createAttributeNS(self, namespaceURI, qualifiedName):
if not get_name_pattern().match(qualifiedName):
raise InvalidCharacterErr()
from Attr import Attr
(prefix, localName) = SplitQName(qualifiedName)
if prefix == 'xml' and namespaceURI != XML_NAMESPACE:
raise NamespaceErr()
if localName == 'xmlns':
if namespaceURI != XMLNS_NAMESPACE:
raise NamespaceErr()
return Attr(self, qualifiedName, XMLNS_NAMESPACE, 'xmlns', prefix)
elif namespaceURI == '':
raise NamespaceErr("Use None instead of '' for empty namespace")
else:
if (not namespaceURI and prefix) or (not prefix and namespaceURI):
raise NamespaceErr()
return Attr(self, qualifiedName, namespaceURI, prefix, localName)
def importNode(self, importedNode, deep):
importType = importedNode.nodeType
# No import allow per spec
if importType in [Node.DOCUMENT_NODE, Node.DOCUMENT_TYPE_NODE]:
raise NotSupportedErr()
# Only the EntRef itself is copied since the source and destination
# documents might have defined the entity differently
#FIXME: If the document being imported into provides a definition for
# this entity name, its value is assigned.
# Need entity support for this!!
elif importType == Node.ENTITY_REFERENCE_NODE:
deep = 0
return importedNode.cloneNode(deep, newOwner=self)
def createElementNS(self, namespaceURI, qualifiedName):
from Element import Element
if not get_name_pattern().match(qualifiedName):
raise InvalidCharacterErr()
(prefix, localName) = SplitQName(qualifiedName)
if prefix == 'xml' and namespaceURI != XML_NAMESPACE:
raise NamespaceErr()
if prefix and not namespaceURI:
raise NamespaceErr()
elif namespaceURI == '':
raise NamespaceErr("Use None instead of '' for empty namespace")
return Element(self, qualifiedName, namespaceURI, prefix, localName)
def getElementsByTagNameNS(self,namespaceURI,localName):
if namespaceURI == '':
raise NamespaceErr("Use None instead of '' for empty namespace")
nodeList = implementation._4dom_createNodeList([])
root = self.documentElement
if root:
if ((namespaceURI == '*' or namespaceURI == root.namespaceURI) and
(localName == '*' or localName == root.localName)):
nodeList.append(root)
nodeList.extend(list(root.getElementsByTagNameNS(namespaceURI,
localName)))
return nodeList
### Document Traversal Factory Functions ###
def createNodeIterator(self, root, whatToShow, filter, entityReferenceExpansion):
from NodeIterator import NodeIterator
return NodeIterator(root, whatToShow, filter, entityReferenceExpansion)
def createTreeWalker(self, root, whatToShow, filter, entityReferenceExpansion):
from TreeWalker import TreeWalker
return TreeWalker(root, whatToShow, filter, entityReferenceExpansion)
### Document Event Factory Functions ###
def createEvent(self,eventType):
import Event
if eventType in Event.supportedEvents:
#Only mutation events are supported
return Event.MutationEvent(eventType)
else:
raise NotSupportedErr()
### Document Range Factory Functions ###
def createRange(self):
if not self.implementation.hasFeature('RANGE','2.0'):
raise NotSupportedErr()
import Range
return Range.Range(self)
### Overridden Methods ###
def appendChild(self, newChild):
self._4dom_addSingle(newChild)
return FtNode.appendChild(self, newChild)
def insertBefore(self, newChild, oldChild):
self._4dom_addSingle(newChild)
return FtNode.insertBefore(self, newChild, oldChild)
def replaceChild(self, newChild, oldChild):
if newChild.nodeType != Node.DOCUMENT_FRAGMENT_NODE:
root = self.__dict__['__documentElement']
if root in [oldChild, newChild]:
self.__dict__['__documentElement'] = None
else:
raise HierarchyRequestErr()
replaced = FtNode.replaceChild(self, newChild, oldChild)
if newChild.nodeType == Node.ELEMENT_NODE:
self.__dict__['__documentElement'] = newChild
if self.__dict__['__doctype']:
self.__dict__['__doctype']._4dom_setName(newChild.nodeName)
return replaced
def removeChild(self,oldChild):
node = FtNode.removeChild(self, oldChild)
if self.documentElement == node:
self.__dict__['__documentElement'] = None
if self.__dict__['__doctype'] == node:
self.__dict__['__doctype'] = None
return node
def cloneNode(self, deep):
doc = self.__class__(None)
if deep:
for child in self.childNodes:
clone = child.cloneNode(deep, newOwner=doc)
if child.nodeType == Node.DOCUMENT_TYPE_NODE:
doc._4dom_setDocumentType(clone)
else:
doc.appendChild(clone)
return doc
def __repr__(self):
return "<%s Document at %x>" % (
(self.isXml() and 'XML' or 'HTML'),
id(self)
)
### Internal Methods ###
def _4dom_createEntity(self, publicId, systemId, notationName):
from Entity import Entity
return Entity(self, publicId, systemId, notationName)
def _4dom_createNotation(self, publicId, systemId, name):
from Notation import Notation
return Notation(self, publicId, systemId, name)
def _4dom_setDocumentType(self, doctype):
if not self.__dict__['__doctype'] and doctype is not None:
self.__dict__['__doctype'] = doctype
doctype._4dom_setOwnerDocument(self)
return FtNode.appendChild(self, doctype)
def _4dom_addSingle(self, node):
'''Make sure only one Element node is added to a Document'''
if node.nodeType == Node.ELEMENT_NODE:
self._4dom_validateNode(node)
if node.parentNode != None:
node.parentNode.removeChild(node)
if self.__dict__['__documentElement']:
raise HierarchyRequestErr()
self.__dict__['__documentElement'] = node
if self.__dict__['__doctype']:
self.__dict__['__doctype']._4dom_setName(node.nodeName)
### Helper Functions for Pickling ###
def __getinitargs__(self):
return (None,)
def __getstate__(self):
return (self.childNodes, self.doctype, self.documentElement)
def __setstate__(self, (children, doctype, root)):
FtNode.__setstate__(self, children)
self.__dict__['__doctype'] = doctype
self.__dict__['__documentElement'] = root
return
### Convenience Functions ###
def isXml(self):
return 1
def isHtml(self):
return 0
### Attribute Access Mappings ###
_readComputedAttrs = FtNode._readComputedAttrs.copy()
_readComputedAttrs.update({'doctype':_get_doctype,
'implementation':_get_implementation,
'documentElement':_get_documentElement,
'ownerDocument':_get_ownerDocument,
})
_writeComputedAttrs = FtNode._writeComputedAttrs.copy()
# Create the read-only list of attributes
_readOnlyAttrs = filter(lambda k,m=_writeComputedAttrs: not m.has_key(k),
FtNode._readOnlyAttrs + _readComputedAttrs.keys())
|