1. /*

  2.  * @(#)StyleSheet.java	1.63 00/02/02

  3.  *

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

  5.  * 

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

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. package javax.swing.text.html;

  11. 

  12. import java.util.*;

  13. import java.awt.*;

  14. import java.io.*;

  15. import java.net.*;

  16. import javax.swing.Icon;

  17. import javax.swing.ImageIcon;

  18. import javax.swing.border.*;

  19. import javax.swing.event.ChangeListener;

  20. import javax.swing.text.*;

  21. 

  22. /**

  23.  * Support for defining the visual characteristics of

  24.  * HTML views being rendered.  The StyleSheet is used to

  25.  * translate the HTML model into visual characteristics.

  26.  * This enables views to be customized by a look-and-feel,

  27.  * multiple views over the same model can be rendered

  28.  * differently, etc.  This can be thought of as a CSS

  29.  * rule repository.  The key for CSS attributes is an

  30.  * object of type CSS.Attribute.  The type of the value

  31.  * is up to the StyleSheet implementation, but the

  32.  * <code>toString</code> method is required

  33.  * to return a string representation of CSS value.

  34.  * <p>

  35.  * The primary entry point for HTML View implementations

  36.  * to get their attributes is the 

  37.  * <a href="#getViewAttributes">getViewAttributes</a>

  38.  * method.  This should be implemented to establish the

  39.  * desired policy used to associate attributes with the view.

  40.  * Each HTMLEditorKit (i.e. and therefore each associated

  41.  * JEditorPane) can have its own StyleSheet, but by default one

  42.  * sheet will be shared by all of the HTMLEditorKit instances.

  43.  * HTMLDocument instance can also have a StyleSheet, which

  44.  * holds the document-specific CSS specifications.

  45.  * <p>

  46.  * In order for Views to store less state and therefore be

  47.  * more lightweight, the StyleSheet can act as a factory for

  48.  * painters that handle some of the rendering tasks.  This allows

  49.  * implementations to determine what they want to cache

  50.  * and have the sharing potentially at the level that a

  51.  * selector is common to multiple views.  Since the StyleSheet

  52.  * may be used by views over multiple documents and typically

  53.  * the HTML attributes don't effect the selector being used,

  54.  * the potential for sharing is significant.

  55.  * <p>

  56.  * The rules are stored as named styles, and other information

  57.  * is stored to translate the context of an element to a 

  58.  * rule quickly.  The following code fragment will display

  59.  * the named styles, and therefore the CSS rules contained.

  60.  * <code><pre>

  61.  *   

  62.  *   import java.util.*;

  63.  *   import javax.swing.text.*;

  64.  *   import javax.swing.text.html.*;

  65.  *   

  66.  *   public class ShowStyles {

  67.  *   

  68.  *       public static void main(String[] args) {

  69.  *   	HTMLEditorKit kit = new HTMLEditorKit();

  70.  *   	HTMLDocument doc = (HTMLDocument) kit.createDefaultDocument();

  71.  *   	StyleSheet styles = doc.getStyleSheet();

  72.  *   	

  73.  *   	Enumeration rules = styles.getStyleNames();

  74.  *   	while (rules.hasMoreElements()) {

  75.  *   	    String name = (String) rules.nextElement();

  76.  *   	    Style rule = styles.getStyle(name);

  77.  *   	    System.out.println(rule.toString());

  78.  *   	}

  79.  *   	System.exit(0);

  80.  *       }

  81.  *   }

  82.  *   

  83.  * </pre></code>

  84.  * <p>

  85.  * The semantics for when a CSS style should overide visual attributes

  86.  * defined by an element are not well defined. For example, the html

  87.  * <code><body bgcolor=red></code> makes the body have a red

  88.  * background. But if the html file also contains the CSS rule

  89.  * <code>body { background: blue }</code> it becomes less clear as to

  90.  * what color the background of the body should be. The current

  91.  * implemention gives visual attributes defined in the element the

  92.  * highest precedence, that is they are always checked before any styles.

  93.  * Therefore, in the previous example the background would have a

  94.  * red color as the body element defines the background color to be red.

  95.  * <p>

  96.  * As already mentioned this supports CSS. We don't support the full CSS

  97.  * spec. Refer to the javadoc of the CSS class to see what properties

  98.  * we support. The two major CSS parsing related

  99.  * concepts we do not currently

  100.  * support are pseudo selectors, such as <code>A:link { color: red }</code>,

  101.  * and the <code>important</code> modifier.

  102.  * <p>

  103.  * <font color="red">Note: This implementation is currently

  104.  * incomplete.  It can be replaced with alternative implementations

  105.  * that are complete.  Future versions of this class will provide

  106.  * better CSS support.</font>

  107.  *

  108.  * @author  Timothy Prinzing

  109.  * @author  Sunita Mani

  110.  * @author  Sara Swanson

  111.  * @author  Jill Nakata

  112.  * @version 1.63 02/02/00

  113.  */

  114. public class StyleSheet extends StyleContext {

  115. 

  116.     /**

  117.      * Construct a StyleSheet

  118.      */

  119.     public StyleSheet() {

  120. 	super();

  121. 	selectorMapping = new Hashtable();

  122. 	resolvedStyles = new Hashtable();

  123. 	if (css == null) {

  124. 	    css = new CSS();

  125. 	}

  126.     }

  127. 

  128.     /**

  129.      * Fetches the style to use to render the given type

  130.      * of HTML tag.  The element given is representing

  131.      * the tag and can be used to determine the nesting

  132.      * for situations where the attributes will differ

  133.      * if nesting inside of elements.

  134.      *

  135.      * @param t the type to translate to visual attributes.

  136.      * @param e the element representing the tag. The element

  137.      *  can be used to determine the nesting for situations where

  138.      *  the attributes will differ if nested inside of other

  139.      *  elements.

  140.      * @returns the set of CSS attributes to use to render

  141.      *  the tag.

  142.      */

  143.     public Style getRule(HTML.Tag t, Element e) {

  144.         SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  145. 

  146.         try {

  147.             // Build an array of all the parent elements.

  148.             Vector searchContext = sb.getVector();

  149. 

  150.             for (Element p = e; p != null; p = p.getParentElement()) {

  151.                 searchContext.addElement(p);

  152.             }

  153. 

  154.             // Build a fully qualified selector.

  155.             int              n = searchContext.size();

  156.             StringBuffer     cacheLookup = sb.getStringBuffer();

  157.             AttributeSet     attr;

  158.             String           eName;

  159.             Object           name;

  160. 

  161.             // >= 1 as the HTML.Tag for the 0th element is passed in.

  162.             for (int counter = n - 1; counter >= 1; counter--) {

  163.                 e = (Element)searchContext.elementAt(counter);

  164.                 attr = e.getAttributes();

  165.                 name = attr.getAttribute(StyleConstants.NameAttribute);

  166. 		eName = name.toString();

  167.                 cacheLookup.append(eName);

  168.                 if (attr != null) {

  169.                     if (attr.isDefined(HTML.Attribute.ID)) {

  170.                         cacheLookup.append('#');

  171.                         cacheLookup.append(attr.getAttribute

  172. 					   (HTML.Attribute.ID));

  173.                     }

  174.                     else if (attr.isDefined(HTML.Attribute.CLASS)) {

  175.                         cacheLookup.append('.');

  176.                         cacheLookup.append(attr.getAttribute

  177. 					   (HTML.Attribute.CLASS));

  178.                     }

  179.                 }

  180.                 cacheLookup.append(' ');

  181.             }

  182.             cacheLookup.append(t.toString());

  183. 	    e = (Element)searchContext.elementAt(0);

  184. 	    attr = e.getAttributes();

  185. 	    if (e.isLeaf()) {

  186. 		// For leafs, we use the second tier attributes.

  187. 		Object testAttr = attr.getAttribute(t);

  188. 		if (testAttr instanceof AttributeSet) {

  189. 		    attr = (AttributeSet)testAttr;

  190. 		}

  191. 		else {

  192. 		    attr = null;

  193. 		}

  194. 	    }

  195.             if (attr != null) {

  196.                 if (attr.isDefined(HTML.Attribute.ID)) {

  197.                     cacheLookup.append('#');

  198.                     cacheLookup.append(attr.getAttribute(HTML.Attribute.ID));

  199.                 }

  200.                 else if (attr.isDefined(HTML.Attribute.CLASS)) {

  201.                     cacheLookup.append('.');

  202.                     cacheLookup.append(attr.getAttribute

  203. 				       (HTML.Attribute.CLASS));

  204.                 }

  205.             }

  206. 

  207.             Style style = getResolvedStyle(cacheLookup.toString(),

  208. 					   searchContext, t);

  209. 	    return style;

  210.         }

  211.         finally {

  212.             SearchBuffer.releaseSearchBuffer(sb);

  213.         }

  214.     }

  215. 

  216.     /**

  217.      * Fetches the rule that best matches the selector given

  218.      * in string form. Where <code>selector</code> is a space separated

  219.      * String of the element names. For example, <code>selector</code>

  220.      * might be 'html body tr td''<p>

  221.      * The attributes of the returned Style will change

  222.      * as rules are added and removed. That is if you to ask for a rule

  223.      * with a selector "table p" and a new rule was added with a selector

  224.      * of "p" the returned Style would include the new attributes from

  225.      * the rule "p".

  226.      */

  227.     public Style getRule(String selector) {

  228. 	selector = cleanSelectorString(selector);

  229. 	if (selector != null) {

  230. 	    Style style = getResolvedStyle(selector);

  231. 	    return style;

  232. 	}

  233. 	return null;

  234.     }

  235. 

  236.     /**

  237.      * Adds a set of rules to the sheet.  The rules are expected to

  238.      * be in valid CSS format.  Typically this would be called as

  239.      * a result of parsing a <style> tag.

  240.      */

  241.     public void addRule(String rule) {

  242. 	if (rule != null) {

  243. 	    CssParser parser = new CssParser();

  244. 	    try {

  245. 		parser.parse(getBase(), new StringReader(rule), false, false);

  246. 	    } catch (IOException ioe) { }

  247. 	}

  248.     }

  249. 

  250.     /**

  251.      * Translates a CSS declaration to an AttributeSet that represents

  252.      * the CSS declaration.  Typically this would be called as a

  253.      * result of encountering an HTML style attribute.

  254.      */

  255.     public AttributeSet getDeclaration(String decl) {

  256. 	if (decl == null) {

  257. 	    return SimpleAttributeSet.EMPTY;

  258. 	}

  259. 	CssParser parser = new CssParser();

  260. 	return parser.parseDeclaration(decl);

  261.     }

  262. 

  263.     /**

  264.      * Loads a set of rules that have been specified in terms of

  265.      * CSS1 grammar.  If there are collisions with existing rules,

  266.      * the newly specified rule will win.

  267.      *

  268.      * @param in the stream to read the CSS grammar from

  269.      * @param ref the reference URL.  This value represents the

  270.      *  location of the stream and may be null.  All relative

  271.      *  URLs specified in the stream will be based upon this

  272.      *  parameter.

  273.      */

  274.     public void loadRules(Reader in, URL ref) throws IOException {

  275. 	CssParser parser = new CssParser();

  276. 	parser.parse(ref, in, false, false);

  277.     }

  278. 

  279.     /**

  280.      * Fetches a set of attributes to use in the view for

  281.      * displaying.  This is basically a set of attributes that

  282.      * can be used for View.getAttributes.

  283.      */

  284.     public AttributeSet getViewAttributes(View v) {

  285. 	return new ViewAttributeSet(v);

  286.     }

  287. 

  288.     /**

  289.      * Removes a named style previously added to the document.

  290.      *

  291.      * @param nm  the name of the style to remove

  292.      */

  293.     public void removeStyle(String nm) {

  294. 	Style       aStyle = getStyle(nm);

  295. 

  296. 	if (aStyle != null) {

  297. 	    String selector = cleanSelectorString(nm);

  298. 	    String[] selectors = getSimpleSelectors(selector);

  299. 	    synchronized(this) {

  300. 		Object mapping = getRootSelectorMapping();

  301. 		for (int i = selectors.length - 1; i >= 0; i--) {

  302. 		    mapping = getSelectorMapping(mapping, selectors[i], true);

  303. 		}

  304. 		Style rule = getMappingStyle(mapping);

  305. 		if (rule != null) {

  306. 		    removeMappingStyle(mapping);

  307. 		    if (resolvedStyles.size() > 0) {

  308. 			Enumeration values = resolvedStyles.elements();

  309. 			while (values.hasMoreElements()) {

  310. 			    ResolvedStyle style = (ResolvedStyle)values.

  311. 				                    nextElement();

  312. 			    style.removeStyle(rule);

  313. 			}

  314. 		    }

  315. 		}

  316. 	    }

  317. 	}

  318. 	super.removeStyle(nm);

  319.     }

  320. 

  321.     /**

  322.      * Adds the rules from the StyleSheet <code>ss</code> to those of

  323.      * the receiver. <code>ss's</code> rules will override the rules of

  324.      * any previously added style sheets. An added StyleSheet will never

  325.      * override the rules of the receiving style sheet.

  326.      *

  327.      * @since 1.3

  328.      */

  329.     public void addStyleSheet(StyleSheet ss) {

  330. 	synchronized(this) {

  331. 	    if (linkedStyleSheets == null) {

  332. 		linkedStyleSheets = new Vector();

  333. 	    }

  334. 	    if (!linkedStyleSheets.contains(ss)) {

  335. 		linkedStyleSheets.insertElementAt(ss, 0);

  336. 		linkStyleSheetAt(ss, 0);

  337. 	    }

  338. 	}

  339.     }

  340. 

  341.     /**

  342.      * Removes the StyleSheet <code>ss</code> from those of the receiver.

  343.      *

  344.      * @since 1.3

  345.      */

  346.     public void removeStyleSheet(StyleSheet ss) {

  347. 	synchronized(this) {

  348. 	    if (linkedStyleSheets != null) {

  349. 		int index = linkedStyleSheets.indexOf(ss);

  350. 		if (index != -1) {

  351. 		    linkedStyleSheets.removeElementAt(index);

  352. 		    unlinkStyleSheet(ss, index);

  353. 		    if (index == 0 && linkedStyleSheets.size() == 0) {

  354. 			linkedStyleSheets = null;

  355. 		    }

  356. 		}

  357. 	    }

  358. 	}

  359.     }

  360. 

  361.     //

  362.     // The following is used to import style sheets.

  363.     //

  364. 

  365.     /**

  366.      * Returns an array of the linked StyleSheets. Will return null

  367.      * if there are no linked StyleSheets.

  368.      *

  369.      * @since 1.3

  370.      */

  371.     public StyleSheet[] getStyleSheets() {

  372. 	StyleSheet[] retValue;

  373. 

  374. 	synchronized(this) {

  375. 	    if (linkedStyleSheets != null) {

  376. 		retValue = new StyleSheet[linkedStyleSheets.size()];

  377. 		linkedStyleSheets.copyInto(retValue);

  378. 	    }

  379. 	    else {

  380. 		retValue = null;

  381. 	    }

  382. 	}

  383. 	return retValue;

  384.     }

  385. 

  386.     /**

  387.      * Imports a style sheet from <code>url</code>. The resulting rules

  388.      * are directly added to the receiver. If you do not want the rules

  389.      * to become part of the receiver, create a new StyleSheet and use

  390.      * addStyleSheet to link it in.

  391.      *

  392.      * @since 1.3

  393.      */

  394.     public void importStyleSheet(URL url) {

  395. 	try {

  396. 	    InputStream is;

  397. 

  398. 	    is = url.openStream();

  399. 	    Reader r = new BufferedReader(new InputStreamReader(is));

  400. 	    CssParser parser = new CssParser();

  401. 	    parser.parse(url, r, false, true);

  402. 	    r.close();

  403. 	    is.close();

  404. 	} catch (Throwable e) {

  405. 	    // on error we simply have no styles... the html

  406. 	    // will look mighty wrong but still function.

  407. 	}

  408.     }

  409. 

  410.     /**

  411.      * Sets the base. All import statements that are relative, will be

  412.      * relative to <code>base</code>.

  413.      *

  414.      * @since 1.3

  415.      */

  416.     public void setBase(URL base) {

  417. 	this.base = base;

  418.     }

  419. 

  420.     /**

  421.      * Returns the base.

  422.      *

  423.      * @since 1.3

  424.      */

  425.     public URL getBase() {

  426. 	return base;

  427.     }

  428. 

  429.     /**

  430.      * Adds a CSS attribute to the given set.

  431.      *

  432.      * @since 1.3

  433.      */

  434.     public void addCSSAttribute(MutableAttributeSet attr, CSS.Attribute key,

  435. 				String value) {

  436. 	css.addInternalCSSValue(attr, key, value);

  437.     }

  438. 

  439.     /**

  440.      * Adds a CSS attribute to the given set.

  441.      *

  442.      * @since 1.3

  443.      */

  444.     public boolean addCSSAttributeFromHTML(MutableAttributeSet attr,

  445. 					   CSS.Attribute key, String value) {

  446. 	Object iValue = css.getCssValue(key, value);

  447. 	if (iValue != null) {

  448. 	    attr.addAttribute(key, iValue);

  449. 	    return true;

  450. 	}

  451. 	return false;

  452.     }

  453. 

  454.     // ---- Conversion functionality ---------------------------------

  455. 

  456.     /**

  457.      * Converts a set of HTML attributes to an equivalent

  458.      * set of CSS attributes.

  459.      *

  460.      * @param AttributeSet containing the HTML attributes.

  461.      * @param AttributeSet containing the corresponding CSS attributes.

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

  463.      *        CSS attributes.

  464.      */

  465.     public AttributeSet translateHTMLToCSS(AttributeSet htmlAttrSet) {

  466. 	AttributeSet cssAttrSet = css.translateHTMLToCSS(htmlAttrSet);

  467. 

  468. 	MutableAttributeSet cssStyleSet = addStyle(null, null);

  469. 	cssStyleSet.addAttributes(cssAttrSet);

  470. 

  471. 	return cssStyleSet;

  472.     }

  473. 

  474.     /**

  475.      * Adds an attribute to the given set, and returns

  476.      * the new representative set.  This is reimplemented to

  477.      * convert StyleConstant attributes to CSS prior to forwarding

  478.      * to the superclass behavior.  The StyleConstants attribute

  479.      * has no corresponding CSS entry, the StyleConstants attribute

  480.      * is stored (but will likely be unused).

  481.      *

  482.      * @param old the old attribute set

  483.      * @param key the non-null attribute key

  484.      * @param value the attribute value

  485.      * @return the updated attribute set

  486.      * @see MutableAttributeSet#addAttribute

  487.      */

  488.     public AttributeSet addAttribute(AttributeSet old, Object key,

  489. 				     Object value) {

  490. 	if (css == null) {

  491. 	    // supers constructor will call this before returning,

  492. 	    // and we need to make sure CSS is non null.

  493. 	    css = new CSS();

  494. 	}

  495. 	if (key instanceof StyleConstants) {

  496. 	    Object cssValue = css.styleConstantsValueToCSSValue

  497. 		              ((StyleConstants)key, value);

  498. 	    if (cssValue != null) {

  499. 		Object cssKey = css.styleConstantsKeyToCSSKey

  500. 		                    ((StyleConstants)key);

  501. 		if (cssKey != null) {

  502. 		    return super.addAttribute(old, cssKey, cssValue);

  503. 		}

  504. 	    }

  505. 	}

  506. 	return super.addAttribute(old, key, value);

  507.     }

  508. 

  509.     /**

  510.      * Adds a set of attributes to the element.  If any of these attributes

  511.      * are StyleConstants attributes, they will be converted to CSS prior

  512.      * to forwarding to the superclass behavior.

  513.      *

  514.      * @param old the old attribute set

  515.      * @param attr the attributes to add

  516.      * @return the updated attribute set

  517.      * @see MutableAttributeSet#addAttribute

  518.      */

  519.     public AttributeSet addAttributes(AttributeSet old, AttributeSet attr) {

  520.         return super.addAttributes(old, convertAttributeSet(attr));

  521.     }

  522. 

  523.     /**

  524.      * Removes an attribute from the set.  If the attribute is a StyleConstants

  525.      * attribute, the request will be converted to a CSS attribute prior to 

  526.      * forwarding to the superclass behavior.

  527.      *

  528.      * @param old the old set of attributes

  529.      * @param key the non-null attribute name

  530.      * @return the updated attribute set

  531.      * @see MutableAttributeSet#removeAttribute

  532.      */

  533.     public AttributeSet removeAttribute(AttributeSet old, Object key) {

  534. 	if (key instanceof StyleConstants) {

  535. 	    Object cssKey = css.styleConstantsKeyToCSSKey((StyleConstants)key);

  536. 	    if (cssKey != null) {

  537. 		return super.removeAttribute(old, cssKey);

  538. 	    }

  539. 	}

  540.         return super.removeAttribute(old, key);

  541.     }

  542. 

  543.     /**

  544.      * Removes a set of attributes for the element.  If any of the attributes

  545.      * is a StyleConstants attribute, the request will be converted to a CSS 

  546.      * attribute prior to forwarding to the superclass behavior.

  547.      *

  548.      * @param old the old attribute set

  549.      * @param names the attribute names

  550.      * @return the updated attribute set

  551.      * @see MutableAttributeSet#removeAttributes

  552.      */

  553.     public AttributeSet removeAttributes(AttributeSet old, Enumeration names) {

  554.         return super.removeAttributes(old, names);

  555.     }

  556. 

  557.     /**

  558.      * Removes a set of attributes. If any of the attributes

  559.      * is a StyleConstants attribute, the request will be converted to a CSS 

  560.      * attribute prior to forwarding to the superclass behavior.

  561.      *

  562.      * @param old the old attribute set

  563.      * @param attrs the attributes

  564.      * @return the updated attribute set

  565.      * @see MutableAttributeSet#removeAttributes

  566.      */

  567.     public AttributeSet removeAttributes(AttributeSet old, AttributeSet attrs) {

  568. 	return super.removeAttributes(old, convertAttributeSet(attrs));

  569.     }

  570. 

  571.     /**

  572.      * Creates a compact set of attributes that might be shared.

  573.      * This is a hook for subclasses that want to alter the 

  574.      * behavior of SmallAttributeSet.  This can be reimplemented

  575.      * to return an AttributeSet that provides some sort of

  576.      * attribute conversion.

  577.      *

  578.      * @param a The set of attributes to be represented in the

  579.      *  the compact form.

  580.      */

  581.     protected SmallAttributeSet createSmallAttributeSet(AttributeSet a) {

  582. 	return new SmallConversionSet(a);

  583.     }

  584. 

  585.     /**

  586.      * Creates a large set of attributes that should trade off

  587.      * space for time.  This set will not be shared.  This is

  588.      * a hook for subclasses that want to alter the behavior

  589.      * of the larger attribute storage format (which is 

  590.      * SimpleAttributeSet by default).   This can be reimplemented

  591.      * to return a MutableAttributeSet that provides some sort of

  592.      * attribute conversion.

  593.      *

  594.      * @param a The set of attributes to be represented in the

  595.      *  the larger form.

  596.      */

  597.     protected MutableAttributeSet createLargeAttributeSet(AttributeSet a) {

  598.         return new LargeConversionSet(a);

  599.     }

  600. 

  601.     /**

  602.      * Converts a set of attributes (if necessary) so that

  603.      * any attributes that were specified as StyleConstants

  604.      * attributes and have a CSS mapping, will be converted

  605.      * to CSS attributes.

  606.      */

  607.     AttributeSet convertAttributeSet(AttributeSet a) {

  608. 	if ((a instanceof LargeConversionSet) || 

  609. 	    (a instanceof SmallConversionSet)) {

  610. 	    // known to be converted.

  611. 	    return a;

  612. 	}

  613. 	// in most cases, there are no StyleConstants attributes

  614. 	// so we iterate the collection of keys to avoid creating

  615. 	// a new set.

  616. 	Enumeration names = a.getAttributeNames();

  617. 	while (names.hasMoreElements()) {

  618. 	    Object name = names.nextElement();

  619. 	    if (name instanceof StyleConstants) {

  620. 		// we really need to do a conversion, iterate again

  621. 		// building a new set.

  622. 		MutableAttributeSet converted = new LargeConversionSet();

  623. 		Enumeration keys = a.getAttributeNames();

  624. 		while (keys.hasMoreElements()) {

  625. 		    Object key = keys.nextElement();

  626. 		    Object cssValue = null;

  627. 		    if (key instanceof StyleConstants) {

  628. 			// convert the StyleConstants attribute if possible

  629. 			Object cssKey = css.styleConstantsKeyToCSSKey

  630. 			                    ((StyleConstants)key);

  631. 			if (cssKey != null) {

  632. 			    Object value = a.getAttribute(key);

  633. 			    cssValue = css.styleConstantsValueToCSSValue

  634. 				           ((StyleConstants)key, value);

  635. 			    if (cssValue != null) {

  636. 				converted.addAttribute(cssKey, cssValue);

  637. 			    }

  638. 			}

  639. 		    }

  640. 		    if (cssValue == null) {

  641. 			converted.addAttribute(key, a.getAttribute(key));

  642. 		    }

  643. 		}

  644. 		return converted;

  645.             }

  646. 	}

  647. 	return a;

  648.     }

  649. 

  650.     /**

  651.      * Large set of attributes that does conversion of requests

  652.      * for attributes of type StyleConstants.

  653.      */

  654.     class LargeConversionSet extends SimpleAttributeSet {

  655. 

  656. 	/**

  657. 	 * Creates a new attribute set based on a supplied set of attributes.

  658. 	 *

  659. 	 * @param source the set of attributes

  660. 	 */

  661.         public LargeConversionSet(AttributeSet source) {

  662. 	    super(source);

  663. 	}

  664. 

  665.         public LargeConversionSet() {

  666. 	    super();

  667. 	}

  668. 

  669.         /**

  670.          * Checks whether a given attribute is defined.

  671.          *

  672.          * @param key the attribute key

  673.          * @return true if the attribute is defined

  674.          * @see AttributeSet#isDefined

  675.          */

  676.         public boolean isDefined(Object key) {

  677. 	    if (key instanceof StyleConstants) {

  678. 		Object cssKey = css.styleConstantsKeyToCSSKey

  679. 		                    ((StyleConstants)key);

  680. 		if (cssKey != null) {

  681. 		    return super.isDefined(cssKey);

  682. 		}

  683. 	    }

  684. 	    return super.isDefined(key);

  685. 	}

  686. 

  687.         /**

  688.          * Gets the value of an attribute.

  689.          *

  690.          * @param key the attribute name

  691.          * @return the attribute value

  692.          * @see AttributeSet#getAttribute

  693.          */

  694.         public Object getAttribute(Object key) {

  695. 	    if (key instanceof StyleConstants) {

  696. 		Object cssKey = css.styleConstantsKeyToCSSKey

  697. 		                    ((StyleConstants)key);

  698. 		if (cssKey != null) {

  699. 		    Object value = super.getAttribute(cssKey);

  700. 		    if (value != null) {

  701. 			return css.cssValueToStyleConstantsValue

  702. 			                   ((StyleConstants)key, value);

  703. 		    }

  704. 		}

  705. 	    }

  706. 	    return super.getAttribute(key);

  707. 	}

  708.     }

  709. 

  710.     /**

  711.      * Small set of attributes that does conversion of requests

  712.      * for attributes of type StyleConstants.

  713.      */

  714.     class SmallConversionSet extends SmallAttributeSet {

  715. 

  716. 	/**

  717. 	 * Creates a new attribute set based on a supplied set of attributes.

  718. 	 *

  719. 	 * @param source the set of attributes

  720. 	 */

  721.         public SmallConversionSet(AttributeSet attrs) {

  722. 	    super(attrs);

  723. 	}

  724.  	

  725.         /**

  726.          * Checks whether a given attribute is defined.

  727.          *

  728.          * @param key the attribute key

  729.          * @return true if the attribute is defined

  730.          * @see AttributeSet#isDefined

  731.          */

  732.         public boolean isDefined(Object key) {

  733. 	    if (key instanceof StyleConstants) {

  734. 		Object cssKey = css.styleConstantsKeyToCSSKey

  735. 		                    ((StyleConstants)key);

  736. 		if (cssKey != null) {

  737. 		    return super.isDefined(cssKey);

  738. 		}

  739. 	    }

  740. 	    return super.isDefined(key);

  741. 	}

  742. 

  743.         /**

  744.          * Gets the value of an attribute.

  745.          *

  746.          * @param key the attribute name

  747.          * @return the attribute value

  748.          * @see AttributeSet#getAttribute

  749.          */

  750.         public Object getAttribute(Object key) {

  751. 	    if (key instanceof StyleConstants) {

  752. 		Object cssKey = css.styleConstantsKeyToCSSKey

  753. 		                    ((StyleConstants)key);

  754. 		if (cssKey != null) {

  755. 		    Object value = super.getAttribute(cssKey);

  756. 		    if (value != null) {

  757. 			return css.cssValueToStyleConstantsValue

  758. 			                   ((StyleConstants)key, value);

  759. 		    }

  760. 		}

  761. 	    }

  762. 	    return super.getAttribute(key);

  763. 	}

  764.     }

  765. 

  766.     // ---- Resource handling ----------------------------------------

  767. 

  768.     /**

  769.      * Fetches the font to use for the given set of attributes.

  770.      */

  771.     public Font getFont(AttributeSet a) {

  772. 	return css.getFont(this, a, 12);

  773.     }

  774. 

  775.     /**

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

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

  778.      * like brighter, more hue, etc.

  779.      *

  780.      * @param a the set of attributes

  781.      * @return the color

  782.      */

  783.     public Color getForeground(AttributeSet a) {

  784. 	Color c = css.getColor(a, CSS.Attribute.COLOR);

  785. 	if (c == null) {

  786. 	    return Color.black;

  787. 	}

  788. 	return c;

  789.     }

  790. 

  791.     /**

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

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

  794.      * like brighter, more hue, etc.

  795.      *

  796.      * @param attr the set of attributes

  797.      * @return the color

  798.      */

  799.     public Color getBackground(AttributeSet a) {

  800. 	return css.getColor(a, CSS.Attribute.BACKGROUND_COLOR);

  801.     }

  802. 

  803.     /**

  804.      * Fetches the box formatter to use for the given set

  805.      * of CSS attributes.

  806.      */

  807.     public BoxPainter getBoxPainter(AttributeSet a) {

  808. 	return new BoxPainter(a, css, this);

  809.     }

  810. 

  811.     /**

  812.      * Fetches the list formatter to use for the given set

  813.      * of CSS attributes.

  814.      */

  815.     public ListPainter getListPainter(AttributeSet a) {

  816. 	return new ListPainter(a, this);

  817.     }

  818. 

  819.     public void setBaseFontSize(int sz) {

  820. 	css.setBaseFontSize(sz);

  821.     }

  822. 

  823.     public void setBaseFontSize(String size) {

  824. 	css.setBaseFontSize(size);

  825.     }

  826. 

  827.     public static int getIndexOfSize(float pt) {

  828. 	return CSS.getIndexOfSize(pt);

  829.     }

  830. 

  831.     /**

  832.      * Returns the point size, given a size index.

  833.      */

  834.     public float getPointSize(int index) {

  835. 	return css.getPointSize(index);

  836.     }

  837. 

  838.     /**

  839.      *  Given a string such as "+2", "-2", or "2",

  840.      *  returns a point size value.

  841.      */

  842.     public float getPointSize(String size) {

  843. 	return css.getPointSize(size);

  844.     }

  845. 

  846.     /**

  847.      * Converts a color string such as "RED" or "#NNNNNN" to a Color.

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

  849.      *       or a string of length 7;

  850.      *       otherwise, it will return null.

  851.      */

  852.     public Color stringToColor(String string) {

  853. 	return CSS.stringToColor(string);

  854.     }

  855. 

  856.     /**

  857.      * Returns the ImageIcon to draw in the background for

  858.      * <code>attr</code>.

  859.      */

  860.     ImageIcon getBackgroundImage(AttributeSet attr) {

  861. 	Object value = attr.getAttribute(CSS.Attribute.BACKGROUND_IMAGE);

  862. 

  863. 	if (value != null) {

  864. 	    return ((CSS.BackgroundImage)value).getImage(getBase());

  865. 	}

  866. 	return null;

  867.     }

  868. 

  869.     /**

  870.      * Adds a rule into the StyleSheet.

  871.      *

  872.      * @param selector the selector to use for the rule.

  873.      *  This will be a set of simple selectors, and must

  874.      *  be a length of 1 or greater.

  875.      * @param declaration the set of CSS attributes that

  876.      *  make up the rule.

  877.      */

  878.     void addRule(String[] selector, AttributeSet declaration,

  879. 		 boolean isLinked) {

  880. 	int n = selector.length;

  881. 	StringBuffer sb = new StringBuffer();

  882. 	sb.append(selector[0]);

  883. 	for (int counter = 1; counter < n; counter++) {

  884. 	    sb.append(' ');

  885. 	    sb.append(selector[counter]);

  886. 	}

  887. 	String selectorName = sb.toString();

  888. 	Style rule = getStyle(selectorName);

  889. 	if (rule == null) {

  890. 	    // Notice how the rule is first created, and it not part of

  891. 	    // the synchronized block. It is done like this as creating

  892. 	    // a new rule will fire a ChangeEvent. We do not want to be

  893. 	    // holding the lock when calling to other objects, it can

  894. 	    // result in deadlock.

  895. 	    Style altRule = addStyle(selectorName, null);

  896. 	    synchronized(this) {

  897. 		Object mapping = getRootSelectorMapping();

  898. 		for (int i = n - 1; i >= 0; i--) {

  899. 		    mapping = getSelectorMapping(mapping, selector[i], true);

  900. 		}

  901. 		rule = getMappingStyle(mapping);

  902. 		if (rule == null) {

  903. 		    rule = createStyleForSelector(selectorName, mapping,

  904. 						  altRule);

  905. 		    refreshResolvedRules(selectorName, selector, rule,

  906. 					 getSpecificity(mapping));

  907. 		}

  908. 	    }

  909. 	}

  910. 	if (isLinked) {

  911. 	    rule = getLinkedStyle(rule);

  912. 	}

  913. 	rule.addAttributes(declaration);

  914.     }

  915. 

  916.     //

  917.     // The following gaggle of methods is used in maintaing the rules from

  918.     // the sheet.

  919.     //

  920. 

  921.     /**

  922.      * Updates the attributes of the rules to reference any related

  923.      * rules in <code>ss</code>.

  924.      */

  925.     private synchronized void linkStyleSheetAt(StyleSheet ss, int index) {

  926. 	if (resolvedStyles.size() > 0) {

  927. 	    Enumeration values = resolvedStyles.elements();

  928. 	    while (values.hasMoreElements()) {

  929. 		ResolvedStyle rule = (ResolvedStyle)values.nextElement();

  930. 		rule.insertExtendedStyleAt(ss.getRule(rule.getName()),

  931. 					   index);

  932. 	    }

  933. 	}

  934.     }

  935. 

  936.     /**

  937.      * Removes references to the rules in <code>ss</code>.

  938.      * <code>index</code> gives the index the StyleSheet was at, that is

  939.      * how many StyleSheets had been added before it.

  940.      */

  941.     private synchronized void unlinkStyleSheet(StyleSheet ss, int index) {

  942. 	if (resolvedStyles.size() > 0) {

  943. 	    Enumeration values = resolvedStyles.elements();

  944. 	    while (values.hasMoreElements()) {

  945. 		ResolvedStyle rule = (ResolvedStyle)values.nextElement();

  946. 		rule.removeExtendedStyleAt(index);

  947. 	    }

  948. 	}

  949.     }

  950. 

  951.     /**

  952.      * Returns the simple selectors that comprise selector.

  953.      */

  954.     /* protected */

  955.     String[] getSimpleSelectors(String selector) {

  956. 	selector = cleanSelectorString(selector);

  957. 	SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  958. 	Vector selectors = sb.getVector();

  959. 	int lastIndex = 0;

  960. 	int length = selector.length();

  961. 	while (lastIndex != -1) {

  962. 	    int newIndex = selector.indexOf(' ', lastIndex);

  963. 	    if (newIndex != -1) {

  964. 		selectors.addElement(selector.substring(lastIndex, newIndex));

  965. 		if (++newIndex == length) {

  966. 		    lastIndex = -1;

  967. 		}

  968. 		else {

  969. 		    lastIndex = newIndex;

  970. 		}

  971. 	    }

  972. 	    else {

  973. 		selectors.addElement(selector.substring(lastIndex));

  974. 		lastIndex = -1;

  975. 	    }

  976. 	}

  977. 	String[] retValue = new String[selectors.size()];

  978. 	selectors.copyInto(retValue);

  979. 	SearchBuffer.releaseSearchBuffer(sb);

  980. 	return retValue;

  981.     }

  982. 

  983.     /**

  984.      * Returns a string that only has one space between simple selectors,

  985.      * which may be the passed in String.

  986.      */

  987.     /*protected*/ String cleanSelectorString(String selector) {

  988. 	boolean lastWasSpace = true;

  989. 	for (int counter = 0, maxCounter = selector.length();

  990. 	     counter < maxCounter; counter++) {

  991. 	    switch(selector.charAt(counter)) {

  992. 	    case ' ':

  993. 		if (lastWasSpace) {

  994. 		    return _cleanSelectorString(selector);

  995. 		}

  996. 		lastWasSpace = true;

  997. 		break;

  998. 	    case '\n':

  999. 	    case '\r':

  1000. 	    case '\t':

  1001. 		return _cleanSelectorString(selector);

  1002. 	    default:

  1003. 		lastWasSpace = false;

  1004. 	    }

  1005. 	}

  1006. 	if (lastWasSpace) {

  1007. 	    return _cleanSelectorString(selector);

  1008. 	}

  1009. 	// It was fine.

  1010. 	return selector;

  1011.     }

  1012. 

  1013.     /**

  1014.      * Returns a new String that contains only one space between non

  1015.      * white space characters.

  1016.      */

  1017.     private String _cleanSelectorString(String selector) {

  1018. 	SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  1019. 	StringBuffer buff = sb.getStringBuffer();

  1020. 	boolean lastWasSpace = true;

  1021. 	int lastIndex = 0;

  1022. 	char[] chars = selector.toCharArray();

  1023. 	int numChars = chars.length;

  1024. 	String retValue = null;

  1025. 	try {

  1026. 	    for (int counter = 0; counter < numChars; counter++) {

  1027. 		switch(chars[counter]) {

  1028. 		case ' ':

  1029. 		    if (!lastWasSpace) {

  1030. 			lastWasSpace = true;

  1031. 			if (lastIndex < counter) {

  1032. 			    buff.append(chars, lastIndex,

  1033. 					1 + counter - lastIndex);

  1034. 			}

  1035. 		    }

  1036. 		    lastIndex = counter + 1;

  1037. 		    break;

  1038. 		case '\n':

  1039. 		case '\r':

  1040. 		case '\t':

  1041. 		    if (!lastWasSpace) {

  1042. 			lastWasSpace = true;

  1043. 			if (lastIndex < counter) {

  1044. 			    buff.append(chars, lastIndex,

  1045. 					counter - lastIndex);

  1046. 			    buff.append(' ');

  1047. 			}

  1048. 		    }

  1049. 		    lastIndex = counter + 1;

  1050. 		    break;

  1051. 		default:

  1052. 		    lastWasSpace = false;

  1053. 		    break;

  1054. 		}

  1055. 	    }

  1056. 	    if (lastWasSpace && buff.length() > 0) {

  1057. 		// Remove last space.

  1058. 		buff.setLength(buff.length() - 1);

  1059. 	    }

  1060. 	    else if (lastIndex < numChars) {

  1061. 		buff.append(chars, lastIndex, numChars - lastIndex);

  1062. 	    }

  1063. 	    retValue = buff.toString();

  1064. 	}

  1065. 	finally {

  1066. 	    SearchBuffer.releaseSearchBuffer(sb);

  1067. 	}

  1068. 	return retValue;

  1069.     }

  1070. 

  1071.     /**

  1072.      * Returns the root selector mapping that all selectors are relative

  1073.      * too. This is an inverted graph of the selectors.

  1074.      */

  1075.     private Object getRootSelectorMapping() {

  1076. 	return selectorMapping;

  1077.     }

  1078. 

  1079.     /**

  1080.      * Returns the child mapping of <code>parent</code> for

  1081.      * <code>selector</code>. If there is no mapping for <code>selector</code>

  1082.      * and <code>create</code> is false, this will return null.

  1083.      */

  1084.     private synchronized Object getSelectorMapping(Object parent,

  1085. 						   String selector,

  1086. 						   boolean create) {

  1087. 	Hashtable retValue = (Hashtable)((Hashtable)parent).get(selector);

  1088. 	if (retValue == null && create) {

  1089. 	    retValue = new Hashtable(7);

  1090. 	    ((Hashtable)parent).put(selector, retValue);

  1091. 

  1092. 	    // Update specificity for child.

  1093. 	    int    specificity = 0;

  1094. 

  1095. 	    if (parent != null) {

  1096. 		Object     pSpec = ((Hashtable)parent).get(SPECIFICITY);

  1097. 

  1098. 		if (pSpec != null) {

  1099. 		    specificity = ((Integer)pSpec).intValue();

  1100. 		}

  1101. 	    }

  1102. 	    // class (.) 100

  1103. 	    // id (#)    10000

  1104. 	    char    firstChar = selector.charAt(0);

  1105. 	    if (firstChar == '.') {

  1106. 		specificity += 100;

  1107. 	    }

  1108. 	    else if (firstChar == '#') {

  1109. 		specificity += 10000;

  1110. 	    }

  1111. 	    else {

  1112. 		specificity += 1;

  1113. 		if (selector.indexOf('.') != -1) {

  1114. 		    specificity += 100;

  1115. 		}

  1116. 		if (selector.indexOf('#') != -1) {

  1117. 		    specificity += 10000;

  1118. 		}

  1119. 	    }

  1120. 	    retValue.put(SPECIFICITY, new Integer(specificity));

  1121. 	}

  1122. 	return retValue;

  1123.     }

  1124. 

  1125.     /**

  1126.      * Returns the specificity of the passed in String. It assumes the

  1127.      * passed in string doesn't contain junk, that is each selector is

  1128.      * separated by a space and each selector at most contains one . or one

  1129.      * #. A simple selector has a weight of 1, an id selector has a weight

  1130.      * of 100, and a class selector has a weight of 10000.

  1131.      */

  1132.     /*protected*/ static int getSpecificity(String selector) {

  1133.         int specificity = 0;

  1134.         boolean lastWasSpace = true;

  1135. 

  1136.         for (int counter = 0, maxCounter = selector.length();

  1137.              counter < maxCounter; counter++) {

  1138.             switch(selector.charAt(counter)) {

  1139.             case '.':

  1140.                 specificity += 100;

  1141.                 break;

  1142.             case '#':

  1143.                 specificity += 10000;

  1144.                 break;

  1145.             case ' ':

  1146.                 lastWasSpace = true;

  1147.                 break;

  1148.             default:

  1149.                 if (lastWasSpace) {

  1150.                     lastWasSpace = false;

  1151.                     specificity += 1;

  1152.                 }

  1153.             }

  1154.         }

  1155.         return specificity;

  1156.     }

  1157. 

  1158.     /**

  1159.      * Returns the specificity of the passed in mapping.

  1160.      */

  1161.     private int getSpecificity(Object mapping) {

  1162. 	Object     pSpec = ((Hashtable)mapping).get(SPECIFICITY);

  1163. 

  1164. 	if (pSpec != null) {

  1165. 	    return ((Integer)pSpec).intValue();

  1166. 	}

  1167. 	return 0;

  1168.     }

  1169. 

  1170.     /**

  1171.      * Returns the style for the passed in mapping.

  1172.      */

  1173.     private Style getMappingStyle(Object mapping) {

  1174. 	return (Style)((Hashtable)mapping).get(RULE);

  1175.     }

  1176. 

  1177.     /**

  1178.      * Removes the previously added mapping style.

  1179.      */

  1180.     private void removeMappingStyle(Object mapping) {

  1181. 	((Hashtable)mapping).remove(RULE);

  1182.     }

  1183. 

  1184.     /**

  1185.      * Returns the style that linked attributes should be added to. This

  1186.      * will create the style if necessary.

  1187.      */

  1188.     private Style getLinkedStyle(Style localStyle) {

  1189. 	// NOTE: This is not synchronized, and the caller of this does

  1190. 	// not synchronize. There is the chance for one of the callers to

  1191. 	// overwrite the existing resolved parent, but it is quite rare.

  1192. 	// The reason this is left like this is because setResolveParent

  1193. 	// will fire a ChangeEvent. It is really, REALLY bad for us to

  1194. 	// hold a lock when calling outside of us, it may cause a deadlock.

  1195. 	Style retStyle = (Style)localStyle.getResolveParent();

  1196. 	if (retStyle == null) {

  1197. 	    retStyle = addStyle(null, null);

  1198. 	    localStyle.setResolveParent(retStyle);

  1199. 	}

  1200. 	return retStyle;

  1201.     }

  1202. 

  1203.     /**

  1204.      * Returns the Style appropriate for <code>selector</code> and

  1205.      * <code>mapping</code>. If a Style does not currently exist,

  1206.      * <code>altStyle</code> will be used.

  1207.      */

  1208.     private synchronized Style createStyleForSelector(String selector,

  1209. 						      Object mapping,

  1210. 						      Style altStyle) {

  1211. 	Style style = (Style)((Hashtable)mapping).get(RULE);

  1212. 	if (style == null) {

  1213. 	    style = altStyle;

  1214. 	    ((Hashtable)mapping).put(RULE, altStyle);

  1215. 	}

  1216. 	return style;

  1217.     }

  1218. 

  1219.     /**

  1220.      * Returns the resolved style for <code>selector</code>. This will

  1221.      * create the resolved style, if necessary.

  1222.      */

  1223.     private synchronized Style getResolvedStyle(String selector,

  1224. 						Vector elements,

  1225. 						HTML.Tag t) {

  1226. 	Style retStyle = (Style)resolvedStyles.get(selector);

  1227. 	if (retStyle == null) {

  1228. 	    retStyle = createResolvedStyle(selector, elements, t);

  1229. 	}

  1230. 	return retStyle;

  1231.     }

  1232. 

  1233.     /**

  1234.      * Returns the resolved style for <code>selector</code>. This will

  1235.      * create the resolved style, if necessary.

  1236.      */

  1237.     private synchronized Style getResolvedStyle(String selector) {

  1238. 	Style retStyle = (Style)resolvedStyles.get(selector);

  1239. 	if (retStyle == null) {

  1240. 	    retStyle = createResolvedStyle(selector);

  1241. 	}

  1242. 	return retStyle;

  1243.     }

  1244. 

  1245.     /**

  1246.      * Adds <code>mapping</code> to <code>elements</code>. It is added

  1247.      * such that <code>elements</code> will remain ordered by 

  1248.      * specificity.

  1249.      */

  1250.     private void addSortedStyle(Object mapping, Vector elements) {

  1251. 	int       size = elements.size();

  1252. 

  1253. 	if (size > 0) {

  1254. 	    int     specificity = getSpecificity(mapping);

  1255. 

  1256. 	    for (int counter = 0; counter < size; counter++) {

  1257. 		if (specificity >= getSpecificity(elements.

  1258. 						  elementAt(counter))) {

  1259. 		    elements.insertElementAt(mapping, counter);

  1260. 		    return;

  1261. 		}

  1262. 	    }

  1263. 	}

  1264. 	elements.addElement(mapping);

  1265.     }

  1266. 

  1267.     /**

  1268.      * Adds <code>parentMapping</code> to <code>styles</code>, and

  1269.      * recursively calls this method if <code>parentMapping</code> has

  1270.      * any child mappings for any of the Elements in <code>elements</code>.

  1271.      */

  1272.     private synchronized void getStyles(Object parentMapping,

  1273.                            Vector styles,

  1274.                            String[] tags, String[] ids, String[] classes,

  1275.                            int index, int numElements,

  1276.                            Hashtable alreadyChecked) {

  1277. 	// Avoid desending the same mapping twice.

  1278. 	if (alreadyChecked.contains(parentMapping)) {

  1279. 	    return;

  1280. 	}

  1281. 	alreadyChecked.put(parentMapping, parentMapping);

  1282. 	Style style = getMappingStyle(parentMapping);

  1283. 	if (style != null) {

  1284. 	    addSortedStyle(parentMapping, styles);

  1285. 	}

  1286. 	for (int counter = index; counter < numElements; counter++) {

  1287.             String tagString = tags[counter];

  1288.             if (tagString != null) {

  1289. 		Object childMapping = getSelectorMapping(parentMapping,

  1290. 							 tagString, false);

  1291. 		if (childMapping != null) {

  1292. 		    getStyles(childMapping, styles, tags, ids, classes,

  1293.                               counter + 1, numElements, alreadyChecked);

  1294. 		}

  1295. 		if (classes[counter] != null) {

  1296. 		    String className = classes[counter];

  1297. 		    childMapping = getSelectorMapping(parentMapping,

  1298. 				       tagString + "." + className, false);

  1299. 		    if (childMapping != null) {

  1300. 			getStyles(childMapping, styles, tags, ids, classes,

  1301.                                   counter + 1, numElements, alreadyChecked);

  1302. 		    }

  1303. 		    childMapping = getSelectorMapping(parentMapping, "." +

  1304. 						      className, false);

  1305. 		    if (childMapping != null) {

  1306. 			getStyles(childMapping, styles, tags, ids, classes,

  1307.                                   counter + 1, numElements, alreadyChecked);

  1308. 		    }

  1309. 		}

  1310. 		if (ids[counter] != null) {

  1311. 		    String idName = ids[counter];

  1312. 		    childMapping = getSelectorMapping(parentMapping,

  1313. 				       tagString + "#" + idName, false);

  1314. 		    if (childMapping != null) {

  1315. 			getStyles(childMapping, styles, tags, ids, classes,

  1316.                                   counter + 1, numElements, alreadyChecked);

  1317. 		    }

  1318. 		    childMapping = getSelectorMapping(parentMapping, "#" +

  1319. 						      idName, false);

  1320. 		    if (childMapping != null) {

  1321. 			getStyles(childMapping, styles, tags, ids, classes,

  1322.                                   counter + 1, numElements, alreadyChecked);

  1323. 		    }

  1324. 		}

  1325. 	    }

  1326. 	}

  1327.     }

  1328. 

  1329.     /**

  1330.      * Creates and returns a Style containing all the rules that match

  1331.      *  <code>selector</code>.

  1332.      */

  1333.     private synchronized Style createResolvedStyle(String selector,

  1334. 				      String[] tags,

  1335. 				      String[] ids, String[] classes) {

  1336. 	SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  1337. 	Vector tempVector = sb.getVector();

  1338. 	Hashtable tempHashtable = sb.getHashtable();

  1339. 	// Determine all the Styles that are appropriate, placing them

  1340. 	// in tempVector

  1341. 	try {

  1342. 	    Object mapping = getRootSelectorMapping();

  1343. 	    int numElements = tags.length;

  1344. 	    String tagString = tags[0];

  1345. 	    Object childMapping = getSelectorMapping(mapping, tagString,

  1346. 						     false);

  1347. 	    if (childMapping != null) {

  1348. 		getStyles(childMapping, tempVector, tags, ids, classes, 1,

  1349. 			  numElements, tempHashtable);

  1350. 	    }

  1351. 	    if (classes[0] != null) {

  1352. 		String className = classes[0];

  1353. 		childMapping = getSelectorMapping(mapping, tagString + "." +

  1354. 						  className, false);

  1355. 		if (childMapping != null) {

  1356. 		    getStyles(childMapping, tempVector, tags, ids, classes, 1,

  1357. 			      numElements, tempHashtable);

  1358. 		}

  1359. 		childMapping = getSelectorMapping(mapping, "." + className,

  1360. 						  false);

  1361. 		if (childMapping != null) {

  1362. 		    getStyles(childMapping, tempVector, tags, ids, classes,

  1363. 			      1, numElements, tempHashtable);

  1364. 		}

  1365. 	    }

  1366. 	    if (ids[0] != null) {

  1367. 		String idName = ids[0];

  1368. 		childMapping = getSelectorMapping(mapping, tagString + "#" +

  1369. 						  idName, false);

  1370. 		if (childMapping != null) {

  1371. 		    getStyles(childMapping, tempVector, tags, ids, classes,

  1372. 			      1, numElements, tempHashtable);

  1373. 		}

  1374. 		childMapping = getSelectorMapping(mapping, "#" + idName,

  1375. 						  false);

  1376. 		if (childMapping != null) {

  1377. 		    getStyles(childMapping, tempVector, tags, ids, classes,

  1378. 			      1, numElements, tempHashtable);

  1379. 		}

  1380. 	    }

  1381. 	    // Create a new Style that will delegate to all the matching

  1382. 	    // Styles.

  1383. 	    int numLinkedSS = (linkedStyleSheets != null) ?

  1384. 		              linkedStyleSheets.size() : 0;

  1385. 	    int numStyles = tempVector.size();

  1386. 	    AttributeSet[] attrs = new AttributeSet[numStyles + numLinkedSS];

  1387. 	    for (int counter = 0; counter < numStyles; counter++) {

  1388. 		attrs[counter] = getMappingStyle(tempVector.

  1389. 						 elementAt(counter));

  1390. 	    }

  1391. 	    // Get the AttributeSet from linked style sheets.

  1392. 	    for (int counter = 0; counter < numLinkedSS; counter++) {

  1393. 		AttributeSet attr = ((StyleSheet)linkedStyleSheets.

  1394. 				 elementAt(counter)).getRule(selector);

  1395. 		if (attr == null) {

  1396. 		    attrs[counter + numStyles] = SimpleAttributeSet.EMPTY;

  1397. 		}

  1398. 		else {

  1399. 		    attrs[counter + numStyles] = attr;

  1400. 		}

  1401. 	    }

  1402. 	    ResolvedStyle retStyle = new ResolvedStyle(selector, attrs,

  1403. 						       numStyles);

  1404. 	    resolvedStyles.put(selector, retStyle);

  1405. 	    return retStyle;

  1406. 	}

  1407. 	finally {

  1408. 	    SearchBuffer.releaseSearchBuffer(sb);

  1409. 	}

  1410.     }

  1411. 

  1412.     /**

  1413.      * Creates and returns a Style containing all the rules that

  1414.      * matches <code>selector</code>.

  1415.      *

  1416.      * @param elements  a Vector of all the Elements

  1417.      *                  the style is being asked for. The

  1418.      *                  first Element is the deepest Element, with the last Element

  1419.      *                  representing the root.

  1420.      * @param t         the Tag to use for

  1421.      *                  the first Element in <code>elements</code>

  1422.      */

  1423.     private Style createResolvedStyle(String selector, Vector elements,

  1424. 				      HTML.Tag t) {

  1425. 	int numElements = elements.size();

  1426.         // Build three arrays, one for tags, one for class's, and one for

  1427.         // id's

  1428.         String tags[] = new String[numElements];

  1429.         String ids[] = new String[numElements];

  1430.         String classes[] = new String[numElements];

  1431.         for (int counter = 0; counter < numElements; counter++) {

  1432.             Element e = (Element)elements.elementAt(counter);

  1433.             AttributeSet attr = e.getAttributes();

  1434. 	    if (counter == 0 && e.isLeaf()) {

  1435. 		// For leafs, we use the second tier attributes.

  1436. 		Object testAttr = attr.getAttribute(t);

  1437. 		if (testAttr instanceof AttributeSet) {

  1438. 		    attr = (AttributeSet)testAttr;

  1439. 		}

  1440. 		else {

  1441. 		    attr = null;

  1442. 		}

  1443. 	    }

  1444.             if (attr != null) {

  1445. 		HTML.Tag tag = (HTML.Tag)attr.getAttribute(StyleConstants.

  1446. 							   NameAttribute);

  1447.                 if (tag != null) {

  1448.                     tags[counter] = tag.toString();

  1449.                 }

  1450.                 else {

  1451.                     tags[counter] = null;

  1452.                 }

  1453. 		if (attr.isDefined(HTML.Attribute.CLASS)) {

  1454.                     classes[counter] = attr.getAttribute

  1455. 			              (HTML.Attribute.CLASS).toString();

  1456. 		}

  1457.                 else {

  1458.                     classes[counter] = null;

  1459.                 }

  1460. 		if (attr.isDefined(HTML.Attribute.ID)) {

  1461.                     ids[counter] = attr.getAttribute(HTML.Attribute.ID).

  1462. 			                toString();

  1463.                 }

  1464.                 else {

  1465.                     ids[counter] = null;

  1466.                 }

  1467.             }

  1468.             else {

  1469.                 tags[counter] = ids[counter] = classes[counter] = null;

  1470.             }

  1471.         }

  1472.         tags[0] = t.toString();

  1473. 	return createResolvedStyle(selector, tags, ids, classes);

  1474.     }

  1475. 

  1476.     /**

  1477.      * Creates and returns a Style containing all the rules that match

  1478.      *  <code>selector</code>. It is assumed that each simple selector

  1479.      * in <code>selector</code> is separated by a space.

  1480.      */

  1481.     private Style createResolvedStyle(String selector) {

  1482. 	SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  1483. 	// Will contain the tags, ids, and classes, in that order.

  1484. 	Vector elements = sb.getVector();

  1485. 	try {

  1486. 	    boolean done;

  1487. 	    int dotIndex = 0;

  1488. 	    int spaceIndex = 0;

  1489. 	    int poundIndex = 0;

  1490. 	    int lastIndex = 0;

  1491. 	    int length = selector.length();

  1492. 	    while (lastIndex < length) {

  1493. 		if (dotIndex == lastIndex) {

  1494. 		    dotIndex = selector.indexOf('.', lastIndex);

  1495. 		}

  1496. 		if (poundIndex == lastIndex) {

  1497. 		    poundIndex = selector.indexOf('#', lastIndex);

  1498. 		}

  1499. 		spaceIndex = selector.indexOf(' ', lastIndex);

  1500. 		if (spaceIndex == -1) {

  1501. 		    spaceIndex = length;

  1502. 		}

  1503. 		if (dotIndex != -1 && poundIndex != -1 &&

  1504. 		    dotIndex < spaceIndex && poundIndex < spaceIndex) {

  1505. 		    if (poundIndex < dotIndex) {

  1506. 			// #.

  1507. 			if (lastIndex == poundIndex) {

  1508. 			    elements.addElement("");

  1509. 			}

  1510. 			else {

  1511. 			    elements.addElement(selector.substring(lastIndex,

  1512. 								  poundIndex));

  1513. 			}

  1514. 			if ((dotIndex + 1) < spaceIndex) {

  1515. 			    elements.addElement(selector.substring

  1516. 						(dotIndex + 1, spaceIndex));

  1517. 			}

  1518. 			else {

  1519. 			    elements.addElement(null);

  1520. 			}

  1521. 			if ((poundIndex + 1) == dotIndex) {

  1522. 			    elements.addElement(null);

  1523. 			}

  1524. 			else {

  1525. 			    elements.addElement(selector.substring

  1526. 						(poundIndex + 1, dotIndex));

  1527. 			}

  1528. 		    }

  1529. 		    else if(poundIndex < spaceIndex) {

  1530. 			// .#

  1531. 			if (lastIndex == dotIndex) {

  1532. 			    elements.addElement("");

  1533. 			}

  1534. 			else {

  1535. 			    elements.addElement(selector.substring(lastIndex,

  1536. 								  dotIndex));

  1537. 			}

  1538. 			if ((dotIndex + 1) < poundIndex) {

  1539. 			    elements.addElement(selector.substring

  1540. 						(dotIndex + 1, poundIndex));

  1541. 			}

  1542. 			else {

  1543. 			    elements.addElement(null);

  1544. 			}

  1545. 			if ((poundIndex + 1) == spaceIndex) {

  1546. 			    elements.addElement(null);

  1547. 			}

  1548. 			else {

  1549. 			    elements.addElement(selector.substring

  1550. 						(poundIndex + 1, spaceIndex));

  1551. 			}

  1552. 		    }

  1553. 		    dotIndex = poundIndex = spaceIndex + 1;

  1554. 		}

  1555. 		else if (dotIndex != -1 && dotIndex < spaceIndex) {

  1556. 		    // .

  1557. 		    if (dotIndex == lastIndex) {

  1558. 			elements.addElement("");

  1559. 		    }

  1560. 		    else {

  1561. 			elements.addElement(selector.substring(lastIndex,

  1562. 							       dotIndex));

  1563. 		    }

  1564. 		    if ((dotIndex + 1) == spaceIndex) {

  1565. 			elements.addElement(null);

  1566. 		    }

  1567. 		    else {

  1568. 			elements.addElement(selector.substring(dotIndex + 1,

  1569. 							       spaceIndex));

  1570. 		    }

  1571. 		    elements.addElement(null);

  1572. 		    dotIndex = spaceIndex + 1;

  1573. 		}

  1574. 		else if (poundIndex != -1 && poundIndex < spaceIndex) {

  1575. 		    // #

  1576. 		    if (poundIndex == lastIndex) {

  1577. 			elements.addElement("");

  1578. 		    }

  1579. 		    else {

  1580. 			elements.addElement(selector.substring(lastIndex,

  1581. 							       poundIndex));

  1582. 		    }

  1583. 		    elements.addElement(null);

  1584. 		    if ((poundIndex + 1) == spaceIndex) {

  1585. 			elements.addElement(null);

  1586. 		    }

  1587. 		    else {

  1588. 			elements.addElement(selector.substring(poundIndex + 1,

  1589. 							       spaceIndex));

  1590. 		    }

  1591. 		    poundIndex = spaceIndex + 1;

  1592. 		}

  1593. 		else {

  1594. 		    // id

  1595. 		    elements.addElement(selector.substring(lastIndex,

  1596. 							   spaceIndex));

  1597. 		    elements.addElement(null);

  1598. 		    elements.addElement(null);

  1599. 		}

  1600. 		lastIndex = spaceIndex + 1;

  1601. 	    }

  1602. 	    // Create the tag, id, and class arrays.

  1603. 	    int total = elements.size();

  1604. 	    int numTags = total / 3;

  1605. 	    String[] tags = new String[numTags];

  1606. 	    String[] ids = new String[numTags];

  1607. 	    String[] classes = new String[numTags];

  1608. 	    for (int index = 0, eIndex = total - 3; index < numTags;

  1609. 		 index++, eIndex -= 3) {

  1610. 		tags[index] = (String)elements.elementAt(eIndex);

  1611. 		ids[index] = (String)elements.elementAt(eIndex + 1);

  1612. 		classes[index] = (String)elements.elementAt(eIndex + 2);

  1613. 	    }

  1614. 	    return createResolvedStyle(selector, tags, ids, classes);

  1615. 	}

  1616. 	finally {

  1617. 	    SearchBuffer.releaseSearchBuffer(sb);

  1618. 	}

  1619.     }

  1620. 

  1621.     /**

  1622.      * Should be invoked when a new rule is added that did not previously

  1623.      * exist. Goes through and refreshes the necessary resolved

  1624.      * rules.

  1625.      */

  1626.     private synchronized void refreshResolvedRules(String selectorName,

  1627. 						   String[] selector,

  1628. 						   Style newStyle,

  1629. 						   int specificity) {

  1630. 	if (resolvedStyles.size() > 0) {

  1631. 	    Enumeration values = resolvedStyles.elements();

  1632. 	    while (values.hasMoreElements()) {

  1633. 		ResolvedStyle style = (ResolvedStyle)values.nextElement();

  1634. 		if (style.matches(selectorName)) {

  1635. 		    style.insertStyle(newStyle, specificity);

  1636. 		}

  1637. 	    }

  1638. 	}

  1639.     }

  1640. 

  1641.     // Serialization support

  1642. 

  1643.     private void readObject(ObjectInputStream s)

  1644. 	throws ClassNotFoundException, IOException {

  1645. 	s.defaultReadObject();

  1646. 	// Remap SheetAttributes to the shared versions

  1647. 	updateSheetAttributes(selectorMapping);

  1648.     }

  1649. 

  1650.     private void updateSheetAttributes(Hashtable mapping) {

  1651. 	Enumeration keys = mapping.keys();

  1652. 	while (keys.hasMoreElements()) {

  1653. 	    Object key = keys.nextElement();

  1654. 	    Object value = mapping.get(key);

  1655. 	    if (key instanceof SheetAttribute) {

  1656. 		if (key.toString().equals("specificity")) {

  1657. 		    mapping.remove(key);

  1658. 		    mapping.put(SPECIFICITY, value);

  1659. 		}

  1660. 		else if (key.toString().equals("rule")) {

  1661. 		    mapping.remove(key);

  1662. 		    mapping.put(RULE, value);

  1663. 		}

  1664. 	    }

  1665. 	    else {

  1666. 		if (value instanceof Hashtable) {

  1667. 		    updateSheetAttributes((Hashtable)value);

  1668. 		}

  1669. 	    }

  1670. 	}

  1671.     }

  1672. 

  1673.     /**

  1674.      * A temporary class used to hold a Vector, a StringBuffer and a

  1675.      * Hashtable. This is used to avoid allocing a lot of garbage when

  1676.      * searching for rules. Use the static method obtainSearchBuffer and

  1677.      * releaseSearchBuffer to get a SearchBuffer, and release it when

  1678.      * done.

  1679.      */

  1680.     private static class SearchBuffer {

  1681. 	/** A stack containing instances of SearchBuffer. Used in getting

  1682. 	 * rules. */

  1683. 	static Stack searchBuffers = new Stack();

  1684. 	// A set of temporary variables that can be used in whatever way.

  1685.         Vector vector = null;

  1686.         StringBuffer stringBuffer = null;

  1687.         Hashtable hashtable = null;

  1688. 

  1689. 	/**

  1690. 	 * Returns an instance of SearchBuffer. Be sure and issue

  1691. 	 * a releaseSearchBuffer when done with it.

  1692. 	 */

  1693. 	static SearchBuffer obtainSearchBuffer() {

  1694. 	    SearchBuffer sb;

  1695. 	    try {

  1696. 		sb = (SearchBuffer)searchBuffers.pop();

  1697. 	    } catch (EmptyStackException ese) {

  1698. 		sb = new SearchBuffer();

  1699. 	    }

  1700. 	    return sb;

  1701. 	}

  1702. 

  1703. 	/**

  1704. 	 * Adds <code>sb</code> to the stack of SearchBuffers that can

  1705. 	 * be used.

  1706. 	 */

  1707. 	static void releaseSearchBuffer(SearchBuffer sb) {

  1708. 	    sb.empty();

  1709. 	    searchBuffers.push(sb);

  1710. 	}

  1711. 

  1712. 	StringBuffer getStringBuffer() {

  1713. 	    if (stringBuffer == null) {

  1714. 		stringBuffer = new StringBuffer();

  1715. 	    }

  1716. 	    return stringBuffer;

  1717. 	}

  1718. 

  1719. 	Vector getVector() {

  1720. 	    if (vector == null) {

  1721. 		vector = new Vector();

  1722. 	    }

  1723. 	    return vector;

  1724. 	}

  1725. 

  1726. 	Hashtable getHashtable() {

  1727. 	    if (hashtable == null) {

  1728. 		hashtable = new Hashtable();

  1729. 	    }

  1730. 	    return hashtable;

  1731. 	}

  1732. 

  1733.         void empty() {

  1734. 	    if (stringBuffer != null) {

  1735. 		stringBuffer.setLength(0);

  1736. 	    }

  1737.             if (vector != null) {

  1738.                 vector.removeAllElements();

  1739.             }

  1740.             if (hashtable != null) {

  1741.                 hashtable.clear();

  1742.             }

  1743.         }

  1744.     }

  1745. 

  1746. 

  1747.     static final Border noBorder = new EmptyBorder(0,0,0,0);

  1748. 

  1749.     /**

  1750.      * Class to carry out some of the duties of

  1751.      * CSS formatting.  Implementations of this

  1752.      * class enable views to present the CSS formatting

  1753.      * while not knowing anything about how the CSS values

  1754.      * are being cached.

  1755.      * <p>

  1756.      * As a delegate of Views, this object is responsible for

  1757.      * the insets of a View and making sure the background

  1758.      * is maintained according to the CSS attributes.

  1759.      */

  1760.     public static class BoxPainter implements Serializable {

  1761. 

  1762. 	BoxPainter(AttributeSet a, CSS css, StyleSheet ss) {

  1763. 	    this.ss = ss;

  1764. 	    this.css = css;

  1765. 	    border = getBorder(a);

  1766. 	    binsets = border.getBorderInsets(null);

  1767. 	    topMargin = getLength(CSS.Attribute.MARGIN_TOP, a);

  1768. 	    bottomMargin = getLength(CSS.Attribute.MARGIN_BOTTOM, a);

  1769. 	    leftMargin = getLength(CSS.Attribute.MARGIN_LEFT, a);

  1770. 	    rightMargin = getLength(CSS.Attribute.MARGIN_RIGHT, a);

  1771. 	    bg = ss.getBackground(a);

  1772. 	    if (ss.getBackgroundImage(a) != null) {

  1773. 		bgPainter = new BackgroundImagePainter(a, css, ss);

  1774. 	    }

  1775. 	}

  1776. 

  1777. 	/**

  1778. 	 * Fetches a border to render for the given attributes.

  1779. 	 * PENDING(prinz) This is pretty badly hacked at the 

  1780. 	 * moment.

  1781. 	 */

  1782. 	Border getBorder(AttributeSet a) {

  1783. 	    Border b = noBorder;

  1784. 	    Object o = a.getAttribute(CSS.Attribute.BORDER_STYLE);

  1785. 	    if (o != null) {

  1786. 		String bstyle = o.toString();

  1787. 		int bw = (int) getLength(CSS.Attribute.BORDER_TOP_WIDTH, a);

  1788. 		if (bw > 0) {

  1789. 		    if (bstyle.equals("inset")) {

  1790. 			Color c = getBorderColor(a);

  1791. 			b = new BevelBorder(BevelBorder.LOWERED, c.brighter(), c.darker());

  1792. 		    } else if (bstyle.equals("outset")) {

  1793. 			Color c = getBorderColor(a);

  1794. 			b = new BevelBorder(BevelBorder.RAISED, c.brighter(), c.darker());

  1795. 		    } else if (bstyle.equals("solid")) {

  1796. 			Color c = getBorderColor(a);

  1797. 			b = new LineBorder(c);

  1798. 		    }

  1799. 		}

  1800. 	    }

  1801. 	    return b;

  1802. 	}

  1803. 

  1804. 	/**

  1805. 	 * Fetches the color to use for borders.  This will either be

  1806. 	 * the value specified by the border-color attribute (which

  1807. 	 * is not inherited), or it will default to the color attribute

  1808. 	 * (which is inherited).

  1809. 	 */

  1810. 	Color getBorderColor(AttributeSet a) {

  1811. 	    Color color = css.getColor(a, CSS.Attribute.BORDER_COLOR);

  1812. 	    if (color == null) {

  1813. 		color = css.getColor(a, CSS.Attribute.COLOR);

  1814. 		if (color == null) {

  1815. 		    return Color.black;

  1816. 		}

  1817. 	    }

  1818. 	    return color;

  1819. 	}

  1820. 

  1821. 	/**

  1822. 	 * Fetches the inset needed on a given side to

  1823. 	 * account for the margin, border, and padding.

  1824. 	 *

  1825. 	 * @param side The size of the box to fetch the

  1826. 	 *  inset for.  This can be View.TOP,

  1827. 	 *  View.LEFT, View.BOTTOM, or View.RIGHT.

  1828. 	 * @param v the view making the request.  This is

  1829. 	 *  used to get the AttributeSet, and may be used to

  1830. 	 *  resolve percentage arguments.

  1831. 	 * @exception IllegalArgumentException for an invalid direction

  1832. 	 */

  1833.         public float getInset(int side, View v) {

  1834. 	    AttributeSet a = v.getAttributes();

  1835. 	    float inset = 0;

  1836. 	    switch(side) {

  1837. 	    case View.LEFT:

  1838. 		inset += leftMargin;

  1839. 		inset += binsets.left;

  1840. 		inset += getLength(CSS.Attribute.PADDING_LEFT, a);

  1841. 		break;

  1842. 	    case View.RIGHT:

  1843. 		inset += rightMargin;

  1844. 		inset += binsets.right;

  1845. 		inset += getLength(CSS.Attribute.PADDING_RIGHT, a);

  1846. 		break;

  1847. 	    case View.TOP:

  1848. 		inset += topMargin;

  1849. 		inset += binsets.top;

  1850. 		inset += getLength(CSS.Attribute.PADDING_TOP, a);

  1851. 		break;

  1852. 	    case View.BOTTOM:

  1853. 		inset += bottomMargin;

  1854. 		inset += binsets.bottom;

  1855. 		inset += getLength(CSS.Attribute.PADDING_BOTTOM, a);

  1856. 		break;

  1857. 	    default:

  1858. 		throw new IllegalArgumentException("Invalid side: " + side);

  1859. 	    }

  1860. 	    return inset;

  1861. 	}

  1862. 

  1863. 	/**

  1864. 	 * Paints the CSS box according to the attributes

  1865. 	 * given.  This should paint the border, padding,

  1866. 	 * and background.

  1867. 	 *

  1868. 	 * @param g the rendering surface.

  1869. 	 * @param x the x coordinate of the allocated area to

  1870. 	 *  render into.

  1871. 	 * @param y the y coordinate of the allocated area to

  1872. 	 *  render into.

  1873. 	 * @param w the width of the allocated area to render into.

  1874. 	 * @param h the height of the allocated area to render into.

  1875. 	 * @param v the view making the request.  This is

  1876. 	 *  used to get the AttributeSet, and may be used to

  1877. 	 *  resolve percentage arguments.

  1878. 	 */

  1879.         public void paint(Graphics g, float x, float y, float w, float h, View v) {

  1880. 	    // PENDING(prinz) implement real rendering... which would

  1881. 	    // do full set of border and background capabilities.

  1882. 	    // remove margin

  1883. 	    x += leftMargin;

  1884. 	    y += topMargin;

  1885. 	    w -= leftMargin + rightMargin;

  1886. 	    h -= topMargin + bottomMargin;

  1887. 

  1888. 	    if (bg != null) {

  1889. 		g.setColor(bg);

  1890. 		g.fillRect((int) x, (int) y, (int) w, (int) h);

  1891. 	    }

  1892. 	    if (bgPainter != null) {

  1893. 		bgPainter.paint(g, x, y, w, h, v);

  1894. 	    }

  1895. 	    border.paintBorder(null, g, (int) x, (int) y, (int) w, (int) h);

  1896. 	}

  1897. 

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

  1899. 	    return css.getLength(a, key);

  1900. 	}

  1901. 

  1902. 	float topMargin;

  1903. 	float bottomMargin;

  1904. 	float leftMargin;

  1905. 	float rightMargin;

  1906. 	// Bitmask, used to indicate what margins are relative:

  1907. 	// bit 0 for top, 1 for bottom, 2 for left and 3 for right.

  1908. 	short marginFlags;

  1909. 	Border border;

  1910. 	Insets binsets;

  1911. 	CSS css;

  1912. 	StyleSheet ss;

  1913. 	Color bg;

  1914. 	BackgroundImagePainter bgPainter;

  1915.     }

  1916. 

  1917.     /**

  1918.      * Class to carry out some of the duties of CSS list

  1919.      * formatting.  Implementations of this

  1920.      * class enable views to present the CSS formatting

  1921.      * while not knowing anything about how the CSS values

  1922.      * are being cached.

  1923.      */

  1924.     public static class ListPainter implements Serializable {

  1925. 

  1926. 	ListPainter(AttributeSet attr, StyleSheet ss) {

  1927. 	    /* Get the image to use as a list bullet */

  1928. 	    String imgstr = (String)attr.getAttribute(CSS.Attribute.

  1929. 						      LIST_STYLE_IMAGE);

  1930. 	    type = null;

  1931. 	    if (imgstr != null && !imgstr.equals("none")) {

  1932. 		String tmpstr = null;

  1933. 		try {

  1934. 		    StringTokenizer st = new StringTokenizer(imgstr, "()");

  1935. 		    if (st.hasMoreTokens())

  1936. 			tmpstr = st.nextToken();

  1937. 		    if (st.hasMoreTokens())

  1938. 			tmpstr = st.nextToken();

  1939. 		    URL u = new URL(tmpstr);

  1940. 		    img = new ImageIcon(u);

  1941. 		} catch (MalformedURLException e) {

  1942. 		    if (tmpstr != null && ss != null && ss.getBase() != null) {

  1943. 			try {

  1944. 			    URL u = new URL(ss.getBase(), tmpstr);

  1945. 			    img = new ImageIcon(u);

  1946. 			} catch (MalformedURLException murle) {

  1947. 			    img = null;

  1948. 			}

  1949. 		    }

  1950. 		    else {

  1951. 			img = null;

  1952. 		    }

  1953. 		}

  1954. 	    }

  1955. 

  1956. 	    /* Get the type of bullet to use in the list */

  1957. 	    if (img == null) {

  1958. 		type = (CSS.Value)attr.getAttribute(CSS.Attribute.

  1959. 						    LIST_STYLE_TYPE);

  1960. 	    }

  1961.             // PENDING(sky): Resolve this, there is no way to get the

  1962.             // start value. start is an HTML attribute, and not visible

  1963.             // from attr.

  1964.             start = 1;

  1965. 	}

  1966. 

  1967. 	/**

  1968. 	 * Returns a string that represents the value

  1969. 	 * of the HTML.Attribute.TYPE attribute.

  1970. 	 * If this attributes is not defined, then

  1971. 	 * then the type defaults to "disc" unless

  1972. 	 * the tag is on Ordered list.  In the case

  1973. 	 * of the latter, the default type is "decimal".

  1974. 	 */

  1975. 	private CSS.Value getChildType(View childView) {

  1976. 	    CSS.Value childtype = (CSS.Value)childView.getAttributes().

  1977.                                   getAttribute(CSS.Attribute.LIST_STYLE_TYPE);

  1978. 

  1979. 	    if (childtype == null) {

  1980. 		if (type == null) {

  1981.                     // Parent view.

  1982.                     View v = childView.getParent();

  1983. 		    HTMLDocument doc = (HTMLDocument)v.getDocument();

  1984. 		    if (doc.matchNameAttribute(v.getElement().getAttributes(),

  1985.                                                HTML.Tag.OL)) {

  1986. 			childtype = CSS.Value.DECIMAL;

  1987. 		    } else {

  1988. 			childtype = CSS.Value.DISC;

  1989. 		    }

  1990. 		} else {

  1991. 		    childtype = type;

  1992. 		}

  1993. 	    }

  1994. 	    return childtype;

  1995. 	}

  1996. 

  1997.         /**

  1998.          * Returns an integer that should be used to render the child at

  1999.          * <code>childIndex</code> with. The retValue will usually be

  2000.          * <code>childIndex</code> + 1, unless <code>parentView</code>

  2001.          * has some Views that do not represent LI's, or one of the views

  2002.          * has a HTML.Attribute.START specified.

  2003.          */

  2004.         private int getRenderIndex(View parentView, int childIndex) {

  2005.             int retIndex = childIndex;

  2006.             for (int counter = childIndex; counter >= 0; counter--) {

  2007.                 AttributeSet as = parentView.getElement().getElement(counter).

  2008.                                   getAttributes();

  2009.                 if (as.getAttribute(StyleConstants.NameAttribute) !=

  2010.                     HTML.Tag.LI) {

  2011.                     retIndex--;

  2012.                 }

  2013.                 else {

  2014.                     Object value = as.getAttribute(HTML.Attribute.VALUE);

  2015.                     if (value != null &&

  2016.                         (value instanceof String)) {

  2017.                         try {

  2018.                             int iValue = Integer.parseInt((String)value);

  2019.                             return retIndex - counter + iValue;

  2020.                         }

  2021.                         catch (NumberFormatException nfe) {}

  2022.                     }

  2023.                 }

  2024.             }

  2025.             return retIndex + start;

  2026.         }

  2027. 

  2028. 	/**

  2029. 	 * Paints the CSS list decoration according to the

  2030. 	 * attributes given.

  2031. 	 *

  2032. 	 * @param g the rendering surface.

  2033. 	 * @param x the x coordinate of the list item allocation

  2034. 	 * @param y the y coordinate of the list item allocation

  2035. 	 * @param w the width of the list item allocation

  2036. 	 * @param h the height of the list item allocation

  2037. 	 * @param s the allocated area to paint into.

  2038. 	 * @param item which list item is being painted.  This

  2039. 	 *  is a number greater than or equal to 0.

  2040. 	 */

  2041.         public void paint(Graphics g, float x, float y, float w, float h, View v, int item) {

  2042. 	    View cv = v.getView(item);

  2043.             Object name = cv.getElement().getAttributes().getAttribute

  2044.                          (StyleConstants.NameAttribute);

  2045.             // Only draw something if the View is a list item. This won't

  2046.             // be the case for comments.

  2047.             if (!(name instanceof HTML.Tag) ||

  2048.                 name != HTML.Tag.LI) {

  2049.                 return;

  2050.             }

  2051. 	    float align = cv.getAlignment(View.Y_AXIS);

  2052. 	    if (img != null) {

  2053.     		drawIcon(g, (int) x, (int) y, (int) h, align,

  2054. 			 v.getContainer());

  2055. 		return;

  2056. 	    }

  2057. 	    CSS.Value childtype = getChildType(cv);

  2058. 	    Font font = ((StyledDocument)cv.getDocument()).

  2059. 		                         getFont(cv.getAttributes());

  2060. 	    if (font != null) {

  2061. 		g.setFont(font);

  2062. 	    }

  2063. 	    if (childtype == CSS.Value.SQUARE || childtype == CSS.Value.CIRCLE

  2064.                 || childtype == CSS.Value.DISC) {

  2065.     		drawShape(g, childtype, (int) x, (int) y, (int) h, align);

  2066. 	    } else if (childtype == CSS.Value.CIRCLE) {

  2067.     		drawShape(g, childtype, (int) x, (int) y, (int) h, align);

  2068. 	    } else if (childtype == CSS.Value.DECIMAL) {

  2069. 		drawLetter(g, '1', (int) x, (int) y, (int) h,

  2070.                            getRenderIndex(v, item));

  2071. 	    } else if (childtype == CSS.Value.LOWER_ALPHA) {

  2072. 		drawLetter(g, 'a', (int) x, (int) y, (int) h,

  2073.                            getRenderIndex(v, item));

  2074. 	    } else if (childtype == CSS.Value.UPPER_ALPHA) {

  2075. 		drawLetter(g, 'A', (int) x, (int) y, (int) h,

  2076.                            getRenderIndex(v, item));

  2077. 	    } else if (childtype == CSS.Value.LOWER_ROMAN) {

  2078. 		drawLetter(g, 'i', (int) x, (int) y, (int) h,

  2079.                            getRenderIndex(v, item));

  2080. 	    } else if (childtype == CSS.Value.UPPER_ROMAN) {

  2081. 		drawLetter(g, 'I', (int) x, (int) y, (int) h,

  2082.                            getRenderIndex(v, item));

  2083. 	    }

  2084. 	}

  2085. 

  2086. 	/**

  2087. 	 * Draws the bullet icon specified by the list-style-image argument.

  2088. 	 *

  2089. 	 * @param g     the graphics context

  2090. 	 * @param ax    x coordinate to place the bullet

  2091. 	 * @param ay    y coordinate to place the bullet

  2092. 	 * @param ah    height of the container the bullet is placed in

  2093. 	 * @param align preferred alignment factor for the child view

  2094. 	 */

  2095. 	void drawIcon(Graphics g, int ax, int ay, int ah,

  2096. 		      float align, Component c) {

  2097. 	    g.setColor(Color.black);

  2098. 	    int x = ax - img.getIconWidth() - bulletgap;

  2099. 	    int y = ay + (int)(ah * align) - 3;

  2100. 

  2101. 	    img.paintIcon(c, g, x, y);

  2102. 	}

  2103. 

  2104. 	/**

  2105. 	 * Draws the graphical bullet item specified by the type argument.

  2106. 	 *

  2107. 	 * @param g     the graphics context

  2108. 	 * @param type  type of bullet to draw (circle, square, disc)

  2109. 	 * @param ax    x coordinate to place the bullet

  2110. 	 * @param ay    y coordinate to place the bullet

  2111. 	 * @param ah    height of the container the bullet is placed in

  2112. 	 * @param align preferred alignment factor for the child view

  2113. 	 */

  2114. 	void drawShape(Graphics g, CSS.Value type, int ax, int ay, int ah,

  2115. 		       float align) {

  2116. 	    g.setColor(Color.black);

  2117. 	    int x = ax - bulletgap - 7;

  2118. 	    int y = ay + (int)(ah * align) - 3;

  2119. 

  2120. 	    if (type == CSS.Value.SQUARE) {

  2121. 		g.drawRect(x, y, 7, 7);

  2122. 	    } else if (type == CSS.Value.CIRCLE) {

  2123. 		g.drawOval(x, y, 7, 7);

  2124. 	    } else {

  2125. 		g.fillOval(x, y, 7, 7);

  2126. 	    }

  2127. 	}

  2128. 

  2129. 	/**

  2130. 	 * Draws the letter or number for an ordered list.

  2131. 	 *

  2132. 	 * @param g     the graphics context

  2133. 	 * @param letter type of ordered list to draw

  2134. 	 * @param ax    x coordinate to place the bullet

  2135. 	 * @param ay    y coordinate to place the bullet

  2136. 	 * @param ah    height of the container the bullet is placed in

  2137. 	 * @param index position of the list item in the list

  2138. 	 */

  2139. 	void drawLetter(Graphics g, char letter, int ax, int ay, int ah,

  2140. 			int index) {

  2141. 	    g.setColor(Color.black);

  2142. 	    String str = formatItemNum(index, letter) + ".";

  2143. 	    FontMetrics fm = g.getFontMetrics();

  2144. 	    int stringwidth = fm.stringWidth(str);

  2145. 	    int x = ax - stringwidth - bulletgap;

  2146. 	    int y = ay + fm.getAscent() + fm.getLeading();

  2147. 	    g.drawString(str, x, y);

  2148. 	}

  2149. 

  2150. 	/**

  2151. 	 * Converts the item number into the ordered list number

  2152. 	 * (i.e.  1 2 3, i ii iii, a b c, etc.

  2153. 	 *

  2154. 	 * @param itemNum number to format

  2155. 	 * @param type    type of ordered list

  2156. 	 */

  2157. 	String formatItemNum(int itemNum, char type) {

  2158. 	    String numStyle = "1";

  2159. 

  2160. 	    boolean uppercase = false;

  2161. 

  2162. 	    String formattedNum;

  2163. 

  2164. 	    switch (type) {

  2165. 	    case '1':

  2166. 	    default:

  2167. 		formattedNum = String.valueOf(itemNum);

  2168. 		break;

  2169. 

  2170. 	    case 'A':

  2171. 		uppercase = true;

  2172. 		// fall through

  2173. 	    case 'a':

  2174. 		formattedNum = formatAlphaNumerals(itemNum);

  2175. 		break;

  2176. 

  2177. 	    case 'I':

  2178. 		uppercase = true;

  2179. 		// fall through

  2180. 	    case 'i':

  2181. 		formattedNum = formatRomanNumerals(itemNum);

  2182. 	    }

  2183. 

  2184. 	    if (uppercase) {

  2185. 		formattedNum = formattedNum.toUpperCase();

  2186. 	    }

  2187. 

  2188. 	    return formattedNum;

  2189. 	}

  2190. 

  2191. 	/**

  2192. 	 * Converts the item number into an alphabetic character

  2193. 	 *

  2194. 	 * @param itemNum number to format

  2195. 	 */

  2196. 	String formatAlphaNumerals(int itemNum) {

  2197. 	    String result = "";

  2198. 

  2199. 	    if (itemNum > 26) {

  2200. 		result = formatAlphaNumerals(itemNum / 26) +

  2201. 		    formatAlphaNumerals(itemNum % 26);

  2202. 	    } else {

  2203. 		// -1 because item is 1 based.

  2204. 		result = String.valueOf((char)('a' + itemNum - 1));

  2205. 	    }

  2206. 

  2207. 	    return result;

  2208. 	}

  2209. 

  2210. 	/* list of roman numerals */

  2211. 	static final char romanChars[][] = {

  2212. 	    {'i', 'v'},

  2213. 	    {'x', 'l' },

  2214. 	    {'c', 'd' },

  2215. 	    {'m', '?' },

  2216.         };

  2217. 

  2218. 	/**

  2219. 	 * Converts the item number into a roman numeral

  2220. 	 *

  2221. 	 * @param num  number to format

  2222. 	 */

  2223. 	String formatRomanNumerals(int num) {

  2224. 	    return formatRomanNumerals(0, num);

  2225. 	}

  2226. 

  2227. 	/**

  2228. 	 * Converts the item number into a roman numeral

  2229. 	 *

  2230. 	 * @param num  number to format

  2231. 	 */

  2232. 	String formatRomanNumerals(int level, int num) {

  2233. 	    if (num < 10) {

  2234. 		return formatRomanDigit(level, num);

  2235. 	    } else {

  2236. 		return formatRomanNumerals(level + 1, num / 10) +

  2237. 		    formatRomanDigit(level, num % 10);

  2238. 	    }

  2239. 	}

  2240. 

  2241. 

  2242. 	/**

  2243. 	 * Converts the item number into a roman numeral

  2244. 	 *

  2245. 	 * @param level position

  2246. 	 * @param num   digit to format

  2247. 	 */

  2248. 	String formatRomanDigit(int level, int digit) {

  2249. 	    String result = "";

  2250. 	    if (digit == 9) {

  2251. 		result = result + romanChars[level][0];

  2252. 		result = result + romanChars[level + 1][0];

  2253. 		return result;

  2254. 	    } else if (digit == 4) {

  2255. 		result = result + romanChars[level][0];

  2256. 		result = result + romanChars[level][1];

  2257. 		return result;

  2258. 	    } else if (digit >= 5) {

  2259. 		result = result + romanChars[level][1];

  2260. 		digit -= 5;

  2261. 	    }

  2262. 

  2263. 	    for (int i = 0; i < digit; i++) {

  2264. 		result = result + romanChars[level][0];

  2265. 	    }

  2266. 

  2267. 	    return result;

  2268. 	}

  2269. 

  2270.         private int start;

  2271.         private CSS.Value type;

  2272.         URL imageurl;

  2273.         Icon img = null;

  2274.         private int bulletgap = 5;

  2275.     }

  2276. 

  2277. 

  2278.     /**

  2279.      * Paints the background image.

  2280.      */

  2281.     static class BackgroundImagePainter implements Serializable {

  2282. 	ImageIcon   backgroundImage;

  2283. 	float       hPosition;

  2284. 	float       vPosition;

  2285. 	// bit mask: 0 for repeat x, 1 for repeat y, 2 for horiz relative,

  2286. 	// 3 for vert relative

  2287. 	short       flags;

  2288. 	// These are used when painting, updatePaintCoordinates updates them.

  2289. 	private int paintX;

  2290. 	private int paintY;

  2291. 	private int paintMaxX;

  2292. 	private int paintMaxY;

  2293. 

  2294. 	BackgroundImagePainter(AttributeSet a, CSS css, StyleSheet ss) {

  2295. 	    backgroundImage = ss.getBackgroundImage(a);

  2296. 	    // Determine the position.

  2297. 	    CSS.BackgroundPosition pos = (CSS.BackgroundPosition)a.getAttribute

  2298. 		                           (CSS.Attribute.BACKGROUND_POSITION);

  2299. 	    if (pos != null) {

  2300. 		hPosition = pos.getHorizontalPosition();

  2301. 		vPosition = pos.getVerticalPosition();

  2302. 		if (pos.isHorizontalPositionRelativeToSize()) {

  2303. 		    flags |= 4;

  2304. 		}

  2305. 		else if (pos.isHorizontalPositionRelativeToSize()) {

  2306. 		    hPosition *= css.getFontSize(a, 12);

  2307. 		}

  2308. 		if (pos.isVerticalPositionRelativeToSize()) {

  2309. 		    flags |= 8;

  2310. 		}

  2311. 		else if (pos.isVerticalPositionRelativeToFontSize()) {

  2312. 		    vPosition *= css.getFontSize(a, 12);

  2313. 		}

  2314. 	    }

  2315. 	    // Determine any repeating values.

  2316. 	    CSS.Value repeats = (CSS.Value)a.getAttribute(CSS.Attribute.

  2317. 							  BACKGROUND_REPEAT);

  2318. 	    if (repeats == null || repeats == CSS.Value.BACKGROUND_REPEAT) {

  2319. 		flags |= 3;

  2320. 	    }

  2321. 	    else if (repeats == CSS.Value.BACKGROUND_REPEAT_X) {

  2322. 		flags |= 1;

  2323. 	    }

  2324. 	    else if (repeats == CSS.Value.BACKGROUND_REPEAT_Y) {

  2325. 		flags |= 2;

  2326. 	    }

  2327. 	}

  2328. 

  2329.         void paint(Graphics g, float x, float y, float w, float h, View v) {

  2330. 	    Rectangle clip = g.getClipRect();

  2331. 	    if (clip != null) {

  2332. 		// Constrain the clip so that images don't draw outside the

  2333. 		// legal bounds.

  2334. 		g.clipRect((int)x, (int)y, (int)w, (int)h);

  2335. 	    }

  2336. 	    if ((flags & 3) == 0) {

  2337. 		// no repeating

  2338. 		int width = backgroundImage.getIconWidth();

  2339. 		int height = backgroundImage.getIconWidth();

  2340. 		if ((flags & 4) == 4) {

  2341. 		    paintX = (int)(x + w * hPosition -

  2342. 				  (float)width * hPosition);

  2343. 		}

  2344. 		else {

  2345. 		    paintX = (int)x + (int)hPosition;

  2346. 		}

  2347. 		if ((flags & 8) == 8) {

  2348. 		    paintY = (int)(y + h * vPosition -

  2349. 				  (float)height * vPosition);

  2350. 		}

  2351. 		else {

  2352. 		    paintY = (int)y + (int)vPosition;

  2353. 		}

  2354. 		if (clip == null ||

  2355. 		    !((paintX + width <= clip.x) ||

  2356. 		      (paintY + height <= clip.y) ||

  2357. 		      (paintX >= clip.x + clip.width) ||

  2358. 		      (paintY >= clip.y + clip.height))) {

  2359. 		    backgroundImage.paintIcon(null, g, paintX, paintY);

  2360. 		}

  2361. 	    }

  2362. 	    else {

  2363. 		int width = backgroundImage.getIconWidth();

  2364. 		int height = backgroundImage.getIconHeight();

  2365. 		if (width > 0 && height > 0) {

  2366. 		    paintX = (int)x;

  2367. 		    paintY = (int)y;

  2368. 		    paintMaxX = (int)(x + w);

  2369. 		    paintMaxY = (int)(y + h);

  2370. 		    if (updatePaintCoordinates(clip, width, height)) {

  2371. 			while (paintX < paintMaxX) {

  2372. 			    int ySpot = paintY;

  2373. 			    while (ySpot < paintMaxY) {

  2374. 				backgroundImage.paintIcon(null, g, paintX,

  2375. 							  ySpot);

  2376. 				ySpot += height;

  2377. 			    }

  2378. 			    paintX += width;

  2379. 			}

  2380. 		    }

  2381. 		}

  2382. 	    }

  2383. 	    if (clip != null) {

  2384. 		// Reset clip.

  2385. 		g.setClip(clip.x, clip.y, clip.width, clip.height);

  2386. 	    }

  2387. 	}

  2388. 

  2389. 	private boolean updatePaintCoordinates

  2390. 	         (Rectangle clip, int width, int height){

  2391. 	    if ((flags & 3) == 1) {

  2392. 		paintMaxY = paintY + 1;

  2393. 	    }

  2394. 	    else if ((flags & 3) == 2) {

  2395. 		paintMaxX = paintX + 1;

  2396. 	    }

  2397. 	    if (clip != null) {

  2398. 		if ((flags & 3) == 1 && ((paintY + height <= clip.y) ||

  2399. 					 (paintY > clip.y + clip.height))) {

  2400. 		    // not visible.

  2401. 		    return false;

  2402. 		}

  2403. 		if ((flags & 3) == 2 && ((paintX + width <= clip.x) ||

  2404. 					 (paintX > clip.x + clip.width))) {

  2405. 		    // not visible.

  2406. 		    return false;

  2407. 		}

  2408. 		if ((flags & 1) == 1) {

  2409. 		    if ((clip.x + clip.width) < paintMaxX) {

  2410. 			if ((clip.x + clip.width - paintX) % width == 0) {

  2411. 			    paintMaxX = clip.x + clip.width;

  2412. 			}

  2413. 			else {

  2414. 			    paintMaxX = ((clip.x + clip.width - paintX) /

  2415. 					 width + 1) * width + paintX;

  2416. 			}

  2417. 		    }

  2418. 		    if (clip.x > paintX) {

  2419. 			paintX = (clip.x - paintX) / width * width + paintX;

  2420. 		    }

  2421. 		}

  2422. 		if ((flags & 2) == 2) {

  2423. 		    if ((clip.y + clip.height) < paintMaxY) {

  2424. 			if ((clip.y + clip.height - paintY) % height == 0) {

  2425. 			    paintMaxY = clip.y + clip.height;

  2426. 			}

  2427. 			else {

  2428. 			    paintMaxY = ((clip.y + clip.height - paintY) /

  2429. 					 height + 1) * height + paintY;

  2430. 			}

  2431. 		    }

  2432. 		    if (clip.y > paintY) {

  2433. 			paintY = (clip.y - paintY) / height * height + paintY;

  2434. 		    }

  2435. 		}

  2436. 	    }

  2437. 	    // Valid

  2438. 	    return true;

  2439. 	}

  2440.     }

  2441. 

  2442. 

  2443.     /**

  2444.      * An implementation of AttributeSet that can multiplex

  2445.      * across a set of AttributeSets.

  2446.      */

  2447.     static class MuxingAttributeSet implements AttributeSet, Serializable {

  2448. 	MuxingAttributeSet(AttributeSet[] attrs) {

  2449. 	    this.attrs = attrs;

  2450. 	}

  2451. 

  2452. 	MuxingAttributeSet() {

  2453. 	}

  2454. 

  2455. 	protected synchronized void setAttributes(AttributeSet[] attrs) {

  2456. 	    this.attrs = attrs;

  2457. 	}

  2458. 

  2459. 	/**

  2460. 	 * Returns the AttributeSets multiplexing too. When the AttributeSets

  2461. 	 * need to be referenced, this should be called.

  2462. 	 */

  2463. 	protected synchronized AttributeSet[] getAttributes() {

  2464. 	    return attrs;

  2465. 	}

  2466. 

  2467. 	/**

  2468. 	 * Inserts <code>as</code> at <code>index</code>. This assumes

  2469. 	 * the value of <code>index</code> is between 0 and attrs.length,

  2470. 	 * inclusive.

  2471. 	 */

  2472. 	protected synchronized void insertAttributeSetAt(AttributeSet as,

  2473. 							 int index) {

  2474. 	    int numAttrs = attrs.length;

  2475. 	    AttributeSet newAttrs[] = new AttributeSet[numAttrs + 1];

  2476. 	    if (index < numAttrs) {

  2477. 		if (index > 0) {

  2478. 		    System.arraycopy(attrs, 0, newAttrs, 0, index);

  2479. 		    System.arraycopy(attrs, index, newAttrs, index + 1,

  2480. 				     numAttrs - index);

  2481. 		}

  2482. 		else {

  2483. 		    System.arraycopy(attrs, 0, newAttrs, 1, numAttrs);

  2484. 		}

  2485. 	    }

  2486. 	    else {

  2487. 		System.arraycopy(attrs, 0, newAttrs, 0, numAttrs);

  2488. 	    }

  2489. 	    newAttrs[index] = as;

  2490.             attrs = newAttrs;

  2491.         }

  2492. 

  2493. 	/**

  2494. 	 * Removes the AttributeSet at <code>index</code>. This assumes

  2495. 	 * the value of <code>index</code> is greater than or equal to 0,

  2496. 	 * and less than attrs.length.

  2497. 	 */

  2498. 	protected synchronized void removeAttributeSetAt(int index) {

  2499. 	    int numAttrs = attrs.length;

  2500. 	    AttributeSet[] newAttrs = new AttributeSet[numAttrs - 1];

  2501. 	    if (numAttrs > 0) {

  2502. 		if (index == 0) {

  2503. 		    // FIRST

  2504. 		    System.arraycopy(attrs, 1, newAttrs, 0, numAttrs - 1);

  2505. 		}

  2506. 		else if (index < (numAttrs - 1)) {

  2507. 		    // MIDDLE

  2508. 		    System.arraycopy(attrs, 0, newAttrs, 0, index);

  2509. 		    System.arraycopy(attrs, index + 1, newAttrs, index,

  2510. 				     numAttrs - index - 1);

  2511. 		}

  2512. 		else {

  2513. 		    // END

  2514. 		    System.arraycopy(attrs, 0, newAttrs, 0, numAttrs - 1);

  2515. 		}

  2516. 	    }

  2517. 	    attrs = newAttrs;

  2518. 	}

  2519. 

  2520. 	//  --- AttributeSet methods ----------------------------

  2521. 

  2522. 	/**

  2523. 	 * Gets the number of attributes that are defined.

  2524. 	 *

  2525. 	 * @return the number of attributes

  2526. 	 * @see AttributeSet#getAttributeCount

  2527. 	 */

  2528.         public int getAttributeCount() {

  2529. 	    AttributeSet[] as = getAttributes();

  2530. 	    int n = 0;

  2531. 	    for (int i = 0; i < as.length; i++) {

  2532. 		n += as[i].getAttributeCount();

  2533. 	    }

  2534. 	    return n;

  2535. 	}

  2536. 

  2537. 	/**

  2538. 	 * Checks whether a given attribute is defined.

  2539. 	 * This will convert the key over to CSS if the

  2540. 	 * key is a StyleConstants key that has a CSS

  2541. 	 * mapping.

  2542. 	 *

  2543. 	 * @param key the attribute key

  2544. 	 * @return true if the attribute is defined

  2545. 	 * @see AttributeSet#isDefined

  2546. 	 */

  2547.         public boolean isDefined(Object key) {

  2548. 	    AttributeSet[] as = getAttributes();

  2549. 	    for (int i = 0; i < as.length; i++) {

  2550. 		if (as[i].isDefined(key)) {

  2551. 		    return true;

  2552. 		}

  2553. 	    }

  2554. 	    return false;

  2555. 	}

  2556. 

  2557. 	/**

  2558. 	 * Checks whether two attribute sets are equal.

  2559. 	 *

  2560. 	 * @param attr the attribute set to check against

  2561. 	 * @return true if the same

  2562. 	 * @see AttributeSet#isEqual

  2563. 	 */

  2564.         public boolean isEqual(AttributeSet attr) {

  2565. 	    return ((getAttributeCount() == attr.getAttributeCount()) &&

  2566. 		    containsAttributes(attr));

  2567. 	}

  2568. 

  2569. 	/**

  2570. 	 * Copies a set of attributes.

  2571. 	 *

  2572. 	 * @return the copy

  2573. 	 * @see AttributeSet#copyAttributes

  2574. 	 */

  2575.         public AttributeSet copyAttributes() {

  2576. 	    AttributeSet[] as = getAttributes();

  2577. 	    MutableAttributeSet a = new SimpleAttributeSet();

  2578. 	    int n = 0;

  2579. 	    for (int i = as.length - 1; i >= 0; i--) {

  2580. 		a.addAttributes(as[i]);

  2581. 	    }

  2582. 	    return a;

  2583. 	}

  2584. 

  2585. 	/**

  2586. 	 * Gets the value of an attribute.  If the requested

  2587. 	 * attribute is a StyleConstants attribute that has

  2588. 	 * a CSS mapping, the request will be converted.

  2589. 	 *

  2590. 	 * @param key the attribute name

  2591. 	 * @return the attribute value

  2592. 	 * @see AttributeSet#getAttribute

  2593. 	 */

  2594.         public Object getAttribute(Object key) {

  2595. 	    AttributeSet[] as = getAttributes();

  2596. 	    int n = as.length;

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

  2598. 		Object o = as[i].getAttribute(key);

  2599. 		if (o != null) {

  2600. 		    return o;

  2601. 		}

  2602. 	    }

  2603. 	    return null;

  2604. 	}

  2605. 

  2606. 	/**

  2607. 	 * Gets the names of all attributes.

  2608. 	 *

  2609. 	 * @return the attribute names

  2610. 	 * @see AttributeSet#getAttributeNames

  2611. 	 */

  2612.         public Enumeration getAttributeNames() {

  2613. 	    return new MuxingAttributeNameEnumeration();

  2614. 	}

  2615. 

  2616. 	/**

  2617. 	 * Checks whether a given attribute name/value is defined.

  2618. 	 *

  2619. 	 * @param name the attribute name

  2620. 	 * @param value the attribute value

  2621. 	 * @return true if the name/value is defined

  2622. 	 * @see AttributeSet#containsAttribute

  2623. 	 */

  2624.         public boolean containsAttribute(Object name, Object value) {

  2625. 	    return value.equals(getAttribute(name));

  2626. 	}

  2627. 

  2628. 	/**

  2629. 	 * Checks whether the attribute set contains all of

  2630. 	 * the given attributes.

  2631. 	 *

  2632. 	 * @param attrs the attributes to check

  2633. 	 * @return true if the element contains all the attributes

  2634. 	 * @see AttributeSet#containsAttributes

  2635. 	 */

  2636.         public boolean containsAttributes(AttributeSet attrs) {

  2637. 	    boolean result = true;

  2638. 

  2639. 	    Enumeration names = attrs.getAttributeNames();

  2640. 	    while (result && names.hasMoreElements()) {

  2641. 		Object name = names.nextElement();

  2642. 		result = attrs.getAttribute(name).equals(getAttribute(name));

  2643. 	    }

  2644. 

  2645. 	    return result;

  2646. 	}

  2647. 

  2648. 	/**

  2649. 	 * Returns null, subclasses may wish to do something more

  2650. 	 * intelligent with this.

  2651. 	 */

  2652.         public AttributeSet getResolveParent() {

  2653. 	    return null;

  2654. 	}

  2655. 

  2656. 	AttributeSet[] attrs;

  2657. 

  2658. 

  2659. 	/**

  2660. 	 * An Enumeration of the Attribute names in a MuxingAttributeSet.

  2661. 	 * This may return the same name more than once.

  2662. 	 */

  2663. 	class MuxingAttributeNameEnumeration implements Enumeration {

  2664. 

  2665. 	    MuxingAttributeNameEnumeration() {

  2666. 		updateEnum();

  2667. 	    }

  2668. 

  2669. 	    public boolean hasMoreElements() {

  2670. 		if (currentEnum == null) {

  2671. 		    return false;

  2672. 		}

  2673. 		return currentEnum.hasMoreElements();

  2674. 	    }

  2675. 

  2676. 	    public Object nextElement() {

  2677. 		if (currentEnum == null) {

  2678. 		    throw new NoSuchElementException("No more names");

  2679. 		}

  2680. 		Object retObject = currentEnum.nextElement();

  2681. 		if (!currentEnum.hasMoreElements()) {

  2682. 		    updateEnum();

  2683. 		}

  2684. 		return retObject;

  2685. 	    }

  2686. 

  2687. 	    void updateEnum() {

  2688. 		AttributeSet[] as = getAttributes();

  2689. 		currentEnum = null;

  2690. 		while (currentEnum == null && attrIndex < as.length) {

  2691. 		    currentEnum = as[attrIndex++].getAttributeNames();

  2692. 		    if (!currentEnum.hasMoreElements()) {

  2693. 			currentEnum = null;

  2694. 		    }

  2695. 		}

  2696. 	    }

  2697. 

  2698. 

  2699. 	    /** Index into attrs the current Enumeration came from. */

  2700. 	    int attrIndex;

  2701. 	    /** Enumeration from attrs. */

  2702. 	    Enumeration currentEnum;

  2703. 	}

  2704.     }

  2705. 

  2706. 

  2707.     /**

  2708.      * A subclass of MuxingAttributeSet that translates between

  2709.      * CSS and HTML and StyleConstants. The AttributeSets used are

  2710.      * the CSS rules that match the Views Elements.

  2711.      */

  2712.     class ViewAttributeSet extends MuxingAttributeSet {

  2713. 	ViewAttributeSet(View v) {

  2714. 	    host = v;

  2715. 

  2716. 	    // PENDING(prinz) fix this up to be a more realistic

  2717. 	    // implementation.

  2718. 	    Document doc = v.getDocument();

  2719. 	    SearchBuffer sb = SearchBuffer.obtainSearchBuffer();

  2720. 	    Vector muxList = sb.getVector();

  2721. 	    try {

  2722. 		if (doc instanceof HTMLDocument) {

  2723. 		    StyleSheet styles = StyleSheet.this;

  2724. 		    Element elem = v.getElement();

  2725. 		    AttributeSet a = elem.getAttributes();

  2726. 		    AttributeSet htmlAttr = styles.translateHTMLToCSS(a);

  2727. 

  2728. 		    if (htmlAttr.getAttributeCount() != 0) {

  2729. 			muxList.addElement(htmlAttr);

  2730. 		    }

  2731. 		    if (elem.isLeaf()) {

  2732. 			Enumeration keys = a.getAttributeNames();

  2733. 			while (keys.hasMoreElements()) {

  2734. 			    Object key = keys.nextElement();

  2735. 			    if (key instanceof HTML.Tag) {

  2736. 				if ((HTML.Tag)key  == HTML.Tag.A) {

  2737. 				    Object o = a.getAttribute((HTML.Tag)key);

  2738. 				/**

  2739. 				   In the case of an A tag, the css rules

  2740. 				   apply only for tags that have their

  2741. 				   href attribute defined and not for

  2742. 				   anchors that only have their name attributes

  2743. 				   defined, i.e anchors that function as

  2744. 				   destinations.  Hence we do not add the

  2745. 				   attributes for that latter kind of 

  2746. 				   anchors.  When CSS2 support is added,

  2747. 				   it will be possible to specificity this

  2748. 				   kind of conditional behaviour in the 

  2749. 				   stylesheet.

  2750. 				 **/

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

  2752. 					AttributeSet attr = (AttributeSet)o;

  2753. 					if (attr.getAttribute(HTML.Attribute.HREF) == null) {

  2754. 					    continue;

  2755. 					}

  2756. 				    }

  2757. 				}

  2758. 				AttributeSet cssRule = styles.getRule((HTML.Tag) key, elem);

  2759. 				if (cssRule != null) {

  2760. 				    muxList.addElement(cssRule);

  2761. 				}

  2762. 			    }

  2763. 			}

  2764. 		    } else {

  2765. 			HTML.Tag t = (HTML.Tag) a.getAttribute

  2766. 			             (StyleConstants.NameAttribute);

  2767. 			AttributeSet cssRule = styles.getRule(t, elem);

  2768. 			if (cssRule != null) {

  2769. 			    muxList.addElement(cssRule);

  2770. 			}

  2771. 		    }

  2772. 		}

  2773. 		this.attrs = new AttributeSet[muxList.size()];

  2774. 		muxList.copyInto(this.attrs);

  2775. 	    }

  2776. 	    finally {

  2777. 		SearchBuffer.releaseSearchBuffer(sb);

  2778. 	    }

  2779. 	}

  2780. 

  2781. 	//  --- AttributeSet methods ----------------------------

  2782. 

  2783. 	/**

  2784. 	 * Checks whether a given attribute is defined.

  2785. 	 * This will convert the key over to CSS if the

  2786. 	 * key is a StyleConstants key that has a CSS

  2787. 	 * mapping.

  2788. 	 *

  2789. 	 * @param key the attribute key

  2790. 	 * @return true if the attribute is defined

  2791. 	 * @see AttributeSet#isDefined

  2792. 	 */

  2793.         public boolean isDefined(Object key) {

  2794. 	    if (key instanceof StyleConstants) {

  2795. 		Object cssKey = css.styleConstantsKeyToCSSKey

  2796. 		                    ((StyleConstants)key);

  2797. 		if (cssKey != null) {

  2798. 		    key = cssKey;

  2799. 		}

  2800. 	    }

  2801. 	    return super.isDefined(key);

  2802. 	}

  2803. 

  2804. 	/**

  2805. 	 * Gets the value of an attribute.  If the requested

  2806. 	 * attribute is a StyleConstants attribute that has

  2807. 	 * a CSS mapping, the request will be converted.

  2808. 	 *

  2809. 	 * @param key the attribute name

  2810. 	 * @return the attribute value

  2811. 	 * @see AttributeSet#getAttribute

  2812. 	 */

  2813.         public Object getAttribute(Object key) {

  2814. 	    if (key instanceof StyleConstants) {

  2815. 		Object cssKey = css.styleConstantsKeyToCSSKey

  2816. 		               ((StyleConstants)key);

  2817. 		if (cssKey != null) {

  2818. 		    Object value = doGetAttribute(cssKey);

  2819. 		    if (value instanceof CSS.CssValue) {

  2820. 			return ((CSS.CssValue)value).toStyleConstants

  2821. 			             ((StyleConstants)key, host);

  2822. 		    }

  2823. 		}

  2824. 	    }

  2825. 	    return doGetAttribute(key);

  2826. 	}

  2827. 

  2828.         Object doGetAttribute(Object key) {

  2829. 	    Object retValue = super.getAttribute(key);

  2830. 	    if (retValue != null) {

  2831. 		return retValue;

  2832. 	    }

  2833. 	    // didn't find it... try parent if it's a css attribute

  2834. 	    // that is inherited.

  2835. 	    if (key instanceof CSS.Attribute) {

  2836. 		CSS.Attribute css = (CSS.Attribute) key;

  2837. 		if (css.isInherited()) {

  2838. 		    AttributeSet parent = getResolveParent();

  2839. 		    if (parent != null)

  2840. 			return parent.getAttribute(key);

  2841. 		}

  2842. 	    }

  2843. 	    return null;

  2844. 	}

  2845. 

  2846. 	/**

  2847. 	 * If not overriden, the resolving parent defaults to

  2848. 	 * the parent element.

  2849. 	 *

  2850. 	 * @return the attributes from the parent

  2851. 	 * @see AttributeSet#getResolveParent

  2852. 	 */

  2853.         public AttributeSet getResolveParent() {

  2854. 	    if (host == null) {

  2855. 		return null;

  2856. 	    }

  2857. 	    View parent = host.getParent();

  2858. 	    return (parent != null) ? parent.getAttributes() : null;

  2859. 	}

  2860. 

  2861. 	/** View created for. */

  2862. 	View host;

  2863.     }

  2864. 

  2865. 

  2866.     /**

  2867.      * A subclass of MuxingAttributeSet that implements Style. Currently

  2868.      * the MutableAttributeSet methods are unimplemented, that is they

  2869.      * do nothing.

  2870.      */

  2871.     // PENDING(sky): Decide what to do with this. Either make it

  2872.     // contain a SimpleAttributeSet that modify methods are delegated to,

  2873.     // or change getRule to return an AttributeSet and then don't make this

  2874.     // implement Style.

  2875.     static class ResolvedStyle extends MuxingAttributeSet implements

  2876.                   Serializable, Style {

  2877. 	ResolvedStyle(String name, AttributeSet[] attrs, int extendedIndex) {

  2878. 	    this.attrs = attrs;

  2879. 	    this.name = name;

  2880. 	    this.extendedIndex = extendedIndex;

  2881. 	}

  2882. 

  2883.         /**

  2884.          * Inserts a Style into the receiver so that the styles the

  2885.          * receiver represents are still ordered by specificity.

  2886. 	 * <code>style</code> will be added before any extended styles, that

  2887. 	 * is before extendedIndex.

  2888.          */

  2889.         synchronized void insertStyle(Style style, int specificity) {

  2890.             int maxCounter = attrs.length;

  2891. 	    int counter = 0;

  2892.             for (;counter < extendedIndex; counter++) {

  2893. 		if (specificity > getSpecificity(((Style)attrs[counter]).

  2894. 						 getName())) {

  2895. 		    break;

  2896.                 }

  2897.             }

  2898. 	    insertAttributeSetAt(style, counter);

  2899. 	    extendedIndex++;

  2900. 	}

  2901. 

  2902. 	/**

  2903. 	 * Removes a previously added style. This will do nothing if

  2904. 	 * <code>style</code> is not referenced by the receiver.

  2905. 	 */

  2906. 	synchronized void removeStyle(Style style) {

  2907. 	    for (int counter = attrs.length - 1; counter >= 0; counter--) {

  2908. 		if (attrs[counter] == style) {

  2909. 		    removeAttributeSetAt(counter);

  2910. 		    if (counter < extendedIndex) {

  2911. 			extendedIndex--;

  2912. 		    }

  2913. 		    break;

  2914. 		}

  2915. 	    }

  2916. 	}

  2917. 

  2918. 	/**

  2919. 	 * Adds <code>s</code> as one of the Attributesets to look up

  2920. 	 * attributes in.

  2921. 	 */

  2922. 	synchronized void insertExtendedStyleAt(Style attr, int index) {

  2923. 	    insertAttributeSetAt(attr, extendedIndex + index);

  2924. 	}

  2925. 

  2926. 	/**

  2927. 	 * Adds <code>s</code> as one of the AttributeSets to look up

  2928. 	 * attributes in. It will be the AttributeSet last checked.

  2929. 	 */

  2930. 	synchronized void addExtendedStyle(Style attr) {

  2931. 	    insertAttributeSetAt(attr, attrs.length);

  2932. 	}

  2933. 

  2934. 	/**

  2935. 	 * Removes the style at <code>index</code> +

  2936. 	 * <code>extendedIndex</code>.

  2937. 	 */

  2938. 	synchronized void removeExtendedStyleAt(int index) {

  2939. 	    removeAttributeSetAt(extendedIndex + index);

  2940. 	}

  2941. 

  2942.         /**

  2943.          * Returns true if the receiver matches <code>selector</code>, where

  2944.          * a match is defined by the CSS rule matching.

  2945. 	 * Each simple selector must be separated by a single space.

  2946.          */

  2947.         protected boolean matches(String selector) {

  2948.             int sLast = selector.length();

  2949. 

  2950.             if (sLast == 0) {

  2951.                 return false;

  2952.             }

  2953.             int thisLast = name.length();

  2954.             int sCurrent = selector.lastIndexOf(' ');

  2955.             int thisCurrent = name.lastIndexOf(' ');

  2956. 	    if (sCurrent >= 0) {

  2957. 		sCurrent++;

  2958. 	    }

  2959. 	    if (thisCurrent >= 0) {

  2960. 		thisCurrent++;

  2961. 	    }

  2962.             if (!matches(selector, sCurrent, sLast, thisCurrent, thisLast)) {

  2963.                 return false;

  2964.             }

  2965.             while (sCurrent != -1) {

  2966.                 sLast = sCurrent - 1;

  2967.                 sCurrent = selector.lastIndexOf(' ', sLast - 1);

  2968. 		if (sCurrent >= 0) {

  2969. 		    sCurrent++;

  2970. 		}

  2971.                 boolean match = false;

  2972.                 while (!match && thisCurrent != -1) {

  2973.                     thisLast = thisCurrent - 1;

  2974.                     thisCurrent = name.lastIndexOf(' ', thisLast - 1);

  2975. 		    if (thisCurrent >= 0) {

  2976. 			thisCurrent++;

  2977. 		    }

  2978.                     match = matches(selector, sCurrent, sLast, thisCurrent,

  2979. 				    thisLast);

  2980.                 }

  2981.                 if (!match) {

  2982.                     return false;

  2983.                 }

  2984.             }

  2985.             return true;

  2986.         }

  2987. 

  2988.         /**

  2989.          * Returns true if the substring of the receiver, in the range

  2990.          * thisCurrent, thisLast matches the substring of selector in

  2991.          * the ranme sCurrent to sLast based on CSS selector matching.

  2992.          */

  2993.         boolean matches(String selector, int sCurrent, int sLast,

  2994.                        int thisCurrent, int thisLast) {

  2995.             sCurrent = Math.max(sCurrent, 0);

  2996.             thisCurrent = Math.max(thisCurrent, 0);

  2997.             int thisDotIndex = boundedIndexOf(name, '.', thisCurrent,

  2998. 					      thisLast);

  2999.             int thisPoundIndex = boundedIndexOf(name, '#', thisCurrent,

  3000. 						thisLast);

  3001.             int sDotIndex = boundedIndexOf(selector, '.', sCurrent, sLast);

  3002.             int sPoundIndex = boundedIndexOf(selector, '#', sCurrent, sLast);

  3003.             if (sDotIndex != -1) {

  3004.                 // Selector has a '.', which indicates name must match it,

  3005.                 // or if the '.' starts the selector than name must have

  3006.                 // the same class (doesn't matter what element name).

  3007.                 if (thisDotIndex == -1) {

  3008.                     return false;

  3009.                 }

  3010.                 if (sCurrent == sDotIndex) {

  3011.                     if ((thisLast - thisDotIndex) != (sLast - sDotIndex) || 

  3012.                         !selector.regionMatches(sCurrent, name, thisDotIndex,

  3013.                                                 (thisLast - thisDotIndex))) {

  3014.                         return false;

  3015.                     }

  3016.                 }

  3017.                 else {

  3018.                     // Has to fully match.

  3019.                     if ((sLast - sCurrent) != (thisLast - thisCurrent) ||

  3020.                         !selector.regionMatches(sCurrent, name, thisCurrent,

  3021.                                                 (thisLast - thisCurrent))) {

  3022.                         return false;

  3023.                     }

  3024.                 }

  3025.                 return true;

  3026.             }

  3027.             if (sPoundIndex != -1) {

  3028.                 // Selector has a '#', which indicates name must match it,

  3029.                 // or if the '#' starts the selector than name must have

  3030.                 // the same id (doesn't matter what element name).

  3031.                 if (thisPoundIndex == -1) {

  3032.                     return false;

  3033.                 }

  3034.                 if (sCurrent == sPoundIndex) {

  3035.                     if ((thisLast - thisPoundIndex) !=(sLast - sPoundIndex) || 

  3036.                         !selector.regionMatches(sCurrent, name, thisPoundIndex,

  3037.                                                 (thisLast - thisPoundIndex))) {

  3038.                         return false;

  3039.                     }

  3040.                 }

  3041.                 else {

  3042.                     // Has to fully match.

  3043.                     if ((sLast - sCurrent) != (thisLast - thisCurrent) ||

  3044.                         !selector.regionMatches(sCurrent, name, thisCurrent,

  3045.                                                (thisLast - thisCurrent))) {

  3046.                         return false;

  3047.                     }

  3048.                 }

  3049.                 return true;

  3050.             }

  3051.             if (thisDotIndex != -1) {

  3052.                 // Reciever references a class, just check element name.

  3053.                 return selector.regionMatches(sCurrent, name, thisCurrent,

  3054.                                               thisDotIndex - thisCurrent);

  3055.             }

  3056.             if (thisPoundIndex != -1) {

  3057.                 // Reciever references an id, just check element name.

  3058.                 return selector.regionMatches(sCurrent, name, thisCurrent,

  3059.                                               thisPoundIndex - thisCurrent);

  3060.             }

  3061.             // Fail through, no classes or ides, just check string.

  3062.             return selector.regionMatches(sCurrent, name, thisCurrent,

  3063.                                               thisLast - thisCurrent);

  3064.         }

  3065. 

  3066.         /**

  3067.          * Similiar to String.indexOf, but allows an upper bound

  3068.          * (this is slower in that it will still check string starting at

  3069.          * start.

  3070.          */

  3071.         int boundedIndexOf(String string, char search, int start,

  3072.                            int end) {

  3073.             int retValue = string.indexOf(search, start);

  3074.             if (retValue >= end) {

  3075.                 return -1;

  3076.             }

  3077.             return retValue;

  3078.         }

  3079. 

  3080. 	public void addAttribute(Object name, Object value) {}

  3081. 	public void addAttributes(AttributeSet attributes) {}

  3082. 	public void removeAttribute(Object name) {}

  3083. 	public void removeAttributes(Enumeration names) {}

  3084. 	public void removeAttributes(AttributeSet attributes) {}

  3085. 	public void setResolveParent(AttributeSet parent) {}

  3086. 	public String getName() {return name;}

  3087. 	public void addChangeListener(ChangeListener l) {}

  3088. 	public void removeChangeListener(ChangeListener l) {}

  3089. 

  3090. 	/** The name of the Style, which is the selector.

  3091. 	 * This will NEVER change!

  3092. 	 */

  3093. 	String name;

  3094. 	/** Start index of styles coming from other StyleSheets. */

  3095. 	private int extendedIndex;

  3096.     }

  3097. 

  3098.     // ---- Variables ---------------------------------------------

  3099. 

  3100.     final static int DEFAULT_FONT_SIZE = 3;

  3101. 

  3102.     private CSS css;

  3103. 

  3104.     /** An inverted graph of the selectors. Each key will be a String tag,

  3105.      * and each value will be a Hashtable. Further the key RULE is used

  3106.      * for the styles attached to the particular location, and 

  3107.      * SPECIFICITY is used to indicate the specificity.

  3108.      */

  3109.     private Hashtable selectorMapping;

  3110. 

  3111.     /** Maps from selector (as a string) to Style that includes all

  3112.      * relevant styles. */

  3113.     private Hashtable resolvedStyles;

  3114. 

  3115.     /** Vector of StyleSheets that the rules are to reference.

  3116.      */

  3117.     private Vector linkedStyleSheets;

  3118. 

  3119.     /** Where the style sheet was found. Used for relative imports. */

  3120.     private URL base;

  3121. 

  3122. 

  3123.     /**

  3124.      * Internal StyleSheet attribute.  This is used for

  3125.      * caches, weights, rule storage, etc.

  3126.      * <p>While this implements serializable, on unarchiving you sure make

  3127.      * sure to reference the static finals.

  3128.      */

  3129.     static class SheetAttribute implements Serializable {

  3130. 

  3131. 	SheetAttribute(String s, boolean cache) {

  3132. 	    name = s;

  3133. 	    this.cache = cache;

  3134. 	}

  3135. 

  3136.         public String toString() {

  3137. 	    return name;

  3138. 	}

  3139. 

  3140.         public boolean isCache() {

  3141. 	    return cache;

  3142. 	}

  3143. 

  3144. 	private boolean cache;

  3145. 	private String name;

  3146.     }

  3147. 

  3148.     static final SheetAttribute SPECIFICITY = new SheetAttribute("specificity", false);

  3149.     static final SheetAttribute RULE = new SheetAttribute("rule", false);

  3150. 

  3151. 

  3152.     /**

  3153.      * Default parser for CSS specifications that get loaded into

  3154.      * the StyleSheet.<p>

  3155.      * This class is NOT thread safe, do not ask it to parse while it is

  3156.      * in the middle of parsing.

  3157.      */

  3158.     class CssParser implements CSSParser.CSSParserCallback {

  3159. 

  3160. 	/**

  3161. 	 * Parses the passed in CSS declaration into an AttributeSet.

  3162. 	 */

  3163. 	public AttributeSet parseDeclaration(String string) {

  3164. 	    try {

  3165. 		return parseDeclaration(new StringReader(string));

  3166. 	    } catch (IOException ioe) {}

  3167. 	    return null;

  3168. 	}

  3169. 

  3170. 	/**

  3171. 	 * Parses the passed in CSS declaration into an AttributeSet.

  3172. 	 */

  3173. 	public AttributeSet parseDeclaration(Reader r) throws IOException {

  3174. 	    parse(base, r, true, false);

  3175. 	    return declaration.copyAttributes();

  3176. 	}

  3177. 

  3178. 	/**

  3179. 	 * Parse the given CSS stream

  3180. 	 */

  3181. 	public void parse(URL base, Reader r, boolean parseDeclaration,

  3182. 			  boolean isLink) throws IOException {

  3183. 	    this.base = base;

  3184. 	    this.isLink = isLink;

  3185. 	    this.parsingDeclaration = parseDeclaration;

  3186. 	    declaration.removeAttributes(declaration);

  3187. 	    selectorTokens.removeAllElements();

  3188. 	    selectors.removeAllElements();

  3189. 	    propertyName = null;

  3190. 	    parser.parse(r, this, parseDeclaration);

  3191. 	}

  3192. 

  3193. 	//

  3194. 	// CSSParserCallback methods, public to implement the interface.

  3195. 	//

  3196. 

  3197. 	/**

  3198. 	 * Invoked when a valid @import is encountered, will call

  3199. 	 * <code>importStyleSheet</code> if a 

  3200. 	 * <code>MalformedURLException</code> is not thrown in creating

  3201. 	 * the URL.

  3202. 	 */

  3203. 	public void handleImport(String importString) {

  3204. 	    URL url = CSS.getURL(base, importString);

  3205. 	    if (url != null) {

  3206. 		importStyleSheet(url);

  3207. 	    }

  3208. 	}

  3209. 

  3210. 	/**

  3211. 	 * A selector has been encountered.

  3212. 	 */

  3213. 	public void handleSelector(String selector) {

  3214. 	    int length = selector.length();

  3215. 

  3216. 	    if (selector.endsWith(",")) {

  3217. 		if (length > 1) {

  3218. 		    selector = selector.substring(0, length - 1);

  3219. 		    selectorTokens.addElement(selector);

  3220. 		}

  3221. 		addSelector();

  3222. 	    }

  3223. 	    else if (length > 0) {

  3224. 		selectorTokens.addElement(selector);

  3225. 	    }

  3226. 	}

  3227. 

  3228. 	/**

  3229. 	 * Invoked when the start of a rule is encountered.

  3230. 	 */

  3231. 	public void startRule() {

  3232. 	    if (selectorTokens.size() > 0) {

  3233. 		addSelector();

  3234. 	    }

  3235. 	    propertyName = null;

  3236. 	}

  3237. 

  3238. 	/**

  3239. 	 * Invoked when a property name is encountered.

  3240. 	 */

  3241. 	public void handleProperty(String property) {

  3242. 	    propertyName = property;

  3243. 	}

  3244. 

  3245. 	/**

  3246. 	 * Invoked when a property value is encountered.

  3247. 	 */

  3248. 	public void handleValue(String value) {

  3249. 	    if (propertyName != null) {

  3250. 		CSS.Attribute cssKey = CSS.getAttribute(propertyName);

  3251. 		if (cssKey != null) {

  3252. 		    addCSSAttribute(declaration, cssKey, value);

  3253. 		}

  3254. 		propertyName = null;

  3255. 	    }

  3256. 	}

  3257. 

  3258. 	/**

  3259. 	 * Invoked when the end of a rule is encountered.

  3260. 	 */

  3261. 	public void endRule() {

  3262. 	    int n = selectors.size();

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

  3264. 		String[] selector = (String[]) selectors.elementAt(i);

  3265. 		if (selector.length > 0) {

  3266. 		    StyleSheet.this.addRule(selector, declaration, isLink);

  3267. 		}

  3268. 	    }

  3269. 	    declaration.removeAttributes(declaration);

  3270. 	    selectors.removeAllElements();

  3271. 	}

  3272. 

  3273. 	private void addSelector() {

  3274. 	    String[] selector = new String[selectorTokens.size()];

  3275. 	    selectorTokens.copyInto(selector);

  3276. 	    selectors.addElement(selector);

  3277. 	    selectorTokens.removeAllElements();

  3278. 	}

  3279. 

  3280. 

  3281. 	Vector selectors = new Vector();

  3282. 	Vector selectorTokens = new Vector();

  3283. 	/** Name of the current property. */

  3284. 	String propertyName;

  3285. 	MutableAttributeSet declaration = new SimpleAttributeSet();

  3286. 	/** True if parsing a declaration, that is the Reader will not

  3287. 	 * contain a selector. */

  3288. 	boolean parsingDeclaration;

  3289. 	/** True if the attributes are coming from a linked/imported style. */

  3290. 	boolean isLink;

  3291. 	/** Where the CSS stylesheet lives. */

  3292. 	URL base;

  3293. 	CSSParser parser = new CSSParser();

  3294.     }

  3295. }