Java > Open Source Codes > org > apache > xml > serializer > ToHTMLSAXHandler


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 /*
17  * $Id: ToHTMLSAXHandler.java,v 1.8 2004/02/17 04:18:19 minchau Exp $
18  */
19
20 package org.apache.xml.serializer;
21
22 import java.io.IOException ;
23 import java.io.OutputStream ;
24 import java.io.Writer ;
25 import java.util.Properties ;
26
27 import javax.xml.transform.Result ;
28
29 import org.w3c.dom.Node ;
30 import org.xml.sax.Attributes ;
31 import org.xml.sax.ContentHandler ;
32 import org.xml.sax.Locator ;
33 import org.xml.sax.SAXException ;
34 import org.xml.sax.ext.LexicalHandler ;
35
36 /**
37  * This class accepts SAX-like calls, then sends true SAX calls to a
38  * wrapped SAX handler. There is optimization done knowing that the ultimate
39  * output is HTML.
40  * @author Santiago Pericas-Geertsen
41  * @author G. Todd Miller
42  */
43 public class ToHTMLSAXHandler extends ToSAXHandler
44 {
45
46     /**
47      * Keeps track of whether output escaping is currently enabled
48      */
49     protected boolean m_escapeSetting = false;
50
51     /**
52      * Returns null.
53      * @return null
54      * @see org.apache.xml.serializer.Serializer#getOutputFormat()
55      */
56     public Properties getOutputFormat()
57     {
58         return null;
59     }
60
61     /**
62      * Reurns null
63      * @return null
64      * @see org.apache.xml.serializer.Serializer#getOutputStream()
65      */
66     public OutputStream getOutputStream()
67     {
68         return null;
69     }
70
71     /**
72      * Returns null
73      * @return null
74      * @see org.apache.xml.serializer.Serializer#getWriter()
75      */
76     public Writer getWriter()
77     {
78         return null;
79     }
80
81     /**
82      * Does nothing.
83      *
84      */
85     public void indent(int n) throws SAXException
86     {
87     }
88
89     /**
90      * Does nothing.
91      * @see org.apache.xml.serializer.DOMSerializer#serialize(Node)
92      */
93     public void serialize(Node node) throws IOException
94     {
95         return;
96     }
97
98     /**
99      * Turns special character escaping on/off.
100      *
101      *
102      * @param excape true if escaping is to be set on.
103      *
104      * @see org.apache.xml.serializer.SerializationHandler#setEscaping(boolean)
105      */
106     public boolean setEscaping(boolean escape) throws SAXException
107     {
108         boolean oldEscapeSetting = m_escapeSetting;
109         m_escapeSetting = escape;
110
111         if (escape) {
112             processingInstruction(Result.PI_ENABLE_OUTPUT_ESCAPING, "");
113         } else {
114             processingInstruction(Result.PI_DISABLE_OUTPUT_ESCAPING, "");
115         }
116
117         return oldEscapeSetting;
118     }
119
120     /**
121      * Does nothing
122      * @param indent the number of spaces to indent per indentation level
123      * (ignored)
124      * @see org.apache.xml.serializer.SerializationHandler#setIndent(boolean)
125      */
126     public void setIndent(boolean indent)
127     {
128     }
129
130     /**
131      * Does nothing.
132      * @param format this parameter is not used
133      * @see org.apache.xml.serializer.Serializer#setOutputFormat(Properties)
134      */
135     public void setOutputFormat(Properties format)
136     {
137     }
138
139     /**
140      * Does nothing.
141      * @param output this parameter is ignored
142      * @see org.apache.xml.serializer.Serializer#setOutputStream(OutputStream)
143      */
144     public void setOutputStream(OutputStream output)
145     {
146     }
147
148
149     /**
150      * Does nothing.
151      * @param writer this parameter is ignored.
152      * @see org.apache.xml.serializer.Serializer#setWriter(Writer)
153      */
154     public void setWriter(Writer writer)
155     {
156     }
157
158     /**
159      * @see org.xml.sax.ext.DeclHandler#attributeDecl(String, String, String, String, String)
160      */
161     /**
162      * Does nothing.
163      *
164      * @param eName this parameter is ignored
165      * @param aName this parameter is ignored
166      * @param type this parameter is ignored
167      * @param valueDefault this parameter is ignored
168      * @param value this parameter is ignored
169      * @see org.xml.sax.ext.DeclHandler#attributeDecl(String, String, String,String,String)
170      */
171     public void attributeDecl(
172         String eName,
173         String aName,
174         String type,
175         String valueDefault,
176         String value)
177         throws SAXException
178     {
179     }
180
181
182     /**
183      * Does nothing.
184      * @see org.xml.sax.ext.DeclHandler#elementDecl(String, String)
185      */
186     public void elementDecl(String name, String model) throws SAXException
187     {
188         return;
189     }
190
191     /**
192      * @see org.xml.sax.ext.DeclHandler#externalEntityDecl(String, String, String)
193      */
194     public void externalEntityDecl(String arg0, String arg1, String arg2)
195         throws SAXException
196     {
197     }
198
199     /**
200      * Does nothing.
201      *
202      * @see org.xml.sax.DTDHandler#unparsedEntityDecl
203      */
204     public void internalEntityDecl(String name, String value)
205         throws SAXException
206     {
207     }
208
209     /**
210      * Receive notification of the end of an element.
211      *
212      * <p>The SAX parser will invoke this method at the end of every
213      * element in the XML document; there will be a corresponding
214      * startElement() event for every endElement() event (even when the
215      * element is empty).</p>
216      *
217      * <p>If the element name has a namespace prefix, the prefix will
218      * still be attached to the name.</p>
219      *
220      *
221      * @param namespaceURI The Namespace URI, or the empty string if the
222      * element has no Namespace URI or if Namespace
223      * processing is not being performed.
224      * @param localName The local name (without prefix), or the
225      * empty string if Namespace processing is not being
226      * performed.
227      * @param name The qualified name (with prefix), or the
228      * empty string if qualified names are not available.
229      * @param name The element type name
230      * @throws org.xml.sax.SAXException Any SAX exception, possibly
231      * wrapping another exception.
232      * @see org.xml.sax.ContentHandler#endElement(String, String, String)
233      */
234     public void endElement(String uri, String localName, String qName)
235         throws SAXException
236     {
237         flushPending();
238         m_saxHandler.endElement(uri, localName, qName);
239         
240         // time to fire off endElement event
241 if (m_tracer != null)
242             super.fireEndElem(qName);
243     }
244
245     /**
246      * Does nothing.
247      */
248     public void endPrefixMapping(String prefix) throws SAXException
249     {
250     }
251
252     /**
253      * Does nothing.
254      * @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
255      */
256     public void ignorableWhitespace(char[] ch, int start, int length)
257         throws SAXException
258     {
259     }
260     
261     /**
262      * Receive notification of a processing instruction.
263      *
264      * <p>The Parser will invoke this method once for each processing
265      * instruction found: note that processing instructions may occur
266      * before or after the main document element.</p>
267      *
268      * <p>A SAX parser should never report an XML declaration (XML 1.0,
269      * section 2.8) or a text declaration (XML 1.0, section 4.3.1)
270      * using this method.</p>
271      *
272      * @param target The processing instruction target.
273      * @param data The processing instruction data, or null if
274      * none was supplied.
275      * @throws org.xml.sax.SAXException Any SAX exception, possibly
276      * wrapping another exception.
277      *
278      * @throws org.xml.sax.SAXException
279      * @see org.xml.sax.ContentHandler#processingInstruction(String, String)
280      */
281     public void processingInstruction(String arg0, String arg1)
282         throws SAXException
283     {
284         flushPending();
285         m_saxHandler.processingInstruction(arg0,arg1);
286
287         // time to fire off processing instruction event
288
289         if (m_tracer != null)
290             super.fireEscapingEvent(arg0,arg1);
291     }
292
293     /**
294      * Does nothing.
295      * @see org.xml.sax.ContentHandler#setDocumentLocator(Locator)
296      */
297     public void setDocumentLocator(Locator arg0)
298     {
299         // do nothing
300 }
301
302     /**
303      * Does nothing.
304      * @see org.xml.sax.ContentHandler#skippedEntity(String)
305      */
306     public void skippedEntity(String arg0) throws SAXException
307     {
308     }
309
310     /**
311      * Receive notification of the beginning of an element, although this is a
312      * SAX method additional namespace or attribute information can occur before
313      * or after this call, that is associated with this element.
314      *
315      *
316      * @param namespaceURI The Namespace URI, or the empty string if the
317      * element has no Namespace URI or if Namespace
318      * processing is not being performed.
319      * @param localName The local name (without prefix), or the
320      * empty string if Namespace processing is not being
321      * performed.
322      * @param qName The elements name.
323      * @param atts The attributes attached to the element, if any.
324      * @throws org.xml.sax.SAXException Any SAX exception, possibly
325      * wrapping another exception.
326      * @see org.xml.sax.ContentHandler#startElement
327      * @see org.xml.sax.ContentHandler#endElement
328      * @see org.xml.sax.AttributeList
329      *
330      * @throws org.xml.sax.SAXException
331      *
332      * @see org.xml.sax.ContentHandler#startElement(String, String, String, Attributes)
333      */
334     public void startElement(
335         String namespaceURI,
336         String localName,
337         String qName,
338         Attributes atts)
339         throws SAXException
340     {
341         flushPending();
342         super.startElement(namespaceURI, localName, qName, atts);
343         m_saxHandler.startElement(namespaceURI, localName, qName, atts);
344         m_elemContext.m_startTagOpen = false;
345     }
346
347     /**
348      * Receive notification of a comment anywhere in the document. This callback
349      * will be used for comments inside or outside the document element.
350      * @param ch An array holding the characters in the comment.
351      * @param start The starting position in the array.
352      * @param length The number of characters to use from the array.
353      * @throws org.xml.sax.SAXException The application may raise an exception.
354      *
355      * @see org.xml.sax.ext.LexicalHandler#comment(char[], int, int)
356      */
357     public void comment(char[] ch, int start, int length) throws SAXException
358     {
359         flushPending();
360         m_lexHandler.comment(ch, start, length);
361
362         // time to fire off comment event
363 if (m_tracer != null)
364             super.fireCommentEvent(ch, start, length);
365         return;
366     }
367
368     /**
369      * Does nothing.
370      * @see org.xml.sax.ext.LexicalHandler#endCDATA()
371      */
372     public void endCDATA() throws SAXException
373     {
374         return;
375     }
376
377     /**
378      * Does nothing.
379      * @see org.xml.sax.ext.LexicalHandler#endDTD()
380      */
381     public void endDTD() throws SAXException
382     {
383     }
384
385     /**
386      * Does nothing.
387      * @see org.xml.sax.ext.LexicalHandler#startCDATA()
388      */
389     public void startCDATA() throws SAXException
390     {
391     }
392
393     /**
394      * Does nothing.
395      * @see org.xml.sax.ext.LexicalHandler#startEntity(String)
396      */
397     public void startEntity(String arg0) throws SAXException
398     {
399     }
400
401     /**
402      * Receive notification of the end of a document.
403      *
404      * <p>The SAX parser will invoke this method only once, and it will
405      * be the last method invoked during the parse. The parser shall
406      * not invoke this method until it has either abandoned parsing
407      * (because of an unrecoverable error) or reached the end of
408      * input.</p>
409      *
410      * @throws org.xml.sax.SAXException Any SAX exception, possibly
411      * wrapping another exception.
412      *
413      * @throws org.xml.sax.SAXException
414      *
415      *
416      */
417     public void endDocument() throws SAXException
418     {
419         flushPending();
420
421         // Close output document
422 m_saxHandler.endDocument();
423
424         if (m_tracer != null)
425             super.fireEndDoc();
426     }
427
428     /**
429      * This method is called when all the data needed for a call to the
430      * SAX handler's startElement() method has been gathered.
431      */
432     protected void closeStartTag() throws SAXException
433     {
434
435         m_elemContext.m_startTagOpen = false;
436
437         // Now is time to send the startElement event
438 m_saxHandler.startElement(
439             EMPTYSTRING,
440             m_elemContext.m_elementName,
441             m_elemContext.m_elementName,
442             m_attributes);
443         m_attributes.clear();
444
445     }
446
447     /**
448      * Do nothing.
449      * @see org.apache.xml.serializer.SerializationHandler#close()
450      */
451     public void close()
452     {
453         return;
454     }
455
456     /**
457      * Receive notification of character data.
458      *
459      * @param chars The string of characters to process.
460      *
461      * @throws org.xml.sax.SAXException
462      *
463      * @see org.apache.xml.serializer.ExtendedContentHandler#characters(String)
464      */
465     public void characters(final String chars) throws SAXException
466     {
467         final int length = chars.length();
468         if (length > m_charsBuff.length)
469         {
470             m_charsBuff = new char[length * 2 + 1];
471         }
472         chars.getChars(0, length, m_charsBuff, 0);
473         this.characters(m_charsBuff, 0, length);
474     }
475
476
477     /**
478      * A constructor
479      * @param handler the wrapped SAX content handler
480      * @param encoding the encoding of the output HTML document
481      */
482     public ToHTMLSAXHandler(ContentHandler handler, String encoding)
483     {
484         super(handler,encoding);
485     }
486     /**
487      * A constructor.
488      * @param handler the wrapped SAX content handler
489      * @param lex the wrapped lexical handler
490      * @param encoding the encoding of the output HTML document
491      */
492     public ToHTMLSAXHandler(
493         ContentHandler handler,
494         LexicalHandler lex,
495         String encoding)
496     {
497         super(handler,lex,encoding);
498     }
499
500     /**
501      * An element starts, but attributes are not fully known yet.
502      *
503      * @param elementNamespaceURI the URI of the namespace of the element
504      * (optional)
505      * @param elementLocalName the element name, but without prefix
506      * (optional)
507      * @param elementName the element name, with prefix, if any (required)
508      *
509      * @see org.apache.xml.serializer.ExtendedContentHandler#startElement(String)
510      */
511     public void startElement(
512         String elementNamespaceURI,
513         String elementLocalName,
514         String elementName) throws SAXException
515     {
516
517         super.startElement(elementNamespaceURI, elementLocalName, elementName);
518
519         flushPending();
520
521         // Handle document type declaration (for first element only)
522 if (m_lexHandler != null)
523         {
524             String doctypeSystem = getDoctypeSystem();
525             String doctypePublic = getDoctypePublic();
526             if ((doctypeSystem != null) || (doctypePublic != null))
527                 m_lexHandler.startDTD(
528                     elementName,
529                     doctypePublic,
530                     doctypeSystem);
531             m_lexHandler = null;
532         }
533         m_elemContext = m_elemContext.push(elementNamespaceURI, elementLocalName, elementName);
534     }
535     /**
536      * An element starts, but attributes are not fully known yet.
537      *
538      * @param elementName the element name, with prefix, if any
539      *
540      * @see org.apache.xml.serializer.ExtendedContentHandler#startElement(String)
541      */
542     public void startElement(String elementName) throws SAXException
543     {
544         this.startElement(null,null, elementName);
545     }
546     
547     /**
548      * Receive notification of the end of an element.
549      * @param elementName The element type name
550      * @throws org.xml.sax.SAXException Any SAX exception, possibly
551      * wrapping another exception.
552      *
553      * @see org.apache.xml.serializer.ExtendedContentHandler#endElement(String)
554      */
555     public void endElement(String elementName) throws SAXException
556     {
557         flushPending();
558         m_saxHandler.endElement(EMPTYSTRING, elementName, elementName);
559
560         // time to fire off endElement event
561 if (m_tracer != null)
562             super.fireEndElem(elementName);
563     }
564
565     /**
566      * Receive notification of character data.
567      *
568      * <p>The Parser will call this method to report each chunk of
569      * character data. SAX parsers may return all contiguous character
570      * data in a single chunk, or they may split it into several
571      * chunks; however, all of the characters in any single event
572      * must come from the same external entity, so that the Locator
573      * provides useful information.</p>
574      *
575      * <p>The application must not attempt to read from the array
576      * outside of the specified range.</p>
577      *
578      * <p>Note that some parsers will report whitespace using the
579      * ignorableWhitespace() method rather than this one (validating
580      * parsers must do so).</p>
581      *
582      * @param ch The characters from the XML document.
583      * @param off The start position in the array.
584      * @param len The number of characters to read from the array.
585      * @throws org.xml.sax.SAXException Any SAX exception, possibly
586      * wrapping another exception.
587      * @see #ignorableWhitespace
588      * @see org.xml.sax.Locator
589      *
590      * @throws org.xml.sax.SAXException
591      *
592      * @see org.xml.sax.ContentHandler#characters(char[], int, int)
593      */
594     public void characters(char[] ch, int off, int len) throws SAXException
595     {
596
597         flushPending();
598         m_saxHandler.characters(ch, off, len);
599
600         // time to fire off characters event
601 if (m_tracer != null)
602             super.fireCharEvent(ch, off, len);
603     }
604
605     /**
606      * This method flushes any pending events, which can be startDocument()
607      * closing the opening tag of an element, or closing an open CDATA section.
608      */
609     public void flushPending() throws SAXException
610     {
611         if (m_needToCallStartDocument)
612         {
613             startDocumentInternal();
614             m_needToCallStartDocument = false;
615         }
616         // Close any open element
617 if (m_elemContext.m_startTagOpen)
618         {
619             closeStartTag();
620             m_elemContext.m_startTagOpen = false;
621         }
622     }
623     /**
624      * Handle a prefix/uri mapping, which is associated with a startElement()
625      * that is soon to follow. Need to close any open start tag to make
626      * sure than any name space attributes due to this event are associated wih
627      * the up comming element, not the current one.
628      * @see org.apache.xml.serializer.ExtendedContentHandler#startPrefixMapping
629      *
630      * @param prefix The Namespace prefix being declared.
631      * @param uri The Namespace URI the prefix is mapped to.
632      * @param shouldFlush true if any open tags need to be closed first, this
633      * will impact which element the mapping applies to (open parent, or its up
634      * comming child)
635      * @return returns true if the call made a change to the current
636      * namespace information, false if it did not change anything, e.g. if the
637      * prefix/namespace mapping was already in scope from before.
638      *
639      * @throws org.xml.sax.SAXException The client may throw
640      * an exception during processing.
641      */
642     public boolean startPrefixMapping(
643         String prefix,
644         String uri,
645         boolean shouldFlush)
646         throws SAXException
647     {
648         // no namespace support for HTML
649 if (shouldFlush)
650             flushPending();
651         m_saxHandler.startPrefixMapping(prefix,uri);
652         return false;
653     }
654
655     /**
656      * Begin the scope of a prefix-URI Namespace mapping
657      * just before another element is about to start.
658      * This call will close any open tags so that the prefix mapping
659      * will not apply to the current element, but the up comming child.
660      *
661      * @see org.xml.sax.ContentHandler#startPrefixMapping
662      *
663      * @param prefix The Namespace prefix being declared.
664      * @param uri The Namespace URI the prefix is mapped to.
665      *
666      * @throws org.xml.sax.SAXException The client may throw
667      * an exception during processing.
668      *
669      */
670     public void startPrefixMapping(String prefix, String uri)
671         throws org.xml.sax.SAXException
672     {
673         startPrefixMapping(prefix,uri,true);
674     }
675
676     /**
677      * This method is used when a prefix/uri namespace mapping
678      * is indicated after the element was started with a
679      * startElement() and before and endElement().
680      * startPrefixMapping(prefix,uri) would be used before the
681      * startElement() call.
682      * @param prefix the prefix associated with the given URI.
683      * @param uri the URI of the namespace
684      *
685      * @see org.apache.xml.serializer.ExtendedContentHandler#namespaceAfterStartElement(String, String)
686      */
687     public void namespaceAfterStartElement(
688         final String prefix,
689         final String uri)
690         throws SAXException
691     {
692         // hack for XSLTC with finding URI for default namespace
693 if (m_elemContext.m_elementURI == null)
694         {
695             String prefix1 = getPrefixPart(m_elemContext.m_elementName);
696             if (prefix1 == null && EMPTYSTRING.equals(prefix))
697             {
698                 // the elements URI is not known yet, and it
699 // doesn't have a prefix, and we are currently
700 // setting the uri for prefix "", so we have
701 // the uri for the element... lets remember it
702 m_elemContext.m_elementURI = uri;
703             }
704         }
705         startPrefixMapping(prefix,uri,false);
706     }
707     
708     /**
709      * Try's to reset the super class and reset this class for
710      * re-use, so that you don't need to create a new serializer
711      * (mostly for performance reasons).
712      *
713      * @return true if the class was successfuly reset.
714      * @see org.apache.xml.serializer.Serializer#reset()
715      */
716     public boolean reset()
717     {
718         boolean wasReset = false;
719         if (super.reset())
720         {
721             resetToHTMLSAXHandler();
722             wasReset = true;
723         }
724         return wasReset;
725     }
726     
727     /**
728      * Reset all of the fields owned by ToHTMLSAXHandler class
729      *
730      */
731     private void resetToHTMLSAXHandler()
732     {
733         this.m_escapeSetting = false;
734     }
735 }
736

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags