Source code: echopoint/stylesheet/CssStyleSheet.java

   package echopoint.stylesheet;
   
   /* 
    * This file is part of the Echo Point Project.  This project is a collection
    * of Components that have extended the Echo Web Application Framework.
    *
    * EchoPoint is free software; you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as published by
    * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * EchoPoint is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with Echo Point; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  import java.beans.IntrospectionException;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.io.File;
  import java.io.Reader;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  
  import nextapp.echo.Component;
  import nextapp.echo.EchoInstance;
  import nextapp.echo.Style;
  import nextapp.echo.Window;
  
  import echopoint.util.IdKit;
  
  
  /**
   * The <code>CssStyleSheet</code> class implements a StyleSheet for 
   * Echo derived Components.
   * <p>
   * A StyleSheet is a collection of style attributes that can be applied 
   * to a Component and any of its children.  A StyleSheet object can 
   * listen for when child Components are added, and apply the StyleSheet
   * to those child components
   * <p>
   * CssStyleSheet style data can be loaded from external files or other
   * reader data sources.  The format of the CssStyleSheet data is based
   * on w3c Cascading Style Sheets, and has been made to look 'CSS like'.
   * (although pure CSS files cannot be used.)
   * <p>
   * A CssStyleSheet file contain style instructions for a Component class.  Lower
   * level class names can be used.  For example the 'font" attribute may be
   * set for the class nextapp.echo.Component to Verdana.  This means that 
   * all derived Components will have the Verdana font style applied to them 
   * unless they have an entry for a more specific class.
   * <p>
   * A map of all styles and classes is kept and when a given component is to
   * have a CssStyleSheet applied to it, the application is done from least 
   * specific Class to most specific Class.
   * <p>
   * For example if a CssStyleSheet is applied to a PasswordField object, then a style 
   * will be searched first for the Component class, then the TextComponent 
   * class, the TextField class and then finally the PasswordField class.
   * <p>
   * This application of styles allows "cascading" style values to be 
   * applied to a given Component object.  The more specific StyleSheet entries will
   * overrride any previous entries.
   * <p>
   * CssStyleSheet data has a 'CSS like' format of :<br>
   * <blockquote><pre>
   * className1 [,classNameN]  {         <br>
   *    attributeName1 : attributeValue2;    <br>
   *    ...                  <br>    
   *    [attributeNameN : attributeValueN;]  <br>
   * }                    <br>
   * </pre></blockquote>
   * <p>
   * Multiple class names can be specified for the one entry.  The class names 
   * are case senstive however the style attribute names and values are not.  
   * Quotes can be used at any time within the entries. 
   * <p>
   * For example :<br>
   * <blockquote><pre>
   * // comments allowed             
   * echopoint.DatePicker  {           
   *    foreground : #FF00CC;          
   *    background : color(AA,99,CC);      
   *    rolloverEnabled : true;        
   *    font : 'sans serif',bold,12;        
   *    calendarFont : font(verdana,italic,16)   
   * }
   * </pre></blockquote>
   * <p>
   * C and C++ style comments (slash slash or slash asterisk) can be used 
   * anywhere within the CssStyleSheet data
  * 
  * <p>
  * The className can be in three forms : 
  * <ul>
  * <li>className</li>
  * <li>className!groupName</li>
  * <li>className#id</li>
  * </ul>
  * <p>
  * Using groupName allows you to "logically" group a number of components under 
  * the one name.  You do this by setting using an attributed identifier of
  * "stylegroup=xxx", where xxx equals groupName. 
  * <p>
  * Using id, will cause the styles to be applied to Components of a certain class
  * that have the specified identifier or an attributed identifier of
  * "style=xxx", where xxx equals id.
  * <p>
  * For more information on attributed identifiers, see {@link echopoint.util.IdKit echopoint.util.IdKit}
  * <p>
  * For example :<br>
  * <blockquote><pre>
  * echopoint.PushButton  {          
  *    foreground : #FF00CC;          
  *    background : color(AA,99,CC);      
  * }                    
  * <br>
  * echopoint.PushButton!large  {      
  *    font : 'sans serif',bold,24;        
  * }
  * <br>
  * echopoint.PushButton!small {        
  *    font : 'verdana',plain,8;          
  * }
  * echopoint.PushButton#pbId  {        
  *    font : 'serif',bold,12;          
  * }
  * <br>
  * </pre></blockquote>
  * <p>
  * The ordering of application of styles is : className, className and groupName, 
  * className and finally id.
  * <p>
  * Use the CssStyleSheet.getInstance() to create new StyleSheet objects.  This method 
  * will return a CssStyleSheet with handlers for both Echo and EchoPoint components.
  * <p>
  * The CssStyleSheet.getEmptyInstance() method returns a CssStyleSheet object with no
  * CssStyleSheetHandlers within it.  You would rarely use this method however.
  * <p>
  * If a Component class has a StyleInfo support class associated with it
  * then the CssStyleSheet will invoke it to find out the class for values of a given
  * style attribute name.  This ensures that Style objects are created safely, with little chance
  * of a ClassCastException when applied.  This also allows case insensitive CCS attribute
  * names to be turned into case sensitive Style attribute names.
  * <p>
  * Internally a SmartStyle object is built with all of the information in the style sheet.
  * This is then applied to the Component via the Component.applyStyle() method.
  * If any of the style attributes are not set during the applyStyle() method, then
  * relection is used to find "setter" methods in the Component and this 
  * is used to set values.
  * <p> 
  * NOTE : that this StyleInfo is optional, and if not found then the CssStyleSheet will make an
  * intelligent guess about what class of object is required for a given attribute name.
  * <p>
  * @see echopoint.stylesheet.StyleSheetIntrospector
  * @see echopoint.stylesheet.StyleInfo
  * @see echopoint.stylesheet.SmartStyle
  * @see echopoint.util.IdKit
  * 
  */
 public class CssStyleSheet implements StyleSheet, PropertyChangeListener, java.io.Serializable {
 
   /* a class to hold style information */
   private class StyleEntry implements java.io.Serializable, Comparable {
     private Class clazz;
     private int lineNo;
     private String name;
     private SmartStyle style;
     
     
     /**
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     public int compareTo(Object o) {
       Class c1 = (Class) this.clazz;
       Class c2 = ((StyleEntry)o).clazz;
       
       if (c1.equals(c2)) {
         return 0;
       } else if (c1.isAssignableFrom(c2)) {
         return -1;
       } else {
         return c1.getName().compareTo(c2.getName());
       }
     }
 
     public String toString() {
       return name + " : " + clazz.getName() + " : " + style.toString() + " line : " + lineNo;
     }
 
     public Class getClazz() {
       return clazz;
     }
 
     public int getLineNo() {
       return lineNo;
     }
 
     public String getName() {
       return name;
     }
 
     public SmartStyle getStyle() {
       return style;
     }
 
     public void setClazz(Class class1) {
       clazz = class1;
     }
 
     public void setLineNo(int i) {
       lineNo = i;
     }
 
     public void setName(String string) {
       name = string;
     }
 
     public void setStyle(SmartStyle style) {
       this.style = style;
     }
 
   }
   private ArrayList exceptionList = new ArrayList();
   private boolean failOnInvalidAttributes = true;
   private ArrayList groupList = new ArrayList();
 
   private ArrayList handlerList = new ArrayList();
   private boolean hasParsingOccurred = false;
   private ArrayList idList = new ArrayList();
   private HashMap styleMap = new HashMap();
   private ArrayList styleSheetGroupList = new ArrayList();
   private boolean parseable = false;
   
   /**
    * CssStyleSheet constructor
    */
   private CssStyleSheet() {
     super();
     // need StyleInfo support for the Echo classes
     new CssEchoStyleSheetHandler();
   }
   /**
    * Tries to apply a style to a component.  
    * <p>
    * SmartStyles are used so that attributes that have not
    * been accessed can still be applied via reflection
    * <p>
    * It catches any exceptions and rethrows them 
    * as StyleSheetInvalidValueException's 
    */
   private void _applyStyle(Component c, StyleEntry entry) {
     try {
       SmartStyle style = entry.getStyle(); 
       c.applyStyle(style);
       //
       // use reflection to set an style attributes that
       // might not be used via applyStyle();
       //
       style.setUnAccessedAttributes(c);
     } catch (Exception e) {
       String msg = "Style Failure : Component class : '" + c.getClass().getName() + "' CSS style Name : '" + entry.getName() + "'";
       if (e.getMessage() != null)
         msg += e.getMessage();
       throw new StyleSheetInvalidValueException(entry.getLineNo(), msg, e);
     }
   }
   /**
    * Recursively applies the StyleSheet to a Component and its chidren
    */
   private void _applyStyleSheetRecursively(Component c) {
     _applyStyleSheetToComponent(c);
 
     Component children[] = c.getComponents();
     for (int i = 0; i < children.length; i++) {
       _applyStyleSheetRecursively(children[i]);
     }
   }
   /**
    * This applyes a style to an Component.  It can be via class
    * and/or via StyleSheetGroup and/or via component identifier (if present).
    * <p>
    * The style application is done in least specific class order. e.g.
    * Component/AbstractButton/Button/PushButton
    * <p>
    * If any Exceptions are encountered during Style application, such as ClassCastExceptions,
    * then they are caught and rethrown as StyleSheetInvalidValueExceptions
    * 
    * @deprecated StyleSheetGroup has been deprecated and will be removed in the next version
    * of EchoPoint.  Use the new attributed identifier on the Component from now on, 
    * eg component.setIdentifier("stylegroup=xxx;");
    */
   private void _applyStyleSheetToComponent(Component c) {
 
     Class classes[] = getClassesLeastSpecific(c.getClass());
 
     // apply styles in least specific class order, wich allows
     // future entries to override their parents.
     for (int i = 0; i < classes.length; i++) {
       Class currentClazz = classes[i];
       if (currentClazz.equals(Object.class))
         continue;
 
       StyleEntry entry = (StyleEntry) styleMap.get(currentClazz);
       if (entry != null)
         _applyStyle(c, entry);
     }
 
     // now try and find a grouping entry for the component
     // We now use thew new attributed identifier method
     // of setting group values
     
     for (int i = 0; i < groupList.size(); i++) {
       StyleEntry entry = (StyleEntry) groupList.get(i);
       //
       // use new method first
       Object identifier = c.getIdentifier();
       if (identifier != null) {
         Object groupName = IdKit.getAttribute(identifier,"stylegroup");
         if (entry.name.equals(groupName) && entry.style != null) {
           _applyStyle(c, entry);
         }
       }
       //
       // This needs to be removed eventually!
       StyleSheetGroup ssGroup = _findStyleSheetGroup(entry.name);
       if (ssGroup != null && ssGroup.contains(c) && entry.clazz.isAssignableFrom(c.getClass())) {
         if (entry.style != null)
           _applyStyle(c, entry);
       }
     }
 
     // now try and find an id entry for the component
     if (c.getIdentifier() != null) {
       for (int i = 0; i < idList.size(); i++) {
         StyleEntry entry = (StyleEntry) idList.get(i);
         if (entry.clazz.isAssignableFrom(c.getClass())) {
           
           Object id = IdKit.getAttribute(c.getIdentifier(),"style");
           if (id == null)
             id = c.getIdentifier();
             
           if (entry.name.equals(id) && entry.style != null) { 
             _applyStyle(c, entry);
           }
         }
       }
     }
   }
   /**
    * This method finds the Class object for a given name.  It also does some simple subsitution 
    * to find inner classe names which must be loaded with the xx.yyy$InnerName syntax.
    */
   private Class _findClassFromName(String className) throws ClassNotFoundException {
     ClassNotFoundException cnfe = null;
     Class clazz = null;
     try {
       clazz = Class.forName(className);
       return clazz;
     } catch (ClassNotFoundException firstE) {
       cnfe = firstE;
     }
 
     //
     // if they have excplicitly names the inner class then go no further
     if (className.indexOf('$') != -1)
       throw cnfe;
 
     //
     // okay run through the class name and substitue . chars for $ chars starting
     // from the back.  This will try and load inner classes
     StringBuffer sb = new StringBuffer(className);
     int index = className.lastIndexOf('.');
     while (index != -1) {
       sb = sb.replace(index, index + 1, "$");
       try {
         clazz = Class.forName(sb.toString());
         return clazz;
       } catch (ClassNotFoundException firstE) {
       }
 
       index = sb.toString().lastIndexOf('.');
     }
     throw cnfe;
   }
   /**
    * @deprecated StyleSheetGroup has been deprecated and will be removed in the next version
    * of EchoPoint.  Use the new attributed identifier on the Component from now on, 
    * eg component.setIdentifier("stylegroup=xxx;");
    */
   private StyleSheetGroup _findStyleSheetGroup(String name) {
     for (int i = 0; i < styleSheetGroupList.size(); i++) {
       StyleSheetGroup group = (StyleSheetGroup) styleSheetGroupList.get(i);
       if (group.getName().equals(name)) {
         return group;
       }
     }
     return null;
   }
   /**
    * This will try and set a value into a Style if it really is of the given type
    * valueClass!  It returns false if the value cannot be set.
    */
   private boolean _magicSetStyleAttribute(
     Style style,
     Class componentClass,
     StyleAttrDescriptor descriptor,
     String attrName,
     String attrValue) {
 
     Class valueClass = descriptor.getType();
 
     // try and match any symbolic constants first
     SymbolicValue[] symbolics = descriptor.getSymbolicValues();
     if (symbolics != null) {
       for (int i = 0; i < symbolics.length; i++) {
         if (symbolics[i].matches(attrValue)) {
           Object val = symbolics[i].getValue();
           style.setAttribute(descriptor.getName(), val);
           return true;
         }
       }
     }
 
     if (valueClass.equals(nextapp.echo.Color.class))
       return CssStyleSheetHelper.setColorAttribute(style, attrName, attrValue);
 
     if (valueClass.equals(nextapp.echo.Font.class))
       return CssStyleSheetHelper.setFontAttribute(style, attrName, attrValue);
 
     if (valueClass.equals(nextapp.echo.Insets.class))
       return CssStyleSheetHelper.setInsetsAttribute(style, attrName, attrValue);
 
     if (valueClass.equals(nextapp.echo.ImageReference.class))
       return CssStyleSheetHelper.setImageAttribute(style, attrName, attrValue);
 
     if (valueClass.equals(echopoint.CornerImages.class))
       return CssStyleSheetHelper.setCornerImagesAttribute(style, attrName, attrValue);
 
     if (valueClass.equals(echopoint.positionable.ClipRect.class))
       return CssStyleSheetHelper.setClipRectAttribute(style, attrName, attrValue);
 
     // boolean
     if (valueClass.equals(Boolean.class) || valueClass.equals(Boolean.TYPE))
       return CssStyleSheetHelper.setBooleanAttribute(style, attrName, attrValue);
 
     // integer
     if (valueClass.equals(Integer.class) || valueClass.equals(Integer.TYPE) || valueClass.equals(Long.class) || valueClass.equals(Long.TYPE)) {
       return CssStyleSheetHelper.setIntegerAttribute(style, attrName, attrValue);
     }
     // string
     if (valueClass.equals(String.class))
       return CssStyleSheetHelper.setStringAttribute(style, attrName, attrValue);
 
     Class ct  = valueClass.getComponentType(); 
     if ((ct == Integer.class || ct == Integer.TYPE) && valueClass.isArray())
       return CssStyleSheetHelper.setIntegerArrayAttribute(style,attrName, attrValue);
 
     // we we dont know about it.  What about the handlers do they 
     // know how to set it
     boolean bHandled = false;
     for (int j = 0; j < handlerList.size(); j++) {
       CssStyleSheetHandler handler = (CssStyleSheetHandler) handlerList.get(j);
       bHandled = handler.setKnownStyleAttribute(componentClass, valueClass, style, attrName, attrValue);
       if (bHandled)
         break;
     }
     return bHandled;
   }
   
   /**
    * Checks that the StyleInfo knows about the attr name.
    */
   private StyleAttrDescriptor _magicStyleFindDescriptor(StyleInfo styleInfo, String attrName) {
     if (styleInfo == null)
       return null;
     StyleAttrDescriptor[] descriptors = styleInfo.getStyleDescriptors();
     for (int i = 0; i < descriptors.length; i++) {
       StyleAttrDescriptor descriptor = descriptors[i];
       if (descriptor.getName().equalsIgnoreCase(attrName)) {
         return descriptor;
       }
     }    
     return null;
   }
   
   /**
    * Check with the component class whether it supports the magic StyleInfo 
    * If yes it determines if the attrName is okay and the value
    * can be set into a Style for the component class.  If not it returns false.
    */
   private boolean _magicStyleInfoSupport(CssStyleSheetParser.AttrEntry attrEntry, Class componentClass, Style style)
     throws StyleSheetParseException {
 
     String attrName = attrEntry.attrName;
     StyleAttrDescriptor theDescriptor = null;
     StyleInfo info = null;
     
     try {
       info = StyleSheetIntrospector.getStyleInfo(componentClass);
       theDescriptor = _magicStyleFindDescriptor(info,attrName);
     } catch (IntrospectionException e) {;}
     
     // finally ask the handlers    
     if (theDescriptor == null) {
       // ask each of the handlers in turn if they have 
       // StyleInfo for a given componentClass 
       for (int j = 0; j < handlerList.size(); j++) {
         CssStyleSheetHandler handler = (CssStyleSheetHandler) handlerList.get(j);
         info = handler.getStyleInfo(componentClass);
         theDescriptor = _magicStyleFindDescriptor(info,attrName);
         if (theDescriptor != null)
           break;
       }
     }
     if (theDescriptor != null) {
       //
       // the Component class knows about the attribute name.  Can it be parsed 
       // into one of those class of values and set into the style??
       boolean isSettable = _magicSetStyleAttribute(style, componentClass, theDescriptor, attrName, attrEntry.attrValue);
       if (! isSettable) {
         //
         // the attrName is known however the attr value is not the right type
         _throwTPE(
           attrEntry.lineNo,
           "Style attribute '"
             + attrEntry.attrName
             + "' in class '"
             //+ componentClass.getName()
             + attrEntry.className
             + "' has an invalid value '"
             + attrEntry.attrValue);
       }
       return true;
     } else {
       // we dont know about it for this component class
       return false;
     }
   }
   /**
    * Processes a style attribute and make sure it can be set okay
    */
   private void _processStyleAttribute(CssStyleSheetParser.AttrEntry attrEntry, Class classes[], Class componentClass, Style style)
     throws StyleSheetParseException {
 
     CssStyleSheetHandler handler;
 
     String attrName = attrEntry.attrName;
     String attrValue = attrEntry.attrValue.trim();
 
     boolean bHandled = false;
     for (int i = 0; i < classes.length; i++) {
       Class clazz = classes[i];
       // skip Object
       if (clazz.equals(Object.class))
         continue;
       //
       // check to see if the Component class has the magic style sheet support
       // and if so, then use it.
       bHandled = _magicStyleInfoSupport(attrEntry, clazz, style);
       //
       // call the handler class to try and set the style attribute for the current 
       // class
       if (!bHandled) {
         for (int j = 0; j < handlerList.size(); j++) {
           handler = (CssStyleSheetHandler) handlerList.get(j);
           bHandled = handler.setUnknownStyleAttribute(clazz, style, attrName, attrValue);
           if (bHandled)
             break;
         }
       }
       // 
       // if its still not handled, then call out to the handlers
       // to parse an Object value.
       //
       if (!bHandled) {
         for (int j = 0; j < handlerList.size(); j++) {
           handler = (CssStyleSheetHandler) handlerList.get(j);
           Object value = handler.parseUnknownStyleValue(clazz, attrName, attrValue);
           if (value != null) {
             bHandled = true;
             style.setAttribute(attrName,value);
             break;
           }
         }
       }
       // if its been handled then no need to go around any further!
       if (bHandled) {
         return;
       }
     }
     //
     // now the none of the component classes have magic support or they have it but dont know 
     // about the attribute name, so we should guess.  In a certain order of course...
     //
     bHandled = bHandled || CssStyleSheetHelper.setColorAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setFontAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setInsetsAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setImageAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setCornerImagesAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setClipRectAttribute(style, attrName, attrValue);
     bHandled = bHandled || CssStyleSheetHelper.setIntegerArrayAttribute(style, attrName, attrValue);
     
     //
     // okay  if we still havent handled it okay we need to try some of the more general cases
     // such as boolean, integers and strings
     //
 
     // boolean
     if (attrValue.equalsIgnoreCase("true") || attrValue.equalsIgnoreCase("false"))
       bHandled = bHandled || CssStyleSheetHelper.setBooleanAttribute(style, attrName, attrValue);
     // integer
     if (CssStyleSheetHelper.isInteger(attrValue))
       bHandled = bHandled || CssStyleSheetHelper.setIntegerAttribute(style, attrName, attrValue);
 
     //
     // not one of the well known object types so again
     // give the handlers another chance to convert the value
     // without much context.
     //    
     if (!bHandled) {
       for (int j = 0; j < handlerList.size(); j++) {
         handler = (CssStyleSheetHandler) handlerList.get(j);
         Object value = handler.parseUnknownStyleValue(attrValue);
         if (value != null) {
           bHandled = true;
           style.setAttribute(attrName,value);
           break;
         }
       }
     }
     
     //
     // finally treat it as a simple string, 
     // but only if it is not in obj(n,n) form
     //
     if (! _isObjValue(attrValue)) {
       //
       // The string value may be surrounded by quotes ' or "
       // in which case we need to remove them
       //
       int last = attrValue.length()-1;
       if (_isQuotedValue(attrValue))
         attrValue = attrValue.substring(1,last);
         
       bHandled = bHandled || CssStyleSheetHelper.setStringAttribute(style, attrName, attrValue);
     }
 
     if (!bHandled) {
       //
       // no one handled the attribute at all. BLAM!
       //
       _throwTPE(
         attrEntry.lineNo,
         "Unhandled style attribute '"
           + attrName
           + "' in class '"
           //+ componentClass.getName()
           + attrEntry.className
           + "' with value '"
           + attrValue);
     }
   }
   
   /**
    * processes style sheet data
    */
   private void _processStyleSheet(Reader styleSheetReader) throws StyleSheetParseException {
     CssStyleSheetHandler handler;
 
     parseable = false;
     // clear all our lists
     exceptionList.clear();
     idList.clear();
     groupList.clear();
     styleMap.clear();
 
     CssStyleSheetParser parser = new CssStyleSheetParser();
 
     // and parse...and parse...and parse
     try {
       parser.parse(styleSheetReader);
     } catch (StyleSheetParseException sse) {
       exceptionList.add(sse);
       throw sse;
     }
 
     // go through all the class entries and process them
     List classList = parser.getClassEntries();
     for (int e = 0; e < classList.size(); e++) {
       CssStyleSheetParser.ClassEntry classEntry = (CssStyleSheetParser.ClassEntry) classList.get(e);
 
       // try and load a class file for the entry
       String className = classEntry.className;
       Class clazz = null;
       try {
         // if we dont have a fully qualified class name then ask each 
         // handler in turn until we do.  We do this in the order in which
         // the handlers where added.
         if (className.indexOf('.') == -1) {
           String fullQualifiedClassName;
           for (int h = 0; h < handlerList.size(); h++) {
             handler = (CssStyleSheetHandler) handlerList.get(h);
             fullQualifiedClassName = handler.getFullQualifiedClassName(className);
             if (fullQualifiedClassName != null) {
               className = fullQualifiedClassName;
               break;
             }
           }
         }
         clazz = _findClassFromName(className);
       } catch (ClassNotFoundException cnfe) {
         StyleSheetParseException sse = new StyleSheetParseException(classEntry.lineNo, cnfe, "Style Failure : " + cnfe.toString());
         exceptionList.add(sse);
         if (isExceptionParseFailure())
           throw sse;
         // this class is a dud...next class please
         continue;
 
       }
 
       //
       // make sure the class name is derived from nextapp.echo.Component.  We cant 
       // help them otherwise
       if (!nextapp.echo.Component.class.isAssignableFrom(clazz)) {
         StyleSheetParseException sse =
           new StyleSheetParseException(
             classEntry.lineNo,
             null,
             "Style Failure : The class '" + clazz.getName() + "' is not derived from nextapp.echo.Component");
         exceptionList.add(sse);
         if (isExceptionParseFailure())
           throw sse;
         // this class is a dud...next class please
         continue;
       }
 
       // ask the component classes about each attribute starting from the most
       // specific first.  Note that this is opposite order in which we apply
       // styles.
       Class classes[] = getClassesMostSpecific(clazz);
 
       //
       // parse all the style attributes and place them into a 
       // SmartStyle
       //
       SmartStyle style = new SmartStyle();
       List attrList = classEntry.listAttrEntries;
       for (int a = 0; a < attrList.size(); a++) {
         CssStyleSheetParser.AttrEntry attrEntry = (CssStyleSheetParser.AttrEntry) attrList.get(a);
         _processStyleAttribute(attrEntry, classes, clazz, style);
       }
 
       // save the new created style for later application
       StyleEntry styleEntry = new StyleEntry();
       styleEntry.setLineNo(classEntry.lineNo);
       styleEntry.setClazz(clazz);
       styleEntry.setStyle(style);
 
       if (classEntry.id == null && classEntry.grouping == null) {
         styleEntry.setName(clazz.getName());
         styleMap.put(clazz, styleEntry);
       } else {
         if (classEntry.id != null) {
           styleEntry.setName(classEntry.id);
           idList.add(styleEntry);
         }
         if (classEntry.grouping != null) {
           styleEntry.setName(classEntry.grouping);
           groupList.add(styleEntry);
         }
       }
     }
     
     // we are parse valid if we dont get an exceptions
     parseable = exceptionList.size() == 0;
 
     // we are now fully parsed.
     hasParsingOccurred = true;
   }
   /**
    * internal function to throw a formatted StyleSheetParseException
    */
   private StyleSheetParseException _throwTPE(int lineNo, String message) throws StyleSheetParseException {
     message = "Style Failure : " + message;
     StyleSheetParseException sse = new StyleSheetParseException(lineNo, null, message);
     exceptionList.add(sse);
     if (isExceptionParseFailure())
       throw sse;
     return sse;
   }
   
    /** 
    * Returns true if a value is in the form obj(...)
    */
   private boolean _isObjValue(String attrValue) {
     if (attrValue == null)
       return false;
       
     attrValue = attrValue.trim();
     //
     // if it's quoted as "ob(...)" then its 
     // not in obj form
     
     if (_isQuotedValue(attrValue))
       return false;
       
     if (attrValue.indexOf('(') > 1 && attrValue.indexOf(')') == attrValue.length()-1)
       return true;
     return false;
   }
   
   private boolean _isQuotedValue(String attrValue) {
     int last = attrValue.length()-1;
     if (attrValue.charAt(0) == '"' && attrValue.charAt(last) == '"') {
       return true;
     } else if (attrValue.charAt(0) == '\'' && attrValue.charAt(last) == '\'') { 
       return true;
     }
     return false;
   }
   
   /**
    * Adds a StyleSheetGroup to the StyleSheet.
    * <p>
    * @deprecated StyleSheetGroup has been deprecated and will be removed in the next version
    * of EchoPoint.  Use the new attributed identifier on the Component from now on, 
    * eg component.setIdentifier("stylegroup=xxx;");
    */
   public void addGroup(StyleSheetGroup styleSheetGroup) {
     if (styleSheetGroup == null)
       throw new IllegalArgumentException("A non null StyleSheetGroup must be provided");
     
     if (! styleSheetGroupList.contains(styleSheetGroup))
       styleSheetGroupList.add(styleSheetGroup);
     if (hasParsingOccurred) {
       for (Iterator it = styleSheetGroup.getIterator(); it.hasNext();) {
         Component c = (Component) it.next();
         applyTo(c);
       }
     }
   }
   /**
    * Adds a CssStyleSheetHandler to the CssStyleSheet.  Ths allows extension of the
    * known style attribute names and values.
    * <p>
    */
   public void addHandler(CssStyleSheetHandler handler) {
     if (handler == null)
       throw new IllegalArgumentException("A non null CssStyleSheetHandler must be provided");
     handlerList.add(handler);
   }
   /**
    * @see echopoint.stylesheet.StyleSheet#applyTo(nextapp.echo.Component)
    */
   public void applyTo(Component c) {
     applyTo(c, false);
   }
   
   /**
    * @see echopoint.stylesheet.StyleSheet#applyTo(nextapp.echo.Component, boolean)
    */
   public void applyTo(Component c, boolean listenForFutureChildren) {
     if (c == null)
       throw new IllegalArgumentException("A non null Component must be provided");
 
     if (listenForFutureChildren)
       startListeningTo(c);
 
     _applyStyleSheetRecursively(c);
   }
   
   /**
    * @see echopoint.stylesheet.StyleSheet#applyTo(nextapp.echo.EchoInstance)
    */
   public void applyTo(EchoInstance instance) {
     applyTo(instance,false);
   }
   /**
    * @see echopoint.stylesheet.StyleSheet#applyTo(nextapp.echo.EchoInstance, boolean)
    */
   public void applyTo(EchoInstance instance, boolean listenForFutureChildren) {
     if (instance == null)
       throw new IllegalArgumentException("A non null EchoInstance must be provided");
 
     if (listenForFutureChildren)
       startListeningTo(instance);
 
     Window[] windows = instance.getWindows();
     for (int i = 0; i < windows.length; i++) {
       _applyStyleSheetRecursively(windows[i]);
     }
   }
   
   /**
    * Returns all the derived classes of clazz, including clazz, in least 
    * specific order (ie clazz is last).
    */
   private Class[] getClassesLeastSpecific(Class clazz) {
 
     ArrayList list = new ArrayList();
     do {
       list.add(clazz);
       clazz = clazz.getSuperclass();
     } while (clazz != null);
     java.util.Collections.reverse(list);
 
     return (Class[]) list.toArray(new Class[list.size()]);
   }
   /**
    * Returns all the derived classes of clazz, including clazz, in most specific
    * order first (ie clazz is first)
    */
   private Class[] getClassesMostSpecific(Class clazz) {
 
     ArrayList list = new ArrayList();
     do {
       list.add(clazz);
       clazz = clazz.getSuperclass();
     } while (clazz != null);
 
     return (Class[]) list.toArray(new Class[list.size()]);
   }
   /**
    * This method returns an array of StyleSheetParseExceptions that have occurred
    * during parsing.  Note that this will only have more than 1 entries if
    * setExceptionParseFailure is set to true.
    */
   public StyleSheetParseException[] getParseExceptions() {
     return (StyleSheetParseException[]) exceptionList.toArray(new StyleSheetParseException[exceptionList.size()]);
   }
   /**
    * This returns true if the CssStyleSheet will throw an StyleSheetParseException if it
    * encounters an invalid or unknown attribute.  The default is true.
    * <p>
    * Note : this only covers the setting of style attributes values, not the general 
    * parsing of the style sheet data.  A general parse problem will always throw a
    * StyleSheetParseException.
    * 
    * @return boolean
    */
   public boolean isExceptionParseFailure() {
     return failOnInvalidAttributes;
   }
   /**
    * Loads the CssStyleSheet data contained in the Reader.
    * <p>
    * @throws StyleSheetParseException - if the data cannot be parsed
    */
   public void loadStyleSheet(Reader styleSheetReader) throws StyleSheetParseException {
     _processStyleSheet(styleSheetReader);
   }
   /**
    * Loads the CssStyleSheet data contained in the file named "fileName".
    * <p>
    * @throws StyleSheetParseException - if the file cannot be parsed
    */
   public void loadStyleSheet(String styleSheetFileName) throws StyleSheetParseException {
     try {
       loadStyleSheet(new java.io.BufferedReader(new java.io.FileReader(new File(styleSheetFileName))));
     } catch (java.io.FileNotFoundException fne) {
       throw new StyleSheetParseException(-1, fne, null);
     }
   }
   /**
    * Loads the CssStyleSheet data contained in the URL.
    * <p>
    * @throws StyleSheetParseException - if the data cannot be parsed
    */
   public void loadStyleSheet(URL styleSheetURL) throws StyleSheetParseException {
     Reader in = null;
     try {
       in = new java.io.BufferedReader(new java.io.InputStreamReader(styleSheetURL.openStream(), "8859_1"));
     } catch (java.io.IOException ioe) {
       throw new StyleSheetParseException(-1, ioe, ioe.toString());
     }
     loadStyleSheet(in);
   }
   /**
    * This method gets called when a bound property is changed.
    * <p>
    * The CssStyleSheet class will listen for Component.CHILDREN_CHANGED_PROPERTY
    * and EchoInstance.WINDOWS_CHANGED_PROPERTY events and 
    * will then apply any applicable Styles to the new Component and 
    * its children, or conversely, stop listening if the child is being 
    * removed.
    * <p>
    *
    * @param evt A PropertyChangeEvent object describing the event source 
    *     and the property that has changed.
    */
  public void propertyChange(PropertyChangeEvent evt) {
    boolean eventQualifies = false;
    if (evt.getSource() instanceof Component && Component.CHILDREN_CHANGED_PROPERTY.equals(evt.getPropertyName())) {
      eventQualifies = true;
    }
    if (evt.getSource() instanceof EchoInstance && EchoInstance.WINDOWS_CHANGED_PROPERTY.equals(evt.getPropertyName())) {
      eventQualifies = true;
    }
      
    if (eventQualifies) {  
      Object newChild = evt.getNewValue();
      Object oldChild = evt.getOldValue();
      if (newChild != null && newChild instanceof Component) {
        //
        // we have a new child addition so start listening to it
        // and then apply some style to it.
        //
        Component child = (Component) evt.getNewValue();
        startListeningTo(child);
        _applyStyleSheetRecursively(child);
      }
      if (oldChild != null && oldChild instanceof Component && newChild == null) {
        //
        // we have a child deletion.  Stop listening to it
        //
        Component child = (Component) evt.getOldValue();
        stopListeningTo(child);
      }
    }
  }
  
  /**
   * This controls whether the CssStyleSheet will throw a StyleSheetParseException if it
   * encounters an invalid or unknown attribute.
   * <p>
   * Note : this only covers the setting of style attributes values, not the general 
   * parsing of the style sheet data.  A general parse problem will always throw a
   * StyleSheetParseException.
   * 
   * @param newExceptionParseFailure boolean
   */
  public void setExceptionParseFailure(boolean newExceptionParseFailure) {
    failOnInvalidAttributes = newExceptionParseFailure;
  }
  
  /** Listens to a Component and all its children */
  private void startListeningTo(Component c) {
    if (c != null) {
      c.addPropertyChangeListener(this);
      Component[] children = c.getComponents();
      for (int i = 0; i < children.length; i++) {
        startListeningTo(children[i]);
      }
    }
  }
  
  /** Listens to a Component and all its children */
  private void startListeningTo(EchoInstance instance) {
    if (instance != null) {
      instance.addPropertyChangeListener(this);
      Window[] windows = instance.getWindows();
      for (int i = 0; i < windows.length; i++) {
        startListeningTo(windows[i]);
      }
    }
  }
  
  /**
   * This stops the CssStyleSheet from listening for CHILDREN_PROPERTY_CHANGED events
   * on the given Component c.
   */
  public void stopListeningTo(Component c) {
    if (c != null) {
      c.removePropertyChangeListener(this);
      Component[] children = c.getComponents();
      for (int i = 0; i < children.length; i++) {
        stopListeningTo(children[i]);
      }
    }
  }
  
  /**
   * @see echopoint.stylesheet.StyleSheet#stopListeningTo(nextapp.echo.EchoInstance)
   */
  public void stopListeningTo(EchoInstance instance) {
    if (instance != null) {
      instance.removePropertyChangeListener(this);
      Window[] windows = instance.getWindows();
      for (int i = 0; i < windows.length; i++) {
        stopListeningTo(windows[i]);
      }
    }
  }
  
  
  /**
   * Returns an empty StyleSheet with no StyleSheetHandlers within it.
   * <p>
   * The returned object implements StyleSheet and is an instance of 
   * CssStyleSheet.
   * <p>
   * Using this form allows the developer to change the StyleSheetHandlers
   * used and/or the order in which they are applied.
   */
  public static CssStyleSheet getEmptyInstance() {
    return new CssStyleSheet();
  }
  /**
   * Returns a StyleSheet object.
   * <p>
   * The returned object implements StyleSheet and is an instance of 
   * CssStyleSheet.
   * <p>
   */
  public static CssStyleSheet getInstance() {

    CssStyleSheet cssStyleSheet = new CssStyleSheet();
    cssStyleSheet.addHandler(new CssEchoStyleSheetHandler());
    cssStyleSheet.addHandler(new CssEchoPointStyleSheetHandler());
    return cssStyleSheet;
  }
  /**
   * Returns a StyleSheet object by parsing the given Reader style sheet data.  
   * <p>
   * The returned object implements StyleSheet and is an instance of 
   * CssStyleSheet.
   * <p>
   */
  public static CssStyleSheet getInstance(Reader styleSheetReader) throws StyleSheetParseException {

    CssStyleSheet cssStyleSheet = new CssStyleSheet();
    cssStyleSheet.addHandler(new CssEchoStyleSheetHandler());
    cssStyleSheet.addHandler(new CssEchoPointStyleSheetHandler());

    // and parse and load the style sheet entries
    cssStyleSheet.loadStyleSheet(styleSheetReader);

    return cssStyleSheet;
  }
  /**
   * Returns a StyleSheet object by parsing the given style sheet file name.
   * <p>
   * The returned object implements StyleSheet and is an instance of 
   * CssStyleSheet.
   * <p>
   */
  public static CssStyleSheet getInstance(String styleSheetFileName) throws StyleSheetParseException {

    CssStyleSheet cssStyleSheet = new CssStyleSheet();
    cssStyleSheet.addHandler(new CssEchoStyleSheetHandler());
    cssStyleSheet.addHandler(new CssEchoPointStyleSheetHandler());

    // and parse and load the style sheet entries
    cssStyleSheet.loadStyleSheet(styleSheetFileName);

    return cssStyleSheet;
  }
  /**
   * Returns a StyleSheet object by parsing the given URL style sheet data.  
   * <p>
   * The returned object implements StyleSheet and is an instance of 
   * CssStyleSheet.
   * <p>
   */
  public static CssStyleSheet getInstance(URL styleSheetURL) throws StyleSheetParseException {

    CssStyleSheet cssStyleSheet = new CssStyleSheet();
    cssStyleSheet.addHandler(new CssEchoStyleSheetHandler());
    cssStyleSheet.addHandler(new CssEchoPointStyleSheetHandler());

    // and parse and load the style sheet entries
    cssStyleSheet.loadStyleSheet(styleSheetURL);

    return cssStyleSheet;
  }
  
  /**
   * Returns true if the current CssStyleSheet can be parsed.  This 
   * does not mean that it is perfectly valid, since the application
   * of the generated Style objects may still pose problems.  But it 
   * does mean that the CssStyleSheet has validated style attribute 
   * name and values as best it can.
   *  
   * @return true if the style sheet could be parsed
   */
  public boolean isParseable() {
    return parseable;
  }
}