public class HTMLWriter extends XMLWriter
HTMLWriter
takes a DOM4J tree and formats it to a stream as
HTML. This formatter is similar to XMLWriter but it outputs the text of CDATA
and Entity sections rather than the serialised format as in XML, it has an
XHTML mode, it retains whitespace in certain elements such as <PRE>,
and it supports certain elements which have no corresponding close tag such
as for <BR> and <P>.
The OutputFormat passed in to the constructor is checked for isXHTML() and
isExpandEmptyElements(). See OutputFormat
for details.
Here are the rules for this class based on an OutputFormat, "format",
passed in to the constructor:
getOmitElementCloseSet
, then it is treated specially:
format.isXHTML()
, then
it has a space before the closing single-tag slash, since Netscape 4.x-
treats this: <HR /> as an element named "HR" with an attribute named
"/", but that's better than when it refuses to recognize this: <hr/>
which it thinks is an element named "HR/".format.isXHTML()
, all
elements must have either a close element, or be a closed single tag.format.isExpandEmptyElements()
() is true, all elements are expanded except
as above.<myelement><![CDATA[My data]]></myelement>Otherwise, they look like this:
<myelement>My data</myelement>Basically,
OutputFormat.isXHTML()
==
true
will produce valid XML, while OutputFormat.isExpandEmptyElements()
determines whether empty elements are
expanded if isXHTML is true, excepting the special HTML single tags.
Also, HTMLWriter handles tags whose contents should be preformatted, that is,
whitespace-preserved. By default, this set includes the tags <PRE>,
<SCRIPT>, <STYLE>, and <TEXTAREA>, case insensitively. It
does not include <IFRAME>. Other tags, such as <CODE>,
<KBD>, <TT>, <VAR>, are usually rendered in a different
font in most browsers, but don't preserve whitespace, so they also don't
appear in the default list. HTML Comments are always whitespace-preserved.
However, the parser you use may store comments with linefeed-only text nodes
(\n) even if your platform uses another line.separator character, and
HTMLWriter outputs Comment nodes exactly as the DOM is set up by the parser.
See examples and discussion here: setPreformattedTags(java.util.Set)
Examples
Pretty Printing
This example shows how to pretty print a string containing a valid HTML
document to a string. You can also just call the static methods of this
class: prettyPrintHTML(String)
or prettyPrintHTML(String,boolean,boolean,boolean,boolean)
or prettyPrintXHTML(String)
for XHTML (note the X)
String testPrettyPrint(String html) { StringWriter sw = new StringWriter(); OutputFormat format = OutputFormat.createPrettyPrint(); // These are the default values for createPrettyPrint, // so you needn't set them: // format.setNewlines(true); // format.setTrimText(true);</font> format.setXHTML(true); HTMLWriter writer = new HTMLWriter(sw, format); Document document = DocumentHelper.parseText(html); writer.write(document); writer.flush(); return sw.toString(); }This example shows how to create a "squeezed" document, but one that will work in browsers even if the browser line length is limited. No newlines are included, no extra whitespace at all, except where it it required by
setPreformattedTags
.
String testCrunch(String html) { StringWriter sw = new StringWriter(); OutputFormat format = OutputFormat.createPrettyPrint(); format.setNewlines(false); format.setTrimText(true); format.setIndent(""); format.setXHTML(true); format.setExpandEmptyElements(false); format.setNewLineAfterNTags(20); org.dom4j.io.HTMLWriter writer = new HTMLWriter(sw, format); org.dom4j.Document document = DocumentHelper.parseText(html); writer.write(document); writer.flush(); return sw.toString(); }
Modifier and Type | Field and Description |
---|---|
protected static OutputFormat |
DEFAULT_HTML_FORMAT |
protected static HashSet<String> |
DEFAULT_PREFORMATTED_TAGS |
DEFAULT_FORMAT, lastOutputNodeType, LEXICAL_HANDLER_NAMES, preserve, writer
Constructor and Description |
---|
HTMLWriter() |
HTMLWriter(OutputFormat format) |
HTMLWriter(OutputStream out) |
HTMLWriter(OutputStream out,
OutputFormat format) |
HTMLWriter(Writer writer) |
HTMLWriter(Writer writer,
OutputFormat format) |
Modifier and Type | Method and Description |
---|---|
void |
endCDATA() |
Set<String> |
getOmitElementCloseSet()
A clone of the Set of elements that can have their close-tags omitted.
|
Set<String> |
getPreformattedTags() |
boolean |
isPreformattedTag(String qualifiedName)
DOCUMENT ME!
|
protected void |
loadOmitElementCloseSet(Set<String> set) |
protected boolean |
omitElementClose(String qualifiedName) |
static String |
prettyPrintHTML(String html)
Convenience method to just get a String result.
|
static String |
prettyPrintHTML(String html,
boolean newlines,
boolean trim,
boolean isXHTML,
boolean expandEmpty)
DOCUMENT ME!
|
static String |
prettyPrintXHTML(String html)
Convenience method to just get a String result, but As XHTML .
|
void |
setOmitElementCloseSet(Set<String> newSet)
To use the empty set, pass an empty Set, or null:
|
void |
setPreformattedTags(Set<String> newSet)
Override the default set, which includes PRE, SCRIPT, STYLE, and
TEXTAREA, case insensitively.
|
void |
startCDATA() |
protected void |
writeCDATA(String text) |
protected void |
writeClose(String qualifiedName)
Overriden method to not close certain element names to avoid wierd
behaviour from browsers for versions up to 5.x
|
protected void |
writeDeclaration()
This will write the declaration to the given Writer.
|
protected void |
writeElement(Element element)
This override handles any elements that should not remove whitespace,
such as <PRE>, <SCRIPT>, <STYLE>, and <TEXTAREA>.
|
protected void |
writeEmptyElementClose(String qualifiedName) |
protected void |
writeEntity(Entity entity) |
protected void |
writeString(String text) |
characters, close, comment, createWriter, defaultMaximumAllowedCharacter, endDocument, endDTD, endElement, endEntity, endPrefixMapping, escapeAttributeEntities, escapeElementEntities, flush, getLexicalHandler, getMaximumAllowedCharacter, getOutputFormat, getProperty, handleException, ignorableWhitespace, indent, installLexicalHandler, isElementSpacePreserved, isEscapeText, isExpandEmptyElements, isNamespaceDeclaration, notationDecl, parse, println, processingInstruction, resolveEntityRefs, setDocumentLocator, setEscapeText, setIndentLevel, setLexicalHandler, setMaximumAllowedCharacter, setOutputStream, setProperty, setResolveEntityRefs, setWriter, shouldEncodeChar, startDocument, startDTD, startElement, startEntity, startPrefixMapping, unparsedEntityDecl, write, write, write, write, write, write, write, write, write, write, write, write, write, writeAttribute, writeAttribute, writeAttributes, writeAttributes, writeClose, writeComment, writeDocType, writeDocType, writeElementContent, writeEntityRef, writeEscapeAttributeEntities, writeNamespace, writeNamespace, writeNamespaces, writeNode, writeNodeText, writeOpen, writePrintln, writeProcessingInstruction
error, fatalError, getContentHandler, getDTDHandler, getEntityResolver, getErrorHandler, getFeature, getParent, parse, resolveEntity, setContentHandler, setDTDHandler, setEntityResolver, setErrorHandler, setFeature, setParent, skippedEntity, warning
protected static final OutputFormat DEFAULT_HTML_FORMAT
public HTMLWriter(Writer writer)
public HTMLWriter(Writer writer, OutputFormat format)
public HTMLWriter() throws UnsupportedEncodingException
UnsupportedEncodingException
public HTMLWriter(OutputFormat format) throws UnsupportedEncodingException
UnsupportedEncodingException
public HTMLWriter(OutputStream out) throws UnsupportedEncodingException
UnsupportedEncodingException
public HTMLWriter(OutputStream out, OutputFormat format) throws UnsupportedEncodingException
UnsupportedEncodingException
public void startCDATA() throws SAXException
startCDATA
in interface LexicalHandler
startCDATA
in class XMLWriter
SAXException
public void endCDATA() throws SAXException
endCDATA
in interface LexicalHandler
endCDATA
in class XMLWriter
SAXException
protected void writeCDATA(String text) throws IOException
writeCDATA
in class XMLWriter
IOException
protected void writeEntity(Entity entity) throws IOException
writeEntity
in class XMLWriter
IOException
protected void writeDeclaration() throws IOException
XMLWriter
This will write the declaration to the given Writer. Assumes XML version 1.0 since we don't directly know.
writeDeclaration
in class XMLWriter
IOException
- DOCUMENT ME!protected void writeString(String text) throws IOException
writeString
in class XMLWriter
IOException
protected void writeClose(String qualifiedName) throws IOException
writeClose
in class XMLWriter
qualifiedName
- DOCUMENT ME!IOException
- DOCUMENT ME!protected void writeEmptyElementClose(String qualifiedName) throws IOException
writeEmptyElementClose
in class XMLWriter
IOException
protected boolean omitElementClose(String qualifiedName)
public Set<String> getOmitElementCloseSet()
public void setOmitElementCloseSet(Set<String> newSet)
setOmitElementCloseSet(new HashSet()); or setOmitElementCloseSet(null);
newSet
- DOCUMENT ME!public Set<String> getPreformattedTags()
setPreformattedTags
public void setPreformattedTags(Set<String> newSet)
Set current = myHTMLWriter.getPreformattedTags(); current.add("IFRAME"); myHTMLWriter.setPreformattedTags(current); //The set is now <b>PRE, SCRIPT, STYLE, TEXTAREA, IFRAME</b>Similarly, you can simply replace it with your own:
HashSet newset = new HashSet(); newset.add("PRE"); newset.add("TEXTAREA"); myHTMLWriter.setPreformattedTags(newset); //The set is now <b>{PRE, TEXTAREA}</b>You can remove all tags from the preformatted tags list, with an empty set, like this:
myHTMLWriter.setPreformattedTags(new HashSet()); //The set is now <b>{}</b>or with null, like this:
myHTMLWriter.setPreformattedTags(null); //The set is now <b>{}</b>
newSet
- DOCUMENT ME!public boolean isPreformattedTag(String qualifiedName)
qualifiedName
- DOCUMENT ME!setPreformattedTags
protected void writeElement(Element element) throws IOException
writeElement
in class XMLWriter
element
- DOCUMENT ME!IOException
- When the stream could not be written to.setPreformattedTags
public static String prettyPrintHTML(String html) throws IOException, UnsupportedEncodingException, DocumentException
html
- DOCUMENT ME!IOException
- DOCUMENT ME!UnsupportedEncodingException
- DOCUMENT ME!DocumentException
- DOCUMENT ME!public static String prettyPrintXHTML(String html) throws IOException, UnsupportedEncodingException, DocumentException
html
- DOCUMENT ME!IOException
- DOCUMENT ME!UnsupportedEncodingException
- DOCUMENT ME!DocumentException
- DOCUMENT ME!public static String prettyPrintHTML(String html, boolean newlines, boolean trim, boolean isXHTML, boolean expandEmpty) throws IOException, UnsupportedEncodingException, DocumentException
html
- DOCUMENT ME!newlines
- DOCUMENT ME!trim
- DOCUMENT ME!isXHTML
- DOCUMENT ME!expandEmpty
- DOCUMENT ME!IOException
- DOCUMENT ME!UnsupportedEncodingException
- DOCUMENT ME!DocumentException
- DOCUMENT ME!Copyright © 2019. All rights reserved.