int         current, last;	int         length = (value == null) ? 0 : value.length();	Vector      temp = new Vector(4);	current = 0;	while (current < length) {	    // Skip ws	    while (current < length && Character.isWhitespace		   (value.charAt(current))) {		current++;	    }	    last = current;	    while (current < length && !Character.isWhitespace		   (value.charAt(current))) {		current++;	    }	    if (last != current) {		temp.addElement(value.substring(last, current));	    }	    current++;	}	String[] retValue = new String[temp.size()];	temp.copyInto(retValue);	return retValue;    }    /**     * Return the point size, given a size index. Legal HTML index sizes     * are 1-7.     */    float getPointSize(int index, StyleSheet ss) {        ss = getStyleSheet(ss);        int[] sizeMap = (ss != null) ? ss.getSizeMap() :             StyleSheet.sizeMapDefault;        --index;	if (index < 0)	  return sizeMap[0];	else if (index > sizeMap.length - 1)	  return sizeMap[sizeMap.length - 1];	else	  return sizeMap[index];    }    private void translateEmbeddedAttributes(AttributeSet htmlAttrSet,					     MutableAttributeSet cssAttrSet) {	Enumeration keys = htmlAttrSet.getAttributeNames();	if (htmlAttrSet.getAttribute(StyleConstants.NameAttribute) ==	    HTML.Tag.HR) {	    // HR needs special handling due to us treating it as a leaf.	    translateAttributes(HTML.Tag.HR, htmlAttrSet, cssAttrSet);	}	while (keys.hasMoreElements()) {	    Object key = keys.nextElement();	    if (key instanceof HTML.Tag) {		HTML.Tag tag = (HTML.Tag)key;		Object o = htmlAttrSet.getAttribute(tag);		if (o != null && o instanceof AttributeSet) {		    translateAttributes(tag, (AttributeSet)o, cssAttrSet);		}	    } else if (key instanceof CSS.Attribute) {		cssAttrSet.addAttribute(key, htmlAttrSet.getAttribute(key));	    }	}    }    private void translateAttributes(HTML.Tag tag,					    AttributeSet htmlAttrSet,					    MutableAttributeSet cssAttrSet) {	Enumeration names = htmlAttrSet.getAttributeNames();	while (names.hasMoreElements()) {	    Object name = names.nextElement();	    if (name instanceof HTML.Attribute) {		HTML.Attribute key = (HTML.Attribute)name;		/*		 * HTML.Attribute.ALIGN needs special processing.		 * It can map to to 1 of many(3) possible CSS attributes		 * depending on the nature of the tag the attribute is		 * part off and depending on the value of the attribute.		 */		if (key == HTML.Attribute.ALIGN) {		    String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);		    if (htmlAttrValue != null) {			CSS.Attribute cssAttr = getCssAlignAttribute(tag, htmlAttrSet);			if (cssAttr != null) {			    Object o = getCssValue(cssAttr, htmlAttrValue);			    if (o != null) {				cssAttrSet.addAttribute(cssAttr, o);			    }			}		    }		} else {		    /*		     * The html size attribute has a mapping in the CSS world only		     * if it is par of a font or base font tag.		     */		    if (key == HTML.Attribute.SIZE && !isHTMLFontTag(tag)) {			continue;		    }		    translateAttribute(key, htmlAttrSet, cssAttrSet);		}	    } else if (name instanceof CSS.Attribute) {		cssAttrSet.addAttribute(name, htmlAttrSet.getAttribute(name));	    }	}    }    private void translateAttribute(HTML.Attribute key,					   AttributeSet htmlAttrSet,					   MutableAttributeSet cssAttrSet) {	/*	 * In the case of all remaining HTML.Attribute's they	 * map to 1 or more CCS.Attribute.	 */	CSS.Attribute[] cssAttrList = getCssAttribute(key);		String htmlAttrValue = (String)htmlAttrSet.getAttribute(key);		if (cssAttrList == null || htmlAttrValue == null) {	    return;	}	for (int i = 0; i < cssAttrList.length; i++) {	    Object o = getCssValue(cssAttrList[i], htmlAttrValue);	    if (o != null) {		cssAttrSet.addAttribute(cssAttrList[i], o);	    }	}    }    /**     * Given a CSS.Attribute object and its corresponding HTML.Attribute's     * value, this method returns a CssValue object to associate with the     * CSS attribute.     *     * @param the CSS.Attribute     * @param a String containing the value associated HTML.Attribtue.     */    Object getCssValue(CSS.Attribute cssAttr, String htmlAttrValue) {	CssValue value = (CssValue)valueConvertor.get(cssAttr);	Object o = value.parseHtmlValue(htmlAttrValue);	return o;    }    /**     * Maps an HTML.Attribute object to its appropriate CSS.Attributes.     *     * @param HTML.Attribute     * @return CSS.Attribute[]     */    private CSS.Attribute[] getCssAttribute(HTML.Attribute hAttr) {	return (CSS.Attribute[])htmlAttrToCssAttrMap.get(hAttr);    }    /**     * Maps HTML.Attribute.ALIGN to either:     *     CSS.Attribute.TEXT_ALIGN     *     CSS.Attribute.FLOAT     *     CSS.Attribute.VERTICAL_ALIGN     * based on the tag associated with the attribute and the     * value of the attribute.     *     * @param AttributeSet containing HTML attributes.     * @return CSS.Attribute mapping for HTML.Attribute.ALIGN.     */    private CSS.Attribute getCssAlignAttribute(HTML.Tag tag,						   AttributeSet htmlAttrSet) {	return CSS.Attribute.TEXT_ALIGN;/*	String htmlAttrValue = (String)htmlAttrSet.getAttribute(HTML.Attribute.ALIGN);	CSS.Attribute cssAttr = CSS.Attribute.TEXT_ALIGN;	if (htmlAttrValue != null && htmlAttrSet instanceof Element) {	    Element elem = (Element)htmlAttrSet;	    if (!elem.isLeaf() && tag.isBlock() && validTextAlignValue(htmlAttrValue)) {		return CSS.Attribute.TEXT_ALIGN;	    } else if (isFloater(htmlAttrValue)) {		return CSS.Attribute.FLOAT;	    } else if (elem.isLeaf()) {		return CSS.Attribute.VERTICAL_ALIGN;	    } 	}	return null;	*/    }    /**     * Fetches the tag associated with the HTML AttributeSet.     *     * @param  AttributeSet containing the HTML attributes.     * @return HTML.Tag     */    private HTML.Tag getHTMLTag(AttributeSet htmlAttrSet) {	Object o = htmlAttrSet.getAttribute(StyleConstants.NameAttribute);	if (o instanceof HTML.Tag) {	    HTML.Tag tag = (HTML.Tag) o;	    return tag;	}	return null;    }    private boolean isHTMLFontTag(HTML.Tag tag) {	return (tag != null && ((tag == HTML.Tag.FONT) || (tag == HTML.Tag.BASEFONT)));    }    private boolean isFloater(String alignValue) {	return (alignValue.equals("left") || alignValue.equals("right"));    }    private boolean validTextAlignValue(String alignValue) {	return (isFloater(alignValue) || alignValue.equals("center"));    }    /**     * Base class to CSS values in the attribute sets.  This     * is intended to act as a convertor to/from other attribute     * formats.     * <p>     * The CSS parser uses the parseCssValue method to convert     * a string to whatever format is appropriate a given key     * (i.e. these convertors are stored in a map using the     * CSS.Attribute as a key and the CssValue as the value).     * <p>     * The HTML to CSS conversion process first converts the     * HTML.Attribute to a CSS.Attribute, and then calls     * the parseHtmlValue method on the value of the HTML     * attribute to produce the corresponding CSS value.     * <p>     * The StyleConstants to CSS conversion process first      * converts the StyleConstants attribute to a      * CSS.Attribute, and then calls the fromStyleConstants     * method to convert the StyleConstants value to a      * CSS value.     * <p>     * The CSS to StyleConstants conversion process first     * converts the StyleConstants attribute to a      * CSS.Attribute, and then calls the toStyleConstants     * method to convert the CSS value to a StyleConstants     * value.     */    static class CssValue implements Serializable {	/**	 * Convert a CSS value string to the internal format	 * (for fast processing) used in the attribute sets.	 * The fallback storage for any value that we don't	 * have a special binary format for is a String. 	 */	Object parseCssValue(String value) {	    return value;	}	/**	 * Convert an HTML attribute value to a CSS attribute	 * value.  If there is no conversion, return null.	 * This is implemented to simply forward to the CSS	 * parsing by default (since some of the attribute	 * values are the same).  If the attribute value	 * isn't recognized as a CSS value it is generally	 * returned as null.	 */	Object parseHtmlValue(String value) {	    return parseCssValue(value);	}	/**	 * Converts a <code>StyleConstants</code> attribute value to	 * a CSS attribute value.  If there is no conversion,	 * returns <code>null</code>.  By default, there is no conversion.	 * 	 * @param key the <code>StyleConstants</code> attribute	 * @param value the value of a <code>StyleConstants</code>         *   attribute to be converted	 * @return the CSS value that represents the          *   <code>StyleConstants</code> value	 */	Object fromStyleConstants(StyleConstants key, Object value) {	    return null;	}	/**	 * Converts a CSS attribute value to a          * <code>StyleConstants</code>	 * value.  If there is no conversion, returns         * <code>null</code>.	 * By default, there is no conversion.	 *	 * @param key the <code>StyleConstants</code> attribute	 * @param v the view containing <code>AttributeSet</code>	 * @return the <code>StyleConstants</code> attribute value that 	 *   represents the CSS attribute value	 */	Object toStyleConstants(StyleConstants key, View v) {	    return null;	}	/**	 * Return the CSS format of the value	 */        public String toString() {	    return svalue;	}	/**	 * The value as a string... before conversion to a	 * binary format.	 */	String svalue;    }    /**     * By default CSS attributes are represented as simple     * strings.  They also have no conversion to/from     * StyleConstants by default. This class represents the      * value as a string (via the superclass), but      * provides StyleConstants conversion support for the      * CSS attributes that are held as strings.     */    static class StringValue extends CssValue {	/**	 * Convert a CSS value string to the internal format	 * (for fast processing) used in the attribute sets.	 * This produces a StringValue, so that it can be	 * used to convert from CSS to StyleConstants values.	 */	Object parseCssValue(String value) {	    StringValue sv = new StringValue();	    sv.svalue = value;	    return sv;	}	/**	 * Converts a <code>StyleConstants</code> attribute value to	 * a CSS attribute value.  If there is no conversion	 * returns <code>null</code>. 	 * 	 * @param key the <code>StyleConstants</code> attribute	 * @param value the value of a <code>StyleConstants</code>	 *   attribute to be converted	 * @return the CSS value that represents the          *   <code>StyleConstants</code> value	 */	Object fromStyleConstants(StyleConstants key, Object value) {	    if (key == StyleConstants.Italic) {		if (value.equals(Boolean.TRUE)) {		    return parseCssValue("italic");		}		return parseCssValue("");	    } else if (key == StyleConstants.Underline) {		if (value.equals(Boolean.TRUE)) {		    return parseCssValue("underline");		} 		return parseCssValue("");	    } else if (key == StyleConstants.Alignment) {		int align = ((Integer)value).intValue();		String ta;		switch(align) {		case StyleConstants.ALIGN_LEFT:		    ta = "left";		    break;		case StyleConstants.ALIGN_RIGHT:		    ta = "right";		    break;		case StyleConstants.ALIGN_CENTER:		    ta = "center";		    break;		case StyleConstants.ALIGN_JUSTIFIED:		    ta = "justify";		    break;		default:		    ta = "left";		}		return parseCssValue(ta);	    } else if (key == StyleConstants.StrikeThrough) {		if (value.equals(Boolean.TRUE)) {		    return parseCssValue("line-through");		} 		return parseCssValue("");	    } else if (key == StyleConstants.Superscript) {		if (value.equals(Boolean.TRUE)) {		    return parseCssValue("super");		}		return parseCssValue("");	    } else if (key == StyleConstants.Subscript) {		if (value.equals(Boolean.TRUE)) {		    return parseCssValue("sub");		}		return parseCssValue("");	    }	    return null;	}	/**	 * Converts a CSS attribute value to a          * <code>StyleConstants</code> value.          * If there is no conversion, returns <code>null</code>.	 * By default, there is no conversion.	 *