Viewing file:  HtmlWriter.py (7.84 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
########################################################################
#
# File Name: HtmlWriter.py
#
#
"""
Implements the HTML output writer for XSLT processor output
WWW: http://4suite.com/4XSLT e-mail: support@4suite.com
Copyright (c) 1999-2000 Fourthought Inc., USA. All Rights Reserved.
See http://4suite.com/COPYRIGHT for license and copyright information
"""
import string
from xml.dom import EMPTY_NAMESPACE
from xml.dom.ext.Printer import TranslateCdata, TranslateCdataAttr
from xml.dom.html import TranslateHtmlCdata
from xml.xslt import NullWriter, XsltException, Error
INDENT = ' '*2
INLINE_ELEMENT = 0
FORBIDDEN_END = 1
PCDATA_ELEMENT = 2
CDATA_CONTENT = 3
HEAD_ELEMENT = 4
NO_STRIP = 5
g_elementTable = {}
g_attributeTable = {}
g_defaultInfo = (0, 0, 0, 0, 0, 0)
def InitTables():
from xml.dom.html import HTML_4_STRICT_INLINE
from xml.dom.html import HTML_FORBIDDEN_END
from xml.dom.html import HTML_BOOLEAN_ATTRS
table = {}
for tagname in HTML_4_STRICT_INLINE:
info = list(g_defaultInfo)
info[INLINE_ELEMENT] = 1
table[tagname] = info
for tagname in HTML_FORBIDDEN_END:
info = table.get(tagname, list(g_defaultInfo))
info[FORBIDDEN_END] = 1
table[tagname] = info
# PCDATA containing elements
for tagname in ['APPLET', 'IMG', 'OBJECT']:
info = table.get(tagname, list(g_defaultInfo))
info[PCDATA_ELEMENT] = 1
table[tagname] = info
# CDATA containing elements
for tagname in ['SCRIPT', 'STYLE']:
info = table.get(tagname, list(g_defaultInfo))
info[CDATA_CONTENT] = 1
table[tagname] = info
# Elements to not strip whitespace from
for tagname in ['SCRIPT', 'STYLE', 'PRE', 'TEXTAREA']:
info = table.get(tagname, list(g_defaultInfo))
info[NO_STRIP] = 1
table[tagname] = info
tagname = 'HEAD'
info = table.get(tagname, list(g_defaultInfo))
info[HEAD_ELEMENT] = 1
table[tagname] = info
for (tagname, value) in table.items():
g_elementTable[string.upper(tagname)] = tuple(value)
for name in HTML_BOOLEAN_ATTRS:
g_attributeTable[string.upper(name)] = 1
InitTables()
class HtmlWriter(NullWriter.NullWriter):
def __init__(self, outputParams, stream=None, restrictElements=None):
NullWriter.NullWriter.__init__(self, outputParams, stream)
# Defaults
self._outputParams.indent = outputParams.indent in [None, 'yes']
self._outputParams.encoding = outputParams.encoding or 'iso-8859-1'
self._outputParams.mediaType = outputParams.mediaType or 'text/html'
# Process flags
self._indentLevel = 0
self._inUnescapedElement = 0
self._inNoStrip = 0
self._isInline = [0]
self._inPCdata = 1
self._inElement = 0
self._inHead = 0
self._first_element = 1
self._elementRestrictions = restrictElements
return
def _tryNewLine(self):
if not self._inPCdata:
self._stream.write('\n')
self._stream.write(INDENT*self._indentLevel)
return
def _doctype(self, docElem):
external_id = ''
if self._outputParams.doctypePublic:
external_id = ' PUBLIC "' + self._outputParams.doctypePublic + '"'
if self._outputParams.doctypeSystem:
external_id = external_id + ' "' + self._outputParams.doctypeSystem + '"'
elif self._outputParams.doctypeSystem:
external_id = external_id + ' SYSTEM "' + self._outputParams.doctypeSystem + '"'
if external_id:
self._stream.write('<!DOCTYPE %s%s>\n' % (docElem, external_id))
self._first_element = 0
return
def _closeElement(self):
if self._inElement:
self._stream.write('>')
self._inElement = 0
if self._inHead and self._outputParams.encoding:
self._inHead = 0
self.startElement('meta')
self.attribute('http-equiv', 'Content-Type')
self.attribute('content', '%s; charset=%s' % (self.getMediaType(),
self._outputParams.encoding))
self.endElement('meta')
return
def endDocument(self):
self._closeElement()
self._stream.flush()
return
def text(self, text, escapeOutput=1):
if (self._outputParams.indent and
not self._inPCdata and
not self._inNoStrip):
text = string.strip(text) and text or ''
if text:
self._closeElement()
if not self._inUnescapedElement and escapeOutput:
if text and text[0] == '>':
self._stream.seek(-2, 2)
last_chars = self._stream.read()
else:
last_chars = ''
text = TranslateHtmlCdata(
text,
self._outputParams.encoding,
last_chars
)
self._stream.write(text)
self._inPCdata = 1
return
def attribute(self, name, value, namespace=EMPTY_NAMESPACE):
self._stream.write(' %s' % name)
# Output boolean attributes in minimized form
name = string.upper(name)
if not (g_attributeTable.get(name) and name == string.upper(value)):
value = TranslateCdata(value, self._outputParams.encoding)
value, delimiter = TranslateCdataAttr(value)
self._stream.write('=%s%s%s' % (delimiter, value, delimiter))
return
def processingInstruction(self, target, data):
self._closeElement()
self._outputParams.indent and self._tryNewLine()
target = TranslateCdata(target, self._outputParams.encoding, '')
data = TranslateCdata(data, self._outputParams.encoding, '')
self._stream.write('<?%s %s>' % (target, data))
return
def comment(self, body):
self._closeElement()
body = TranslateCdata(body, self._outputParams.encoding, '')
self._outputParams.indent and self._tryNewLine()
self._stream.write('<!--%s-->' % body)
return
def startElement(self, name, namespace=EMPTY_NAMESPACE, extraNss=None):
if self._elementRestrictions is not None:
if name not in self._elementRestrictions:
raise XsltException(Error.RESTRICTED_OUTPUT_VIOLATION, name)
# Close previous element, if any
self._closeElement()
self._inElement = 1
info = g_elementTable.get(string.upper(name), g_defaultInfo)
if self._outputParams.indent:
if not self._isInline[-1] and not self._first_element:
self._tryNewLine()
self._indentLevel = self._indentLevel + 1
if self._first_element:
self._doctype(name)
self._stream.write('<' + name)
self._inPCdata = 0
self._isInline.append(info[INLINE_ELEMENT])
self._inUnescapedElement = info[CDATA_CONTENT]
self._inHead = info[HEAD_ELEMENT]
self._inNoStrip = info[NO_STRIP]
return
def endElement(self, name):
# Close previous element, if any
empty = self._inElement
self._closeElement()
info = g_elementTable.get(string.upper(name), g_defaultInfo)
indent = self._outputParams.indent
if indent:
self._indentLevel = self._indentLevel - 1
if not info[FORBIDDEN_END]:
if (indent and not empty and not self._inPCdata
and (not self._isInline[-1] or not info[INLINE_ELEMENT])):
self._tryNewLine()
self._isInline.pop()
self._stream.write('</%s>' % name)
self._inPCdata = info[PCDATA_ELEMENT]
self._inUnescapedElement = 0
return
|