HTMLWriter (dom4j 2.1.1 API)

java.lang.Object
- org.xml.sax.helpers.XMLFilterImpl
- - org.dom4j.io.XMLWriter
  - - org.dom4j.io.HTMLWriter

```
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 OutputFormatfor details. Here are the rules for this class based on an OutputFormat, "format", passed in to the constructor:
- If an element is in getOmitElementCloseSet, then it is treated specially:
  - It never expands, since some browsers treat this as two separate Horizontal Rules: <HR></HR>
  - If 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/".
- If format.isXHTML(), all elements must have either a close element, or be a closed single tag.
- If format.isExpandEmptyElements()() is true, all elements are expanded except as above.
Examples If isXHTML == true, CDATA sections look like this:
```
 <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();
 }
 
```

Field Summary

Fields
Modifier and Type Field Description

protected static OutputFormat DEFAULT_HTML_FORMAT

protected static java.util.HashSet<java.lang.String> DEFAULT_PREFORMATTED_TAGS
- Fields inherited from class org.dom4j.io.XMLWriter
  DEFAULT_FORMAT, lastOutputNodeType, LEXICAL_HANDLER_NAMES, preserve, writer

Fields
Modifier and Type	Field	Description
`protected static OutputFormat`	`DEFAULT_HTML_FORMAT`
`protected static java.util.HashSet<java.lang.String>`	`DEFAULT_PREFORMATTED_TAGS`

Constructor Summary

Constructors
Constructor	Description
`HTMLWriter()`
`HTMLWriter(java.io.OutputStream out)`
`HTMLWriter(java.io.OutputStream out, OutputFormat format)`
`HTMLWriter(java.io.Writer writer)`
`HTMLWriter(java.io.Writer writer, OutputFormat format)`
`HTMLWriter(OutputFormat format)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`endCDATA()`
`java.util.Set<java.lang.String>`	`getOmitElementCloseSet()`	A clone of the Set of elements that can have their close-tags omitted.
`java.util.Set<java.lang.String>`	`getPreformattedTags()`
`boolean`	`isPreformattedTag(java.lang.String qualifiedName)`	DOCUMENT ME!
`protected void`	`loadOmitElementCloseSet(java.util.Set<java.lang.String> set)`
`protected boolean`	`omitElementClose(java.lang.String qualifiedName)`
`static java.lang.String`	`prettyPrintHTML(java.lang.String html)`	Convenience method to just get a String result.
`static java.lang.String`	`prettyPrintHTML(java.lang.String html, boolean newlines, boolean trim, boolean isXHTML, boolean expandEmpty)`	DOCUMENT ME!
`static java.lang.String`	`prettyPrintXHTML(java.lang.String html)`	Convenience method to just get a String result, but As XHTML .
`void`	`setOmitElementCloseSet(java.util.Set<java.lang.String> newSet)`	To use the empty set, pass an empty Set, or null:
`void`	`setPreformattedTags(java.util.Set<java.lang.String> newSet)`	Override the default set, which includes PRE, SCRIPT, STYLE, and TEXTAREA, case insensitively.
`void`	`startCDATA()`
`protected void`	`writeCDATA(java.lang.String text)`
`protected void`	`writeClose(java.lang.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(java.lang.String qualifiedName)`
`protected void`	`writeEntity(Entity entity)`
`protected void`	`writeString(java.lang.String text)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from class org.xml.sax.helpers.XMLFilterImpl
error, fatalError, getContentHandler, getDTDHandler, getEntityResolver, getErrorHandler, getFeature, getParent, parse, resolveEntity, setContentHandler, setDTDHandler, setEntityResolver, setErrorHandler, setFeature, setParent, skippedEntity, warning

Methods inherited from class org.dom4j.io.XMLWriter
close, comment, createWriter, defaultMaximumAllowedCharacter, endDocument, endDTD, endElement, endEntity, endPrefixMapping, escapeAttributeEntities, escapeElementEntities, flush, getLexicalHandler, getMaximumAllowedCharacter, getOutputFormat, getProperty, handleException, characters, 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, writeNamespaces, writeNode, writeNodeText, writeOpen, writePrintln, writeProcessingInstruction

- Field Detail
  - DEFAULT_PREFORMATTED_TAGS
```
protected static final java.util.HashSet<java.lang.String> DEFAULT_PREFORMATTED_TAGS
```
  - DEFAULT_HTML_FORMAT
```
protected static final OutputFormat DEFAULT_HTML_FORMAT
```
- Constructor Detail
  - HTMLWriter
```
public HTMLWriter(java.io.Writer writer)
```
  - HTMLWriter
```
public HTMLWriter(java.io.Writer writer,
                  OutputFormat format)
```
  - HTMLWriter
```
public HTMLWriter()
           throws java.io.UnsupportedEncodingException
```
    Throws:
    
    java.io.UnsupportedEncodingException
  - HTMLWriter
```
public HTMLWriter(OutputFormat format)
           throws java.io.UnsupportedEncodingException
```
    Throws:
    
    java.io.UnsupportedEncodingException
  - HTMLWriter
```
public HTMLWriter(java.io.OutputStream out)
           throws java.io.UnsupportedEncodingException
```
    Throws:
    
    java.io.UnsupportedEncodingException
  - HTMLWriter
```
public HTMLWriter(java.io.OutputStream out,
                  OutputFormat format)
           throws java.io.UnsupportedEncodingException
```
    Throws:
    
    java.io.UnsupportedEncodingException
- Method Detail
  - startCDATA
```
public void startCDATA()
                throws org.xml.sax.SAXException
```
    Overrides:
    
    startCDATA in class XMLWriter
    
    Throws:
    
    org.xml.sax.SAXException
  - endCDATA
```
public void endCDATA()
              throws org.xml.sax.SAXException
```
    Overrides:
    
    endCDATA in class XMLWriter
    
    Throws:
    
    org.xml.sax.SAXException
  - writeCDATA
```
protected void writeCDATA(java.lang.String text)
                   throws java.io.IOException
```
    Overrides:
    
    writeCDATA in class XMLWriter
    
    Throws:
    
    java.io.IOException
  - writeEntity
```
protected void writeEntity(Entity entity)
                    throws java.io.IOException
```
    Overrides:
    
    writeEntity in class XMLWriter
    
    Throws:
    
    java.io.IOException
  - writeDeclaration
```
protected void writeDeclaration()
                         throws java.io.IOException
```
    Description copied from class: XMLWriter
    
    This will write the declaration to the given Writer. Assumes XML version 1.0 since we don't directly know.
    
    Overrides:
    
    writeDeclaration in class XMLWriter
    
    Throws:
    
    java.io.IOException - DOCUMENT ME!
  - writeString
```
protected void writeString(java.lang.String text)
                    throws java.io.IOException
```
    Overrides:
    
    writeString in class XMLWriter
    
    Throws:
    
    java.io.IOException
  - writeClose
```
protected void writeClose(java.lang.String qualifiedName)
                   throws java.io.IOException
```
    Overriden method to not close certain element names to avoid wierd behaviour from browsers for versions up to 5.x
    
    Overrides:
    
    writeClose in class XMLWriter
    
    Parameters:
    
    qualifiedName - DOCUMENT ME!
    
    Throws:
    
    java.io.IOException - DOCUMENT ME!
  - writeEmptyElementClose
```
protected void writeEmptyElementClose(java.lang.String qualifiedName)
                               throws java.io.IOException
```
    Overrides:
    
    writeEmptyElementClose in class XMLWriter
    
    Throws:
    
    java.io.IOException
  - omitElementClose
```
protected boolean omitElementClose(java.lang.String qualifiedName)
```
  - loadOmitElementCloseSet
```
protected void loadOmitElementCloseSet(java.util.Set<java.lang.String> set)
```
  - getOmitElementCloseSet
```
public java.util.Set<java.lang.String> getOmitElementCloseSet()
```
    A clone of the Set of elements that can have their close-tags omitted. By default it should be "AREA", "BASE", "BR", "COL", "HR", "IMG", "INPUT", "LINK", "META", "P", "PARAM"
    
    Returns:
    
    A clone of the Set.
  - setOmitElementCloseSet
```
public void setOmitElementCloseSet(java.util.Set<java.lang.String> newSet)
```
    To use the empty set, pass an empty Set, or null:
```
 
 
       setOmitElementCloseSet(new HashSet());
     or
       setOmitElementCloseSet(null);
 
  
 
```
    Parameters:
    
    newSet - DOCUMENT ME!
  - getPreformattedTags
```
public java.util.Set<java.lang.String> getPreformattedTags()
```
    Returns:
    
    DOCUMENT ME!
    
    See Also:
    
    setPreformattedTags
  - setPreformattedTags
```
public void setPreformattedTags(java.util.Set<java.lang.String> newSet)
```
    Override the default set, which includes PRE, SCRIPT, STYLE, and TEXTAREA, case insensitively. Setting Preformatted Tags Pass in a Set of Strings, one for each tag name that should be treated like a PRE tag. You may pass in null or an empty Set to assign the empty set, in which case no tags will be treated as preformatted, except that HTML Comments will continue to be preformatted. If a tag is included in the set of preformatted tags, all whitespace within the tag will be preserved, including whitespace on the same line preceding the close tag. This will generally make the close tag not line up with the start tag, but it preserves the intention of the whitespace within the tag. The browser considers leading whitespace before the close tag to be significant, but leading whitespace before the open tag to be insignificant. For example, if the HTML author doesn't put the close TEXTAREA tag flush to the left margin, then the TEXTAREA control in the browser will have spaces on the last line inside the control. This may be the HTML author's intent. Similarly, in a PRE, the browser treats a flushed left close PRE tag as different from a close tag with leading whitespace. Again, this must be left up to the HTML author. Examples Here is an example of how you can set the PreformattedTags list using setPreformattedTags to include IFRAME, as well as the default set, if you have an instance of this class named myHTMLWriter:
```
 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>
 
  
 
```
    Parameters:
    
    newSet - DOCUMENT ME!
  - isPreformattedTag
```
public boolean isPreformattedTag(java.lang.String qualifiedName)
```
    DOCUMENT ME!
    
    Parameters:
    
    qualifiedName - DOCUMENT ME!
    
    Returns:
    
    true if the qualifiedName passed in matched (case-insensitively) a tag in the preformattedTags set, or false if not found or if the set is empty or null.
    
    See Also:
    
    setPreformattedTags
  - writeElement
```
protected void writeElement(Element element)
                     throws java.io.IOException
```
    This override handles any elements that should not remove whitespace, such as <PRE>, <SCRIPT>, <STYLE>, and <TEXTAREA>. Note: the close tags won't line up with the open tag, but we can't alter that. See javadoc note at setPreformattedTags.
    
    Overrides:
    
    writeElement in class XMLWriter
    
    Parameters:
    
    element - DOCUMENT ME!
    
    Throws:
    
    java.io.IOException - When the stream could not be written to.
    
    See Also:
    
    setPreformattedTags
  - prettyPrintHTML
```
public static java.lang.String prettyPrintHTML(java.lang.String html)
                                        throws java.io.IOException,
                                               java.io.UnsupportedEncodingException,
                                               DocumentException
```
    Convenience method to just get a String result.
    
    Parameters:
    
    html - DOCUMENT ME!
    
    Returns:
    
    a pretty printed String from the source string, preserving whitespace in the defaultPreformattedTags set, and leaving the close tags off of the default omitElementCloseSet set. Use one of the write methods if you want stream output.
    
    Throws:
    
    java.io.IOException - DOCUMENT ME!
    
    java.io.UnsupportedEncodingException - DOCUMENT ME!
    
    DocumentException - DOCUMENT ME!
  - prettyPrintXHTML
```
public static java.lang.String prettyPrintXHTML(java.lang.String html)
                                         throws java.io.IOException,
                                                java.io.UnsupportedEncodingException,
                                                DocumentException
```
    Convenience method to just get a String result, but As XHTML .
    
    Parameters:
    
    html - DOCUMENT ME!
    
    Returns:
    
    a pretty printed String from the source string, preserving whitespace in the defaultPreformattedTags set, but conforming to XHTML: no close tags are omitted (though if empty, they will be converted to XHTML empty tags: <HR/> Use one of the write methods if you want stream output.
    
    Throws:
    
    java.io.IOException - DOCUMENT ME!
    
    java.io.UnsupportedEncodingException - DOCUMENT ME!
    
    DocumentException - DOCUMENT ME!
  - prettyPrintHTML
```
public static java.lang.String prettyPrintHTML(java.lang.String html,
                                               boolean newlines,
                                               boolean trim,
                                               boolean isXHTML,
                                               boolean expandEmpty)
                                        throws java.io.IOException,
                                               java.io.UnsupportedEncodingException,
                                               DocumentException
```
    DOCUMENT ME!
    
    Parameters:
    
    html - DOCUMENT ME!
    
    newlines - DOCUMENT ME!
    
    trim - DOCUMENT ME!
    
    isXHTML - DOCUMENT ME!
    
    expandEmpty - DOCUMENT ME!
    
    Returns:
    
    a pretty printed String from the source string, preserving whitespace in the defaultPreformattedTags set, and leaving the close tags off of the default omitElementCloseSet set. This override allows you to specify various formatter options. Use one of the write methods if you want stream output.
    
    Throws:
    
    java.io.IOException - DOCUMENT ME!
    
    java.io.UnsupportedEncodingException - DOCUMENT ME!
    
    DocumentException - DOCUMENT ME!

Class HTMLWriter

Field Summary

Fields inherited from class org.dom4j.io.XMLWriter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from class org.xml.sax.helpers.XMLFilterImpl

Methods inherited from class org.dom4j.io.XMLWriter

Field Detail

DEFAULT_PREFORMATTED_TAGS

DEFAULT_HTML_FORMAT

Constructor Detail

HTMLWriter

HTMLWriter

HTMLWriter

HTMLWriter

HTMLWriter

HTMLWriter

Method Detail

startCDATA

endCDATA

writeCDATA

writeEntity

writeDeclaration

writeString

writeClose

writeEmptyElementClose

omitElementClose

loadOmitElementCloseSet

getOmitElementCloseSet

setOmitElementCloseSet

getPreformattedTags

setPreformattedTags

isPreformattedTag

writeElement

prettyPrintHTML

prettyPrintXHTML

prettyPrintHTML