1. /*

  2.  * @(#)RTFGenerator.java	1.9 00/02/02

  3.  *

  4.  * Copyright 1997-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. package javax.swing.text.rtf;

  11. 

  12. import java.lang.*;

  13. import java.util.*;

  14. import java.awt.Color;

  15. import java.awt.Font;

  16. import java.io.OutputStream;

  17. import java.io.IOException;

  18. 

  19. import javax.swing.text.*;

  20. 

  21. /**

  22.  * Generates an RTF output stream (java.io.OutputStream) from rich text

  23.  * (handed off through a series of LTTextAcceptor calls).  Can be used to

  24.  * generate RTF from any object which knows how to write to a text acceptor

  25.  * (e.g., LTAttributedText and LTRTFFilter).

  26.  *

  27.  * <p>Note that this is a lossy conversion since RTF's model of

  28.  * text does not exactly correspond with LightText's. 

  29.  *

  30.  * @see LTAttributedText

  31.  * @see LTRTFFilter

  32.  * @see LTTextAcceptor

  33.  * @see java.io.OutputStream

  34.  */

  35. 

  36. class RTFGenerator extends Object

  37. {

  38.     /* These dictionaries map Colors, font names, or Style objects

  39.        to Integers */

  40.     Dictionary colorTable;

  41.     int colorCount;

  42.     Dictionary fontTable;

  43.     int fontCount;

  44.     Dictionary styleTable;

  45.     int styleCount;

  46. 

  47.     /* where all the text is going */

  48.     OutputStream outputStream;

  49. 

  50.     boolean afterKeyword;

  51. 

  52.     MutableAttributeSet outputAttributes;

  53. 

  54.     /* the value of the last \\ucN keyword emitted */

  55.     int unicodeCount;

  56. 

  57.     /* for efficiency's sake (ha) */

  58.     private Segment workingSegment;

  59. 

  60.     int[] outputConversion;

  61. 

  62.     /** The default color, used for text without an explicit color

  63.      *  attribute. */

  64.     static public final Color defaultRTFColor = Color.black;

  65. 

  66.     static public final float defaultFontSize = 12f;

  67. 

  68.     static public final String defaultFontFamily = "Helvetica";

  69. 

  70.     /* constants so we can avoid allocating objects in inner loops */

  71.     /* these should all be final, but javac seems to be a bit buggy */

  72.     static protected Integer One, Zero;

  73.     static protected Boolean False;

  74.     static protected Float ZeroPointZero;

  75.     static private Object MagicToken;

  76. 

  77.     /* An array of character-keyword pairs. This could be done

  78.        as a dictionary (and lookup would be quicker), but that

  79.        would require allocating an object for every character

  80.        written (slow!). */

  81.     static class CharacterKeywordPair

  82.       { public char character; public String keyword; };

  83.     static protected CharacterKeywordPair[] textKeywords;

  84. 

  85.     static {

  86. 	One = new Integer(1);

  87. 	Zero = new Integer(0);

  88. 	False = new Boolean(false);

  89. 	MagicToken = new Object();

  90. 	ZeroPointZero = new Float(0);

  91. 

  92. 	Dictionary textKeywordDictionary = RTFReader.textKeywords;

  93.         Enumeration keys = textKeywordDictionary.keys();

  94. 	Vector tempPairs = new Vector();

  95. 	while(keys.hasMoreElements()) {

  96. 	    CharacterKeywordPair pair = new CharacterKeywordPair();

  97. 	    pair.keyword = (String)keys.nextElement();

  98. 	    pair.character = ((String)textKeywordDictionary.get(pair.keyword)).charAt(0);

  99. 	    tempPairs.addElement(pair);

  100. 	}

  101. 	textKeywords = new CharacterKeywordPair[tempPairs.size()];

  102. 	tempPairs.copyInto(textKeywords);

  103.     }

  104. 

  105.     static final char[] hexdigits = { '0', '1', '2', '3', '4', '5', '6', '7',

  106. 				      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

  107. 

  108. static public void writeDocument(Document d, OutputStream to)

  109.     throws IOException

  110. {

  111.     RTFGenerator gen = new RTFGenerator(to);

  112.     Element root = d.getDefaultRootElement();

  113. 

  114.     gen.examineElement(root);

  115.     gen.writeRTFHeader();

  116.     gen.writeDocumentProperties(d);

  117. 

  118.     /* TODO this assumes a particular element structure; is there

  119.        a way to iterate more generically ? */

  120.     int max = root.getElementCount();

  121.     for(int idx = 0; idx < max; idx++)

  122. 	gen.writeParagraphElement(root.getElement(idx));

  123. 

  124.     gen.writeRTFTrailer();

  125. }

  126. 

  127. public RTFGenerator(OutputStream to)

  128. {

  129.     colorTable = new Hashtable();

  130.     colorTable.put(defaultRTFColor, new Integer(0));

  131.     colorCount = 1;

  132. 

  133.     fontTable = new Hashtable();

  134.     fontCount = 0;

  135. 

  136.     styleTable = new Hashtable();

  137.     /* TODO: put default style in style table */

  138.     styleCount = 0;

  139. 

  140.     workingSegment = new Segment();

  141. 

  142.     outputStream = to;

  143. 

  144.     unicodeCount = 1;

  145. }

  146. 

  147. public void examineElement(Element el)

  148. {

  149.     AttributeSet a = el.getAttributes();

  150.     String fontName;

  151.     Object foregroundColor, backgroundColor;

  152. 

  153.     tallyStyles(a);

  154. 

  155.     if (a != null) {

  156. 	/* TODO: default color must be color 0! */

  157. 	

  158. 	foregroundColor = StyleConstants.getForeground(a);

  159. 	if (foregroundColor != null &&

  160. 	    colorTable.get(foregroundColor) == null) {

  161. 	    colorTable.put(foregroundColor, new Integer(colorCount));

  162. 	    colorCount ++;

  163. 	}

  164. 	

  165. 	backgroundColor = a.getAttribute(StyleConstants.Background);

  166. 	if (backgroundColor != null &&

  167. 	    colorTable.get(backgroundColor) == null) {

  168. 	    colorTable.put(backgroundColor, new Integer(colorCount));

  169. 	    colorCount ++;

  170. 	}

  171. 	

  172. 	fontName = StyleConstants.getFontFamily(a);

  173. 	

  174. 	if (fontName == null)

  175. 	    fontName = defaultFontFamily;

  176. 

  177. 	if (fontName != null &&

  178. 	    fontTable.get(fontName) == null) {

  179. 	    fontTable.put(fontName, new Integer(fontCount));

  180. 	    fontCount ++;

  181. 	}

  182.     }

  183. 

  184.     int el_count = el.getElementCount();

  185.     for(int el_idx = 0; el_idx < el_count; el_idx ++) {

  186. 	examineElement(el.getElement(el_idx));

  187.     }

  188. }

  189. 

  190. private void tallyStyles(AttributeSet a) {

  191.     while (a != null) {

  192.         if (a instanceof Style) {

  193. 	    Integer aNum = (Integer)styleTable.get(a);

  194. 	    if (aNum == null) {

  195. 		styleCount = styleCount + 1;

  196. 	        aNum = new Integer(styleCount);

  197. 		styleTable.put(a, aNum);

  198. 	    }

  199. 	}

  200. 	a = a.getResolveParent();

  201.     }

  202. }

  203. 

  204. private Style findStyle(AttributeSet a)

  205. {

  206.     while(a != null) {

  207.         if (a instanceof Style) {

  208. 	    Object aNum = styleTable.get(a);

  209. 	    if (aNum != null)

  210. 	        return (Style)a;

  211. 	}

  212. 	a = a.getResolveParent();

  213.     }

  214.     return null;

  215. }

  216. 

  217. private Integer findStyleNumber(AttributeSet a, String domain)

  218. {

  219.     while(a != null) {

  220.         if (a instanceof Style) {

  221. 	    Integer aNum = (Integer)styleTable.get(a);

  222. 	    if (aNum != null) {

  223. 		if (domain == null ||

  224. 		    domain.equals(a.getAttribute(Constants.StyleType)))

  225. 		    return aNum;

  226. 	    }

  227. 		  

  228. 	}

  229. 	a = a.getResolveParent();

  230.     }

  231.     return null;

  232. }

  233. 

  234. static private Object attrDiff(MutableAttributeSet oldAttrs,

  235. 			       AttributeSet newAttrs, 

  236. 			       Object key,

  237. 			       Object dfl)

  238. {

  239.     Object oldValue, newValue;

  240. 

  241.     oldValue = oldAttrs.getAttribute(key);

  242.     newValue = newAttrs.getAttribute(key);

  243. 

  244.     if (newValue == oldValue)

  245. 	return null;

  246.     if (newValue == null) {

  247. 	oldAttrs.removeAttribute(key);

  248. 	if (dfl != null && !dfl.equals(oldValue))

  249. 	    return dfl;

  250.         else

  251. 	    return null;

  252.     }

  253.     if (oldValue == null ||

  254. 	!equalArraysOK(oldValue, newValue)) {

  255. 	oldAttrs.addAttribute(key, newValue);

  256. 	return newValue;

  257.     }

  258.     return null;

  259. }

  260. 

  261. static private boolean equalArraysOK(Object a, Object b)

  262. {

  263.     Object[] aa, bb;

  264.     if (a == b)

  265. 	return true;

  266.     if (a == null || b == null)

  267. 	return false;

  268.     if (a.equals(b))

  269. 	return true;

  270.     if (!(a.getClass().isArray() && b.getClass().isArray()))

  271. 	return false;

  272.     aa = (Object[])a;

  273.     bb = (Object[])b;

  274.     if (aa.length != bb.length)

  275. 	return false;

  276.     

  277.     int i;

  278.     int l = aa.length;

  279.     for(i = 0; i < l; i++) {

  280. 	if (!equalArraysOK(aa[i], bb[i]))

  281. 	    return false;

  282.     }

  283. 

  284.     return true;

  285. }

  286.     

  287. /* Writes a line break to the output file, for ease in debugging */

  288. public void writeLineBreak()

  289.     throws IOException

  290. {

  291.     writeRawString("\n");

  292.     afterKeyword = false;

  293. }

  294. 

  295. 

  296. public void writeRTFHeader()

  297.     throws IOException

  298. {

  299.     int index;

  300. 

  301.     /* TODO: Should the writer attempt to examine the text it's writing

  302.        and pick a character set which will most compactly represent the

  303.        document? (currently the writer always uses the ansi character

  304.        set, which is roughly ISO-8859 Latin-1, and uses Unicode escapes

  305.        for all other characters. However Unicode is a relatively

  306.        recent addition to RTF, and not all readers will understand it.) */

  307.     writeBegingroup();

  308.     writeControlWord("rtf", 1);

  309.     writeControlWord("ansi");

  310.     outputConversion = outputConversionForName("ansi");

  311.     writeLineBreak();

  312. 

  313.     /* write font table */

  314.     String[] sortedFontTable = new String[fontCount];

  315.     Enumeration fonts = fontTable.keys();

  316.     String font;

  317.     while(fonts.hasMoreElements()) {

  318. 	font = (String)fonts.nextElement();

  319. 	Integer num = (Integer)(fontTable.get(font));

  320. 	sortedFontTable[num.intValue()] = font;

  321.     }

  322.     writeBegingroup();

  323.     writeControlWord("fonttbl");

  324.     for(index = 0; index < fontCount; index ++) {

  325. 	writeControlWord("f", index);

  326. 	writeControlWord("fnil");  /* TODO: supply correct font style */

  327. 	writeText(sortedFontTable[index]);

  328. 	writeText(";");

  329.     }

  330.     writeEndgroup();

  331.     writeLineBreak();

  332. 

  333.     /* write color table */

  334.     if (colorCount > 1) {

  335. 	Color[] sortedColorTable = new Color[colorCount];

  336. 	Enumeration colors = colorTable.keys();

  337. 	Color color;

  338. 	while(colors.hasMoreElements()) {

  339. 	    color = (Color)colors.nextElement();

  340. 	    Integer num = (Integer)(colorTable.get(color));

  341. 	    sortedColorTable[num.intValue()] = color;

  342. 	}

  343. 	writeBegingroup();

  344. 	writeControlWord("colortbl");

  345. 	for(index = 0; index < colorCount; index ++) {

  346. 	    color = sortedColorTable[index];

  347. 	    if (color != null) {

  348. 		writeControlWord("red", color.getRed());

  349. 		writeControlWord("green", color.getGreen());

  350. 		writeControlWord("blue", color.getBlue());

  351. 	    }

  352. 	    writeRawString(";");

  353. 	}

  354. 	writeEndgroup();

  355. 	writeLineBreak();

  356.     }

  357. 

  358.     /* write the style sheet */

  359.     if (styleCount > 1) {

  360. 	writeBegingroup();

  361. 	writeControlWord("stylesheet");

  362. 	Enumeration styles = styleTable.keys();

  363. 	while(styles.hasMoreElements()) {

  364. 	    Style style = (Style)styles.nextElement();

  365. 	    int styleNumber = ((Integer)styleTable.get(style)).intValue();

  366. 	    writeBegingroup();

  367. 	    String styleType = (String)style.getAttribute(Constants.StyleType);

  368. 	    if (styleType == null)

  369. 	        styleType = Constants.STParagraph;

  370. 	    if (styleType.equals(Constants.STCharacter)) {

  371. 	        writeControlWord("*");

  372. 		writeControlWord("cs", styleNumber);

  373. 	    } else if(styleType.equals(Constants.STSection)) {

  374. 	        writeControlWord("*");

  375. 		writeControlWord("ds", styleNumber);

  376. 	    } else {

  377. 	        writeControlWord("s", styleNumber);

  378. 	    }

  379.         

  380. 	    AttributeSet basis = style.getResolveParent();

  381. 	    MutableAttributeSet goat;

  382. 	    if (basis == null) {

  383. 	        goat = new SimpleAttributeSet();

  384. 	    } else {

  385. 	        goat = new SimpleAttributeSet(basis);

  386. 	    }

  387. 

  388. 	    updateSectionAttributes(goat, style, false);

  389. 	    updateParagraphAttributes(goat, style, false);

  390. 	    updateCharacterAttributes(goat, style, false);

  391. 

  392. 	    basis = style.getResolveParent();

  393. 	    if (basis != null && basis instanceof Style) {

  394. 	        Integer basedOn = (Integer)styleTable.get(basis);

  395. 		if (basedOn != null) {

  396. 		    writeControlWord("sbasedon", basedOn.intValue());

  397. 		}

  398. 	    }

  399. 	    

  400. 	    Style nextStyle = (Style)style.getAttribute(Constants.StyleNext);

  401. 	    if (nextStyle != null) {

  402. 	        Integer nextNum = (Integer)styleTable.get(nextStyle);

  403. 		if (nextNum != null) {

  404. 		    writeControlWord("snext", nextNum.intValue());

  405. 		}

  406. 	    }

  407. 	    

  408. 	    Boolean hidden = (Boolean)style.getAttribute(Constants.StyleHidden);

  409. 	    if (hidden != null && hidden.booleanValue())

  410. 	        writeControlWord("shidden");

  411. 

  412. 	    Boolean additive = (Boolean)style.getAttribute(Constants.StyleAdditive);

  413. 	    if (additive != null && additive.booleanValue())

  414. 	        writeControlWord("additive");

  415. 

  416. 	    

  417. 	    writeText(style.getName());

  418. 	    writeText(";");

  419. 	    writeEndgroup();

  420. 	}

  421. 	writeEndgroup();

  422. 	writeLineBreak();

  423.     }

  424. 

  425.     outputAttributes = new SimpleAttributeSet();

  426. }

  427. 

  428. void writeDocumentProperties(Document doc)

  429.     throws IOException

  430. {

  431.     /* Write the document properties */

  432.     int i;

  433.     boolean wroteSomething = false;

  434.     

  435.     for(i = 0; i < RTFAttributes.attributes.length; i++) {

  436.         RTFAttribute attr = RTFAttributes.attributes[i];

  437. 	if (attr.domain() != RTFAttribute.D_DOCUMENT)

  438. 	    continue;

  439. 	Object prop = doc.getProperty(attr.swingName());

  440. 	boolean ok = attr.writeValue(prop, this, false);

  441. 	if (ok)

  442. 	    wroteSomething = true;

  443.     }

  444. 

  445.     if (wroteSomething)

  446.         writeLineBreak();

  447. }

  448. 

  449. public void writeRTFTrailer()

  450.     throws IOException

  451. {

  452.     writeEndgroup();

  453.     writeLineBreak();

  454. }

  455. 

  456. protected void checkNumericControlWord(MutableAttributeSet currentAttributes,

  457. 				       AttributeSet newAttributes,

  458. 				       Object attrName,

  459. 				       String controlWord,

  460. 				       float dflt, float scale)

  461.     throws IOException

  462. {

  463.     Object parm;

  464. 

  465.     if ((parm = attrDiff(currentAttributes, newAttributes,

  466. 			 attrName, MagicToken)) != null) {

  467. 	float targ;

  468. 	if (parm == MagicToken)

  469. 	    targ = dflt;

  470. 	else

  471. 	    targ = ((Number)parm).floatValue();

  472. 	writeControlWord(controlWord, Math.round(targ * scale));

  473.     }

  474. }

  475. 

  476. protected void checkControlWord(MutableAttributeSet currentAttributes,

  477. 				AttributeSet newAttributes,

  478. 				RTFAttribute word)

  479.     throws IOException

  480. {

  481.     Object parm;

  482. 

  483.     if ((parm = attrDiff(currentAttributes, newAttributes,

  484. 			 word.swingName(), MagicToken)) != null) {

  485.         if (parm == MagicToken)

  486. 	    parm = null;

  487. 	word.writeValue(parm, this, true);

  488.     }

  489. }

  490. 

  491. protected void checkControlWords(MutableAttributeSet currentAttributes,

  492. 				 AttributeSet newAttributes,

  493. 				 RTFAttribute words[],

  494. 				 int domain)

  495.     throws IOException

  496. {

  497.     int wordIndex;

  498.     int wordCount = words.length;

  499.     for(wordIndex = 0; wordIndex < wordCount; wordIndex++) {

  500.         RTFAttribute attr = words[wordIndex];

  501. 	if (attr.domain() == domain)

  502. 	    checkControlWord(currentAttributes, newAttributes, attr);

  503.     }

  504. }

  505. 

  506. void updateSectionAttributes(MutableAttributeSet current,

  507. 			     AttributeSet newAttributes,

  508. 			     boolean emitStyleChanges)

  509.     throws IOException

  510. {

  511.     if (emitStyleChanges) {

  512. 	Object oldStyle = current.getAttribute("sectionStyle");

  513. 	Object newStyle = findStyleNumber(newAttributes, Constants.STSection);

  514. 	if (oldStyle != newStyle) {

  515. 	    if (oldStyle != null) {

  516. 		resetSectionAttributes(current);

  517. 	    }

  518. 	    if (newStyle != null) {

  519. 		writeControlWord("ds", ((Integer)newStyle).intValue());

  520. 		current.addAttribute("sectionStyle", newStyle);

  521. 	    } else {

  522. 		current.removeAttribute("sectionStyle");

  523. 	    }

  524. 	}

  525.     }

  526. 	

  527.     checkControlWords(current, newAttributes,

  528. 		      RTFAttributes.attributes, RTFAttribute.D_SECTION);

  529. }

  530. 

  531. protected void resetSectionAttributes(MutableAttributeSet currentAttributes)

  532.     throws IOException

  533. {

  534.     writeControlWord("sectd");

  535. 

  536.     int wordIndex;

  537.     int wordCount = RTFAttributes.attributes.length;

  538.     for(wordIndex = 0; wordIndex < wordCount; wordIndex++) {

  539.         RTFAttribute attr = RTFAttributes.attributes[wordIndex];

  540. 	if (attr.domain() == RTFAttribute.D_SECTION)

  541. 	    attr.setDefault(currentAttributes);

  542.     }

  543. 

  544.     currentAttributes.removeAttribute("sectionStyle");

  545. }    

  546. 

  547. void updateParagraphAttributes(MutableAttributeSet current,

  548. 			       AttributeSet newAttributes,

  549. 			       boolean emitStyleChanges)

  550.     throws IOException

  551. {

  552.     Object parm;

  553.     Object oldStyle, newStyle;

  554.     

  555.     /* The only way to get rid of tabs or styles is with the \pard keyword,

  556.        emitted by resetParagraphAttributes(). Ideally we should avoid

  557.        emitting \pard if the new paragraph's tabs are a superset of the old

  558.        paragraph's tabs. */

  559. 

  560.     if (emitStyleChanges) {

  561. 	oldStyle = current.getAttribute("paragraphStyle");

  562. 	newStyle = findStyleNumber(newAttributes, Constants.STParagraph);

  563. 	if (oldStyle != newStyle) {

  564. 	    if (oldStyle != null) {

  565. 		resetParagraphAttributes(current);

  566. 		oldStyle = null;

  567. 	    }

  568. 	}

  569.     } else {

  570. 	oldStyle = null;

  571. 	newStyle = null;

  572.     }

  573. 	

  574.     Object oldTabs = current.getAttribute(Constants.Tabs);

  575.     Object newTabs = newAttributes.getAttribute(Constants.Tabs);

  576.     if (oldTabs != newTabs) {

  577. 	if (oldTabs != null) {

  578. 	    resetParagraphAttributes(current);

  579. 	    oldTabs = null;

  580. 	    oldStyle = null;

  581. 	}

  582.     }

  583. 

  584.     if (oldStyle != newStyle && newStyle != null) {

  585. 	writeControlWord("s", ((Integer)newStyle).intValue());

  586. 	current.addAttribute("paragraphStyle", newStyle);

  587.     }

  588. 

  589.     checkControlWords(current, newAttributes,

  590. 		      RTFAttributes.attributes, RTFAttribute.D_PARAGRAPH);

  591. 

  592.     if (oldTabs != newTabs && newTabs != null) {

  593. 	TabStop tabs[] = (TabStop[])newTabs;

  594. 	int index;

  595. 	for(index = 0; index < tabs.length; index ++) {

  596. 	    TabStop tab = tabs[index];

  597. 	    switch (tab.getAlignment()) {

  598. 	      case TabStop.ALIGN_LEFT:

  599. 	      case TabStop.ALIGN_BAR:

  600. 		break;

  601. 	      case TabStop.ALIGN_RIGHT:

  602. 		writeControlWord("tqr");

  603. 		break;

  604. 	      case TabStop.ALIGN_CENTER:

  605. 		writeControlWord("tqc");

  606. 		break;

  607. 	      case TabStop.ALIGN_DECIMAL:

  608. 		writeControlWord("tqdec");

  609. 		break;

  610. 	    }

  611. 	    switch (tab.getLeader()) {

  612. 	      case TabStop.LEAD_NONE:

  613. 		break;

  614. 	      case TabStop.LEAD_DOTS:

  615. 		writeControlWord("tldot");

  616. 		break;

  617. 	      case TabStop.LEAD_HYPHENS:

  618. 		writeControlWord("tlhyph");

  619. 		break;

  620. 	      case TabStop.LEAD_UNDERLINE:

  621. 		writeControlWord("tlul");

  622. 		break;

  623. 	      case TabStop.LEAD_THICKLINE:

  624. 		writeControlWord("tlth");

  625. 		break;

  626. 	      case TabStop.LEAD_EQUALS:

  627. 		writeControlWord("tleq");

  628. 		break;

  629. 	    }

  630. 	    int twips = Math.round(20f * tab.getPosition());

  631. 	    if (tab.getAlignment() == TabStop.ALIGN_BAR) {

  632. 		writeControlWord("tb", twips);

  633. 	    } else {

  634. 		writeControlWord("tx", twips);

  635. 	    }

  636. 	}

  637. 	current.addAttribute(Constants.Tabs, tabs);

  638.     }

  639. }

  640. 

  641. public void writeParagraphElement(Element el)

  642.     throws IOException

  643. {

  644.     updateParagraphAttributes(outputAttributes, el.getAttributes(), true);

  645. 

  646.     int sub_count = el.getElementCount();

  647.     for(int idx = 0; idx < sub_count; idx ++) {

  648. 	writeTextElement(el.getElement(idx));

  649.     }

  650. 

  651.     writeControlWord("par");

  652.     writeLineBreak();  /* makes the raw file more readable */

  653. }

  654. 

  655. /* debugging. TODO: remove.

  656. private static String tabdump(Object tso)

  657. {

  658.     String buf;

  659.     int i;

  660. 

  661.     if (tso == null)

  662. 	return "[none]";

  663. 

  664.     TabStop[] ts = (TabStop[])tso;

  665. 

  666.     buf = "[";

  667.     for(i = 0; i < ts.length; i++) {

  668. 	buf = buf + ts[i].toString();

  669. 	if ((i+1) < ts.length)

  670. 	    buf = buf + ",";

  671.     }

  672.     return buf + "]";

  673. }

  674. */

  675. 

  676. protected void resetParagraphAttributes(MutableAttributeSet currentAttributes)

  677.     throws IOException

  678. {

  679.     writeControlWord("pard");

  680. 

  681.     currentAttributes.addAttribute(StyleConstants.Alignment,       Zero);

  682. 

  683.     int wordIndex;

  684.     int wordCount = RTFAttributes.attributes.length;

  685.     for(wordIndex = 0; wordIndex < wordCount; wordIndex++) {

  686.         RTFAttribute attr = RTFAttributes.attributes[wordIndex];

  687. 	if (attr.domain() == RTFAttribute.D_PARAGRAPH)

  688. 	    attr.setDefault(currentAttributes);

  689.     }

  690. 

  691.     currentAttributes.removeAttribute("paragraphStyle");

  692.     currentAttributes.removeAttribute(Constants.Tabs);

  693. }    

  694. 

  695. void updateCharacterAttributes(MutableAttributeSet current,

  696. 			       AttributeSet newAttributes,

  697. 			       boolean updateStyleChanges)

  698.     throws IOException

  699. {

  700.     Object parm;

  701. 

  702.     if (updateStyleChanges) {

  703. 	Object oldStyle = current.getAttribute("characterStyle");

  704. 	Object newStyle = findStyleNumber(newAttributes,

  705. 					  Constants.STCharacter);

  706. 	if (oldStyle != newStyle) {

  707. 	    if (oldStyle != null) {

  708. 		resetCharacterAttributes(current);

  709. 	    }

  710. 	    if (newStyle != null) {

  711. 		writeControlWord("cs", ((Integer)newStyle).intValue());

  712. 		current.addAttribute("characterStyle", newStyle);

  713. 	    } else {

  714. 		current.removeAttribute("characterStyle");

  715. 	    }

  716. 	}

  717.     }

  718. 

  719.     if ((parm = attrDiff(current, newAttributes,

  720. 			 StyleConstants.FontFamily, null)) != null) {

  721. 	Number fontNum = (Number)fontTable.get(parm);

  722. 	writeControlWord("f", fontNum.intValue());

  723.     }

  724. 

  725.     checkNumericControlWord(current, newAttributes,

  726. 			    StyleConstants.FontSize, "fs",

  727. 			    defaultFontSize, 2f);

  728. 

  729.     checkControlWords(current, newAttributes,

  730. 		      RTFAttributes.attributes, RTFAttribute.D_CHARACTER);

  731. 

  732.     checkNumericControlWord(current, newAttributes,

  733. 			    StyleConstants.LineSpacing, "sl",

  734. 			    0, 20f); /* TODO: sl wackiness */

  735. 

  736.     if ((parm = attrDiff(current, newAttributes,

  737. 			 StyleConstants.Background, MagicToken)) != null) {

  738. 	int colorNum;

  739. 	if (parm == MagicToken)

  740. 	    colorNum = 0;

  741. 	else

  742. 	    colorNum = ((Number)colorTable.get(parm)).intValue();

  743. 	writeControlWord("cb", colorNum);

  744.     }

  745. 

  746.     if ((parm = attrDiff(current, newAttributes,

  747. 			 StyleConstants.Foreground, null)) != null) {

  748. 	int colorNum;

  749. 	if (parm == MagicToken)

  750. 	    colorNum = 0;

  751. 	else

  752. 	    colorNum = ((Number)colorTable.get(parm)).intValue();

  753. 	writeControlWord("cf", colorNum);

  754.     }

  755. }

  756. 

  757. protected void resetCharacterAttributes(MutableAttributeSet currentAttributes)

  758.     throws IOException

  759. {

  760.     writeControlWord("plain");

  761. 

  762.     int wordIndex;

  763.     int wordCount = RTFAttributes.attributes.length;

  764.     for(wordIndex = 0; wordIndex < wordCount; wordIndex++) {

  765.         RTFAttribute attr = RTFAttributes.attributes[wordIndex];

  766. 	if (attr.domain() == RTFAttribute.D_CHARACTER)

  767. 	    attr.setDefault(currentAttributes);

  768.     }

  769. 

  770.     StyleConstants.setFontFamily(currentAttributes, defaultFontFamily);

  771.     currentAttributes.removeAttribute(StyleConstants.FontSize); /* =default */

  772.     currentAttributes.removeAttribute(StyleConstants.Background);

  773.     currentAttributes.removeAttribute(StyleConstants.Foreground);

  774.     currentAttributes.removeAttribute(StyleConstants.LineSpacing);

  775.     currentAttributes.removeAttribute("characterStyle");

  776. }    

  777. 

  778. public void writeTextElement(Element el)

  779.     throws IOException

  780. {

  781.     updateCharacterAttributes(outputAttributes, el.getAttributes(), true);

  782. 

  783.     if (el.isLeaf()) {

  784. 	try {

  785. 	    el.getDocument().getText(el.getStartOffset(),

  786. 				     el.getEndOffset() - el.getStartOffset(),

  787. 				     this.workingSegment);

  788. 	} catch (BadLocationException ble) {

  789. 	    /* TODO is this the correct error to raise? */

  790. 	    ble.printStackTrace();

  791. 	    throw new InternalError(ble.getMessage());

  792. 	}

  793. 	writeText(this.workingSegment);

  794.     } else {

  795. 	int sub_count = el.getElementCount();

  796. 	for(int idx = 0; idx < sub_count; idx ++)

  797. 	    writeTextElement(el.getElement(idx));

  798.     }

  799. }

  800. 

  801. public void writeText(Segment s)

  802.     throws IOException

  803. {

  804.     int pos, end;

  805.     char[] array;

  806. 

  807.     pos = s.offset;

  808.     end = pos + s.count;

  809.     array = s.array;

  810.     for( ; pos < end; pos ++)

  811. 	writeCharacter(array[pos]);

  812. }

  813. 

  814. public void writeText(String s)

  815.     throws IOException

  816. {

  817.     int pos, end;

  818. 

  819.     pos = 0;

  820.     end = s.length();

  821.     for( ; pos < end; pos ++)

  822. 	writeCharacter(s.charAt(pos));

  823. }

  824. 

  825. public void writeRawString(String str)

  826.     throws IOException

  827. {

  828.     int strlen = str.length();

  829.     for (int offset = 0; offset < strlen; offset ++)

  830. 	outputStream.write((int)str.charAt(offset));

  831. }

  832. 

  833. public void writeControlWord(String keyword)

  834.     throws IOException

  835. {

  836.     outputStream.write('\\');

  837.     writeRawString(keyword);

  838.     afterKeyword = true;

  839. }

  840. 

  841. public void writeControlWord(String keyword, int arg)

  842.     throws IOException

  843. {

  844.     outputStream.write('\\');

  845.     writeRawString(keyword);

  846.     writeRawString(String.valueOf(arg)); /* TODO: correct in all cases? */

  847.     afterKeyword = true;

  848. }

  849.     

  850. public void writeBegingroup()

  851.     throws IOException

  852. {

  853.     outputStream.write('{');

  854.     afterKeyword = false;

  855. }

  856. 

  857. public void writeEndgroup()

  858.     throws IOException

  859. {

  860.     outputStream.write('}');

  861.     afterKeyword = false;

  862. }

  863. 

  864. public void writeCharacter(char ch)

  865.     throws IOException

  866. {

  867.     /* Nonbreaking space is in most RTF encodings, but the keyword is

  868.        preferable; same goes for tabs */

  869.     if (ch == 0xA0) { /* nonbreaking space */

  870.         outputStream.write(0x5C);  /* backslash */

  871. 	outputStream.write(0x7E);  /* tilde */

  872. 	afterKeyword = false; /* non-alpha keywords are self-terminating */

  873. 	return;

  874.     }

  875. 

  876.     if (ch == 0x09) { /* horizontal tab */

  877. 	writeControlWord("tab");

  878. 	return;

  879.     }

  880. 

  881.     if (ch == 10 || ch == 13) { /* newline / paragraph */

  882. 	/* ignore CRs, we'll write a paragraph element soon enough */

  883. 	return;

  884.     }

  885. 

  886.     int b = convertCharacter(outputConversion, ch);

  887.     if (b == 0) {

  888.         /* Unicode characters which have corresponding RTF keywords */

  889.         int i;

  890. 	for(i = 0; i < textKeywords.length; i++) {

  891. 	    if (textKeywords[i].character == ch) {

  892. 	        writeControlWord(textKeywords[i].keyword);

  893. 		return;

  894. 	    }

  895. 	}

  896.         /* In some cases it would be reasonable to check to see if the

  897. 	   glyph being written out is in the Symbol encoding, and if so,

  898. 	   to switch to the Symbol font for this character. TODO. */

  899.         /* Currently all unrepresentable characters are written as

  900. 	   Unicode escapes. */

  901.         String approximation = approximationForUnicode(ch);

  902. 	if (approximation.length() != unicodeCount) {

  903. 	    unicodeCount = approximation.length();

  904. 	    writeControlWord("uc", unicodeCount);

  905. 	}

  906. 	writeControlWord("u", (int)ch);

  907. 	writeRawString(" ");

  908. 	writeRawString(approximation);

  909. 	afterKeyword = false;

  910.         return;

  911.     }

  912. 

  913.     if (b > 127) {

  914. 	int nybble;

  915.         outputStream.write('\\');

  916. 	outputStream.write('\'');

  917. 	nybble = ( b & 0xF0 ) >>> 4;

  918. 	outputStream.write(hexdigits[nybble]);

  919. 	nybble = ( b & 0x0F );

  920. 	outputStream.write(hexdigits[nybble]);

  921. 	afterKeyword = false;

  922. 	return;

  923.     }

  924. 

  925.     switch (b) {

  926.     case '}':

  927.     case '{':

  928.     case '\\':

  929.         outputStream.write(0x5C);  /* backslash */

  930. 	afterKeyword = false;  /* in a keyword, actually ... */

  931.         /* fall through */

  932.     default:

  933. 	if (afterKeyword) {

  934.             outputStream.write(0x20);  /* space */

  935. 	    afterKeyword = false;

  936. 	}

  937.         outputStream.write(b);

  938.         break;

  939.     }

  940. }

  941. 

  942. String approximationForUnicode(char ch)

  943. {

  944.     /* TODO: Find reasonable approximations for all Unicode characters

  945.        in all RTF code pages... heh, heh... */

  946.     return "?";

  947. }

  948.     

  949. /** Takes a translation table (a 256-element array of characters)

  950.  * and creates an output conversion table for use by 

  951.  * convertCharacter(). */

  952.     /* Not very efficient at all. Could be changed to sort the table

  953.        for binary search. TODO. (Even though this is inefficient however,

  954.        writing RTF is still much faster than reading it.) */

  955. static int[] outputConversionFromTranslationTable(char[] table)

  956. {

  957.     int[] conversion = new int[2 * table.length];

  958. 

  959.     int index;

  960. 

  961.     for(index = 0; index < table.length; index ++) {

  962.         conversion[index * 2] = table[index];

  963. 	conversion[(index * 2) + 1] = index;

  964.     }

  965. 

  966.     return conversion;

  967. }

  968.     

  969. static int[] outputConversionForName(String name)

  970.     throws IOException

  971. {

  972.     char[] table = (char[])RTFReader.getCharacterSet(name);

  973.     return outputConversionFromTranslationTable(table);

  974. }

  975. 

  976. /** Takes a char and a conversion table (an int[] in the current

  977.  * implementation, but conversion tables should be treated as an opaque

  978.  * type) and returns the

  979.  * corresponding byte value (as an int, since bytes are signed).

  980.  */

  981.     /* Not very efficient. TODO. */

  982. static protected int convertCharacter(int[] conversion, char ch)

  983. {

  984.    int index;

  985. 

  986.    for(index = 0; index < conversion.length; index += 2) {

  987.        if(conversion[index] == ch)

  988. 	   return conversion[index + 1];

  989.    }

  990. 

  991.    return 0;  /* 0 indicates an unrepresentable character */

  992. }

  993. 

  994. }