1. /*

  2.  * @(#)CSS.java	1.14 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package javax.swing.text.html;

  8. 

  9. import java.awt.Color;

  10. import java.awt.Font;

  11. import java.io.*;

  12. import java.util.Enumeration;

  13. import java.util.Hashtable;

  14. import javax.swing.text.*;

  15. 

  16. /**

  17.  * Defines a set of

  18.  * <a href="http://www.w3.org/TR/REC-CSS1">CSS attributes</a>

  19.  * as a typesafe enumeration.  The html View implementations use

  20.  * css attributes to determine how they will render. This also defines

  21.  * methods to map between CSS<->HTML<->StyleConstants.

  22.  *

  23.  * @author  Timothy Prinzing

  24.  * @version 1.14 11/29/01

  25.  * @see StyleSheet

  26.  */

  27. public class CSS {

  28. 

  29.     /**

  30.      * Definitions to be used as a key on AttributeSet's

  31.      * that might hold css attributes.  Since this is a

  32.      * closed set (i.e. defined exactly by the specification),

  33.      * it is final and cannot be extended.

  34.      */

  35.     public static final class Attribute {

  36. 

  37. 	private Attribute(String name, String defaultValue, boolean inherited) {

  38. 	    this.name = name;

  39. 	    this.defaultValue = defaultValue;

  40. 	    this.inherited = inherited;

  41. 	}

  42. 

  43. 	/**

  44. 	 * The string representation of the attribute.  This

  45. 	 * should exactly match the string specified in the

  46. 	 * css specification.

  47. 	 */

  48. 	public String toString() {

  49. 	    return name;

  50. 	}

  51. 

  52. 	/**

  53. 	 * Fetch the default value for the attribute.

  54. 	 * If there is no default value (such as for

  55. 	 * composite attributes), null will be returned.

  56. 	 */

  57. 	public String getDefaultValue() {

  58. 	    return defaultValue;

  59. 	}

  60. 

  61. 	/**

  62. 	 * Indicates if the attribute should be inherited

  63. 	 * from the parent or not.

  64. 	 */

  65. 	public boolean isInherited() {

  66. 	    return inherited;

  67. 	}

  68. 

  69. 	private String name;

  70. 	private String defaultValue;

  71. 	private boolean inherited;

  72. 

  73. 

  74. 	public static final Attribute BACKGROUND =

  75. 	    new Attribute("background", null, false);

  76. 

  77. 	public static final Attribute BACKGROUND_ATTACHMENT =

  78. 	    new Attribute("background-attachment", "scroll", false);

  79. 

  80. 	public static final Attribute BACKGROUND_COLOR =

  81. 	    new Attribute("background-color", "transparent", false);

  82. 

  83. 	public static final Attribute BACKGROUND_IMAGE =

  84. 	    new Attribute("background-image", "none", false);

  85. 

  86. 	public static final Attribute BACKGROUND_POSITION =

  87. 	    new Attribute("background-position", null, false);

  88. 

  89. 	public static final Attribute BACKGROUND_REPEAT =

  90. 	    new Attribute("background-repeat", "repeat", false);

  91. 

  92. 	public static final Attribute BORDER =

  93. 	    new Attribute("border", null, false);

  94. 

  95. 	public static final Attribute BORDER_BOTTOM =

  96. 	    new Attribute("border-bottom", null, false);

  97. 

  98. 	public static final Attribute BORDER_BOTTOM_WIDTH =

  99. 	    new Attribute("border-bottom-width", "medium", false);

  100. 

  101. 	public static final Attribute BORDER_COLOR =

  102. 	    new Attribute("border-color", null, false);

  103. 

  104. 	public static final Attribute BORDER_LEFT =

  105. 	    new Attribute("border-left", null, false);

  106. 

  107. 	public static final Attribute BORDER_LEFT_WIDTH =

  108. 	    new Attribute("border-left-width", "medium", false);

  109. 

  110. 	public static final Attribute BORDER_RIGHT =

  111. 	    new Attribute("border-right", null, false);

  112. 

  113. 	public static final Attribute BORDER_RIGHT_WIDTH =

  114. 	    new Attribute("border-right-width", "medium", false);

  115. 

  116. 	public static final Attribute BORDER_STYLE =

  117. 	    new Attribute("border-style", "none", false);

  118. 

  119. 	public static final Attribute BORDER_TOP =

  120. 	    new Attribute("border-top", null, false);

  121. 

  122. 	public static final Attribute BORDER_TOP_WIDTH =

  123. 	    new Attribute("border-top-width", "medium", false);

  124. 

  125. 	public static final Attribute BORDER_WIDTH =

  126. 	    new Attribute("border-width", "medium", false);

  127. 

  128. 	public static final Attribute CLEAR =

  129. 	    new Attribute("clear", "none", false);

  130. 

  131. 	public static final Attribute COLOR =

  132. 	    new Attribute("color", null, true);

  133. 

  134. 	public static final Attribute DISPLAY =

  135. 	    new Attribute("display", "block", false);

  136. 

  137. 	public static final Attribute FLOAT =

  138. 	    new Attribute("float", "none", false);

  139. 

  140. 	public static final Attribute FONT =

  141. 	    new Attribute("font", null, true);

  142. 

  143. 	public static final Attribute FONT_FAMILY =

  144. 	    new Attribute("font-family", null, true);

  145. 

  146. 	public static final Attribute FONT_SIZE =

  147. 	    new Attribute("font-size", "medium", true);

  148. 

  149. 	public static final Attribute FONT_STYLE =

  150. 	    new Attribute("font-style", "normal", true);

  151. 

  152. 	public static final Attribute FONT_VARIANT =

  153. 	    new Attribute("font-variant", "normal", true);

  154. 

  155. 	public static final Attribute FONT_WEIGHT =

  156. 	    new Attribute("font-weight", "normal", true);

  157. 

  158. 	public static final Attribute HEIGHT =

  159. 	    new Attribute("height", "auto", false);

  160. 

  161. 	public static final Attribute LETTER_SPACING =

  162. 	    new Attribute("letter-spacing", "normal", true);

  163. 

  164. 	public static final Attribute LINE_HEIGHT =

  165. 	    new Attribute("line-height", "normal", true);

  166. 

  167. 	public static final Attribute LIST_STYLE =

  168. 	    new Attribute("list-style", null, true);

  169. 

  170. 	public static final Attribute LIST_STYLE_IMAGE =

  171. 	    new Attribute("list-style-image", "none", true);

  172. 

  173. 	public static final Attribute LIST_STYLE_POSITION =

  174. 	    new Attribute("list-style-position", "outside", true);

  175. 

  176. 	public static final Attribute LIST_STYLE_TYPE =

  177. 	    new Attribute("list-style-type", "disc", true);

  178. 

  179. 	public static final Attribute MARGIN =

  180. 	    new Attribute("margin", null, false);

  181. 

  182. 	public static final Attribute MARGIN_BOTTOM =

  183. 	    new Attribute("margin-bottom", "0", false);

  184. 

  185. 	public static final Attribute MARGIN_LEFT =

  186. 	    new Attribute("margin-left", "0", false);

  187. 

  188. 	public static final Attribute MARGIN_RIGHT =

  189. 	    new Attribute("margin-right", "0", false);

  190. 

  191. 	public static final Attribute MARGIN_TOP =

  192. 	    new Attribute("margin-top", "0", false);

  193. 

  194. 	public static final Attribute PADDING =

  195. 	    new Attribute("padding", null, false);

  196. 

  197. 	public static final Attribute PADDING_BOTTOM =

  198. 	    new Attribute("padding-bottom", "0", false);

  199. 

  200. 	public static final Attribute PADDING_LEFT =

  201. 	    new Attribute("padding-left", "0", false);

  202. 

  203. 	public static final Attribute PADDING_RIGHT =

  204. 	    new Attribute("padding-right", "0", false);

  205. 

  206. 	public static final Attribute PADDING_TOP =

  207. 	    new Attribute("padding-top", "0", false);

  208. 

  209. 	public static final Attribute TEXT_ALIGN =

  210. 	    new Attribute("text-align", null, true);

  211. 

  212. 	public static final Attribute TEXT_DECORATION =

  213. 	    new Attribute("text-decoration", "none", true);

  214. 

  215. 	public static final Attribute TEXT_INDENT =

  216. 	    new Attribute("text-indent", "0", true);

  217. 

  218. 	public static final Attribute TEXT_TRANSFORM =

  219. 	    new Attribute("text-transform", "none", true);

  220. 

  221. 	public static final Attribute VERTICAL_ALIGN =

  222. 	    new Attribute("vertical-align", "baseline", false);

  223. 

  224. 	public static final Attribute WORD_SPACING =

  225. 	    new Attribute("word-spacing", "normal", true);

  226. 

  227. 	public static final Attribute WHITE_SPACE =

  228. 	    new Attribute("whitespace", "normal", true);

  229. 

  230. 	public static final Attribute WIDTH =

  231. 	    new Attribute("width", "auto", false);

  232. 

  233. 	// All possible css attribute keys.

  234. 	static final Attribute[] allAttributes = {

  235. 	    BACKGROUND, BACKGROUND_ATTACHMENT, BACKGROUND_COLOR,

  236. 	    BACKGROUND_IMAGE, BACKGROUND_POSITION, BACKGROUND_REPEAT,

  237. 	    BORDER, BORDER_BOTTOM, BORDER_BOTTOM_WIDTH, BORDER_COLOR,

  238. 	    BORDER_LEFT, BORDER_LEFT_WIDTH, BORDER_RIGHT, BORDER_RIGHT_WIDTH,

  239. 	    BORDER_STYLE, BORDER_TOP, BORDER_TOP_WIDTH, BORDER_WIDTH,

  240. 	    CLEAR, COLOR, DISPLAY, FLOAT, FONT, FONT_FAMILY, FONT_SIZE,

  241. 	    FONT_STYLE, FONT_VARIANT, FONT_WEIGHT, HEIGHT, LETTER_SPACING,

  242. 	    LINE_HEIGHT, LIST_STYLE, LIST_STYLE_IMAGE, LIST_STYLE_POSITION,

  243. 	    LIST_STYLE_TYPE, MARGIN, MARGIN_BOTTOM, MARGIN_LEFT, MARGIN_RIGHT,

  244. 	    MARGIN_TOP, PADDING, PADDING_BOTTOM, PADDING_LEFT, PADDING_RIGHT,

  245. 	    PADDING_TOP, TEXT_ALIGN, TEXT_DECORATION, TEXT_INDENT, TEXT_TRANSFORM,

  246. 	    VERTICAL_ALIGN, WORD_SPACING, WHITE_SPACE, WIDTH

  247. 	};

  248. 

  249.     }

  250. 

  251.     static final class Value {

  252. 

  253. 	private Value(String name) {

  254. 	    this.name = name;

  255. 	}

  256. 

  257. 	/**

  258. 	 * The string representation of the attribute.  This

  259. 	 * should exactly match the string specified in the

  260. 	 * css specification.

  261. 	 */

  262. 	public String toString() {

  263. 	    return name;

  264. 	}

  265. 

  266. 	static final Value INHERITED = new Value("inherited");

  267. 	static final Value NONE = new Value("none");

  268. 	static final Value DOTTED = new Value("dotted");

  269. 	static final Value DASHED = new Value("dashed");

  270. 	static final Value SOLID = new Value("solid");

  271. 	static final Value DOUBLE = new Value("double");

  272. 	static final Value GROOVE = new Value("groove");

  273. 	static final Value RIDGE = new Value("ridge");

  274. 	static final Value INSET = new Value("inset");

  275. 	static final Value OUTSET = new Value("outset");

  276. 	// Lists.

  277. 	static final Value BLANK_LIST_ITEM = new Value("none");

  278. 	static final Value DISC = new Value("disc");

  279. 	static final Value CIRCLE = new Value("circle");

  280. 	static final Value SQUARE = new Value("square");

  281. 	static final Value DECIMAL = new Value("decimal");

  282. 	static final Value LOWER_ROMAN = new Value("lower-roman");

  283. 	static final Value UPPER_ROMAN = new Value("upper-roman");

  284. 	static final Value LOWER_ALPHA = new Value("lower-alpha");

  285. 	static final Value UPPER_ALPHA = new Value("upper-alpha");

  286. 

  287. 	private String name;

  288. 

  289. 	static final Value[] allValues = {

  290. 	    INHERITED, NONE, DOTTED, DASHED, SOLID, DOUBLE, GROOVE,

  291. 	    RIDGE, INSET, OUTSET, DISC, CIRCLE, SQUARE, DECIMAL,

  292. 	    LOWER_ROMAN, UPPER_ROMAN, LOWER_ALPHA, UPPER_ALPHA,

  293. 	    BLANK_LIST_ITEM

  294. 	};

  295.     }

  296. 

  297.     public CSS() {

  298. 	baseFontSize = 3;

  299. 	// setup the css conversion table

  300. 	valueConvertor = new Hashtable();

  301. 	valueConvertor.put(CSS.Attribute.FONT_SIZE, new FontSize());

  302. 	valueConvertor.put(CSS.Attribute.FONT_FAMILY, new FontFamily());

  303. 	valueConvertor.put(CSS.Attribute.FONT_WEIGHT, new FontWeight());

  304. 	valueConvertor.put(CSS.Attribute.BORDER_STYLE, new BorderStyle());

  305. 	Object cv = new ColorValue();

  306. 	valueConvertor.put(CSS.Attribute.COLOR, cv);

  307. 	valueConvertor.put(CSS.Attribute.BACKGROUND_COLOR, cv);

  308. 	valueConvertor.put(CSS.Attribute.BORDER_COLOR, cv);

  309. 	Object lv = new LengthValue();

  310. 	valueConvertor.put(CSS.Attribute.MARGIN_TOP, lv);

  311. 	valueConvertor.put(CSS.Attribute.MARGIN_BOTTOM, lv);

  312. 	valueConvertor.put(CSS.Attribute.MARGIN_LEFT, lv);

  313. 	valueConvertor.put(CSS.Attribute.MARGIN_RIGHT, lv);

  314. 	valueConvertor.put(CSS.Attribute.PADDING_TOP, lv);

  315. 	valueConvertor.put(CSS.Attribute.PADDING_BOTTOM, lv);

  316. 	valueConvertor.put(CSS.Attribute.PADDING_LEFT, lv);

  317. 	valueConvertor.put(CSS.Attribute.PADDING_RIGHT, lv);

  318. 	valueConvertor.put(CSS.Attribute.BORDER_WIDTH, lv);

  319. 	valueConvertor.put(CSS.Attribute.BORDER_TOP_WIDTH, lv);

  320. 	valueConvertor.put(CSS.Attribute.BORDER_BOTTOM_WIDTH, lv);

  321. 	valueConvertor.put(CSS.Attribute.BORDER_LEFT_WIDTH, lv);

  322. 	valueConvertor.put(CSS.Attribute.BORDER_RIGHT_WIDTH, lv);

  323. 	valueConvertor.put(CSS.Attribute.TEXT_INDENT, lv);

  324. 	valueConvertor.put(CSS.Attribute.WIDTH, lv);

  325. 	valueConvertor.put(CSS.Attribute.HEIGHT, lv);

  326. 	Object sv = new StringValue();

  327. 	valueConvertor.put(CSS.Attribute.FONT_STYLE, sv);

  328. 	valueConvertor.put(CSS.Attribute.TEXT_DECORATION, sv);

  329. 	valueConvertor.put(CSS.Attribute.TEXT_ALIGN, sv);

  330. 	valueConvertor.put(CSS.Attribute.VERTICAL_ALIGN, sv);

  331. 	valueConvertor.put(CSS.Attribute.LIST_STYLE_TYPE, new ListType());

  332. 	Object generic = new CssValue();

  333. 	int n = CSS.Attribute.allAttributes.length;

  334. 	for (int i = 0; i < n; i++) {

  335. 	    CSS.Attribute key = CSS.Attribute.allAttributes[i];

  336. 	    if (valueConvertor.get(key) == null) {

  337. 		valueConvertor.put(key, generic);

  338. 	    }

  339. 	}

  340.     }

  341. 

  342.     /**

  343.      * Sets the base font size. <code>sz</code> is a CSS value, and is

  344.      * not necessarily the point size. Use getPointSize to determine the

  345.      * point size corresponding to <code>sz</code>.

  346.      */

  347.     void setBaseFontSize(int sz) {

  348. 	if (sz < 1)

  349. 	  baseFontSize = 0;

  350. 	else if (sz > 7)

  351. 	  baseFontSize = 7;

  352. 	else

  353. 	  baseFontSize = sz;

  354.     }

  355. 

  356.     /**

  357.      * Sets the base font size from the passed in string.

  358.      */

  359.     void setBaseFontSize(String size) {

  360. 	int relSize, absSize, diff;

  361. 

  362. 	if (size != null) {

  363. 	    if (size.startsWith("+")) {

  364. 		relSize = Integer.valueOf(size.substring(1)).intValue();

  365. 		setBaseFontSize(baseFontSize + relSize);

  366. 	    } else if (size.startsWith("-")) {

  367. 		relSize = -Integer.valueOf(size.substring(1)).intValue();

  368. 		setBaseFontSize(baseFontSize + relSize);

  369. 	    } else {

  370. 		setBaseFontSize(Integer.valueOf(size).intValue());

  371. 	    }

  372. 	}

  373.     }

  374. 

  375.     /**

  376.      * Returns the base font size.

  377.      */

  378.     int getBaseFontSize() {

  379. 	return baseFontSize;

  380.     }

  381. 

  382.     /**

  383.      * Gets the internal CSS representation of <code>value</code> which is

  384.      * a CSS value of the CSS attribute named <code>key</code>.

  385.      */

  386.     Object getInternalCSSValue(CSS.Attribute key, String value) {

  387. 	CssValue conv = (CssValue) valueConvertor.get(key);

  388. 	return conv.parseCssValue(value);

  389.     }

  390. 

  391.     /**

  392.      * Maps from a StyleConstants to a CSS Attribute.

  393.      */

  394.     Attribute styleConstantsKeyToCSSKey(StyleConstants sc) {

  395. 	return (Attribute)styleConstantToCssMap.get(sc);

  396.     }

  397. 

  398.     /**

  399.      * Maps from a StyleConstants value to a CSS value.

  400.      */

  401.     Object styleConstantsValueToCSSValue(StyleConstants sc,

  402. 					 Object styleValue) {

  403. 	Object cssKey = styleConstantsKeyToCSSKey(sc);

  404. 	if (cssKey != null) {

  405. 	    CssValue conv = (CssValue)valueConvertor.get(cssKey);

  406. 	    return conv.fromStyleConstants(sc, styleValue);

  407. 	}

  408. 	return null;

  409.     }

  410. 

  411.     /**

  412.      * Converts the passed in CSS value to a StyleConstants value.

  413.      * <code>key</code> identifies the CSS attribute being mapped.

  414.      */

  415.     Object cssValueToStyleConstantsValue(StyleConstants key, Object value) {

  416. 	if (value instanceof CssValue) {

  417. 	    return ((CssValue)value).toStyleConstants((StyleConstants)key);

  418. 	}

  419. 	return null;

  420.     }

  421. 

  422.     /**

  423.      * Returns the font for the values in the passed in AttributeSet.

  424.      * It is assumed the keys will be CSS.Attribute keys.

  425.      * <code>sc</code> is the StyleContext that will be messaged to get

  426.      * the font once the size, name and style have been determined.

  427.      */

  428.     Font getFont(StyleContext sc, AttributeSet a, int defaultSize) {

  429. 	// PENDING(prinz) this is a 1.1 based implementation, need to also

  430. 	// have a 1.2 version.

  431. 	FontSize sizeValue = (FontSize)a.getAttribute(CSS.Attribute.FONT_SIZE);

  432. 

  433. 	int size = (sizeValue != null) ? (int) sizeValue.getValue(a) :

  434. 	                                 defaultSize;

  435. 

  436. 	/*

  437. 	 * If the vertical alignment is set to either superscirpt or

  438. 	 * subscript we reduce the font size by 2 points.

  439. 	 */

  440. 	StringValue vAlignV = (StringValue)a.getAttribute

  441. 	                      (CSS.Attribute.VERTICAL_ALIGN);

  442. 	if ((vAlignV != null)) {

  443. 	    String vAlign = vAlignV.toString();

  444. 	    if ((vAlign.indexOf("sup") >= 0) ||

  445. 		(vAlign.indexOf("sub") >= 0)) {

  446. 		size -= 2;

  447. 	    }

  448. 	}

  449. 	

  450. 	FontFamily familyValue = (FontFamily)a.getAttribute

  451. 	                                    (CSS.Attribute.FONT_FAMILY);

  452. 	String family = (familyValue != null) ? familyValue.getValue() :

  453. 	                          "SansSerif";

  454. 	int style = Font.PLAIN;

  455. 	FontWeight weightValue = (FontWeight) a.getAttribute

  456. 	                          (CSS.Attribute.FONT_WEIGHT);

  457. 	if ((weightValue != null) && (weightValue.getValue() > 400)) {

  458. 	    style |= Font.BOLD;

  459. 	}

  460. 	Object fs = a.getAttribute(CSS.Attribute.FONT_STYLE);

  461. 	if ((fs != null) && (fs.toString().indexOf("italic") >= 0)) {

  462. 	    style |= Font.ITALIC;

  463. 	}

  464. 	Font f = sc.getFont(family, style, size);

  465. 	return f;

  466.     }

  467. 

  468.     /**

  469.      * Takes a set of attributes and turn it into a color

  470.      * specification.  This might be used to specify things

  471.      * like brighter, more hue, etc.

  472.      * This will return null if there is no value for <code>key</code>.

  473.      *

  474.      * @parram key CSS.Attribute identifying where color is stored.

  475.      * @param a the set of attributes

  476.      * @return the color

  477.      */

  478.     Color getColor(AttributeSet a, CSS.Attribute key) {

  479. 	ColorValue cv = (ColorValue) a.getAttribute(key);

  480. 	if (cv != null) {

  481. 	    return cv.getValue();

  482. 	}

  483. 	return null;

  484.     }

  485. 

  486.     /**

  487.      * Returns the size of a font from the passed in string.

  488.      *

  489.      * @param size CSS string describing font size

  490.      * @param baseFontSize size to use for relative units.

  491.      */

  492.     float getPointSize(String size) {

  493. 	int relSize, absSize, diff, index;

  494. 	if (size != null) {

  495. 	    if (size.startsWith("+")) {

  496. 		relSize = Integer.valueOf(size.substring(1)).intValue();

  497. 		return getPointSize(baseFontSize + relSize);

  498. 	    } else if (size.startsWith("-")) {

  499. 		relSize = -Integer.valueOf(size.substring(1)).intValue();

  500. 		return getPointSize(baseFontSize + relSize);

  501. 	    } else {

  502. 		absSize = Integer.valueOf(size).intValue();

  503. 		return getPointSize(absSize);

  504. 	    }

  505. 	}

  506. 	return 0;

  507.     }

  508. 

  509.     /**

  510.      * Returns the length of the attribute in <code>a</code> with

  511.      * key <code>key</code>.

  512.      */

  513.     float getLength(AttributeSet a, CSS.Attribute key) {

  514. 	LengthValue lv = (LengthValue) a.getAttribute(key);

  515. 	float len = (lv != null) ? lv.getValue() : 0;

  516. 	return len;

  517.     }

  518. 

  519.     /**

  520.      * Convert a set of html attributes to an equivalent

  521.      * set of css attributes.

  522.      *

  523.      * @param AttributeSet containing the HTML attributes.

  524.      * @return AttributeSet containing the corresponding CSS attributes.

  525.      *        The AttributeSet will be empty if there are no mapping

  526.      *        CSS attributes.

  527.      */

  528.     AttributeSet translateHTMLToCSS(AttributeSet htmlAttrSet) {

  529. 	MutableAttributeSet cssAttrSet = new SimpleAttributeSet();

  530. 	Element elem = (Element)htmlAttrSet;

  531. 	HTML.Tag tag = getHTMLTag(htmlAttrSet);

  532. 	if ((tag == HTML.Tag.TD) || (tag == HTML.Tag.TH)) {

  533. 	    // translate border width into the cells

  534. 	    AttributeSet tableAttr = elem.getParentElement().

  535. 		                     getParentElement().getAttributes();

  536. 	    translateAttribute(HTML.Attribute.BORDER, tableAttr, cssAttrSet);

  537. 	    String pad = (String)tableAttr.getAttribute(HTML.Attribute.CELLPADDING);

  538. 	    if (pad != null) {

  539. 		Object v = getInternalCSSValue(CSS.Attribute.PADDING_TOP, pad);

  540. 		cssAttrSet.addAttribute(CSS.Attribute.PADDING_TOP, v);

  541. 		cssAttrSet.addAttribute(CSS.Attribute.PADDING_BOTTOM, v);

  542. 		cssAttrSet.addAttribute(CSS.Attribute.PADDING_LEFT, v);

  543. 		cssAttrSet.addAttribute(CSS.Attribute.PADDING_RIGHT, v);

  544. 	    }

  545. 	}

  546. 	if (elem.isLeaf()) {

  547. 	    translateEmbeddedAttributes(htmlAttrSet, cssAttrSet);

  548. 	} else {

  549. 	    translateAttributes(tag, htmlAttrSet, cssAttrSet);

  550. 	}

  551. 	return cssAttrSet;

  552.     }

  553. 

  554. 

  555.     private static final Hashtable attributeMap = new Hashtable();

  556.     private static final Hashtable valueMap = new Hashtable();

  557.     /**

  558.      * The html/css size model has seven slots

  559.      * that one can assign sizes to.

  560.      */

  561.     static int sizeMap[] = { 8, 10, 12, 14, 18, 24, 36 };

  562. 

  563.     /**

  564.      * The hashtable and the static initalization block below,

  565.      * set up a mapping from well-known HTML attributes to

  566.      * CSS attributes.  For the most part, there is a 1-1 mapping

  567.      * between the two.  However in the case of certain HTML

  568.      * attributes for example HTML.Attribute.VSPACE or

  569.      * HTML.Attribute.HSPACE, end up mapping to two CSS.Attribute's.

  570.      * Therefore, the value associated with each HTML.Attribute.

  571.      * key ends up being an array of CSS.Attribute.* objects.

  572.      */

  573.     private static final Hashtable htmlAttrToCssAttrMap = new Hashtable(20);

  574. 

  575.     /**

  576.      * The hashtable and static initialization that follows sets

  577.      * up a translation from StyleConstants (i.e. the <em>well known</em>

  578.      * attributes) to the associated CSS attributes.

  579.      */

  580.     private static final Hashtable styleConstantToCssMap = new Hashtable(17);

  581.     /** Maps from HTML value to a CSS value. Used in internal mapping. */

  582.     private static final Hashtable htmlValueToCssValueMap = new Hashtable(8);

  583.     /** Maps from CSS value (string) to internal value. */

  584.     private static final Hashtable cssValueToInternalValueMap = new Hashtable(8);

  585. 

  586.     static {

  587. 	// load the attribute map

  588. 	for (int i = 0; i < Attribute.allAttributes.length; i++ ) {

  589. 	    attributeMap.put(Attribute.allAttributes[i].toString(),

  590. 			     Attribute.allAttributes[i]);

  591. 	}

  592. 	// load the value map

  593. 	for (int i = 0; i < Value.allValues.length; i++ ) {

  594. 	    valueMap.put(Value.allValues[i].toString(), 

  595. 			     Value.allValues[i]);

  596. 	}

  597. 

  598. 	htmlAttrToCssAttrMap.put(HTML.Attribute.COLOR,

  599. 				 new CSS.Attribute[]{CSS.Attribute.COLOR});

  600. 	htmlAttrToCssAttrMap.put(HTML.Attribute.TEXT,

  601. 				 new CSS.Attribute[]{CSS.Attribute.COLOR});

  602. 	htmlAttrToCssAttrMap.put(HTML.Attribute.CLEAR,

  603. 				 new CSS.Attribute[]{CSS.Attribute.CLEAR});

  604. 	htmlAttrToCssAttrMap.put(HTML.Attribute.BACKGROUND,

  605. 				 new CSS.Attribute[]{CSS.Attribute.BACKGROUND_IMAGE});

  606. 	htmlAttrToCssAttrMap.put(HTML.Attribute.BGCOLOR,

  607. 				 new CSS.Attribute[]{CSS.Attribute.BACKGROUND_COLOR});

  608. 	htmlAttrToCssAttrMap.put(HTML.Attribute.WIDTH,

  609. 				 new CSS.Attribute[]{CSS.Attribute.WIDTH});

  610. 	htmlAttrToCssAttrMap.put(HTML.Attribute.HEIGHT,

  611. 				 new CSS.Attribute[]{CSS.Attribute.HEIGHT});

  612. 	htmlAttrToCssAttrMap.put(HTML.Attribute.BORDER,

  613. 				 new CSS.Attribute[]{CSS.Attribute.BORDER_WIDTH});

  614. 	htmlAttrToCssAttrMap.put(HTML.Attribute.CELLPADDING,

  615. 				 new CSS.Attribute[]{CSS.Attribute.PADDING});

  616. 	htmlAttrToCssAttrMap.put(HTML.Attribute.CELLSPACING,

  617. 				 new CSS.Attribute[]{CSS.Attribute.MARGIN});

  618. 	htmlAttrToCssAttrMap.put(HTML.Attribute.MARGINWIDTH,

  619. 				 new CSS.Attribute[]{CSS.Attribute.MARGIN_LEFT,

  620. 						     CSS.Attribute.MARGIN_RIGHT});

  621. 	htmlAttrToCssAttrMap.put(HTML.Attribute.MARGINHEIGHT,

  622. 				 new CSS.Attribute[]{CSS.Attribute.MARGIN_TOP,

  623. 						     CSS.Attribute.MARGIN_BOTTOM});

  624. 	htmlAttrToCssAttrMap.put(HTML.Attribute.HSPACE,

  625. 				 new CSS.Attribute[]{CSS.Attribute.PADDING_LEFT,

  626. 						     CSS.Attribute.PADDING_RIGHT});

  627. 	htmlAttrToCssAttrMap.put(HTML.Attribute.VSPACE,

  628. 				 new CSS.Attribute[]{CSS.Attribute.PADDING_BOTTOM,

  629. 						     CSS.Attribute.PADDING_TOP});

  630. 	htmlAttrToCssAttrMap.put(HTML.Attribute.FACE,

  631. 				 new CSS.Attribute[]{CSS.Attribute.FONT_FAMILY});

  632. 	htmlAttrToCssAttrMap.put(HTML.Attribute.SIZE,

  633. 				 new CSS.Attribute[]{CSS.Attribute.FONT_SIZE});

  634. 	htmlAttrToCssAttrMap.put(HTML.Attribute.VALIGN,

  635. 				 new CSS.Attribute[]{CSS.Attribute.VERTICAL_ALIGN});

  636. 	htmlAttrToCssAttrMap.put(HTML.Attribute.ALIGN,

  637. 				 new CSS.Attribute[]{CSS.Attribute.VERTICAL_ALIGN,

  638. 						     CSS.Attribute.TEXT_ALIGN,

  639. 						     CSS.Attribute.FLOAT});

  640. 	htmlAttrToCssAttrMap.put(HTML.Attribute.TYPE,

  641. 				 new CSS.Attribute[]{CSS.Attribute.LIST_STYLE_TYPE});

  642. 

  643. 	// initialize StyleConstants mapping 

  644. 	styleConstantToCssMap.put(StyleConstants.FontFamily, 

  645. 				  CSS.Attribute.FONT_FAMILY);

  646. 	styleConstantToCssMap.put(StyleConstants.FontSize, 

  647. 				  CSS.Attribute.FONT_SIZE);

  648. 	styleConstantToCssMap.put(StyleConstants.Bold, 

  649. 				  CSS.Attribute.FONT_WEIGHT);

  650. 	styleConstantToCssMap.put(StyleConstants.Italic, 

  651. 				  CSS.Attribute.FONT_STYLE);

  652. 	styleConstantToCssMap.put(StyleConstants.Underline, 

  653. 				  CSS.Attribute.TEXT_DECORATION);

  654. 	styleConstantToCssMap.put(StyleConstants.StrikeThrough, 

  655. 				  CSS.Attribute.TEXT_DECORATION);

  656. 	styleConstantToCssMap.put(StyleConstants.Superscript, 

  657. 				  CSS.Attribute.VERTICAL_ALIGN);

  658. 	styleConstantToCssMap.put(StyleConstants.Subscript, 

  659. 				  CSS.Attribute.VERTICAL_ALIGN);

  660. 	styleConstantToCssMap.put(StyleConstants.Foreground, 

  661. 				  CSS.Attribute.COLOR);

  662. 	styleConstantToCssMap.put(StyleConstants.Background, 

  663. 				  CSS.Attribute.BACKGROUND_COLOR);

  664. 	styleConstantToCssMap.put(StyleConstants.FirstLineIndent, 

  665. 				  CSS.Attribute.TEXT_INDENT);

  666. 	styleConstantToCssMap.put(StyleConstants.LeftIndent, 

  667. 				  CSS.Attribute.MARGIN_LEFT);

  668. 	styleConstantToCssMap.put(StyleConstants.RightIndent, 

  669. 				  CSS.Attribute.MARGIN_RIGHT);

  670. 	styleConstantToCssMap.put(StyleConstants.SpaceAbove, 

  671. 				  CSS.Attribute.MARGIN_TOP);

  672. 	styleConstantToCssMap.put(StyleConstants.SpaceBelow, 

  673. 				  CSS.Attribute.MARGIN_BOTTOM);

  674. 	styleConstantToCssMap.put(StyleConstants.Alignment, 

  675. 				  CSS.Attribute.TEXT_ALIGN);

  676. 

  677. 	// HTML->CSS

  678. 	htmlValueToCssValueMap.put("disc", CSS.Value.DISC);

  679. 	htmlValueToCssValueMap.put("square", CSS.Value.SQUARE);

  680. 	htmlValueToCssValueMap.put("circle", CSS.Value.CIRCLE);

  681. 	htmlValueToCssValueMap.put("1", CSS.Value.DECIMAL);

  682. 	htmlValueToCssValueMap.put("a", CSS.Value.LOWER_ALPHA);

  683. 	htmlValueToCssValueMap.put("A", CSS.Value.UPPER_ALPHA);

  684. 	htmlValueToCssValueMap.put("i", CSS.Value.LOWER_ROMAN);

  685. 	htmlValueToCssValueMap.put("I", CSS.Value.UPPER_ROMAN);

  686. 

  687. 	// CSS-> internal CSS

  688. 	cssValueToInternalValueMap.put("disc", CSS.Value.DISC);

  689. 	cssValueToInternalValueMap.put("square", CSS.Value.SQUARE);

  690. 	cssValueToInternalValueMap.put("circle", CSS.Value.CIRCLE);

  691. 	cssValueToInternalValueMap.put("decimal", CSS.Value.DECIMAL);

  692. 	cssValueToInternalValueMap.put("lower-roman", CSS.Value.LOWER_ROMAN);

  693. 	cssValueToInternalValueMap.put("upper-roman", CSS.Value.UPPER_ROMAN);

  694. 	cssValueToInternalValueMap.put("lower-alpha", CSS.Value.LOWER_ALPHA);

  695. 	cssValueToInternalValueMap.put("upper-alpha", CSS.Value.UPPER_ALPHA);

  696. 

  697.         // Register all the CSS attribute keys for archival/unarchival

  698. 	Object[] keys = CSS.Attribute.allAttributes;

  699. 	try {

  700. 	    for (int i = 0; i < keys.length; i++) {

  701. 		StyleContext.registerStaticAttributeKey(keys[i]);

  702. 	    }

  703. 	} catch (Throwable e) {

  704. 	    e.printStackTrace();

  705. 	}

  706.     }

  707. 

  708.     /**

  709.      * Return the set of all possible CSS attribute keys.

  710.      */

  711.     public static Attribute[] getAllAttributeKeys() {

  712. 	Attribute[] keys = new Attribute[Attribute.allAttributes.length];

  713. 	System.arraycopy(Attribute.allAttributes, 0, keys, 0, Attribute.allAttributes.length);

  714. 	return keys;

  715.     }

  716. 

  717.     /**

  718.      * Translate a string to a CSS.Attribute object.  This

  719.      * will return null if there is no attribute by the given

  720.      * name.

  721.      * @param name the name of the css attribute to fetch the

  722.      *  typesafe enumeration for.

  723.      * @returns the CSS.Attribute object, or null if the string

  724.      *  doesn't represent a valid attribute key.

  725.      */

  726.     public static final Attribute getAttribute(String name) {

  727. 	return (Attribute) attributeMap.get(name);

  728.     }

  729. 

  730.     /**

  731.      * Translate a string to a CSS.Value object.  This

  732.      * will return null if there is no value by the given

  733.      * name.

  734.      * @param name the name of the css value to fetch the

  735.      *  typesafe enumeration for.

  736.      * @returns the CSS.Value object, or null if the string

  737.      *  doesn't represent a valid css value name.  This does

  738.      *  not mean it doesn't represent a valid css value.

  739.      */

  740.     static final Value getValue(String name) {

  741. 	return (Value) valueMap.get(name);

  742.     }

  743. 

  744. 

  745.     //

  746.     // Conversion related methods/classes

  747.     //

  748. 

  749.     /**

  750.      * Converts a type Color to a hex string

  751.      * in the format "#RRGGBB"

  752.      */

  753.     static String colorToHex(Color color) {

  754. 

  755.       String colorstr = new String("#");

  756. 

  757.       // Red

  758.       String str = Integer.toHexString(color.getRed());

  759.       if (str.length() > 2)

  760. 	str = str.substring(0, 2);

  761.       else if (str.length() < 2)

  762. 	colorstr += "0" + str;

  763.       else

  764. 	colorstr += str;

  765. 

  766.       // Green

  767.       str = Integer.toHexString(color.getGreen());

  768.       if (str.length() > 2)

  769. 	str = str.substring(0, 2);

  770.       else if (str.length() < 2)

  771. 	colorstr += "0" + str;

  772.       else

  773. 	colorstr += str;

  774. 

  775.       // Blue

  776.       str = Integer.toHexString(color.getBlue());

  777.       if (str.length() > 2)

  778. 	str = str.substring(0, 2);

  779.       else if (str.length() < 2)

  780. 	colorstr += "0" + str;

  781.       else

  782. 	colorstr += str;

  783. 

  784.       return colorstr;

  785.     }

  786. 

  787.      /**

  788.       * Convert a "#FFFFFF" hex string to a Color.

  789.       * If the color specification is bad, an attempt

  790.       * will be made to fix it up.

  791.       */

  792.     static final Color hexToColor(String value) {

  793. 	 if (value.startsWith("#")) {

  794. 	     String digits = value.substring(1, Math.min(value.length(), 7));

  795. 	     String hstr = "0x" + digits;

  796. 	     Color c = Color.decode(hstr);

  797. 	     return c;

  798. 	 }

  799. 	 return null;

  800.      }

  801. 

  802.     /**

  803.      * Convert a color string "RED" or "#NNNNNN" to a Color.

  804.      * Note: This will only convert the HTML3.2 colors strings

  805.      *       or string of length 7

  806.      *       otherwise, it will return null.

  807.      */

  808.     static Color stringToColor(String str) {

  809.       Color color = null;

  810. 

  811.       if (str.charAt(0) == '#')

  812.         color = hexToColor(str);

  813.       else if (str.equalsIgnoreCase("Black"))

  814.         color = hexToColor("#000000");

  815.       else if(str.equalsIgnoreCase("Silver"))

  816.         color = hexToColor("#C0C0C0");

  817.       else if(str.equalsIgnoreCase("Gray"))

  818.         color = hexToColor("#808080");

  819.       else if(str.equalsIgnoreCase("White"))

  820.         color = hexToColor("#FFFFFF");

  821.       else if(str.equalsIgnoreCase("Maroon"))

  822.         color = hexToColor("#800000");

  823.       else if(str.equalsIgnoreCase("Red"))

  824.         color = hexToColor("#FF0000");

  825.       else if(str.equalsIgnoreCase("Purple"))

  826.         color = hexToColor("#800080");

  827.       else if(str.equalsIgnoreCase("Fuchsia"))

  828.         color = hexToColor("#FF00FF");

  829.       else if(str.equalsIgnoreCase("Green"))

  830.         color = hexToColor("#008000");

  831.       else if(str.equalsIgnoreCase("Lime"))

  832.         color = hexToColor("#00FF00");

  833.       else if(str.equalsIgnoreCase("Olive"))

  834.         color = hexToColor("#808000");

  835.       else if(str.equalsIgnoreCase("Yellow"))

  836.         color = hexToColor("#FFFF00");

  837.       else if(str.equalsIgnoreCase("Navy"))

  838.         color = hexToColor("#000080");

  839.       else if(str.equalsIgnoreCase("Blue"))

  840.         color = hexToColor("#0000FF");

  841.       else if(str.equalsIgnoreCase("Teal"))

  842.         color = hexToColor("#008080");

  843.       else if(str.equalsIgnoreCase("Aqua"))

  844.         color = hexToColor("#00FFFF");

  845.       return color;

  846.     }

  847. 

  848.     static int getIndexOfSize(float pt) {

  849.         for (int i = 0; i < sizeMap.length; i ++ )

  850.                 if (pt <= sizeMap[i])

  851.                         return i;

  852.         return sizeMap.length - 1;

  853.     }

  854. 

  855.     /**

  856.      * Return the point size, given a size index.

  857.      */

  858.     float getPointSize(int index) {

  859. 	if (index < 0)

  860. 	  return sizeMap[0];

  861. 	else if (index > sizeMap.length - 1)

  862. 	  return sizeMap[sizeMap.length - 1];

  863. 	else

  864. 	  return sizeMap[index];

  865.     }

  866. 

  867. 

  868.     private void translateEmbeddedAttributes(AttributeSet htmlAttrSet,

  869. 					     MutableAttributeSet cssAttrSet) {

  870. 	Enumeration keys = htmlAttrSet.getAttributeNames();

  871. 	while (keys.hasMoreElements()) {

  872. 	    Object key = keys.nextElement();

  873. 	    if (key instanceof HTML.Tag) {

  874. 		HTML.Tag tag = (HTML.Tag)key;

  875. 		Object o = htmlAttrSet.getAttribute(tag);

  876. 		if (o != null && o instanceof AttributeSet) {

  877. 		    translateAttributes(tag, (AttributeSet)o, cssAttrSet);

  878. 		}

  879. 	    } else if (key instanceof CSS.Attribute) {

  880. 		cssAttrSet.addAttribute(key, htmlAttrSet.getAttribute(key));

  881. 	    }

  882. 	}

  883.     }

  884. 

  885.     private void translateAttributes(HTML.Tag tag,

  886. 					    AttributeSet htmlAttrSet,

  887. 					    MutableAttributeSet cssAttrSet) {

  888. 	Enumeration names = htmlAttrSet.getAttributeNames();

  889. 	while (names.hasMoreElements()) {

  890. 	    Object name = names.nextElement();

  891. 

  892. 	    if (name instanceof HTML.Attribute) {

  893. 		HTML.Attribute key = (HTML.Attribute)name;

  894. 

  895. 		/*

  896. 		 * HTML.Attribute.ALIGN needs special processing.

  897. 		 * It can map to to 1 of many(3) possible CSS attributes

  898. 		 * depending on the nature of the tag the attribute is

  899. 		 * part off and depending on the value of the attribute.

  900. 		 */

  901. 		if (key == HTML.Attribute.ALIGN) {

  902. 		    String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);

  903. 		    if (htmlAttrValue != null) {

  904. 			CSS.Attribute cssAttr = getCssAlignAttribute(tag, htmlAttrSet);

  905. 			if (cssAttr != null) {

  906. 			    Object o = getCssValue(cssAttr, htmlAttrValue);

  907. 			    if (o != null) {

  908. 				cssAttrSet.addAttribute(cssAttr, o);

  909. 			    }

  910. 			}

  911. 		    }

  912. 		} else {

  913. 

  914. 		    /*

  915. 		     * The html size attribute has a mapping in the CSS world only

  916. 		     * if it is par of a font or base font tag.

  917. 		     */

  918. 

  919. 		    if (key == HTML.Attribute.SIZE && !isHTMLFontTag(tag)) {

  920. 			continue;

  921. 		    }

  922. 

  923. 		    translateAttribute(key, htmlAttrSet, cssAttrSet);

  924. 		}

  925. 	    } else if (name instanceof CSS.Attribute) {

  926. 		cssAttrSet.addAttribute(name, htmlAttrSet.getAttribute(name));

  927. 	    }

  928. 	}

  929.     }

  930. 

  931.     private void translateAttribute(HTML.Attribute key,

  932. 					   AttributeSet htmlAttrSet,

  933. 					   MutableAttributeSet cssAttrSet) {

  934. 	/*

  935. 	 * In the case of all remaining HTML.Attribute's they

  936. 	 * map to 1 or more CCS.Attribute.

  937. 	 */

  938. 	CSS.Attribute[] cssAttrList = getCssAttribute(key);

  939. 	

  940. 	String htmlAttrValue = (String)htmlAttrSet.getAttribute(key);

  941. 	

  942. 	if (cssAttrList == null || htmlAttrValue == null) {

  943. 	    return;

  944. 	}

  945. 	for (int i = 0; i < cssAttrList.length; i++) {

  946. 	    Object o = getCssValue(cssAttrList[i], htmlAttrValue);

  947. 	    if (o != null) {

  948. 		cssAttrSet.addAttribute(cssAttrList[i], o);

  949. 	    }

  950. 	}

  951.     }

  952. 

  953.     /**

  954.      * Given a CSS.Attribute object and its corresponding HTML.Attribute's

  955.      * value, this method returns a CssValue object to associate with the

  956.      * CSS attribute.

  957.      *

  958.      * @param the CSS.Attribute

  959.      * @param a String containing the value associated HTML.Attribtue.

  960.      */

  961.     Object getCssValue(CSS.Attribute cssAttr, String htmlAttrValue) {

  962. 	CssValue value = (CssValue)valueConvertor.get(cssAttr);

  963. 	Object o = value.parseHtmlValue(htmlAttrValue);

  964. 	return o;

  965.     }

  966. 

  967.     /**

  968.      * Maps an HTML.Attribute object to its appropriate CSS.Attributes.

  969.      *

  970.      * @param HTML.Attribute

  971.      * @return CSS.Attribute[]

  972.      */

  973.     private CSS.Attribute[] getCssAttribute(HTML.Attribute hAttr) {

  974. 	return (CSS.Attribute[])htmlAttrToCssAttrMap.get(hAttr);

  975.     }

  976. 

  977.     /**

  978.      * Maps HTML.Attribute.ALIGN to either:

  979.      *     CSS.Attribute.TEXT_ALIGN

  980.      *     CSS.Attribute.FLOAT

  981.      *     CSS.Attribute.VERTICAL_ALIGN

  982.      * based on the tag associated with the attribute and the

  983.      * value of the attribute.

  984.      *

  985.      * @param AttributeSet containing html attributes.

  986.      * @return CSS.Attribute mapping for HTML.Attribute.ALIGN.

  987.      */

  988.     private CSS.Attribute getCssAlignAttribute(HTML.Tag tag,

  989. 						   AttributeSet htmlAttrSet) {

  990. 	return CSS.Attribute.TEXT_ALIGN;

  991. /*

  992. 	String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);

  993. 	CSS.Attribute cssAttr = CSS.Attribute.TEXT_ALIGN;

  994. 	if (htmlAttrValue != null && htmlAttrSet instanceof Element) {

  995. 	    Element elem = (Element)htmlAttrSet;

  996. 	    if (!elem.isLeaf() && tag.isBlock() && validTextAlignValue(htmlAttrValue)) {

  997. 		return CSS.Attribute.TEXT_ALIGN;

  998. 	    } else if (isFloater(htmlAttrValue)) {

  999. 		return CSS.Attribute.FLOAT;

  1000. 	    } else if (elem.isLeaf()) {

  1001. 		return CSS.Attribute.VERTICAL_ALIGN;

  1002. 	    }

  1003.  	}

  1004. 	return null;

  1005. 	*/

  1006.     }

  1007. 

  1008.     /**

  1009.      * Fetches the tag associated with the HTML AttributeSet.

  1010.      *

  1011.      * @param  AttributeSet containing the html attributes.

  1012.      * @return HTML.Tag

  1013.      */

  1014.     private HTML.Tag getHTMLTag(AttributeSet htmlAttrSet) {

  1015. 	Object o = htmlAttrSet.getAttribute(StyleConstants.NameAttribute);

  1016. 	if (o instanceof HTML.Tag) {

  1017. 	    HTML.Tag tag = (HTML.Tag) o;

  1018. 	    return tag;

  1019. 	}

  1020. 	return null;

  1021.     }

  1022. 

  1023. 

  1024.     private boolean isHTMLFontTag(HTML.Tag tag) {

  1025. 	return (tag != null && ((tag == HTML.Tag.FONT) || (tag == HTML.Tag.BASEFONT)));

  1026.     }

  1027. 

  1028. 

  1029.     private boolean isFloater(String alignValue) {

  1030. 	return (alignValue.equals("left") || alignValue.equals("right"));

  1031.     }

  1032. 

  1033.     private boolean validTextAlignValue(String alignValue) {

  1034. 	return (isFloater(alignValue) || alignValue.equals("center"));

  1035.     }

  1036. 

  1037.     /**

  1038.      * Base class to CSS values in the attribute sets.  This

  1039.      * is intended to act as a convertor to/from other attribute

  1040.      * formats.

  1041.      * <p>

  1042.      * The css parser uses the parseCssValue method to convert

  1043.      * a string to whatever format is appropriate a given key

  1044.      * (i.e. these convertors are stored in a map using the

  1045.      * CSS.Attribute as a key and the CssValue as the value).

  1046.      * <p>

  1047.      * The html to css conversion process first converts the

  1048.      * HTML.Attribute to a CSS.Attribute, and then calls

  1049.      * the parseHtmlValue method on the value of the html

  1050.      * attribute to produce the corresponding css value.

  1051.      * <p>

  1052.      * The StyleConstants to CSS conversion process first 

  1053.      * converts the StyleConstants attribute to a 

  1054.      * CSS.Attribute, and then calls the fromStyleConstants

  1055.      * method to convert the StyleConstants value to a 

  1056.      * CSS value.

  1057.      * <p>

  1058.      * The CSS to StyleConstants conversion process first

  1059.      * converts the StyleConstants attribute to a 

  1060.      * CSS.Attribute, and then calls the toStyleConstants

  1061.      * method to convert the CSS value to a StyleConstants

  1062.      * value.

  1063.      */

  1064.     static class CssValue implements Serializable {

  1065. 

  1066. 	/**

  1067. 	 * Convert a css value string to the internal format

  1068. 	 * (for fast processing) used in the attribute sets.

  1069. 	 * The fallback storage for any value that we don't

  1070. 	 * have a special binary format for is a String.

  1071. 	 */

  1072. 	Object parseCssValue(String value) {

  1073. 	    return value;

  1074. 	}

  1075. 

  1076. 	/**

  1077. 	 * Convert an html attribute value to a css attribute

  1078. 	 * value.  If there is no conversion, return null.

  1079. 	 * This is implemented to simply forward to the css

  1080. 	 * parsing by default (since some of the attribute

  1081. 	 * values are the same).  If the attribute value

  1082. 	 * isn't recognized as a css value it is generally

  1083. 	 * returned as null.

  1084. 	 */

  1085. 	Object parseHtmlValue(String value) {

  1086. 	    return parseCssValue(value);

  1087. 	}

  1088. 

  1089. 	/**

  1090. 	 * Convert a StyleConstants attribute value to

  1091. 	 * a css attribute value.  If there is no conversion

  1092. 	 * return null.  By default, there is no conversion.

  1093. 	 * 

  1094. 	 * @param key the StyleConstants attribute.

  1095. 	 * @param value the value of a StyleConstants attribute,

  1096. 	 *   to be converted.

  1097. 	 * @returns the CSS value that represents the StyleConstants

  1098. 	 *   value.

  1099. 	 */

  1100. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1101. 	    return null;

  1102. 	}

  1103. 

  1104. 	/**

  1105. 	 * Convert a CSS attribute value to a StyleConstants

  1106. 	 * value.  If there is no conversion, return null.

  1107. 	 * By default, there is no conversion.

  1108. 	 *

  1109. 	 * @param key the StyleConstants attribute.

  1110. 	 * @returns the StyleConstants attribute value that 

  1111. 	 *   represents the CSS attribute value.

  1112. 	 */

  1113. 	Object toStyleConstants(StyleConstants key) {

  1114. 	    return null;

  1115. 	}

  1116. 

  1117. 	/**

  1118. 	 * Return the css format of the value

  1119. 	 */

  1120.         public String toString() {

  1121. 	    return svalue;

  1122. 	}

  1123. 

  1124. 	/**

  1125. 	 * The value as a string... before conversion to a

  1126. 	 * binary format.

  1127. 	 */

  1128. 	String svalue;

  1129.     }

  1130. 

  1131.     /**

  1132.      * By default CSS attributes are represented as simple

  1133.      * strings.  They also have no conversion to/from

  1134.      * StyleConstants by default. This class represents the 

  1135.      * value as a string (via the superclass), but 

  1136.      * provides StyleConstants conversion support for the 

  1137.      * CSS attributes that are held as strings.

  1138.      */

  1139.     static class StringValue extends CssValue {

  1140. 

  1141. 	/**

  1142. 	 * Convert a css value string to the internal format

  1143. 	 * (for fast processing) used in the attribute sets.

  1144. 	 * This produces a StringValue, so that it can be

  1145. 	 * used to convert from CSS to StyleConstants values.

  1146. 	 */

  1147. 	Object parseCssValue(String value) {

  1148. 	    StringValue sv = new StringValue();

  1149. 	    sv.svalue = value;

  1150. 	    return sv;

  1151. 	}

  1152. 

  1153. 	/**

  1154. 	 * Convert a StyleConstants attribute value to

  1155. 	 * a css attribute value.  If there is no conversion

  1156. 	 * return null. 

  1157. 	 * 

  1158. 	 * @param key the StyleConstants attribute.

  1159. 	 * @param value the value of a StyleConstants attribute,

  1160. 	 *   to be converted.

  1161. 	 * @returns the CSS value that represents the StyleConstants

  1162. 	 *   value.

  1163. 	 */

  1164. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1165. 	    if (key == StyleConstants.Italic) {

  1166. 		if (value.equals(Boolean.TRUE)) {

  1167. 		    return parseCssValue("italic");

  1168. 		}

  1169. 		return parseCssValue("");

  1170. 	    } else if (key == StyleConstants.Underline) {

  1171. 		if (value.equals(Boolean.TRUE)) {

  1172. 		    return parseCssValue("underline");

  1173. 		} 

  1174. 		return parseCssValue("");

  1175. 	    } else if (key == StyleConstants.Alignment) {

  1176. 		int align = ((Integer)value).intValue();

  1177. 		String ta;

  1178. 		switch(align) {

  1179. 		case StyleConstants.ALIGN_LEFT:

  1180. 		    ta = "left";

  1181. 		    break;

  1182. 		case StyleConstants.ALIGN_RIGHT:

  1183. 		    ta = "right";

  1184. 		    break;

  1185. 		case StyleConstants.ALIGN_CENTER:

  1186. 		    ta = "center";

  1187. 		    break;

  1188. 		case StyleConstants.ALIGN_JUSTIFIED:

  1189. 		    ta = "justify";

  1190. 		    break;

  1191. 		default:

  1192. 		    ta = "left";

  1193. 		}

  1194. 		return parseCssValue(ta);

  1195. 	    } else if (key == StyleConstants.StrikeThrough) {

  1196. 		if (value.equals(Boolean.TRUE)) {

  1197. 		    return parseCssValue("line-through");

  1198. 		} 

  1199. 		return parseCssValue("");

  1200. 	    } else if (key == StyleConstants.Superscript) {

  1201. 		if (value.equals(Boolean.TRUE)) {

  1202. 		    return parseCssValue("super");

  1203. 		}

  1204. 		return parseCssValue("");

  1205. 	    } else if (key == StyleConstants.Subscript) {

  1206. 		if (value.equals(Boolean.TRUE)) {

  1207. 		    return parseCssValue("sub");

  1208. 		}

  1209. 		return parseCssValue("");

  1210. 	    }

  1211. 	    return null;

  1212. 	}

  1213. 

  1214. 	/**

  1215. 	 * Convert a CSS attribute value to a StyleConstants

  1216. 	 * value.  If there is no conversion, return null.

  1217. 	 * By default, there is no conversion.

  1218. 	 *

  1219. 	 * @param key the StyleConstants attribute.

  1220. 	 * @returns the StyleConstants attribute value that 

  1221. 	 *   represents the CSS attribute value.

  1222. 	 */

  1223. 	Object toStyleConstants(StyleConstants key) {

  1224. 	    if (key == StyleConstants.Italic) {

  1225. 		if (svalue.indexOf("italic") >= 0) {

  1226. 		    return Boolean.TRUE;

  1227. 		}

  1228. 		return Boolean.FALSE;

  1229. 	    } else if (key == StyleConstants.Underline) {

  1230. 		if (svalue.indexOf("underline") >= 0) {

  1231. 		    return Boolean.TRUE;

  1232. 		} 

  1233. 		return Boolean.FALSE;

  1234. 	    } else if (key == StyleConstants.Alignment) {

  1235. 		if (svalue.equals("right")) {

  1236. 		    return new Integer(StyleConstants.ALIGN_RIGHT);

  1237. 		} else if (svalue.equals("center")) {

  1238. 		    return new Integer(StyleConstants.ALIGN_CENTER);

  1239. 		} else if  (svalue.equals("justify")) {

  1240. 		    return new Integer(StyleConstants.ALIGN_JUSTIFIED);

  1241. 		}

  1242. 		return new Integer(StyleConstants.ALIGN_LEFT);

  1243. 	    } else if (key == StyleConstants.StrikeThrough) {

  1244. 		if (svalue.indexOf("line-through") >= 0) {

  1245. 		    return Boolean.TRUE;

  1246. 		} 

  1247. 		return Boolean.FALSE;

  1248. 	    } else if (key == StyleConstants.Superscript) {

  1249. 		if (svalue.indexOf("super") >= 0) {

  1250. 		    return Boolean.TRUE;

  1251. 		} 

  1252. 		return Boolean.FALSE;

  1253. 	    } else if (key == StyleConstants.Subscript) {

  1254. 		if (svalue.indexOf("sub") >= 0) {

  1255. 		    return Boolean.TRUE;

  1256. 		} 

  1257. 		return Boolean.FALSE;

  1258. 	    }

  1259. 	    return null;

  1260. 	}

  1261. 

  1262.     }

  1263. 

  1264.     /**

  1265.      * Represents a value for the CSS.FONT_SIZE attribute.

  1266.      * The binary format of the value can be one of several

  1267.      * types.  If the type is Float,

  1268.      * the value is specified in terms of point or

  1269.      * percentage, depending upon the ending of the

  1270.      * associated string.

  1271.      * If the type is Integer, the value is specified

  1272.      * in terms of a size index.

  1273.      */

  1274.     class FontSize extends CssValue {

  1275. 

  1276. 	/**

  1277. 	 * Returns the size in points.  This is ultimately

  1278. 	 * what we need for the purpose of creating/fetching

  1279. 	 * a Font object.

  1280. 	 *

  1281. 	 * @param a the attribute set the value is being

  1282. 	 *  requested from.  We may need to walk up the

  1283. 	 *  resolve hierarchy if it's relative.

  1284. 	 */

  1285. 	float getValue(AttributeSet a) {

  1286. 	    // PENDING(prinz) need to add support for relative

  1287. 	    // and percentage.

  1288. 	    if (index) {

  1289. 		// it's an index, translate from size table

  1290. 		return getPointSize((int) value);

  1291. 	    } else {

  1292. 		return value;

  1293. 	    }

  1294. 	}

  1295. 

  1296. 	boolean isRelative() {

  1297. 	    return relative;

  1298. 	}

  1299. 

  1300. 	Object parseCssValue(String value) {

  1301. 	    FontSize fs = new FontSize();

  1302. 	    fs.svalue = value;

  1303. 	    try {

  1304. 		if (value.equals("xx-small")) {

  1305. 		    fs.value = 0;

  1306. 		    fs.index = true;

  1307. 		} else if (value.equals("x-small")) {

  1308. 		    fs.value = 1;

  1309. 		    fs.index = true;

  1310. 		} else if (value.equals("small")) {

  1311. 		    fs.value = 2;

  1312. 		    fs.index = true;

  1313. 		} else if (value.equals("medium")) {

  1314. 		    fs.value = 3;

  1315. 		    fs.index = true;

  1316. 		} else if (value.equals("large")) {

  1317. 		    fs.value = 4;

  1318. 		    fs.index = true;

  1319. 		} else if (value.equals("x-large")) {

  1320. 		    fs.value = 5;

  1321. 		    fs.index = true;

  1322. 		} else if (value.equals("xx-large")) {

  1323. 		    fs.value = 6;

  1324. 		    fs.index = true;

  1325. 		} else if (value.equals("bigger")) {

  1326. 		    fs.value = 1;

  1327. 		    fs.index = true;

  1328. 		    fs.relative = true;

  1329. 		} else if (value.equals("smaller")) {

  1330. 		    fs.value = -1;

  1331. 		    fs.index = true;

  1332. 		    fs.relative = true;

  1333. 		} else if (value.endsWith("pt")) {

  1334. 		    String sz = value.substring(0, value.length() - 2);

  1335. 		    fs.value = Float.valueOf(sz).floatValue();

  1336. 		} else {

  1337. 		    // TBD - further processing

  1338. 		    fs.value = Float.valueOf(value).floatValue();

  1339. 		}

  1340. 	    } catch (NumberFormatException nfe) {

  1341. 		fs = null;

  1342. 	    }

  1343. 	    return fs;

  1344. 	}

  1345. 

  1346. 	Object parseHtmlValue(String value) {

  1347. 	    FontSize fs = new FontSize();

  1348. 	    fs.svalue = value;

  1349. 

  1350. 	    try {

  1351. 		/*

  1352. 		 * relative sizes in the size attribute are relative

  1353. 		 * to the <basefont>'s size.

  1354. 		 */

  1355. 		int baseFontSize = getBaseFontSize();

  1356. 		if ((value != null) && (value.charAt(0) == '+')) {

  1357. 		    int relSize = Integer.valueOf(value.substring(1)).intValue();

  1358. 		    fs.value = baseFontSize + relSize;

  1359. 		    fs.index = true;

  1360. 		} else if ((value != null) && (value.charAt(0) == '-')) {

  1361. 		    int relSize = -Integer.valueOf(value.substring(1)).intValue();

  1362. 		    fs.value = baseFontSize + relSize;

  1363. 		    fs.index = true;

  1364. 		} else {

  1365. 		    fs.value = Integer.parseInt(value);

  1366. 		    if (fs.value > 6) {

  1367. 			fs.value = 6;

  1368. 		    } else if (fs.value < 0) {

  1369. 			fs.value = 0;

  1370. 		    }

  1371. 		    fs.index = true;

  1372. 		}

  1373. 

  1374. 	    } catch (NumberFormatException nfe) {

  1375. 		fs = null;

  1376. 	    }

  1377. 	    return fs;

  1378. 	}

  1379. 

  1380. 	/**

  1381. 	 * Convert a StyleConstants attribute value to

  1382. 	 * a css attribute value.  If there is no conversion

  1383. 	 * return null.  By default, there is no conversion.

  1384. 	 * 

  1385. 	 * @param key the StyleConstants attribute.

  1386. 	 * @param value the value of a StyleConstants attribute,

  1387. 	 *   to be converted.

  1388. 	 * @returns the CSS value that represents the StyleConstants

  1389. 	 *   value.

  1390. 	 */

  1391. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1392. 	    return parseCssValue(value.toString());

  1393. 	}

  1394. 

  1395. 	/**

  1396. 	 * Convert a CSS attribute value to a StyleConstants

  1397. 	 * value.  If there is no conversion, return null.

  1398. 	 * By default, there is no conversion.

  1399. 	 *

  1400. 	 * @param key the StyleConstants attribute.

  1401. 	 * @returns the StyleConstants attribute value that 

  1402. 	 *   represents the CSS attribute value.

  1403. 	 */

  1404. 	Object toStyleConstants(StyleConstants key) {

  1405. 	    return new Integer((int) getValue(null));

  1406. 	}

  1407. 

  1408. 	float value;

  1409. 	boolean relative;

  1410. 	boolean index;

  1411. 	boolean percentage;

  1412.     }

  1413. 

  1414.     static class FontFamily extends CssValue {

  1415. 

  1416. 	/**

  1417. 	 * Returns the font family to use.  This is expected

  1418. 	 * to be a legal font for this platform.

  1419. 	 */

  1420. 	String getValue() {

  1421. 	    return family;

  1422. 	}

  1423. 

  1424. 	Object parseCssValue(String value) {

  1425. 	    FontFamily ff = new FontFamily();

  1426. 	    // TBD - a real implementation

  1427. 	    if (value.equals("monospace")) {

  1428. 		ff.family = "Monospaced";

  1429. 	    }

  1430. 	    else {

  1431. 		ff.family = value;

  1432. 	    }

  1433. 	    ff.svalue = value;

  1434. 	    return ff;

  1435. 	}

  1436. 

  1437. 	Object parseHtmlValue(String value) {

  1438. 	    // TBD

  1439. 	    return parseCssValue(value);

  1440. 	}

  1441. 

  1442. 	/**

  1443. 	 * Convert a StyleConstants attribute value to

  1444. 	 * a css attribute value.  If there is no conversion

  1445. 	 * return null.  By default, there is no conversion.

  1446. 	 * 

  1447. 	 * @param key the StyleConstants attribute.

  1448. 	 * @param value the value of a StyleConstants attribute,

  1449. 	 *   to be converted.

  1450. 	 * @returns the CSS value that represents the StyleConstants

  1451. 	 *   value.

  1452. 	 */

  1453. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1454. 	    return parseCssValue(value.toString());

  1455. 	}

  1456. 

  1457. 	/**

  1458. 	 * Convert a CSS attribute value to a StyleConstants

  1459. 	 * value.  If there is no conversion, return null.

  1460. 	 * By default, there is no conversion.

  1461. 	 *

  1462. 	 * @param key the StyleConstants attribute.

  1463. 	 * @returns the StyleConstants attribute value that 

  1464. 	 *   represents the CSS attribute value.

  1465. 	 */

  1466. 	Object toStyleConstants(StyleConstants key) {

  1467. 	    return family;

  1468. 	}

  1469. 

  1470. 	String family;

  1471.     }

  1472. 

  1473.     static class FontWeight extends CssValue {

  1474. 

  1475. 	int getValue() {

  1476. 	    return weight;

  1477. 	}

  1478. 

  1479. 	Object parseCssValue(String value) {

  1480. 	    FontWeight fw = new FontWeight();

  1481. 	    fw.svalue = value;

  1482. 	    if (value.equals("bold")) {

  1483. 		fw.weight = 700;

  1484. 	    } else if (value.equals("normal")) {

  1485. 		fw.weight = 400;

  1486. 	    } else {

  1487. 		// PENDING(prinz) add support for relative values

  1488. 		try {

  1489. 		    fw.weight = Integer.parseInt(value);

  1490. 		} catch (NumberFormatException nfe) {

  1491. 		    fw = null;

  1492. 		}

  1493. 	    }

  1494. 	    return fw;

  1495. 	}

  1496. 

  1497. 	/**

  1498. 	 * Convert a StyleConstants attribute value to

  1499. 	 * a css attribute value.  If there is no conversion

  1500. 	 * return null.  By default, there is no conversion.

  1501. 	 * 

  1502. 	 * @param key the StyleConstants attribute.

  1503. 	 * @param value the value of a StyleConstants attribute,

  1504. 	 *   to be converted.

  1505. 	 * @returns the CSS value that represents the StyleConstants

  1506. 	 *   value.

  1507. 	 */

  1508. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1509. 	    if (value.equals(Boolean.TRUE)) {

  1510. 		return parseCssValue("bold");

  1511. 	    }

  1512. 	    return parseCssValue("normal");

  1513. 	}

  1514. 

  1515. 	/**

  1516. 	 * Convert a CSS attribute value to a StyleConstants

  1517. 	 * value.  If there is no conversion, return null.

  1518. 	 * By default, there is no conversion.

  1519. 	 *

  1520. 	 * @param key the StyleConstants attribute.

  1521. 	 * @returns the StyleConstants attribute value that 

  1522. 	 *   represents the CSS attribute value.

  1523. 	 */

  1524. 	Object toStyleConstants(StyleConstants key) {

  1525. 	    return (weight > 500) ? Boolean.TRUE : Boolean.FALSE;

  1526. 	}

  1527. 

  1528. 	int weight;

  1529.     }

  1530. 

  1531.     static class ColorValue extends CssValue {

  1532. 

  1533. 	/**

  1534. 	 * Returns the color to use.

  1535. 	 */

  1536. 	Color getValue() {

  1537. 	    return c;

  1538. 	}

  1539. 

  1540. 	Object parseCssValue(String value) {

  1541. 

  1542. 	    Color c = stringToColor(value);

  1543. 	    if (c != null) {

  1544. 		ColorValue cv = new ColorValue();

  1545. 		cv.svalue = value;

  1546. 		cv.c = c;

  1547. 		return cv;

  1548. 	    }

  1549. 	    return null;

  1550. 	}

  1551. 

  1552. 	Object parseHtmlValue(String value) {

  1553. 	    return parseCssValue(value);

  1554. 	}

  1555. 

  1556. 	/**

  1557. 	 * Convert a StyleConstants attribute value to

  1558. 	 * a css attribute value.  If there is no conversion

  1559. 	 * return null.  By default, there is no conversion.

  1560. 	 * 

  1561. 	 * @param key the StyleConstants attribute.

  1562. 	 * @param value the value of a StyleConstants attribute,

  1563. 	 *   to be converted.

  1564. 	 * @returns the CSS value that represents the StyleConstants

  1565. 	 *   value.

  1566. 	 */

  1567. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1568. 	    return parseCssValue(colorToHex((Color) value));

  1569. 	}

  1570. 

  1571. 	/**

  1572. 	 * Convert a CSS attribute value to a StyleConstants

  1573. 	 * value.  If there is no conversion, return null.

  1574. 	 * By default, there is no conversion.

  1575. 	 *

  1576. 	 * @param key the StyleConstants attribute.

  1577. 	 * @returns the StyleConstants attribute value that 

  1578. 	 *   represents the CSS attribute value.

  1579. 	 */

  1580. 	Object toStyleConstants(StyleConstants key) {

  1581. 	    return c;

  1582. 	}

  1583. 

  1584. 	Color c;

  1585.     }

  1586. 

  1587.     static class BorderStyle extends CssValue {

  1588. 

  1589. 	CSS.Value getValue() {

  1590. 	    return style;

  1591. 	}

  1592. 

  1593. 	Object parseCssValue(String value) {

  1594. 	    CSS.Value cssv = CSS.getValue(value);

  1595. 	    if (cssv != null) {

  1596. 		if ((cssv == CSS.Value.INSET) ||

  1597. 		    (cssv == CSS.Value.OUTSET) ||

  1598. 		    (cssv == CSS.Value.NONE) ||

  1599. 		    (cssv == CSS.Value.DOTTED) ||

  1600. 		    (cssv == CSS.Value.DASHED) ||

  1601. 		    (cssv == CSS.Value.SOLID) ||

  1602. 		    (cssv == CSS.Value.DOUBLE) ||

  1603. 		    (cssv == CSS.Value.GROOVE) ||

  1604. 		    (cssv == CSS.Value.RIDGE)) {

  1605. 

  1606. 		    BorderStyle bs = new BorderStyle();

  1607. 		    bs.svalue = value;

  1608. 		    bs.style = cssv;

  1609. 		    return bs;

  1610. 		}

  1611. 	    }

  1612. 	    return null;

  1613. 	}

  1614. 

  1615. 	private void writeObject(java.io.ObjectOutputStream s)

  1616. 	             throws IOException {

  1617. 	    s.defaultWriteObject();

  1618. 	    if (style == null) {

  1619. 		s.writeObject(null);

  1620. 	    }

  1621. 	    else {

  1622. 		s.writeObject(style.toString());

  1623. 	    }

  1624. 	}

  1625. 

  1626. 	private void readObject(ObjectInputStream s)

  1627. 		throws ClassNotFoundException, IOException {

  1628. 	    s.defaultReadObject();

  1629. 	    Object value = s.readObject();

  1630. 	    if (value != null) {

  1631. 		style = CSS.getValue((String)value);

  1632. 	    }

  1633. 	}

  1634. 

  1635. 	// CSS.Values are static, don't archive it.

  1636. 	transient private CSS.Value style;

  1637.     }

  1638. 

  1639.     static class LengthValue extends CssValue {

  1640. 

  1641. 	/**

  1642. 	 * Returns the length (span) to use.

  1643. 	 */

  1644. 	float getValue() {

  1645. 	    return span;

  1646. 	}

  1647. 

  1648. 	Object parseCssValue(String value) {

  1649. 	    LengthValue lv = new LengthValue();

  1650. 	    lv.svalue = value;

  1651. 	    try {

  1652. 		if (value.endsWith("pt")) {

  1653. 		    String sz = value.substring(0, value.length() - 2);

  1654. 		    lv.span = Float.valueOf(sz).floatValue();

  1655. 		} else {

  1656. 		    // TBD - further processing

  1657. 		    lv.span = Float.valueOf(value).floatValue();

  1658. 		}

  1659. 	    } catch (NumberFormatException nfe) {

  1660. 		lv = null;

  1661. 	    }

  1662. 	    return lv;

  1663. 	}

  1664. 

  1665. 	Object parseHtmlValue(String value) {

  1666. 	    if (value.equals(HTML.NULL_ATTRIBUTE_VALUE)) {

  1667. 		value = "1";

  1668. 	    }

  1669. 	    return parseCssValue(value);

  1670. 	}

  1671. 	/**

  1672. 	 * Convert a StyleConstants attribute value to

  1673. 	 * a css attribute value.  If there is no conversion

  1674. 	 * return null.  By default, there is no conversion.

  1675. 	 * 

  1676. 	 * @param key the StyleConstants attribute.

  1677. 	 * @param value the value of a StyleConstants attribute,

  1678. 	 *   to be converted.

  1679. 	 * @returns the CSS value that represents the StyleConstants

  1680. 	 *   value.

  1681. 	 */

  1682. 	Object fromStyleConstants(StyleConstants key, Object value) {

  1683. 	    

  1684. 	    LengthValue v = new LengthValue();

  1685. 	    v.svalue = value.toString();

  1686. 	    v.span = ((Float)value).floatValue();

  1687. 	    return v;

  1688. 	}

  1689. 

  1690. 	/**

  1691. 	 * Convert a CSS attribute value to a StyleConstants

  1692. 	 * value.  If there is no conversion, return null.

  1693. 	 * By default, there is no conversion.

  1694. 	 *

  1695. 	 * @param key the StyleConstants attribute.

  1696. 	 * @returns the StyleConstants attribute value that 

  1697. 	 *   represents the CSS attribute value.

  1698. 	 */

  1699. 	Object toStyleConstants(StyleConstants key) {

  1700. 	    return new Float(span);

  1701. 	}

  1702. 

  1703. 	float span;

  1704.     }

  1705. 

  1706. 

  1707.     /**

  1708.      * Handles conversion of list types.

  1709.      */

  1710.     static class ListType extends CssValue {

  1711. 	Object parseCssValue(String value) {

  1712. 	    Object retValue = cssValueToInternalValueMap.get(value);

  1713. 	    if (retValue == null) {

  1714. 		retValue = cssValueToInternalValueMap.get(value.toLowerCase());

  1715. 	    }

  1716. 	    return retValue;

  1717. 	}

  1718. 

  1719. 

  1720. 	Object parseHtmlValue(String value) {

  1721. 	    Object retValue = htmlValueToCssValueMap.get(value);

  1722. 	    if (retValue == null) {

  1723. 		retValue = htmlValueToCssValueMap.get(value.toLowerCase());

  1724. 	    }

  1725. 	    return retValue;

  1726. 	}

  1727.     }

  1728. 

  1729. 

  1730.     //

  1731.     // Serialization support

  1732.     //

  1733. 

  1734.     private void writeObject(java.io.ObjectOutputStream s)

  1735.         throws IOException

  1736.     {

  1737.         s.defaultWriteObject();

  1738. 

  1739. 	// Determine what values in valueConvertor need to be written out.

  1740. 	Enumeration keys = valueConvertor.keys();

  1741. 	s.writeInt(valueConvertor.size());

  1742. 	if (keys != null) {

  1743. 	    while (keys.hasMoreElements()) {

  1744. 		Object key = keys.nextElement();

  1745. 		Object value = valueConvertor.get(key);

  1746. 		if (!(key instanceof Serializable) &&

  1747. 		    (key = StyleContext.getStaticAttributeKey(key)) == null) {

  1748. 		    // Should we throw an exception here?

  1749. 		    key = null;

  1750. 		    value = null;

  1751. 		}

  1752. 		else if (!(value instanceof Serializable) &&

  1753. 		    (value = StyleContext.getStaticAttributeKey(value)) == null){

  1754. 		    // Should we throw an exception here?

  1755. 		    key = null;

  1756. 		    value = null;

  1757. 		}

  1758. 		s.writeObject(key);

  1759. 		s.writeObject(value);

  1760. 	    }

  1761. 	}

  1762.     }

  1763. 

  1764.     private void readObject(ObjectInputStream s)

  1765.       throws ClassNotFoundException, IOException 

  1766.     {

  1767.         s.defaultReadObject();

  1768. 	// Reconstruct the hashtable.

  1769. 	int numValues = s.readInt();

  1770. 	valueConvertor = new Hashtable(Math.max(1, numValues));

  1771. 	while (numValues-- > 0) {

  1772. 	    Object key = s.readObject();

  1773. 	    Object value = s.readObject();

  1774. 	    Object staticKey = StyleContext.getStaticAttribute(key);

  1775. 	    if (staticKey != null) {

  1776. 		key = staticKey;

  1777. 	    }

  1778. 	    Object staticValue = StyleContext.getStaticAttribute(value);

  1779. 	    if (staticValue != null) {

  1780. 		value = staticValue;

  1781. 	    }

  1782. 	    if (key != null && value != null) {

  1783. 		valueConvertor.put(key, value);

  1784. 	    }

  1785. 	}

  1786.     }

  1787. 

  1788.     //

  1789.     // Instance variables

  1790.     //

  1791. 

  1792.     /** Maps from CSS key to CssValue. */

  1793.     private transient Hashtable valueConvertor;

  1794. 

  1795.     /** Size used for relative units. */

  1796.     private int baseFontSize;

  1797. }