package net.sf.tomp.xtcl.filter;
   
   import net.sf.tomp.general.Parametrized;
   
   import org.xml.sax.Attributes;
   import org.xml.sax.ContentHandler;
   import org.xml.sax.DTDHandler;
   import org.xml.sax.EntityResolver;
   import org.xml.sax.ErrorHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.Locator;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXNotRecognizedException;
  import org.xml.sax.SAXNotSupportedException;
  import org.xml.sax.SAXParseException;
  import org.xml.sax.XMLFilter;
  import org.xml.sax.XMLReader;
  import org.xml.sax.ext.LexicalHandler;
  
  import java.io.IOException;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Properties;
  
  /***
   * DOCUMENT ME!
   * 
   * @author tomp
   */
  public class DynamicMultiFilterImpl extends XTFilterImpl implements
          DynamicMultiFilter {
  
      /***
       * DOCUMENT ME!
       * 
       * @param parent DOCUMENT ME!
       * @param f DOCUMENT ME!
       */
      protected static void connectHandlers(XMLReader parent, XMLFilter f) {
          // route messages from parent to f
          //System.out.println(parent+" *** SETS HANDLERS to "+f);
          // comm out by TP Oct 5 2004
  /*        if (f instanceof EntityResolver) {
              parent.setEntityResolver((EntityResolver) f);
          }
  */
          if (f instanceof DTDHandler) {
              parent.setDTDHandler((DTDHandler) f);
          }
  
          if (f instanceof ContentHandler) {
              parent.setContentHandler((ContentHandler) f);
          }
  
          if (f instanceof ErrorHandler) {
              parent.setErrorHandler((ErrorHandler) f);
          }
  
          try {
              if (f instanceof LexicalHandler) {
                  //System.out.println(parent+" *** SETS LexicalHandler to "+f);
                  parent.setProperty(
                          "http://xml.org/sax/properties/lexical-handler", f);
              }
          } catch (SAXException se) {
              se.printStackTrace();
          }
  
          // connect f to parent
          f.setParent(parent);
      }
  
      /***
       * DOCUMENT ME!
       * 
       * @param from DOCUMENT ME!
       * @param to DOCUMENT ME!
       */
      protected static void copyHandlers(XMLReader from, XMLReader to) {
          // route messages from last filter to further handlers
          //System.out.println(f+" *** SETS DTD HANDLER to "+getDTDHandler());
          ContentHandler ch = from.getContentHandler();
  
          if (ch != null) {
              to.setContentHandler(ch);
          }
  
          DTDHandler dh = from.getDTDHandler();
  
          if (dh != null) {
              to.setDTDHandler(dh);
          }
  
  /*        EntityResolver er = from.getEntityResolver();
  
          if (er != null) {
              to.setEntityResolver(er);
          }
 */
         ErrorHandler eh = from.getErrorHandler();
 
         if (eh != null) {
             to.setErrorHandler(eh);
         }
 
         try {
             Object lh = from
                     .getProperty("http://xml.org/sax/properties/lexical-handler");
 
             if (lh != null) {
                 to.setProperty("http://xml.org/sax/properties/lexical-handler",
                         lh);
             }
         } catch (SAXException se) {
             //se.printStackTrace();
         }
     }
     ////////////////////////////////////////////////////////////////////
     // Internal state.
     ////////////////////////////////////////////////////////////////////
 
     /*** DOCUMENT ME! */
     protected List filters;
 
     /*** DOCUMENT ME! */
     protected XMLFilter firstFilter = null;
 
     /*** DOCUMENT ME! */
     protected boolean isContentHandler;
 
     /*** DOCUMENT ME! */
     protected boolean isDTDHandler;
 
     /*** DOCUMENT ME! */
     protected boolean isEntityResolver;
 
     /*** DOCUMENT ME! */
     protected boolean isErrorHandler;
 
     /*** DOCUMENT ME! */
     protected boolean isLexicalHandler;
 
     /*** DOCUMENT ME! */
     protected XMLFilter lastFilter = null;
 
     /*** DOCUMENT ME! */
     protected HasOutputProperties outputPropertiesListener = null;
 
     ////////////////////////////////////////////////////////////////////
     // Constructors.
     ////////////////////////////////////////////////////////////////////
     public DynamicMultiFilterImpl() {
         super();
         filters = new ArrayList();
 
         //setFilter(f);
     }
 
     /***
      * Creates a new DynamicMultiFilterImpl object.
      * 
      * @param parent DOCUMENT ME!
      */
     public DynamicMultiFilterImpl(XMLReader parent) {
         this();
         setParent(parent);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param pos DOCUMENT ME!
      * @param f DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void addFilter(int pos, XMLFilter f) throws SAXException {
         // FIXME
         // use case 1: add(0, f)
         if (pos == 0) {
             XMLReader parent = getParent();
 
             if (parent != null) {
                 connectHandlers(parent, f);
             }
 
             if (0 == getFilterCount()) {
                 // the one and only
                 copyHandlers(this, f);
                 lastFilter = f;
             } else {
                 // already has some filters...
                 copyHandlers(firstFilter, f);
                 connectHandlers(f, firstFilter);
             }
 
             firstFilter = f;
             determineHandlerInfo();
 
             // use case 2: add(last, f)
         } else if (pos == getFilterCount()) {
             // already has some filters...
             copyHandlers(lastFilter, f);
 
             connectHandlers(lastFilter, f);
 
             lastFilter = f;
 
             // use case 3: add(n, f) - general case, # of filters > 1
         } else {
             XMLFilter next = getFilter(pos);
             XMLReader parent = next.getParent();
 
             copyHandlers(parent, f);
             connectHandlers(parent, f);
         }
 
         filters.add(pos, f);
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of the LexicalHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Callback interface for SAX (part of LexicalHandler interface): not for
      * application use
      * 
      * @param ch DOCUMENT ME!
      * @param start DOCUMENT ME!
      * @param length DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void comment(char[] ch, int start, int length) throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).comment(ch, start, length);
             }
         } else {
             super.comment(ch, start, length);
         }
     }
 
     /***
      * DOCUMENT ME!
      */
     protected void determineHandlerInfo() {
         isContentHandler = firstFilter instanceof ContentHandler;
         isDTDHandler = firstFilter instanceof DTDHandler;
         isErrorHandler = firstFilter instanceof ErrorHandler;
         isLexicalHandler = firstFilter instanceof LexicalHandler;
         isEntityResolver = firstFilter instanceof EntityResolver;
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void endCDATA() throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).endCDATA();
             }
         } else {
             super.endCDATA();
         }
     }
 
     /***
      * Filter an end document event.
      * 
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endDocument() throws SAXException {
         //System.out.println("---DynamicFilter "+this+".endDocument,
         // firstFilter="+firstFilter);
         if (firstFilter != null) {
             //System.out.println("---firstFilter has
             // contenthandler="+firstFilter.getContentHandler());
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).endDocument();
             }
         } else {
             super.endDocument();
         }
     }
 
     /***
      * Register the end of the DTD. Comments in the DTD are skipped because they
      * are not part of the XPath data model
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void endDTD() throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).endDTD();
             }
         } else {
             super.endDTD();
         }
     }
 
     /***
      * Filter an end element event.
      * 
      * @param uri The element's Namespace URI, or the empty string.
      * @param localName The element's local name, or the empty string.
      * @param qName The element's qualified (prefixed) name, or the empty
      *            string.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endElement(String uri, String localName, String qName)
             throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter)
                         .endElement(uri, localName, qName);
             }
         } else {
             super.endElement(uri, localName, qName);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param name DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void endEntity(String name) throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).endEntity(name);
             }
         } else {
             super.endEntity(name);
         }
     }
 
     /***
      * Filter an end Namespace prefix mapping event.
      * 
      * @param prefix The Namespace prefix.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void endPrefixMapping(String prefix) throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).endPrefixMapping(prefix);
             }
         } else {
             super.endPrefixMapping(prefix);
         }
     }
 
     /***
      * Filter an error event.
      * 
      * @param e The error as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void error(SAXParseException e) throws SAXException {
         if (firstFilter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) firstFilter).error(e);
             }
         } else {
             super.error(e);
         }
     }
 
     /***
      * Filter a fatal error event.
      * 
      * @param e The error as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void fatalError(SAXParseException e) throws SAXException {
         if (firstFilter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) firstFilter).fatalError(e);
             }
         } else {
             super.fatalError(e);
         }
     }
 
     /***
      * Get the content event handler.
      * 
      * @return The current content handler, or null if none was set.
      */
     public ContentHandler getContentHandler() {
         //System.out.println(""+this+".getContentHandler=>"+contentHandler);
         if (lastFilter != null) {
             return lastFilter.getContentHandler();
         } else {
             return super.getContentHandler();
         }
     }
 
     /***
      * Get the current DTD event handler.
      * 
      * @return The current DTD handler, or null if none was set.
      */
     public DTDHandler getDTDHandler() {
         if (lastFilter != null) {
             return lastFilter.getDTDHandler();
         } else {
             return super.getDTDHandler();
         }
     }
 
     /***
      * Get the current entity resolver.
      * 
      * @return The current entity resolver, or null if none was set.
      */
     public EntityResolver getEntityResolver() {
         if (firstFilter != null) {
             return firstFilter.getEntityResolver();
         } else {
             return super.getEntityResolver();
         }
     }
 
     /***
      * Get the current error event handler.
      * 
      * @return The current error handler, or null if none was set.
      */
     public ErrorHandler getErrorHandler() {
         if (lastFilter != null) {
             return lastFilter.getErrorHandler();
         } else {
             return super.getErrorHandler();
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param name DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws SAXNotRecognizedException DOCUMENT ME!
      * @throws SAXNotSupportedException DOCUMENT ME!
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException,
             SAXNotSupportedException {
         // FIXME: the same problem
         if (firstFilter != null) {
             return firstFilter.getFeature(name);
         } else {
             return super.getFeature(name);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param pos DOCUMENT ME!
      * @return DOCUMENT ME!
      */
     public XMLFilter getFilter(int pos) {
         return (XMLFilter) filters.get(pos);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
     public int getFilterCount() {
         return filters.size();
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
     public Properties getOutputProperties() {
         //System.out.println(this+" +++++++++++++ getOutputProperties from
         // lastFilter=" + lastFilter);
         if (lastFilter instanceof HasOutputProperties) {
             return ((HasOutputProperties) lastFilter).getOutputProperties();
         }
 
         return null;
     }
 
     /*
      * public void setProperty (String name, Object value) throws
      * SAXNotRecognizedException, SAXNotSupportedException { if(firstFilter !=
      * null) firstFilter.setProperty(name, value); super.setProperty(name,
      * value); }
      */
 
     /***
      * Look up the value of a property.
      * 
      * @param name The property name.
      * @return The current value of the property.
      * @exception SAXNotRecognizedException If the property value can't be
      *                assigned or retrieved from the parent.
      * @exception SAXNotSupportedException When the parent recognizes the
      *                property name but cannot determine its value at this time.
      */
     public Object getProperty(String name) throws SAXNotRecognizedException,
             SAXNotSupportedException {
         if (firstFilter != null) {
             return firstFilter.getProperty(name);
         } else {
             return super.getProperty(name);
         }
     }
 
     /***
      * Filter a character data event.
      * 
      * @param ch An array of characters.
      * @param start The starting position in the array.
      * @param length The number of characters to use from the array.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void characters(char[] ch, int start, int length)
             throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).characters(ch, start, length);
             }
         } else {
             super.characters(ch, start, length);
         }
     }
 
     /***
      * Filter an ignorable whitespace event.
      * 
      * @param ch An array of characters.
      * @param start The starting position in the array.
      * @param length The number of characters to use from the array.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void ignorableWhitespace(char[] ch, int start, int length)
             throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).ignorableWhitespace(ch, start,
                         length);
             }
         } else {
             super.ignorableWhitespace(ch, start, length);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.DTDHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a notation declaration event.
      * 
      * @param name The notation name.
      * @param publicId The notation's public identifier, or null.
      * @param systemId The notation's system identifier, or null.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void notationDecl(String name, String publicId, String systemId)
             throws SAXException {
         if (firstFilter != null) {
             if (isDTDHandler) {
                 ((DTDHandler) firstFilter).notationDecl(name, publicId,
                         systemId);
             } else {
                 super.notationDecl(name, publicId, systemId);
             }
         }
     }
 
     /***
      * Parse a document.
      * 
      * @param input The input source for the document entity.
      * @exception SAXException Any SAX exception, possibly wrapping another
      *                exception.
      * @exception IOException An IO exception from the parser, possibly from a
      *                byte stream or character stream supplied by the
      *                application.
      */
     public void parse(InputSource input) throws SAXException, IOException {
         if (lastFilter != null) {
             lastFilter.parse(input);
         } else {
             super.parse(input);
         }
     }
 
     /***
      * Filter a processing instruction event.
      * 
      * @param target The processing instruction target.
      * @param data The text following the target.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void processingInstruction(String target, String data)
             throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).processingInstruction(target,
                         data);
             }
         } else {
             super.processingInstruction(target, data);
         }
     }
 
 	// No-op methods to satisfy lexical handler interface
 	
 	/***
 	 * Register the start of the DTD. Comments in the DTD are skipped because
 	 * they are not part of the XPath data model
 	 * 
 	 * @param name DOCUMENT ME!
 	 * @param publicId DOCUMENT ME!
 	 * @param systemId DOCUMENT ME!
 	 * @throws SAXException DOCUMENT ME!
 	 */
 	public void startDTD(String name, String publicId, String systemId)
 	        throws SAXException {
 	    if (firstFilter != null) {
 	        if (isLexicalHandler) {
 	            ((LexicalHandler) firstFilter).startDTD(name, publicId,
 	                    systemId);
 	        }
 	    } else {
 	        super.startDTD(name, publicId, systemId);
 	    }
 	}
 
     /***
      * DOCUMENT ME!
      * 
      * @param pos DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      * @throws UnsupportedOperationException DOCUMENT ME!
      */
     public void removeFilter(int pos) throws SAXException {
         // FIXME
         throw new UnsupportedOperationException();
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.EntityResolver.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter an external entity resolution.
      * 
      * @param publicId The entity's public identifier, or null.
      * @param systemId The entity's system identifier.
      * @return A new InputSource or null for the default.
      * @exception SAXException The client may throw an exception during
      *                processing.
      * @exception IOException The client may throw an I/O-related exception
      *                while obtaining the new InputSource.
      */
     public InputSource resolveEntity(String publicId, String systemId)
             throws SAXException, IOException {
         // FIXME ??? firstFilter or last or what?
 //        System.out.println(toString()+"try to resolveEntity="+systemId);
         if ((firstFilter != null) && isEntityResolver) {
             return ((EntityResolver) firstFilter).resolveEntity(publicId,
                     systemId);
         } else {
             return super.resolveEntity(publicId, systemId);
         }
     }
 
     /***
      * Set the content event handler.
      * 
      * @param handler The new content handler.
      */
     public void setContentHandler(ContentHandler handler) {
         //System.out.println(""+this+".setContentHandler="+handler);
         if (lastFilter != null) {
             lastFilter.setContentHandler(handler);
         }
 
         super.setContentHandler(handler);
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.ContentHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a new document locator event.
      * 
      * @param locator The document locator.
      */
     public void setDocumentLocator(Locator locator) {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).setDocumentLocator(locator);
             }
         }
 
         super.setDocumentLocator(locator);
     }
 
     /***
      * Set the DTD event handler.
      * 
      * @param handler The new DTD handler.
      */
     public void setDTDHandler(DTDHandler handler) {
         if (lastFilter != null) {
             lastFilter.setDTDHandler(handler);
         }
 
         super.setDTDHandler(handler);
     }
 
     /***
      * Set the entity resolver.
      * 
      * @param resolver The new entity resolver.
      */
     public void setEntityResolver(EntityResolver resolver) {
         // FIXME: to all???
         if (firstFilter != null) {
             firstFilter.setEntityResolver(resolver);
         }
 
         super.setEntityResolver(resolver);
     }
 
     /***
      * Set the error event handler.
      * 
      * @param handler The new error handler.
      */
     public void setErrorHandler(ErrorHandler handler) {
         if (lastFilter != null) {
             lastFilter.setErrorHandler(handler);
         }
 
         super.setErrorHandler(handler);
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.XMLReader.
     ////////////////////////////////////////////////////////////////////
     public void setFeature(String name, boolean value)
             throws SAXNotRecognizedException, SAXNotSupportedException {
         // FIXME: setFeature to all filters or the 1st only?
         if (firstFilter != null) {
             firstFilter.setFeature(name, value);
         }
 
         super.setFeature(name, value);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param pos DOCUMENT ME!
      * @param f DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      * @throws UnsupportedOperationException DOCUMENT ME!
      */
     public void setFilter(int pos, XMLFilter f) throws SAXException {
         // FIXME
         throw new UnsupportedOperationException();
     }
 
     ////////////////////////////////////////////////////////////////////
     // Internal methods.
     ////////////////////////////////////////////////////////////////////
     public void setLexicalHandler(LexicalHandler handler) {
         //System.out.println(""+this+".setContentHandler="+handler);
         super.setLexicalHandler(handler);
 
         if ((lastFilter != null) && lastFilter instanceof LexicalHandler) {
             try {
                 //System.out.println(" *** DMF.setLexicalHandler to "+handler);
                 lastFilter.setProperty(
                         "http://xml.org/sax/properties/lexical-handler",
                         handler);
             } catch (SAXException se) {
                 se.printStackTrace();
             }
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param p DOCUMENT ME!
      * @throws UnsupportedOperationException DOCUMENT ME!
      */
     public void setOutputProperties(Properties p) {
         throw new UnsupportedOperationException(
                 "Cannot setOutputProperties on " + this);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param l DOCUMENT ME!
      */
     public void setOutputPropertiesListener(HasOutputProperties l) {
         outputPropertiesListener = l;
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of net.sf.tomp.general.Parametrized.
     ////////////////////////////////////////////////////////////////////
     public void setParameter(String k, Object v) {
         //System.out.println("Setting param "+k+"="+v);
         int fc = getFilterCount();
         for(int i = 0; i < fc; i++) {
             setParameterToFilter(k, v, getFilter(i));
         }
     }
 
     protected void setParameterToFilter(String k, Object v, XMLFilter filter) {
         if(filter instanceof Parametrized) {
             Parametrized pf = (Parametrized)filter;
 //            if(filter instanceof Identifiable) {
 //                Identifiable fi = (Identifiable)pf;
 //                if(k.startsWith(fi.getId()+":")) {
 //                    pf.setParameter(k, v);
 //                }
 //            } else {
 //            System.out.println("DMF Setting param "+k+"="+v+ " to "+filter);
                 pf.setParameter(k, v);
 //            }
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.XMLFilter.
     ////////////////////////////////////////////////////////////////////
     public void setParent(XMLReader parent) {
         super.setParent(parent);
 
         //System.out.println(" ***DynamicMultiFilter:"+this+"
         // setParent="+parent+"... ");
         if (firstFilter != null) {
             connectHandlers(parent, firstFilter);
 
             //firstFilter.setParent(parent);
             //System.out.println("... also to firstFilter="+firstFilter);
         }
     }
 
     /***
      * Filter a skipped entity event.
      * 
      * @param name The name of the skipped entity.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void skippedEntity(String name) throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).skippedEntity(name);
             }
         } else {
             super.skippedEntity(name);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @throws SAXException DOCUMENT ME!
      */
     public void startCDATA() throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).startCDATA();
             }
         } else {
             super.startCDATA();
         }
     }
 
     /***
      * Filter a start document event.
      * 
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startDocument() throws SAXException {
         //System.out.println(""+this+".startDocument");
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).startDocument();
             }
         } else {
             super.startDocument();
         }
 
         if (outputPropertiesListener != null) {
             outputPropertiesListener.setOutputProperties(getOutputProperties());
         }
     }
 
     // No-op methods to satisfy lexical handler interface
 
     /***
      * Filter a start element event.
      * 
      * @param uri The element's Namespace URI, or the empty string.
      * @param localName The element's local name, or the empty string.
      * @param qName The element's qualified (prefixed) name, or the empty
      *            string.
      * @param atts The element's attributes.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startElement(String uri, String localName, String qName,
             Attributes atts) throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).startElement(uri, localName,
                         qName, atts);
             }
         } else {
             super.startElement(uri, localName, qName, atts);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param name DOCUMENT ME!
      * @throws SAXException DOCUMENT ME!
      */
     public void startEntity(String name) throws SAXException {
         if (firstFilter != null) {
             if (isLexicalHandler) {
                 ((LexicalHandler) firstFilter).startEntity(name);
             }
         } else {
             super.startEntity(name);
         }
     }
 
     /***
      * Filter a start Namespace prefix mapping event.
      * 
      * @param prefix The Namespace prefix.
      * @param uri The Namespace URI.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void startPrefixMapping(String prefix, String uri)
             throws SAXException {
         if (firstFilter != null) {
             if (isContentHandler) {
                 ((ContentHandler) firstFilter).startPrefixMapping(prefix, uri);
             }
         } else {
             super.startPrefixMapping(prefix, uri);
         }
     }
 
     /***
      * Filter an unparsed entity declaration event.
      * 
      * @param name The entity name.
      * @param publicId The entity's public identifier, or null.
      * @param systemId The entity's system identifier, or null.
      * @param notationName The name of the associated notation.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void unparsedEntityDecl(String name, String publicId,
             String systemId, String notationName) throws SAXException {
         if (firstFilter != null) {
             if (isDTDHandler) {
                 ((DTDHandler) firstFilter).unparsedEntityDecl(name, publicId,
                         systemId, notationName);
             }
         } else {
             super.unparsedEntityDecl(name, publicId, systemId, notationName);
         }
     }
 
     ////////////////////////////////////////////////////////////////////
     // Implementation of org.xml.sax.ErrorHandler.
     ////////////////////////////////////////////////////////////////////
 
     /***
      * Filter a warning event.
      * 
      * @param e The warning as an exception.
      * @exception SAXException The client may throw an exception during
      *                processing.
      */
     public void warning(SAXParseException e) throws SAXException {
         if (firstFilter != null) {
             if (isErrorHandler) {
                 ((ErrorHandler) firstFilter).warning(e);
             }
         } else {
             super.warning(e);
         }
     }
 }
 
 /*
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with the
  * License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  * the specific language governing rights and limitations under the License. The
  * Original Code is: all this file. The Initial Developer of the Original Code
  * is: Tomas Pitner, Masaryk University in Brno, Czech Republic. Contributor(s):
  */