1. /*

  2.  * @(#)MinimalHTMLWriter.java	1.11 00/02/02

  3.  *

  4.  * Copyright 1998-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package javax.swing.text.html;

  12. 

  13. import java.io.Writer;

  14. import java.io.IOException;

  15. import java.util.*;

  16. import java.awt.Color;

  17. import javax.swing.text.*;

  18. 

  19. /**

  20.  * MinimalHTMLWriter is a fallback writer used by the

  21.  * HTMLEditorKit to write out HTML for a document that

  22.  * is a not produced by the EditorKit.

  23.  *

  24.  * The format for the document is:

  25.  * <pre>

  26.  * <html>

  27.  *   <head>

  28.  *     <style>

  29.  *        <!-- list of named styles

  30.  *         p.normal {

  31.  *            font-family: SansSerif;

  32.  *	      margin-height: 0;

  33.  *	      font-size: 14

  34.  *	   }

  35.  *        -->

  36.  *      </style>

  37.  *   </head>

  38.  *   <body>

  39.  *    <p style=normal>

  40.  *        <b>Bold, italic, and underline attributes

  41.  *        of the run are emitted as HTML tags.

  42.  *        The remaining attributes are emitted as

  43.  *        part of the style attribute of a <span> tag.

  44.  *        The syntax is similar to inline styles.</b>

  45.  *    </p>

  46.  *   </body>

  47.  * </html>

  48.  * </pre>

  49.  *

  50.  * @author Sunita Mani

  51.  * @version 1.11, 02/02/00

  52.  */

  53. 

  54. public class MinimalHTMLWriter extends AbstractWriter {

  55. 

  56.     /**

  57.      * These static finals are used to

  58.      * tweak and query the fontMask about which

  59.      * of these tags need to be generated or

  60.      * terminated.

  61.      */

  62.     private static final int BOLD = 0x01;

  63.     private static final int ITALIC = 0x02;

  64.     private static final int UNDERLINE = 0x04;

  65. 

  66.     // Used to map StyleConstants to CSS.

  67.     private static final CSS css = new CSS();

  68. 

  69.     private int fontMask = 0;

  70. 

  71.     int startOffset = 0;

  72.     int endOffset = 0;

  73. 

  74.     /**

  75.      * Stores the attributes of the previous run.

  76.      * Used to compare with the current run's

  77.      * attributeset.  If identical, then a

  78.      * <span> tag is not emitted.

  79.      */

  80.     private AttributeSet fontAttributes;

  81. 

  82.     /**

  83.      * Maps from style name as held by the Document, to the archived

  84.      * style name (style name written out). These may differ.

  85.      */

  86.     private Hashtable styleNameMapping;

  87. 

  88.     /**

  89.      * Creates a new MinimalHTMLWriter.

  90.      *

  91.      * @param w  Writer

  92.      * @param doc StyledDocument

  93.      *

  94.      */

  95.     public MinimalHTMLWriter(Writer w, StyledDocument doc) {

  96. 	super(w, doc);

  97.     }

  98. 

  99.     /**

  100.      * Creates a new MinimalHTMLWriter.

  101.      *

  102.      * @param w  Writer

  103.      * @param doc StyledDocument

  104.      * @param pos The location in the document to fetch the

  105.      *   content.

  106.      * @param len The amount to write out.

  107.      *

  108.      */

  109.     public MinimalHTMLWriter(Writer w, StyledDocument doc, int pos, int len) {

  110. 	super(w, doc, pos, len);

  111.     }

  112. 

  113.     /**

  114.      * Generates HTML output

  115.      * from a StyledDocument.

  116.      *

  117.      * @exception IOException on any I/O error

  118.      * @exception BadLocationException if pos represents an invalid

  119.      *            location within the document.

  120.      *

  121.      */

  122.     public void write() throws IOException, BadLocationException {

  123. 	styleNameMapping = new Hashtable();

  124. 	writeStartTag("<html>");

  125. 	writeHeader();

  126. 	writeBody();

  127. 	writeEndTag("</html>");

  128.     }

  129. 

  130. 

  131.     /**

  132.      * Writes out all the attributes for the

  133.      * following types:

  134.      *  StyleConstants.ParagraphConstants,

  135.      *  StyleConstants.CharacterConstants,

  136.      *  StyleConstants.FontConstants,

  137.      *  StyleConstants.ColorConstants.

  138.      * The attribute name and value are separated by a colon.

  139.      * Each pair is separated by a semicolon.

  140.      *

  141.      * @exception IOException on any I/O error

  142.      */

  143.     protected void writeAttributes(AttributeSet attr) throws IOException {

  144. 	Enumeration attributeNames = attr.getAttributeNames();

  145. 	while (attributeNames.hasMoreElements()) {

  146. 	    Object name = attributeNames.nextElement();

  147. 	    if ((name instanceof StyleConstants.ParagraphConstants) ||

  148. 		(name instanceof StyleConstants.CharacterConstants) ||

  149. 		(name instanceof StyleConstants.FontConstants) ||

  150. 		(name instanceof StyleConstants.ColorConstants)) {

  151. 		indent();

  152. 		write(name.toString());

  153. 		write(':');

  154. 		write(css.styleConstantsValueToCSSValue

  155. 		      ((StyleConstants)name, attr.getAttribute(name)).

  156. 		      toString());

  157. 		write(';');

  158. 		write(NEWLINE);

  159. 	    }

  160. 	}

  161.     }

  162. 

  163. 

  164.     /**

  165.      * Writes out text.

  166.      *

  167.      * @exception IOException on any I/O error

  168.      */

  169.     protected void text(Element elem) throws IOException, BadLocationException {

  170. 	String contentStr = getText(elem);

  171. 	if ((contentStr.length() > 0) && 

  172. 	    (contentStr.charAt(contentStr.length()-1) == NEWLINE)) {

  173. 	    contentStr = contentStr.substring(0, contentStr.length()-1);

  174. 	}

  175. 	if (contentStr.length() > 0) {

  176. 	    write(contentStr);

  177. 	}

  178.     }

  179. 

  180.     /**

  181.      * Writes out a start tag appropriately

  182.      * indented.  Also increments the indent level.

  183.      *

  184.      * @exception IOException on any I/O error

  185.      */

  186.     protected void writeStartTag(String tag) throws IOException {

  187. 	indent();

  188. 	write(tag);

  189. 	write(NEWLINE);

  190. 	incrIndent();

  191.     }

  192. 

  193. 

  194.     /**

  195.      * Writes out an end tag appropriately

  196.      * indented.  Also decrements the indent level.

  197.      *

  198.      * @exception IOException on any I/O error

  199.      */

  200.     protected void writeEndTag(String endTag) throws IOException {

  201. 	decrIndent();

  202. 	indent();

  203. 	write(endTag);

  204. 	write(NEWLINE);

  205.     }

  206. 

  207. 

  208.     /**

  209.      * Writes out the <head> and <style>

  210.      * tags, and then invokes writeStyles() to write

  211.      * out all the named styles as the content of the

  212.      * <style> tag.  The content is surrounded by

  213.      * valid HTML comment markers to ensure that the

  214.      * document is viewable in applications/browsers

  215.      * that do not support the tag.

  216.      *

  217.      * @exception IOException on any I/O error

  218.      */

  219.     protected void writeHeader() throws IOException {

  220. 	writeStartTag("<head>");

  221. 	writeStartTag("<style>");

  222. 	writeStartTag("<!--");

  223. 	writeStyles();

  224. 	writeEndTag("-->");

  225. 	writeEndTag("</style>");

  226. 	writeEndTag("</head>");

  227.     }

  228. 

  229. 

  230. 

  231.     /**

  232.      * Writes out all the named styles as the

  233.      * content of the <style> tag.

  234.      *

  235.      * @exception IOException on any I/O error

  236.      */

  237.     protected void writeStyles() throws IOException {

  238. 	/*

  239. 	 *  Access to DefaultStyledDocument done to workaround

  240. 	 *  a missing API in styled document to access the

  241. 	 *  stylenames.

  242. 	 */

  243. 	DefaultStyledDocument styledDoc =  ((DefaultStyledDocument)getDocument());

  244. 	Enumeration styleNames = styledDoc.getStyleNames();

  245. 

  246. 	while (styleNames.hasMoreElements()) {

  247. 	    Style s = styledDoc.getStyle((String)styleNames.nextElement());

  248. 

  249. 	    /** PENDING: Once the name attribute is removed

  250. 		from the list we check check for 0. **/

  251. 	    if (s.getAttributeCount() == 1 &&

  252. 		s.isDefined(StyleConstants.NameAttribute)) {

  253. 		continue;

  254. 	    }

  255. 	    indent();

  256. 	    write("p." + addStyleName(s.getName()));

  257. 	    write(" {\n");

  258. 	    incrIndent();

  259. 	    writeAttributes(s);

  260. 	    decrIndent();

  261. 	    indent();

  262. 	    write("}\n");

  263. 	}

  264.     }

  265. 

  266. 

  267.     /**

  268.      * Iterates over the elements in the document

  269.      * and processes elements based on whether they are

  270.      * branch elements or leaf elements.  This method specially handles

  271.      * leaf elements that are text.

  272.      *

  273.      * @exception IOException on any I/O error

  274.      */

  275.     protected void writeBody() throws IOException, BadLocationException {

  276. 	ElementIterator it = getElementIterator();

  277. 

  278. 	/*

  279. 	  This will be a section element for a styled document.

  280. 	  We represent this element in HTML as the body tags.

  281. 	  Therefore we ignore it.

  282. 	 */

  283. 	it.current();

  284. 

  285. 	Element next = null;

  286. 

  287. 	writeStartTag("<body>");

  288. 

  289. 	boolean inContent = false;

  290. 

  291. 	while((next = it.next()) != null) {

  292. 	    if (!inRange(next)) {

  293. 		continue;

  294. 	    }

  295. 	    if (next instanceof AbstractDocument.BranchElement) {

  296. 		if (inContent) {

  297. 		    writeEndParagraph();

  298. 		    inContent = false;

  299. 		    fontMask = 0;

  300. 		}

  301. 		writeStartParagraph(next);

  302. 	    } else if (isText(next)) {

  303. 		writeContent(next, !inContent);

  304. 		inContent = true;

  305. 	    } else {

  306. 		writeLeaf(next);

  307. 		inContent = true;

  308. 	    }

  309. 	}

  310. 	if (inContent) {

  311. 	    writeEndParagraph();

  312. 	}

  313. 	writeEndTag("</body>");

  314.     }

  315. 

  316. 

  317.     /**

  318.      * Emits an end tag for a <p>

  319.      * tag.  Before writing out the tag, this method ensures

  320.      * that all other tags that have been opened are

  321.      * appropriately closed off.

  322.      *

  323.      * @exception IOException on any I/O error

  324.      */

  325.     protected void writeEndParagraph() throws IOException {

  326. 	writeEndMask(fontMask);

  327. 	if (inFontTag()) {

  328. 	    endSpanTag();

  329. 	} else {

  330. 	    write(NEWLINE);

  331. 	}

  332. 	writeEndTag("</p>");

  333.     }

  334. 

  335. 

  336.     /**

  337.      * Emits the start tag for a paragraph. If

  338.      * the paragraph has a named style associated with it,

  339.      * then this method also generates a class attribute for the

  340.      * <p> tag and sets its value to be the name of the

  341.      * style.

  342.      *

  343.      * @exception IOException on any I/O error

  344.      */

  345.     protected void writeStartParagraph(Element elem) throws IOException {

  346. 	AttributeSet attr = elem.getAttributes();

  347. 	Object resolveAttr = attr.getAttribute(StyleConstants.ResolveAttribute);

  348. 	if (resolveAttr instanceof StyleContext.NamedStyle) {

  349. 	    writeStartTag("<p class=" + mapStyleName(((StyleContext.NamedStyle)resolveAttr).getName()) + ">");

  350. 	} else {

  351. 	    writeStartTag("<p>");

  352. 	}

  353.     }

  354. 

  355. 

  356.     /**

  357.      * Responsible for writing out other non-text leaf

  358.      * elements.

  359.      *

  360.      * @exception IOException on any I/O error

  361.      */

  362.     protected void writeLeaf(Element elem) throws IOException {

  363. 	indent();

  364. 	if (elem.getName() == StyleConstants.IconElementName) {

  365. 	    writeImage(elem);

  366. 	} else if (elem.getName() == StyleConstants.ComponentElementName) {

  367. 	    writeComponent(elem);

  368. 	}

  369.     }

  370. 

  371. 

  372.     /**

  373.      * Responsible for handling Icon Elements;

  374.      * deliberately unimplemented.  How to implement this method is 

  375.      * an issue of policy.  For example, if you're generating

  376.      * an <img> tag, how should you 

  377.      * represent the src attribute (the location of the image)?

  378.      * In certain cases it could be a URL, in others it could

  379.      * be read from a stream.

  380.      *

  381.      * @param elem element of type StyleConstants.IconElementName

  382.      */

  383.     protected void writeImage(Element elem) throws IOException {

  384.     }

  385. 

  386. 

  387.     /**

  388.      * Responsible for handling Component Elements;  

  389.      * deliberately unimplemented.

  390.      * How this method is implemented is a matter of policy.

  391.      */

  392.     protected void writeComponent(Element elem) throws IOException {

  393.     }

  394. 

  395. 

  396.     /**

  397.      * Returns true if the element is a text element.

  398.      *

  399.      */

  400.     protected boolean isText(Element elem) {

  401. 	return (elem.getName() == AbstractDocument.ContentElementName);

  402.     }

  403. 

  404. 

  405.     /**

  406.      * Writes out the attribute set

  407.      * in an HTML-compliant manner.

  408.      *

  409.      * @exception IOException on any I/O error

  410.      * @exception BadLocationException if pos represents an invalid

  411.      *            location within the document.

  412.      */

  413.     protected void writeContent(Element elem,  boolean needsIndenting)

  414. 	throws IOException, BadLocationException {

  415. 

  416. 	AttributeSet attr = elem.getAttributes();

  417. 	writeNonHTMLAttributes(attr);

  418. 	if (needsIndenting) {

  419. 	    indent();

  420. 	}

  421. 	writeHTMLTags(attr);

  422. 	text(elem);

  423.     }

  424. 

  425. 

  426.     /**

  427.      * Generates

  428.      * bold <b>, italic <i>, and <u> tags for the

  429.      * text based on its attribute settings.

  430.      *

  431.      * @exception IOException on any I/O error

  432.      */

  433. 

  434.     protected void writeHTMLTags(AttributeSet attr) throws IOException {

  435. 

  436. 	int oldMask = fontMask;

  437. 	setFontMask(attr);

  438. 

  439. 	int endMask = 0;

  440. 	int startMask = 0;

  441. 	if ((oldMask & BOLD) != 0) {

  442. 	    if ((fontMask & BOLD) == 0) {

  443. 		endMask |= BOLD;

  444. 	    }

  445. 	} else if ((fontMask & BOLD) != 0) {

  446. 	    startMask |= BOLD;

  447. 	}

  448. 

  449. 	if ((oldMask & ITALIC) != 0) {

  450. 	    if ((fontMask & ITALIC) == 0) {

  451. 		endMask |= ITALIC;

  452. 	    }

  453. 	} else if ((fontMask & ITALIC) != 0) {

  454. 	    startMask |= ITALIC;

  455. 	}

  456. 

  457. 	if ((oldMask & UNDERLINE) != 0) {

  458. 	    if ((fontMask & UNDERLINE) == 0) {

  459. 		endMask |= UNDERLINE;

  460. 	    }

  461. 	} else if ((fontMask & UNDERLINE) != 0) {

  462. 	    startMask |= UNDERLINE;

  463. 	}

  464. 	writeEndMask(endMask);

  465. 	writeStartMask(startMask);

  466.     }

  467. 

  468. 

  469.     /**

  470.      * Tweaks the appropriate bits of fontMask

  471.      * to reflect whether the text is to be displayed in

  472.      * bold, italic, and/or with an underline.

  473.      *

  474.      */

  475.     private void setFontMask(AttributeSet attr) {

  476. 	if (StyleConstants.isBold(attr)) {

  477. 	    fontMask |= BOLD;

  478. 	}

  479. 

  480. 	if (StyleConstants.isItalic(attr)) {

  481. 	    fontMask |= ITALIC;

  482. 	}

  483. 

  484. 	if (StyleConstants.isUnderline(attr)) {

  485. 	    fontMask |= UNDERLINE;

  486. 	}

  487.     }

  488. 

  489. 

  490. 

  491. 

  492.     /**

  493.      * Writes out start tags <u>, <i>, and <b> based on

  494.      * the mask settings.

  495.      *

  496.      * @exception IOException on any I/O error

  497.      */

  498.     private void writeStartMask(int mask) throws IOException  {

  499. 	if (mask != 0) {

  500. 	    if ((mask & UNDERLINE) != 0) {

  501. 		write("<u>");

  502. 	    }

  503. 	    if ((mask & ITALIC) != 0) {

  504. 		write("<i>");

  505. 	    }

  506. 	    if ((mask & BOLD) != 0) {

  507. 		write("<b>");

  508. 	    }

  509. 	}

  510.     }

  511. 

  512.     /**

  513.      * Writes out end tags for <u>, <i>, and <b> based on

  514.      * the mask settings.

  515.      *

  516.      * @exception IOException on any I/O error

  517.      */

  518.     private void writeEndMask(int mask) throws IOException {

  519. 	if (mask != 0) {

  520. 	    if ((mask & BOLD) != 0) {

  521. 		write("</b>");

  522. 	    }

  523. 	    if ((mask & ITALIC) != 0) {

  524. 		write("</i>");

  525. 	    }

  526. 	    if ((mask & UNDERLINE) != 0) {

  527. 		write("</u>");

  528. 	    }

  529. 	}

  530.     }

  531. 

  532. 

  533.     /**

  534.      * Writes out the remaining

  535.      * character-level attributes (attributes other than bold,

  536.      * italic, and underline) in an HTML-compliant way.  Given that

  537.      * attributes such as font family and font size have no direct

  538.      * mapping to HTML tags, a <span> tag is generated and its

  539.      * style attribute is set to contain the list of remaining

  540.      * attributes just like inline styles.

  541.      *

  542.      * @exception IOException on any I/O error

  543.      */

  544.     protected void writeNonHTMLAttributes(AttributeSet attr) throws IOException {

  545. 

  546. 	String style = "";

  547. 	String separator = "; ";

  548. 

  549. 	if (inFontTag() && fontAttributes.isEqual(attr)) {

  550. 	    return;

  551. 	}

  552. 

  553. 	boolean first = true;

  554. 	Color color = (Color)attr.getAttribute(StyleConstants.Foreground);

  555. 	if (color != null) {

  556. 	    style += "color: " + css.styleConstantsValueToCSSValue

  557. 		                    ((StyleConstants)StyleConstants.Foreground,

  558. 				     color);

  559. 	    first = false;

  560. 	}

  561. 	Integer size = (Integer)attr.getAttribute(StyleConstants.FontSize);

  562. 	if (size != null) {

  563. 	    if (!first) {

  564. 		style += separator;

  565. 	    }

  566. 	    style += "font-size: " + size.intValue() + "pt";

  567. 	    first = false;

  568. 	}

  569. 

  570. 	String family = (String)attr.getAttribute(StyleConstants.FontFamily);

  571. 	if (family != null) {

  572. 	    if (!first) {

  573. 		style += separator;

  574. 	    }

  575. 	    style += "font-family: " + family;

  576. 	    first = false;

  577. 	}

  578. 

  579. 	if (style.length() > 0) {

  580. 	    if (fontMask != 0) {

  581. 		writeEndMask(fontMask);

  582. 		fontMask = 0;

  583. 	    }

  584. 	    startSpanTag(style);

  585. 	    fontAttributes = attr;

  586. 	}

  587. 	else if (fontAttributes != null) {

  588. 	    writeEndMask(fontMask);

  589. 	    fontMask = 0;

  590. 	    endSpanTag();

  591. 	}

  592.     }

  593. 

  594. 

  595.     /**

  596.      * Returns true if we are currently in a <font> tag.

  597.      */

  598.     protected boolean inFontTag() {

  599. 	return (fontAttributes != null);

  600.     }

  601. 

  602.     /**

  603.      * This is no longer used, instead <span> will be written out.

  604.      * <p>

  605.      * Writes out an end tag for the <font> tag.

  606.      *

  607.      * @exception IOException on any I/O error

  608.      */

  609.     protected void endFontTag() throws IOException {

  610. 	write(NEWLINE);

  611. 	writeEndTag("</font>");

  612. 	fontAttributes = null;

  613.     }

  614. 

  615. 

  616.     /**

  617.      * This is no longer used, instead <span> will be written out.

  618.      * <p>

  619.      * Writes out a start tag for the <font> tag.

  620.      * Because font tags cannot be nested, 

  621.      * this method closes out

  622.      * any enclosing font tag before writing out a

  623.      * new start tag.

  624.      *

  625.      * @exception IOException on any I/O error

  626.      */

  627.     protected void startFontTag(String style) throws IOException {

  628. 	boolean callIndent = false;

  629. 	if (inFontTag()) {

  630. 	    endFontTag();

  631. 	    callIndent = true;

  632. 	}

  633. 	writeStartTag("<font style=\"" + style + "\">");

  634. 	if (callIndent) {

  635. 	    indent();

  636. 	}

  637.     }

  638. 

  639.     /**

  640.      * Writes out a start tag for the <font> tag.

  641.      * Because font tags cannot be nested, 

  642.      * this method closes out

  643.      * any enclosing font tag before writing out a

  644.      * new start tag.

  645.      *

  646.      * @exception IOException on any I/O error

  647.      */

  648.     private void startSpanTag(String style) throws IOException {

  649. 	boolean callIndent = false;

  650. 	if (inFontTag()) {

  651. 	    endSpanTag();

  652. 	    callIndent = true;

  653. 	}

  654. 	writeStartTag("<span style=\"" + style + "\">");

  655. 	if (callIndent) {

  656. 	    indent();

  657. 	}

  658.     }

  659. 

  660.     /**

  661.      * Writes out an end tag for the <span> tag.

  662.      *

  663.      * @exception IOException on any I/O error

  664.      */

  665.     private void endSpanTag() throws IOException {

  666. 	write(NEWLINE);

  667. 	writeEndTag("</span>");

  668. 	fontAttributes = null;

  669.     }

  670. 

  671.     /**

  672.      * Adds the style named <code>style</code> to the style mapping. This

  673.      * returns the name that should be used when outputting. CSS does not

  674.      * allow the full Unicode set to be used as a style name.

  675.      */

  676.     private String addStyleName(String style) {

  677. 	if (styleNameMapping == null) {

  678. 	    return style;

  679. 	}

  680. 	StringBuffer sb = null;

  681. 	for (int counter = style.length() - 1; counter >= 0; counter--) {

  682. 	    if (!isValidCharacter(style.charAt(counter))) {

  683. 		if (sb == null) {

  684. 		    sb = new StringBuffer(style);

  685. 		}

  686. 		sb.setCharAt(counter, 'a');

  687. 	    }

  688. 	}

  689. 	String mappedName = (sb != null) ? sb.toString() : style;

  690. 	while (styleNameMapping.get(mappedName) != null) {

  691. 	    mappedName = mappedName + 'x';

  692. 	}

  693. 	styleNameMapping.put(style, mappedName);

  694. 	return mappedName;

  695.     }

  696. 

  697.     /**

  698.      * Returns the mapped style name corresponding to <code>style</code>.

  699.      */

  700.     private String mapStyleName(String style) {

  701. 	if (styleNameMapping == null) {

  702. 	    return style;

  703. 	}

  704. 	String retValue = (String)styleNameMapping.get(style);

  705. 	return (retValue == null) ? style : retValue;

  706.     }

  707. 

  708.     private boolean isValidCharacter(char character) {

  709. 	return ((character >= 'a' && character <= 'z') ||

  710. 		(character >= 'A' && character <= 'Z'));

  711.     }

  712. }