1. /*

  2.  * @(#)CSS.java	1.30 00/02/02

  3.  *

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

  5.  * 

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

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. package javax.swing.text.html;

  11. 

  12. import java.awt.Color;

  13. import java.awt.Font;

  14. import java.awt.Toolkit;

  15. import java.io.*;

  16. import java.lang.reflect.Method;

  17. import java.net.URL;

  18. import java.net.MalformedURLException;

  19. import java.util.Enumeration;

  20. import java.util.Hashtable;

  21. import java.util.Vector;

  22. import javax.swing.ImageIcon;

  23. import javax.swing.SizeRequirements;

  24. import javax.swing.text.*;

  25. 

  26. /**

  27.  * Defines a set of

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

  29.  * as a typesafe enumeration.  The HTML View implementations use

  30.  * CSS attributes to determine how they will render. This also defines

  31.  * methods to map between CSS/HTML/StyleConstants. Any shorthand

  32.  * properties, such as font, are mapped to the intrinsic properties.

  33.  * <p>The following describes the CSS properties that are suppored by the

  34.  * rendering engine:

  35.  * <ul><li>font-family

  36.  *   <li>font-style

  37.  *   <li>font-size (supports relative units)

  38.  *   <li>font-weight

  39.  *   <li>font

  40.  *   <li>color

  41.  *   <li>background-color (with the exception of transparent)

  42.  *   <li>background-image

  43.  *   <li>background-repeat

  44.  *   <li>background-position

  45.  *   <li>background

  46.  *   <li>background-repeat

  47.  *   <li>text-decoration (with the exception of blink and overline)

  48.  *   <li>vertical-align (only sup and super)

  49.  *   <li>text-align (justify is treated as center)

  50.  *   <li>margin-top

  51.  *   <li>margin-right

  52.  *   <li>margin-bottom

  53.  *   <li>margin-left

  54.  *   <li>margin

  55.  *   <li>padding-top

  56.  *   <li>padding-right

  57.  *   <li>padding-bottom

  58.  *   <li>padding-left

  59.  *   <li>border-style (only supports inset, outset and none)

  60.  *   <li>list-style-type

  61.  *   <li>list-style-position

  62.  * </ul>

  63.  * The following are modeled, but currently not rendered.

  64.  * <ul><li>font-variant

  65.  *   <li>background-attachment (background always treated as scroll)

  66.  *   <li>word-spacing

  67.  *   <li>letter-spacing

  68.  *   <li>text-indent

  69.  *   <li>text-transform

  70.  *   <li>line-height

  71.  *   <li>border-top-width (this is used to indicate if a border should be used)

  72.  *   <li>border-right-width

  73.  *   <li>border-bottom-width

  74.  *   <li>border-left-width

  75.  *   <li>border-width

  76.  *   <li>border-top

  77.  *   <li>border-right

  78.  *   <li>border-bottom

  79.  *   <li>border-left

  80.  *   <li>border

  81.  *   <li>width

  82.  *   <li>height

  83.  *   <li>float

  84.  *   <li>clear

  85.  *   <li>display

  86.  *   <li>white-space

  87.  *   <li>list-style

  88.  * </ul>

  89.  * <p><b>Note: for the time being we do not fully support relative units,

  90.  * unless noted, so that

  91.  * p { margin-top: 10% } will be treated as if no margin-top was specified.

  92.  *

  93.  * @author  Timothy Prinzing

  94.  * @author  Scott Violet

  95.  * @version 1.30 02/02/00

  96.  * @see StyleSheet

  97.  */

  98. public class CSS implements Serializable {

  99. 

  100.     /**

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

  102.      * that might hold CSS attributes.  Since this is a

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

  104.      * it is final and cannot be extended.

  105.      */

  106.     public static final class Attribute {

  107. 

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

  109. 	    this.name = name;

  110. 	    this.defaultValue = defaultValue;

  111. 	    this.inherited = inherited;

  112. 	}

  113. 

  114. 	/**

  115. 	 * The string representation of the attribute.  This

  116. 	 * should exactly match the string specified in the

  117. 	 * CSS specification.

  118. 	 */

  119. 	public String toString() {

  120. 	    return name;

  121. 	}

  122. 

  123. 	/**

  124. 	 * Fetch the default value for the attribute.

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

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

  127. 	 */

  128. 	public String getDefaultValue() {

  129. 	    return defaultValue;

  130. 	}

  131. 

  132. 	/**

  133. 	 * Indicates if the attribute should be inherited

  134. 	 * from the parent or not.

  135. 	 */

  136. 	public boolean isInherited() {

  137. 	    return inherited;

  138. 	}

  139. 

  140. 	private String name;

  141. 	private String defaultValue;

  142. 	private boolean inherited;

  143. 

  144. 

  145. 	public static final Attribute BACKGROUND =

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

  147. 

  148. 	public static final Attribute BACKGROUND_ATTACHMENT =

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

  150. 

  151. 	public static final Attribute BACKGROUND_COLOR =

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

  153. 

  154. 	public static final Attribute BACKGROUND_IMAGE =

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

  156. 

  157. 	public static final Attribute BACKGROUND_POSITION =

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

  159. 

  160. 	public static final Attribute BACKGROUND_REPEAT =

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

  162. 

  163. 	public static final Attribute BORDER =

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

  165. 

  166. 	public static final Attribute BORDER_BOTTOM =

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

  168. 

  169. 	public static final Attribute BORDER_BOTTOM_WIDTH =

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

  171. 

  172. 	public static final Attribute BORDER_COLOR =

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

  174. 

  175. 	public static final Attribute BORDER_LEFT =

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

  177. 

  178. 	public static final Attribute BORDER_LEFT_WIDTH =

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

  180. 

  181. 	public static final Attribute BORDER_RIGHT =

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

  183. 

  184. 	public static final Attribute BORDER_RIGHT_WIDTH =

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

  186. 

  187. 	public static final Attribute BORDER_STYLE =

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

  189. 

  190. 	public static final Attribute BORDER_TOP =

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

  192. 

  193. 	public static final Attribute BORDER_TOP_WIDTH =

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

  195. 

  196. 	public static final Attribute BORDER_WIDTH =

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

  198. 

  199. 	public static final Attribute CLEAR =

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

  201. 

  202. 	public static final Attribute COLOR =

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

  204. 

  205. 	public static final Attribute DISPLAY =

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

  207. 

  208. 	public static final Attribute FLOAT =

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

  210. 

  211. 	public static final Attribute FONT =

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

  213. 

  214. 	public static final Attribute FONT_FAMILY =

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

  216. 

  217. 	public static final Attribute FONT_SIZE =

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

  219. 

  220. 	public static final Attribute FONT_STYLE =

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

  222. 

  223. 	public static final Attribute FONT_VARIANT =

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

  225. 

  226. 	public static final Attribute FONT_WEIGHT =

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

  228. 

  229. 	public static final Attribute HEIGHT =

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

  231. 

  232. 	public static final Attribute LETTER_SPACING =

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

  234. 

  235. 	public static final Attribute LINE_HEIGHT =

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

  237. 

  238. 	public static final Attribute LIST_STYLE =

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

  240. 

  241. 	public static final Attribute LIST_STYLE_IMAGE =

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

  243. 

  244. 	public static final Attribute LIST_STYLE_POSITION =

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

  246. 

  247. 	public static final Attribute LIST_STYLE_TYPE =

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

  249. 

  250. 	public static final Attribute MARGIN =

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

  252. 

  253. 	public static final Attribute MARGIN_BOTTOM =

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

  255. 

  256. 	public static final Attribute MARGIN_LEFT =

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

  258. 

  259. 	public static final Attribute MARGIN_RIGHT =

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

  261. 

  262. 	public static final Attribute MARGIN_TOP =

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

  264. 

  265. 	public static final Attribute PADDING =

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

  267. 

  268. 	public static final Attribute PADDING_BOTTOM =

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

  270. 

  271. 	public static final Attribute PADDING_LEFT =

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

  273. 

  274. 	public static final Attribute PADDING_RIGHT =

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

  276. 

  277. 	public static final Attribute PADDING_TOP =

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

  279. 

  280. 	public static final Attribute TEXT_ALIGN =

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

  282. 

  283. 	public static final Attribute TEXT_DECORATION =

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

  285. 

  286. 	public static final Attribute TEXT_INDENT =

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

  288. 

  289. 	public static final Attribute TEXT_TRANSFORM =

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

  291. 

  292. 	public static final Attribute VERTICAL_ALIGN =

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

  294. 

  295. 	public static final Attribute WORD_SPACING =

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

  297. 

  298. 	public static final Attribute WHITE_SPACE =

  299. 	    new Attribute("white-space", "normal", true);

  300. 

  301. 	public static final Attribute WIDTH =

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

  303. 

  304. 	/*public*/ static final Attribute BORDER_SPACING = 

  305. 	    new Attribute("border-spacing", "0", true);

  306. 

  307. 	/*public*/ static final Attribute CAPTION_SIDE = 

  308. 	    new Attribute("caption-side", "left", true);

  309. 

  310. 	// All possible CSS attribute keys.

  311. 	static final Attribute[] allAttributes = {

  312. 	    BACKGROUND, BACKGROUND_ATTACHMENT, BACKGROUND_COLOR,

  313. 	    BACKGROUND_IMAGE, BACKGROUND_POSITION, BACKGROUND_REPEAT,

  314. 	    BORDER, BORDER_BOTTOM, BORDER_BOTTOM_WIDTH, BORDER_COLOR,

  315. 	    BORDER_LEFT, BORDER_LEFT_WIDTH, BORDER_RIGHT, BORDER_RIGHT_WIDTH,

  316. 	    BORDER_STYLE, BORDER_TOP, BORDER_TOP_WIDTH, BORDER_WIDTH,

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

  318. 	    FONT_STYLE, FONT_VARIANT, FONT_WEIGHT, HEIGHT, LETTER_SPACING,

  319. 	    LINE_HEIGHT, LIST_STYLE, LIST_STYLE_IMAGE, LIST_STYLE_POSITION,

  320. 	    LIST_STYLE_TYPE, MARGIN, MARGIN_BOTTOM, MARGIN_LEFT, MARGIN_RIGHT,

  321. 	    MARGIN_TOP, PADDING, PADDING_BOTTOM, PADDING_LEFT, PADDING_RIGHT,

  322. 	    PADDING_TOP, TEXT_ALIGN, TEXT_DECORATION, TEXT_INDENT, TEXT_TRANSFORM,

  323. 	    VERTICAL_ALIGN, WORD_SPACING, WHITE_SPACE, WIDTH, 

  324. 	    BORDER_SPACING, CAPTION_SIDE

  325. 	};

  326. 

  327. 	private static final Attribute[] ALL_MARGINS =

  328. 	        { MARGIN_TOP, MARGIN_RIGHT, MARGIN_BOTTOM, MARGIN_LEFT };

  329. 	private static final Attribute[] ALL_PADDING =

  330. 	        { PADDING_TOP, PADDING_RIGHT, PADDING_BOTTOM, PADDING_LEFT };

  331. 	private static final Attribute[] ALL_BORDER_WIDTHS =

  332. 	        { BORDER_TOP_WIDTH, BORDER_RIGHT_WIDTH, BORDER_BOTTOM_WIDTH,

  333. 		  BORDER_LEFT_WIDTH };

  334. 

  335.     }

  336. 

  337.     static final class Value {

  338. 

  339. 	private Value(String name) {

  340. 	    this.name = name;

  341. 	}

  342. 

  343. 	/**

  344. 	 * The string representation of the attribute.  This

  345. 	 * should exactly match the string specified in the

  346. 	 * CSS specification.

  347. 	 */

  348. 	public String toString() {

  349. 	    return name;

  350. 	}

  351. 

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

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

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

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

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

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

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

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

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

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

  362. 	// Lists.

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

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

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

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

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

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

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

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

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

  372. 	// background-repeat

  373. 	static final Value BACKGROUND_NO_REPEAT = new Value("no-repeat");

  374. 	static final Value BACKGROUND_REPEAT = new Value("repeat");

  375. 	static final Value BACKGROUND_REPEAT_X = new Value("repeat-x");

  376. 	static final Value BACKGROUND_REPEAT_Y = new Value("repeat-y");

  377. 	// background-attachment

  378. 	static final Value BACKGROUND_SCROLL = new Value("scroll");

  379. 	static final Value BACKGROUND_FIXED = new Value("fixed");

  380. 

  381. 	private String name;

  382. 

  383. 	static final Value[] allValues = {

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

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

  386. 	    LOWER_ROMAN, UPPER_ROMAN, LOWER_ALPHA, UPPER_ALPHA,

  387. 	    BLANK_LIST_ITEM, BACKGROUND_NO_REPEAT, BACKGROUND_REPEAT,

  388. 	    BACKGROUND_REPEAT_X, BACKGROUND_REPEAT_Y,

  389. 	    BACKGROUND_FIXED, BACKGROUND_FIXED

  390. 	};

  391.     }

  392. 

  393.     public CSS() {

  394. 	baseFontSize = 3;

  395. 	// setup the css conversion table

  396. 	valueConvertor = new Hashtable();

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

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

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

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

  401. 	Object cv = new ColorValue();

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

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

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

  405. 	Object lv = new LengthValue();

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

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

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

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

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

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

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

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

  414. 	Object bv = new BorderWidthValue(null, 0);

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

  416. 	valueConvertor.put(CSS.Attribute.BORDER_TOP_WIDTH, bv);

  417. 	valueConvertor.put(CSS.Attribute.BORDER_BOTTOM_WIDTH, bv);

  418. 	valueConvertor.put(CSS.Attribute.BORDER_LEFT_WIDTH, bv);

  419. 	valueConvertor.put(CSS.Attribute.BORDER_RIGHT_WIDTH, bv);

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

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

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

  423. 	valueConvertor.put(CSS.Attribute.BORDER_SPACING, lv);

  424. 	Object sv = new StringValue();

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

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

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

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

  429. 	Object valueMapper = new CssValueMapper();

  430. 	valueConvertor.put(CSS.Attribute.LIST_STYLE_TYPE,

  431. 			   valueMapper);

  432. 	valueConvertor.put(CSS.Attribute.BACKGROUND_IMAGE,

  433. 			   new BackgroundImage());

  434. 	valueConvertor.put(CSS.Attribute.BACKGROUND_POSITION,

  435. 			   new BackgroundPosition());

  436. 	valueConvertor.put(CSS.Attribute.BACKGROUND_REPEAT,

  437. 			   valueMapper);

  438. 	valueConvertor.put(CSS.Attribute.BACKGROUND_ATTACHMENT,

  439. 			   valueMapper);

  440. 	Object generic = new CssValue();

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

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

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

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

  445. 		valueConvertor.put(key, generic);

  446. 	    }

  447. 	}

  448.     }

  449. 

  450.     /**

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

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

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

  454.      */

  455.     void setBaseFontSize(int sz) {

  456. 	if (sz < 1)

  457. 	  baseFontSize = 0;

  458. 	else if (sz > 7)

  459. 	  baseFontSize = 7;

  460. 	else

  461. 	  baseFontSize = sz;

  462.     }

  463. 

  464.     /**

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

  466.      */

  467.     void setBaseFontSize(String size) {

  468. 	int relSize, absSize, diff;

  469. 

  470. 	if (size != null) {

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

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

  473. 		setBaseFontSize(baseFontSize + relSize);

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

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

  476. 		setBaseFontSize(baseFontSize + relSize);

  477. 	    } else {

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

  479. 	    }

  480. 	}

  481.     }

  482. 

  483.     /**

  484.      * Returns the base font size.

  485.      */

  486.     int getBaseFontSize() {

  487. 	return baseFontSize;

  488.     }

  489. 

  490.     /**

  491.      * Parses the CSS property <code>key</code> with value

  492.      * <code>value</code> placing the result in <code>att</code>.

  493.      */

  494.     void addInternalCSSValue(MutableAttributeSet attr,

  495. 			     CSS.Attribute key, String value) {

  496. 	if (key == CSS.Attribute.FONT) {

  497. 	    ShorthandFontParser.parseShorthandFont(this, value, attr);

  498. 	}

  499. 	else if (key == CSS.Attribute.BACKGROUND) {

  500. 	    ShorthandBackgroundParser.parseShorthandBackground

  501. 		               (this, value, attr);

  502. 	}

  503. 	else if (key == CSS.Attribute.MARGIN) {

  504. 	    ShorthandMarginParser.parseShorthandMargin(this, value, attr,

  505. 					   CSS.Attribute.ALL_MARGINS);

  506. 	}

  507. 	else if (key == CSS.Attribute.PADDING) {

  508. 	    ShorthandMarginParser.parseShorthandMargin(this, value, attr,

  509. 					   CSS.Attribute.ALL_PADDING);

  510. 	}

  511. 	else if (key == CSS.Attribute.BORDER_WIDTH) {

  512. 	    ShorthandMarginParser.parseShorthandMargin(this, value, attr,

  513. 					   CSS.Attribute.ALL_BORDER_WIDTHS);

  514. 	}

  515. 	else {

  516. 	    Object iValue = getInternalCSSValue(key, value);

  517. 	    if (iValue != null) {

  518. 		attr.addAttribute(key, iValue);

  519. 	    }

  520. 	}

  521.     }

  522. 

  523.     /**

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

  525.      * a CSS value of the CSS attribute named <code>key</code>. The receiver

  526.      * should not modify <code>value</code>, and the first <code>count</code>

  527.      * strings are valid.

  528.      */

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

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

  531. 	return conv.parseCssValue(value);

  532.     }

  533. 

  534.     /**

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

  536.      */

  537.     Attribute styleConstantsKeyToCSSKey(StyleConstants sc) {

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

  539.     }

  540. 

  541.     /**

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

  543.      */

  544.     Object styleConstantsValueToCSSValue(StyleConstants sc,

  545. 					 Object styleValue) {

  546. 	Object cssKey = styleConstantsKeyToCSSKey(sc);

  547. 	if (cssKey != null) {

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

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

  550. 	}

  551. 	return null;

  552.     }

  553. 

  554.     /**

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

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

  557.      */

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

  559. 	if (value instanceof CssValue) {

  560. 	    return ((CssValue)value).toStyleConstants((StyleConstants)key,

  561. 						      null);

  562. 	}

  563. 	return null;

  564.     }

  565. 

  566.     /**

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

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

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

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

  571.      */

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

  573. 	int size = getFontSize(a, defaultSize);

  574. 

  575. 	/*

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

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

  578. 	 */

  579. 	StringValue vAlignV = (StringValue)a.getAttribute

  580. 	                      (CSS.Attribute.VERTICAL_ALIGN);

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

  582. 	    String vAlign = vAlignV.toString();

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

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

  585. 		size -= 2;

  586. 	    }

  587. 	}

  588. 	

  589. 	FontFamily familyValue = (FontFamily)a.getAttribute

  590. 	                                    (CSS.Attribute.FONT_FAMILY);

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

  592. 	                          "SansSerif";

  593. 	int style = Font.PLAIN;

  594. 	FontWeight weightValue = (FontWeight) a.getAttribute

  595. 	                          (CSS.Attribute.FONT_WEIGHT);

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

  597. 	    style |= Font.BOLD;

  598. 	}

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

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

  601. 	    style |= Font.ITALIC;

  602. 	}

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

  604. 	return f;

  605.     }

  606. 

  607.     static int getFontSize(AttributeSet attr, int defaultSize) {

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

  609. 	// have a 1.2 version.

  610. 	FontSize sizeValue = (FontSize)attr.getAttribute(CSS.Attribute.

  611. 							 FONT_SIZE);

  612. 

  613. 	return (sizeValue != null) ? (int)sizeValue.getValue(attr) :

  614. 	                             defaultSize;

  615.     }

  616. 

  617.     /**

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

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

  620.      * like brighter, more hue, etc.

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

  622.      *

  623.      * @param key CSS.Attribute identifying where color is stored.

  624.      * @param a the set of attributes

  625.      * @return the color

  626.      */

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

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

  629. 	if (cv != null) {

  630. 	    return cv.getValue();

  631. 	}

  632. 	return null;

  633.     }

  634. 

  635.     /**

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

  637.      *

  638.      * @param size CSS string describing font size

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

  640.      */

  641.     float getPointSize(String size) {

  642. 	int relSize, absSize, diff, index;

  643. 	if (size != null) {

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

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

  646. 		return getPointSize(baseFontSize + relSize);

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

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

  649. 		return getPointSize(baseFontSize + relSize);

  650. 	    } else {

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

  652. 		return getPointSize(absSize);

  653. 	    }

  654. 	}

  655. 	return 0;

  656.     }

  657. 

  658.     /**

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

  660.      * key <code>key</code>.

  661.      */

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

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

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

  665. 	return len;

  666.     }

  667. 

  668.     /**

  669.      * Convert a set of HTML attributes to an equivalent

  670.      * set of CSS attributes.

  671.      *

  672.      * @param AttributeSet containing the HTML attributes.

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

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

  675.      *        CSS attributes.

  676.      */

  677.     AttributeSet translateHTMLToCSS(AttributeSet htmlAttrSet) {

  678. 	MutableAttributeSet cssAttrSet = new SimpleAttributeSet();

  679. 	Element elem = (Element)htmlAttrSet;

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

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

  682. 	    // translate border width into the cells

  683. 	    AttributeSet tableAttr = elem.getParentElement().

  684. 		                     getParentElement().getAttributes();

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

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

  687. 	    if (pad != null) {

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

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

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

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

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

  693. 	    }

  694. 	}

  695. 	if (elem.isLeaf()) {

  696. 	    translateEmbeddedAttributes(htmlAttrSet, cssAttrSet);

  697. 	} else {

  698. 	    translateAttributes(tag, htmlAttrSet, cssAttrSet);

  699. 	}

  700. 	if (tag == HTML.Tag.CAPTION) {

  701. 	    /* 

  702. 	     * Navigator uses ALIGN for caption placement and IE uses VALIGN.

  703. 	     */

  704. 	    Object v = htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);

  705. 	    if ((v != null) && (v.equals("top") || v.equals("bottom"))) {

  706. 		cssAttrSet.addAttribute(CSS.Attribute.CAPTION_SIDE, v);

  707. 		cssAttrSet.removeAttribute(CSS.Attribute.TEXT_ALIGN);

  708. 	    } else {

  709. 		v = htmlAttrSet.getAttribute(HTML.Attribute.VALIGN);

  710. 		if (v != null) {

  711. 		    cssAttrSet.addAttribute(CSS.Attribute.CAPTION_SIDE, v);

  712. 		}

  713. 	    }

  714. 	}

  715. 	return cssAttrSet;

  716.     }

  717. 

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

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

  720.     /**

  721.      * The HTML/CSS size model has seven slots

  722.      * that one can assign sizes to.

  723.      */

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

  725. 

  726.     /**

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

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

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

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

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

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

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

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

  735.      */

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

  737. 

  738.     /**

  739.      * The hashtable and static initialization that follows sets

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

  741.      * attributes) to the associated CSS attributes.

  742.      */

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

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

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

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

  747.     private static final Hashtable cssValueToInternalValueMap = new Hashtable(13);

  748. 

  749.     /** Used to indicate if a font family name is valid. */

  750.     private static Hashtable fontMapping;

  751.     private static final Object fontMappingLock = new Object();

  752. 

  753.     static {

  754. 	// load the attribute map

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

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

  757. 			     Attribute.allAttributes[i]);

  758. 	}

  759. 	// load the value map

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

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

  762. 			     Value.allValues[i]);

  763. 	}

  764. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  780. 				 new CSS.Attribute[]{CSS.Attribute.BORDER_TOP_WIDTH, CSS.Attribute.BORDER_RIGHT_WIDTH, CSS.Attribute.BORDER_BOTTOM_WIDTH, CSS.Attribute.BORDER_LEFT_WIDTH});

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

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

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

  784. 				 new CSS.Attribute[]{CSS.Attribute.BORDER_SPACING});

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

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

  787. 						     CSS.Attribute.MARGIN_RIGHT});

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

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

  790. 						     CSS.Attribute.MARGIN_BOTTOM});

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

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

  793. 						     CSS.Attribute.PADDING_RIGHT});

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

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

  796. 						     CSS.Attribute.PADDING_TOP});

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

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

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

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

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

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

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

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

  805. 						     CSS.Attribute.TEXT_ALIGN,

  806. 						     CSS.Attribute.FLOAT});

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

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

  809. 	htmlAttrToCssAttrMap.put(HTML.Attribute.NOWRAP,

  810. 				 new CSS.Attribute[]{CSS.Attribute.WHITE_SPACE});

  811. 

  812. 	// initialize StyleConstants mapping 

  813. 	styleConstantToCssMap.put(StyleConstants.FontFamily, 

  814. 				  CSS.Attribute.FONT_FAMILY);

  815. 	styleConstantToCssMap.put(StyleConstants.FontSize, 

  816. 				  CSS.Attribute.FONT_SIZE);

  817. 	styleConstantToCssMap.put(StyleConstants.Bold, 

  818. 				  CSS.Attribute.FONT_WEIGHT);

  819. 	styleConstantToCssMap.put(StyleConstants.Italic, 

  820. 				  CSS.Attribute.FONT_STYLE);

  821. 	styleConstantToCssMap.put(StyleConstants.Underline, 

  822. 				  CSS.Attribute.TEXT_DECORATION);

  823. 	styleConstantToCssMap.put(StyleConstants.StrikeThrough, 

  824. 				  CSS.Attribute.TEXT_DECORATION);

  825. 	styleConstantToCssMap.put(StyleConstants.Superscript, 

  826. 				  CSS.Attribute.VERTICAL_ALIGN);

  827. 	styleConstantToCssMap.put(StyleConstants.Subscript, 

  828. 				  CSS.Attribute.VERTICAL_ALIGN);

  829. 	styleConstantToCssMap.put(StyleConstants.Foreground, 

  830. 				  CSS.Attribute.COLOR);

  831. 	styleConstantToCssMap.put(StyleConstants.Background, 

  832. 				  CSS.Attribute.BACKGROUND_COLOR);

  833. 	styleConstantToCssMap.put(StyleConstants.FirstLineIndent, 

  834. 				  CSS.Attribute.TEXT_INDENT);

  835. 	styleConstantToCssMap.put(StyleConstants.LeftIndent, 

  836. 				  CSS.Attribute.MARGIN_LEFT);

  837. 	styleConstantToCssMap.put(StyleConstants.RightIndent, 

  838. 				  CSS.Attribute.MARGIN_RIGHT);

  839. 	styleConstantToCssMap.put(StyleConstants.SpaceAbove, 

  840. 				  CSS.Attribute.MARGIN_TOP);

  841. 	styleConstantToCssMap.put(StyleConstants.SpaceBelow, 

  842. 				  CSS.Attribute.MARGIN_BOTTOM);

  843. 	styleConstantToCssMap.put(StyleConstants.Alignment, 

  844. 				  CSS.Attribute.TEXT_ALIGN);

  845. 

  846. 	// HTML->CSS

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

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

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

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

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

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

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

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

  855. 

  856. 	// CSS-> internal CSS

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

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

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

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

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

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

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

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

  865. 	cssValueToInternalValueMap.put("repeat", CSS.Value.BACKGROUND_REPEAT);

  866. 	cssValueToInternalValueMap.put("no-repeat",

  867. 				       CSS.Value.BACKGROUND_NO_REPEAT);

  868. 	cssValueToInternalValueMap.put("repeat-x",

  869. 				       CSS.Value.BACKGROUND_REPEAT_X);

  870. 	cssValueToInternalValueMap.put("repeat-y",

  871. 				       CSS.Value.BACKGROUND_REPEAT_Y);

  872. 	cssValueToInternalValueMap.put("scroll",

  873. 				       CSS.Value.BACKGROUND_SCROLL);

  874. 	cssValueToInternalValueMap.put("fixed",

  875. 				       CSS.Value.BACKGROUND_FIXED);

  876. 

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

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

  879. 	try {

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

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

  882. 	    }

  883. 	} catch (Throwable e) {

  884. 	    e.printStackTrace();

  885. 	}

  886. 

  887.         // Register all the CSS Values for archival/unarchival

  888. 	keys = CSS.Value.allValues;

  889. 	try {

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

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

  892. 	    }

  893. 	} catch (Throwable e) {

  894. 	    e.printStackTrace();

  895. 	}

  896.     }

  897. 

  898.     /**

  899.      * Returns a hashtable whose contents are used to indicate the valid

  900.      * fonts.

  901.      */

  902.     static Hashtable getValidFontNameMapping() {

  903. 	if (fontMapping == null) {

  904. 	    // This can get called from multiple threads, lock before setting

  905. 	    synchronized(fontMappingLock) {

  906. 		if (fontMapping == null) {

  907. 		    String[]      names = null;

  908. 

  909. 		    // Use the 1.2 GraphicsEnvironment for getting font names,

  910. 		    // if we can.

  911. 		    try {

  912. 			Class ge = Class.forName("java.awt.GraphicsEnvironment");

  913. 			if (ge != null) {

  914. 			    Method method = ge.getDeclaredMethod

  915. 				("getLocalGraphicsEnvironment", null);

  916. 			    if (method != null) {

  917. 				Object instance = method.invoke(ge, null);

  918. 				if (instance != null) {

  919. 				    method = ge.getMethod

  920. 					("getAvailableFontFamilyNames", null);

  921. 				    if (method != null) {

  922. 					names = (String[])method.invoke

  923. 					    (instance, null);

  924. 				    }

  925. 				}

  926. 			    }

  927. 			}

  928. 		    }

  929. 		    catch (Throwable th) { }

  930. 		    if (names == null) {

  931. 			// We can't, use the Toolkit method.

  932. 			names = Toolkit.getDefaultToolkit().getFontList();

  933. 		    }

  934. 		    if (names != null) {

  935. 			fontMapping = new Hashtable(names.length * 2);

  936. 			for (int counter = names.length - 1; counter >= 0;

  937. 			     counter--) {

  938. 			    // Put both lowercase and case value in table.

  939. 			    fontMapping.put(names[counter].toLowerCase(),

  940. 					    names[counter]);

  941. 			    fontMapping.put(names[counter], names[counter]);

  942. 			}

  943. 		    }

  944. 		    else {

  945. 			fontMapping = new Hashtable(1);

  946. 		    }

  947. 		}

  948. 	    }

  949. 	}

  950. 	return fontMapping;

  951.     }

  952. 

  953.     /**

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

  955.      */

  956.     public static Attribute[] getAllAttributeKeys() {

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

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

  959. 	return keys;

  960.     }

  961. 

  962.     /**

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

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

  965.      * name.

  966.      * @param name the name of the CSS attribute to fetch the

  967.      *  typesafe enumeration for.

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

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

  970.      */

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

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

  973.     }

  974. 

  975.     /**

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

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

  978.      * name.

  979.      * @param name the name of the CSS value to fetch the

  980.      *  typesafe enumeration for.

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

  982.      *  doesn't represent a valid CSS value name.  This does

  983.      *  not mean it doesn't represent a valid CSS value.

  984.      */

  985.     static final Value getValue(String name) {

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

  987.     }

  988. 

  989. 

  990.     //

  991.     // Conversion related methods/classes

  992.     //

  993. 

  994.     /**

  995.      * Returns a URL for the given CSS url string. If relative,

  996.      * <code>base</code> is used as the parent. If a valid URL can not

  997.      * be found, this will not throw a MalformedURLException, instead 

  998.      * null will be returned.

  999.      */

  1000.     static URL getURL(URL base, String cssString) {

  1001. 	if (cssString == null) {

  1002. 	    return null;

  1003. 	}

  1004. 	if (cssString.startsWith("url(") &&

  1005. 	    cssString.endsWith(")")) {

  1006. 	    cssString = cssString.substring(4, cssString.length() - 1);

  1007. 	}

  1008. 	// Absolute first

  1009. 	try {

  1010. 	    URL url = new URL(cssString);

  1011. 	    if (url != null) {

  1012. 		return url;

  1013. 	    }

  1014. 	} catch (MalformedURLException mue) {

  1015. 	}

  1016. 	// Then relative

  1017. 	if (base != null) {

  1018. 	    // Relative URL, try from base

  1019. 	    try {

  1020. 		URL url = new URL(base, cssString);

  1021. 		return url;

  1022. 	    }

  1023. 	    catch (MalformedURLException muee) {

  1024. 	    }

  1025. 	}

  1026. 	return null;

  1027.     }

  1028. 

  1029.     /**

  1030.      * Converts a type Color to a hex string

  1031.      * in the format "#RRGGBB"

  1032.      */

  1033.     static String colorToHex(Color color) {

  1034. 

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

  1036. 

  1037.       // Red

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

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

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

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

  1042. 	colorstr += "0" + str;

  1043.       else

  1044. 	colorstr += str;

  1045. 

  1046.       // Green

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

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

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

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

  1051. 	colorstr += "0" + str;

  1052.       else

  1053. 	colorstr += str;

  1054. 

  1055.       // Blue

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

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

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

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

  1060. 	colorstr += "0" + str;

  1061.       else

  1062. 	colorstr += str;

  1063. 

  1064.       return colorstr;

  1065.     }

  1066. 

  1067.      /**

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

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

  1070.       * will be made to fix it up.

  1071.       */

  1072.     static final Color hexToColor(String value) {

  1073. 	String digits;

  1074. 	int n = value.length();

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

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

  1077. 	} else {

  1078. 	    digits = value;

  1079. 	}

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

  1081. 	Color c;

  1082. 	try {

  1083. 	    c = Color.decode(hstr);

  1084. 	} catch (NumberFormatException nfe) {

  1085. 	    c = null;

  1086. 	}

  1087. 	 return c;

  1088.      }

  1089. 

  1090.     /**

  1091.      * Convert a color string such as "RED" or "#NNNNNN" to a Color.

  1092.      * Note: This will only convert the HTML3.2 color strings

  1093.      *       or a string of length 7;

  1094.      *       otherwise, it will return null.

  1095.      */

  1096.     static Color stringToColor(String str) {

  1097.       Color color = null;

  1098. 

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

  1100.         color = hexToColor(str);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1133.       else

  1134. 	  color = hexToColor(str); // sometimes get specified without leading #

  1135.       return color;

  1136.     }

  1137. 

  1138.     static int getIndexOfSize(float pt) {

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

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

  1141.                         return i;

  1142.         return sizeMap.length - 1;

  1143.     }

  1144. 

  1145.     /**

  1146.      * @return an array of all the strings in <code>value</code>

  1147.      *         that are separated by whitespace.

  1148.      */

  1149.     static String[] parseStrings(