Doc generation: add a method HTMLDocbookTagConverter::getGenerationType() to know...
[scilab.git] / scilab / modules / helptools / src / java / org / scilab / modules / helptools / HTMLDocbookTagConverter.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - Calixte DENIZET
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 package org.scilab.modules.helptools;
14
15 import java.io.File;
16 import java.io.IOException;
17 import java.net.URI;
18 import java.net.URISyntaxException;
19 import java.util.Date;
20 import java.util.Map;
21 import java.util.Stack;
22 import java.util.regex.Pattern;
23
24 import org.xml.sax.SAXException;
25
26 import org.scilab.modules.helptools.image.ImageConverter;
27 import org.scilab.modules.helptools.image.LaTeXImageConverter;
28 import org.scilab.modules.helptools.image.MathMLImageConverter;
29 import org.scilab.modules.helptools.image.ScilabImageConverter;
30 import org.scilab.modules.helptools.image.SVGImageConverter;
31 import org.scilab.modules.helptools.scilab.ScilabLexer;
32 import org.scilab.modules.helptools.scilab.HTMLScilabCodeHandler;
33 import org.scilab.modules.helptools.scilab.AbstractScilabCodeHandler;
34 import org.scilab.modules.helptools.XML.XMLLexer;
35 import org.scilab.modules.helptools.XML.HTMLXMLCodeHandler;
36 import org.scilab.modules.helptools.c.CLexer;
37 import org.scilab.modules.helptools.c.HTMLCCodeHandler;
38 import org.scilab.modules.helptools.java.JavaLexer;
39 import org.scilab.modules.localization.Messages;
40
41 /**
42  * Class to convert DocBook to HTML
43  * @author Calixte DENIZET
44  */
45 public class HTMLDocbookTagConverter extends DocbookTagConverter implements TemplateFiller {
46
47     public static enum GenerationType { WEB, JAVAHELP, CHM, HTML };
48
49     private static final String SCILAB_URI = "http://www.scilab.org";
50     private static final String LATEXBASENAME = "Equation_LaTeX_";
51     private static final String VERSION = Messages.gettext("Version");
52     private static final String DESCRIPTION = Messages.gettext("Description");
53
54     private StringBuilder buffer = new StringBuilder(8192);
55     private int latexCompt;
56     private String imageDir;
57     private String outName;
58     private String urlBase;
59     private boolean linkToTheWeb;
60     private boolean hasExamples;
61     private int warnings;
62     private int nbFiles;
63
64     protected Map<String, String> mapId;
65     protected Map<String, String> tocitem;
66     protected HTMLDocbookLinkResolver.TreeId tree;
67     protected Map<String, HTMLDocbookLinkResolver.TreeId> mapTreeId;
68     protected Map<String, String> mapIdPurpose;
69
70     protected TemplateHandler templateHandler;
71
72     protected ScilabLexer scilabLexer;
73     protected XMLLexer xmlLexer;
74     protected CLexer cLexer;
75     protected JavaLexer javaLexer;
76
77     protected String bookTitle = "";
78     protected String partTitle = "";
79     protected String chapterTitle = "";
80     protected String sectionTitle = "";
81     protected String fileSubtitle = "";
82
83     protected String refpurpose = "";
84     protected String refname = "";
85     protected String version;
86     protected String appendToProgramListing;
87     protected String appendForExecToProgramListing;
88     protected String prependToProgramListing;
89     protected String currentId;
90     protected String indexFilename = "index" /*UUID.randomUUID().toString()*/ + ".html";
91
92     protected boolean isToolbox;
93     protected final GenerationType type;
94
95     /**
96      * Constructor
97      * @param inName the name of the input stream
98      * @param outName the output directory
99      * @param primConf the file containing the primitives of Scilab
100      * @param macroConf the file containing the macros of Scilab
101      * @param template the template to use
102      * @param version the version
103      * @param imageDir the image directory (relative to outName)
104      * @param isToolbox is true when compile a toolbox' help
105      * @param urlBase the base url for external link
106      */
107     public HTMLDocbookTagConverter(String inName, String outName, String[] primConf, String[] macroConf, String template, String version, String imageDir, boolean isToolbox, String urlBase, GenerationType type) throws IOException, SAXException {
108         super(inName);
109
110         this.version = version;
111         this.imageDir = imageDir;
112         this.outName = outName + File.separator;
113         HTMLDocbookLinkResolver resolver = new HTMLDocbookLinkResolver(inName);
114         mapId = resolver.getMapId();
115         tocitem = resolver.getToc();
116         tree = resolver.getTree();
117         mapTreeId = resolver.getMapTreeId();
118         mapIdPurpose = resolver.getMapIdPurpose();
119         scilabLexer = new ScilabLexer(primConf, macroConf);
120         this.urlBase = urlBase;
121         this.linkToTheWeb = urlBase != null && !urlBase.equals("scilab://");
122         this.isToolbox = isToolbox;
123         this.type = type;
124         if (isToolbox) {// we generate a toolbox's help
125             HTMLScilabCodeHandler.setLinkWriter(new AbstractScilabCodeHandler.LinkWriter() {
126                     public String getLink(String id) {
127                         if (id.length() > 0 && id.charAt(0) == '%') {
128                             id = id.replace("%", "percent");
129                         }
130                         String link = mapId.get(id);
131                         if (link == null) {
132                             return HTMLDocbookTagConverter.this.urlBase + id;
133                         } else {
134                             return link;
135                         }
136                     }
137                 });
138         } else {// we generate Scilab's help
139             HTMLScilabCodeHandler.setLinkWriter(new AbstractScilabCodeHandler.LinkWriter() {
140                     public String getLink(String id) {
141                         if (id.length() > 0 && id.charAt(0) == '%') {
142                             id = id.replace("%", "percent");
143                         }
144                         return mapId.get(id);
145                     }
146                 });
147         }
148
149         xmlLexer = new XMLLexer();
150         cLexer = new CLexer();
151         javaLexer = new JavaLexer();
152         File tpl = new File(template);
153         templateHandler = new TemplateHandler(this, tpl);
154         ImageConverter.registerExternalImageConverter(LaTeXImageConverter.getInstance(type));
155         ImageConverter.registerExternalImageConverter(MathMLImageConverter.getInstance(type));
156         ImageConverter.registerExternalImageConverter(SVGImageConverter.getInstance(type));
157         ImageConverter.registerExternalImageConverter(ScilabImageConverter.getInstance(type));
158     }
159
160     /**
161      * Get the type of the generation
162      * @return the generation type
163      */
164     public final GenerationType getGenerationType() {
165         return type;
166     }
167
168     /**
169      * @return the buffer used
170      */
171     public StringBuilder getBuffer() {
172         return buffer;
173     }
174
175     /**
176      * @param tag the tag name
177      * @param contents the contents to enclose between opening and closing tags
178      */
179     public String encloseContents(final String tag, final String contents) {
180         buffer.setLength(0);
181         buffer.append("<");
182         buffer.append(tag);
183         buffer.append(">");
184         if (contents != null) {
185             buffer.append(contents);
186         }
187         buffer.append("</");
188         buffer.append(tag);
189         buffer.append(">");
190
191         return buffer.toString();
192     }
193
194     /**
195      * @param tag the tag name
196      * @param attrs the attributes {attr1, value1, attr2, value2, ...}
197      * @param contents the contents to enclose between opening and closing tags
198      */
199     public String encloseContents(final String tag, final String[] attrs, final String contents) {
200         buffer.setLength(0);
201         buffer.append("<");
202         buffer.append(tag);
203         if (attrs != null) {
204             for (int i = 0; i < attrs.length; i += 2) {
205                 buffer.append(" ");
206                 buffer.append(attrs[i]);
207                 buffer.append("=\"");
208                 buffer.append(attrs[i + 1]);
209                 buffer.append("\"");
210             }
211         }
212
213         buffer.append(">");
214         if (contents != null) {
215             buffer.append(contents);
216         }
217         buffer.append("</");
218         buffer.append(tag);
219         buffer.append(">");
220
221         return buffer.toString();
222     }
223
224     /**
225      * @param tag the tag name
226      * @param clazz the css class name
227      * @param contents the contents to enclose between opening and closing tags
228      */
229     public String encloseContents(final String tag, final String clazz, final String contents) {
230         buffer.setLength(0);
231         buffer.append("<");
232         buffer.append(tag);
233         buffer.append(" class=\"");
234         buffer.append(clazz);
235         buffer.append("\">");
236         if (contents != null) {
237             buffer.append(contents);
238         }
239         buffer.append("</");
240         buffer.append(tag);
241         buffer.append(">");
242
243         return buffer.toString();
244     }
245
246     /**
247      * {@inheritDoc}
248      */
249     public boolean isEscapable(final String tagName, final String uri) {
250         return !"latex".equals(tagName) && !"screen".equals(tagName) && !"programlisting".equals(tagName) && !"code".equals(tagName) && !"synopsis".equals(tagName) && !(uri.equals(SCILAB_URI) && tagName.equals("image"));
251     }
252
253     /**
254      * {@inheritDoc}
255      */
256     public boolean isTrimable(final String tagName) {
257         return !"screen".equals(tagName) && !"programlisting".equals(tagName) && !"code".equals(tagName) && !"synopsis".equals(tagName);
258     }
259
260     /**
261      * @param fileName the file to create
262      * @param subtitle the subtitle of the file
263      * @param contents the contents of the file
264      */
265     public void createHTMLFile(final String id, final String fileName, final String subtitle, final String contents) {
266         if (!hasError) {
267             fileSubtitle = subtitle;
268             nbFiles++;
269             templateHandler.generateFileFromTemplate(outName + fileName, id, contents);
270         }
271     }
272
273     /**
274      * {@inheritDoc}
275      */
276     public String makeTitle(final String id) {
277         if (refname.length() > 0) {
278             return tocitem.get(id);
279         }
280
281         return "";
282     }
283
284     /**
285      * {@inheritDoc}
286      */
287     public String makeSubtitle(final String id) {
288         return fileSubtitle;
289     }
290
291     /**
292      * {@inheritDoc}
293      */
294     public String makePrevious(final String id) {
295         buffer.setLength(0);
296         buffer.append("<span class=\"previous\">");
297         HTMLDocbookLinkResolver.TreeId leaf = mapTreeId.get(id);
298         if (leaf == null) {
299             return "";
300         }
301         HTMLDocbookLinkResolver.TreeId prev = leaf.getPrevious();
302         if (prev.parent != null) {
303             buffer.append("<a href=\"");
304             buffer.append(mapId.get(prev.id));
305             buffer.append("\">&lt;&lt; ");
306             buffer.append(tocitem.get(prev.id));
307             buffer.append("</a></span>\n");
308
309             return buffer.toString();
310         }
311
312         return "";
313     }
314
315     /**
316      * {@inheritDoc}
317      */
318     public String makePath(final String id) {
319         buffer.setLength(0);
320         buffer.append("<span class=\"path\">");
321         HTMLDocbookLinkResolver.TreeId leaf = mapTreeId.get(id);
322         if (leaf == null) {
323             return "";
324         }
325         String str = tocitem.get(id);
326         leaf = leaf.parent;
327         while (leaf != null && !leaf.isRoot()) {
328             str = "<a href=\"" + mapId.get(leaf.id) + "\">" + tocitem.get(leaf.id) + "</a> &gt; " + str;
329             leaf = leaf.parent;
330         }
331
332         str = "<a href=\"" + indexFilename  + "\">" + bookTitle + "</a> &gt;&gt; " + str;
333         buffer.append(str);
334         buffer.append("</span>\n");
335
336         return buffer.toString();
337     }
338
339     /**
340      * {@inheritDoc}
341      */
342     public String makeTop(final String id) {
343         buffer.setLength(0);
344         buffer.append("<span class=\"top\">");
345         HTMLDocbookLinkResolver.TreeId leaf = mapTreeId.get(id);
346         if (leaf == null) {
347             return "";
348         }
349
350         leaf = leaf.parent;
351         if (leaf != null) {
352             buffer.append("<a href=\"");
353             if (!leaf.isRoot()) {
354                 buffer.append(mapId.get(leaf.id));
355                 buffer.append("\">");
356                 buffer.append(tocitem.get(leaf.id));
357             } else {
358                 buffer.append(indexFilename);
359                 buffer.append("\">");
360                 buffer.append(bookTitle);
361             }
362             buffer.append("</a></span>\n");
363         } else {
364             return "";
365         }
366
367         return buffer.toString();
368     }
369
370     /**
371      * {@inheritDoc}
372      */
373     public String makeNext(final String id) {
374         buffer.setLength(0);
375         buffer.append("<span class=\"next\">");
376         HTMLDocbookLinkResolver.TreeId leaf = mapTreeId.get(id);
377         if (leaf == null) {
378             return "";
379         }
380         HTMLDocbookLinkResolver.TreeId next = leaf.getNext();
381         if (next != null) {
382             buffer.append("<a href=\"");
383             buffer.append(mapId.get(next.id));
384             buffer.append("\">");
385             buffer.append(tocitem.get(next.id));
386             buffer.append(" &gt;&gt;</a></span>\n");
387
388             return buffer.toString();
389         }
390
391         return "";
392     }
393
394     /**
395      * {@inheritDoc}
396      */
397     public String makeStart(final String id) {
398         buffer.setLength(0);
399         buffer.append("<span class=\"start\">");
400         buffer.append("<a href=\"");
401         buffer.append(indexFilename);
402         buffer.append("\">");
403         buffer.append(bookTitle);
404         buffer.append("</a></span>\n");
405
406         return buffer.toString();
407     }
408
409     /**
410      * {@inheritDoc}
411      */
412     public String makeTocList(final String id) {
413         buffer.setLength(0);
414         HTMLDocbookLinkResolver.TreeId leaf = mapTreeId.get(id);
415         if (leaf == null) {
416             return "";
417         }
418
419         HTMLDocbookLinkResolver.TreeId parent = leaf.parent;
420         buffer.append("<ul class=\"toc\">\n");
421         String str = "";
422         while (parent != null && !parent.isRoot()) {
423             str = "<li class=\"parent\"><a href=\"" + mapId.get(parent.id) + "\">" + tocitem.get(parent.id) + "</a></li>\n" + str;
424             parent = parent.parent;
425         }
426         buffer.append("<li class=\"root\"><a href=\"");
427         buffer.append(indexFilename);
428         buffer.append("\">");
429         buffer.append(bookTitle);
430         buffer.append("</a></li>\n");
431         buffer.append(str);
432
433         parent = leaf.parent;
434
435         for (HTMLDocbookLinkResolver.TreeId c : parent.children) {
436             if (c == leaf) {
437                 buffer.append("<li class=\"list-active\"><a href=\"");
438             } else {
439                 buffer.append("<li><a href=\"");
440             }
441             buffer.append(mapId.get(c.id));
442             buffer.append("\">");
443             buffer.append(tocitem.get(c.id));
444             buffer.append("</a></li>\n");
445         }
446         buffer.append("</ul>\n");
447
448         return buffer.toString();
449     }
450
451     /**
452      * {@inheritDoc}
453      */
454     public String makeLastModified(final String id) {
455         buffer.setLength(0);
456         try {
457             buffer.append("<span class=\"lastmodified\">");
458             buffer.append(new Date(new File(new URI(currentFileName)).lastModified()).toString());
459             buffer.append("</span>\n");
460         } catch (URISyntaxException e) {
461             e.printStackTrace();
462         }
463         return buffer.toString();
464     }
465
466     /**
467      * {@inheritDoc}
468      */
469     public String makeGenerationDate(final String id) {
470         buffer.setLength(0);
471         buffer.append("<span class=\"generationdate\">");
472         buffer.append(new Date(System.currentTimeMillis()).toString());
473         buffer.append("</span>\n");
474
475         return buffer.toString();
476     }
477
478     /**
479      * {@inheritDoc}
480      */
481     public String makeVersion(final String id) {
482         buffer.setLength(0);
483         buffer.append("<span class=\"version\">");
484         buffer.append(version);
485         buffer.append("</span>\n");
486
487         return buffer.toString();
488     }
489
490     /**
491      * Handle a refentry
492      * @param attributes the tag attributes
493      * @param contents the tag contents
494      * @return the HTML code
495      * @throws SAXEception if an error is encountered
496      */
497     public String handleRefentry(final Map<String, String> attributes, final String contents) throws SAXException {
498         String id = attributes.get("id");
499         if (id != null) {
500             currentId = id;
501         }
502         String fileName = mapId.get(currentId);
503         createHTMLFile(currentId, fileName, refpurpose, contents);
504         if (!hasExamples) {
505             warnings++;
506             //System.err.println("Warning (should be fixed): no example in " + currentFileName);
507         } else {
508             hasExamples = false;
509         }
510         String rp = encloseContents("span", "refentry-description", refpurpose);
511         String str = encloseContents("li", encloseContents("a", new String[] {"href", fileName, "class", "refentry"}, currentId) + " &#8212; " + rp);
512         refpurpose = "";
513         refname = "";
514         currentId = null;
515
516         return str;
517     }
518
519     /**
520      * Handle a section
521      * @param attributes the tag attributes
522      * @param contents the tag contents
523      * @return the HTML code
524      * @throws SAXEception if an error is encountered
525      */
526     public String handleSection(final Map<String, String> attributes, final String contents) throws SAXException {
527         String fileName = attributes.get("id") + ".html";
528         String str = encloseContents("ul", "list-refentry", contents);
529         String title = encloseContents("h3", "title-section", sectionTitle);
530         createHTMLFile(attributes.get("id"), fileName, sectionTitle, title + "\n" + str);
531
532         str = encloseContents("li", encloseContents("a", new String[] {"href", fileName, "class", "section"}, sectionTitle) + "\n" + str);
533         sectionTitle = "";
534
535         return str;
536     }
537
538     /**
539      * Handle a book
540      * @param attributes the tag attributes
541      * @param contents the tag contents
542      * @return the HTML code
543      * @throws SAXEception if an error is encountered
544      */
545     public String handleBook(final Map<String, String> attributes, final String contents) throws SAXException {
546         String str = encloseContents("ul", "list-part", contents);
547         String btitle;
548         if (bookTitle.trim().equalsIgnoreCase("Scilab")) {
549             btitle = version;
550         } else {
551             btitle = bookTitle;
552         }
553         String title = encloseContents("h3", "book-title", btitle);
554         createHTMLFile("index", indexFilename, btitle, title + "\n" + str);
555
556         if (warnings != 0) {
557             System.err.println("Total files without example: " + warnings);
558             System.err.println("Total generated html files: " + nbFiles);
559         }
560
561         return encloseContents("li", encloseContents("a", new String[] {"href", indexFilename, "class", "part"}, bookTitle) + "\n" + str);
562     }
563
564     /**
565      * Handle a part
566      * @param attributes the tag attributes
567      * @param contents the tag contents
568      * @return the HTML code
569      * @throws SAXEception if an error is encountered
570      */
571     public String handlePart(final Map<String, String> attributes, final String contents) throws SAXException {
572         String fileName = attributes.get("id") + ".html";
573         String str = encloseContents("ul", "list-chapter", contents);
574         String title = encloseContents("h3", "title-part", partTitle);
575         createHTMLFile(attributes.get("id"), fileName, partTitle, title + "\n" + str);
576
577         str = encloseContents("li", encloseContents("a", new String[] {"href", fileName, "class", "part"}, partTitle) + "\n" + str);
578         partTitle = "";
579
580         return str;
581     }
582
583     /**
584      * Handle a chapter
585      * @param attributes the tag attributes
586      * @param contents the tag contents
587      * @return the HTML code
588      * @throws SAXEception if an error is encountered
589      */
590     public String handleChapter(final Map<String, String> attributes, final String contents) throws SAXException {
591         String fileName = attributes.get("id") + ".html";
592         String str = encloseContents("ul", "list-refentry", contents);
593         String title = encloseContents("h3", "title-chapter", chapterTitle);
594         createHTMLFile(attributes.get("id"), fileName, chapterTitle, title + "\n" + str);
595
596         str = encloseContents("li", encloseContents("a", new String[] {"href", fileName, "class", "chapter"}, chapterTitle) + "\n" + str);
597         chapterTitle = "";
598
599         return str;
600     }
601
602     // partiellement merdique car le style de title depend du noeud pere.
603     /**
604      * Handle a title
605      * @param attributes the tag attributes
606      * @param contents the tag contents
607      * @return the HTML code
608      * @throws SAXEception if an error is encountered
609      */
610     public String handleTitle(final Map<String, String> attributes, final String contents) throws SAXException {
611         String clazz = "title";
612         String parent = getParentTagName();
613         if (parent.equals("chapter")) {
614             chapterTitle = contents;
615         } else if (parent.equals("part")) {
616             partTitle = contents;
617         } else if (parent.equals("info")) {
618             bookTitle = contents;
619         } else if (parent.equals("section")) {
620             sectionTitle = contents;
621         } else if (parent.equals("refsection") && Pattern.matches("^[ \\t]*ex[ea]mpl[eo].*", contents.toLowerCase())) {
622             hasExamples = true;
623             return encloseContents("h3", clazz, contents);
624         } else {
625             return encloseContents("h3", clazz, contents);
626         }
627
628         return null;
629     }
630
631     /**
632      * Handle a para
633      * @param attributes the tag attributes
634      * @param contents the tag contents
635      * @return the HTML code
636      * @throws SAXEception if an error is encountered
637      */
638     public String handlePara(final Map<String, String> attributes, final String contents) throws SAXException {
639         return encloseContents("p", "para", contents);
640     }
641
642     /**
643      * Handle a literal
644      * @param attributes the tag attributes
645      * @param contents the tag contents
646      * @return the HTML code
647      * @throws SAXEception if an error is encountered
648      */
649     public String handleLiteral(final Map<String, String> attributes, final String contents) throws SAXException {
650         return encloseContents("code", "literal", contents);
651     }
652
653     /**
654      * Handle a varname
655      * @param attributes the tag attributes
656      * @param contents the tag contents
657      * @return the HTML code
658      * @throws SAXEception if an error is encountered
659      */
660     public String handleVarname(final Map<String, String> attributes, final String contents) throws SAXException {
661         return encloseContents("code", "varname", contents);
662     }
663
664     /**
665      * Handle a command
666      * @param attributes the tag attributes
667      * @param contents the tag contents
668      * @return the HTML code
669      * @throws SAXEception if an error is encountered
670      */
671     public String handleCommand(final Map<String, String> attributes, final String contents) throws SAXException {
672         return encloseContents("code", "command", contents);
673     }
674
675     /**
676      * Handle a code
677      * @param attributes the tag attributes
678      * @param contents the tag contents
679      * @return the HTML code
680      * @throws SAXEception if an error is encountered
681      */
682     public String handleCode(final Map<String, String> attributes, final String contents) throws SAXException {
683         return encloseContents("code", "scilabcode", scilabLexer.convert(HTMLScilabCodeHandler.getInstance(refname, currentFileName), contents));//encloseContents("code", "code", contents);
684     }
685
686     /**
687      * Handle a function
688      * @param attributes the tag attributes
689      * @param contents the tag contents
690      * @return the HTML code
691      * @throws SAXEception if an error is encountered
692      */
693     public String handleFunction(final Map<String, String> attributes, final String contents) throws SAXException {
694         return encloseContents("code", "function", contents);
695     }
696
697     /**
698      * Handle a constant
699      * @param attributes the tag attributes
700      * @param contents the tag contents
701      * @return the HTML code
702      * @throws SAXEception if an error is encountered
703      */
704     public String handleConstant(final Map<String, String> attributes, final String contents) throws SAXException {
705         return encloseContents("code", "constant", contents);
706     }
707
708     /**
709      * Handle an option
710      * @param attributes the tag attributes
711      * @param contents the tag contents
712      * @return the HTML code
713      * @throws SAXEception if an error is encountered
714      */
715     public String handleOption(final Map<String, String> attributes, final String contents) throws SAXException {
716         return encloseContents("code", "option", contents);
717     }
718
719     /**
720      * Handle a refnamediv
721      * @param attributes the tag attributes
722      * @param contents the tag contents
723      * @return the HTML code
724      * @throws SAXEception if an error is encountered
725      */
726     public String handleRefnamediv(final Map<String, String> attributes, final String contents) throws SAXException {
727         String id = attributes.get("id");
728         if (id != null) {
729             currentId = id;
730         }
731
732         return encloseContents("div", "refnamediv", contents);
733     }
734
735     /**
736      * Handle a refname
737      * @param attributes the tag attributes
738      * @param contents the tag contents
739      * @return the HTML code
740      * @throws SAXEception if an error is encountered
741      */
742     public String handleRefname(final Map<String, String> attributes, final String contents) throws SAXException {
743         refname = contents;
744         return encloseContents("h1", "refname", contents);
745     }
746
747     /**
748      * Handle a refpurpose
749      * @param attributes the tag attributes
750      * @param contents the tag contents
751      * @return the HTML code
752      * @throws SAXEception if an error is encountered
753      */
754     public String handleRefpurpose(final Map<String, String> attributes, final String contents) throws SAXException {
755         refpurpose = contents;
756         return encloseContents("p", "refpurpose", contents);
757     }
758
759     /**
760      * Handle a refsynopsisdiv
761      * @param attributes the tag attributes
762      * @param contents the tag contents
763      * @return the HTML code
764      * @throws SAXEception if an error is encountered
765      */
766     public String handleRefsynopsisdiv(final Map<String, String> attributes, final String contents) throws SAXException {
767         String id = attributes.get("id");
768         if (id != null) {
769             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "refsynopsisdiv", contents);
770         } else {
771             return encloseContents("div", "refsynopsisdiv", contents);
772         }
773     }
774
775     /**
776      * Handle a synopsis
777      * @param attributes the tag attributes
778      * @param contents the tag contents
779      * @return the HTML code
780      * @throws SAXEception if an error is encountered
781      */
782     public String handleSynopsis(final Map<String, String> attributes, final String contents) throws SAXException {
783         String id = attributes.get("id");
784         String str = encloseContents("div", "synopsis", encloseContents("pre", SynopsisLexer.convert(refname, contents)));
785         if (id != null) {
786             return "<a name=\"" + id + "\"></a>" + str;
787         } else {
788             return str;
789         }
790     }
791
792     /**
793      * Handle a info
794      * @param attributes the tag attributes
795      * @param contents the tag contents
796      * @return the HTML code
797      * @throws SAXEception if an error is encountered
798      */
799     public String handleInfo(final Map<String, String> attributes, final String contents) throws SAXException {
800         String id = attributes.get("id");
801         if (id != null) {
802             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "info", contents);
803         } else {
804             return encloseContents("div", "info", contents);
805         }
806     }
807
808     /**
809      * Handle a refsection
810      * @param attributes the tag attributes
811      * @param contents the tag contents
812      * @return the HTML code
813      * @throws SAXEception if an error is encountered
814      */
815     public String handleRefsection(final Map<String, String> attributes, final String contents) throws SAXException {
816         String id = attributes.get("id");
817         if (id != null) {
818             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "refsection", contents);
819         } else {
820             return encloseContents("div", "refsection", contents);
821         }
822     }
823
824     /**
825      * Handle a progamlisting
826      * @param attributes the tag attributes
827      * @param contents the tag contents
828      * @return the HTML code
829      * @throws SAXEception if an error is encountered
830      */
831     public String handleProgramlisting(final Map<String, String> attributes, final String contents) throws SAXException {
832         String id = attributes.get("id");
833         String role = attributes.get("role");
834         String str;
835         if (role == null) {
836             String code = encloseContents("pre", "scilabcode", scilabLexer.convert(HTMLScilabCodeHandler.getInstance(refname, currentFileName), contents));
837             if (prependToProgramListing != null) {
838                 code = prependToProgramListing + code;
839             }
840             if (appendToProgramListing != null) {
841                 code += appendToProgramListing;
842             }
843             str = encloseContents("div", "programlisting", code);
844         } else {
845             if (role.equals("xml")) {
846                 str = encloseContents("div", "programlisting", encloseContents("pre", "xmlcode", xmlLexer.convert(HTMLXMLCodeHandler.getInstance(), contents)));
847             } else if (role.equals("c") || role.equals("cpp") || role.equals("code_gateway")) {
848                 str = encloseContents("div", "programlisting", encloseContents("pre", "ccode", cLexer.convert(HTMLCCodeHandler.getInstance(), contents)));
849             } else if (role.equals("java")) {
850                 str = encloseContents("div", "programlisting", encloseContents("pre", "ccode", javaLexer.convert(HTMLCCodeHandler.getInstance(), contents)));
851             } else if (role.equals("exec")) {
852                 String code = encloseContents("pre", "scilabcode", scilabLexer.convert(HTMLScilabCodeHandler.getInstance(refname, currentFileName), contents));
853                 if (prependToProgramListing != null) {
854                     code = prependToProgramListing + code;
855                 }
856                 if (appendForExecToProgramListing != null) {
857                     code += appendForExecToProgramListing;
858                 }
859                 str = encloseContents("div", "programlisting", code);
860             } else if (role.equals("no-scilab-exec")) {
861                 String code = encloseContents("pre", "scilabcode", scilabLexer.convert(HTMLScilabCodeHandler.getInstance(refname, currentFileName), contents));
862                 str = encloseContents("div", "programlisting", code);
863             } else {
864                 String code = encloseContents("pre", "scilabcode", scilabLexer.convert(HTMLScilabCodeHandler.getInstance(refname, currentFileName), contents));
865                 if (prependToProgramListing != null) {
866                     code = prependToProgramListing + code;
867                 }
868                 if (appendToProgramListing != null) {
869                     code += appendToProgramListing;
870                 }
871                 str = encloseContents("div", "programlisting", code);
872             }
873         }
874         if (id != null) {
875             return "<a name=\"" + id + "\"></a>" + str;
876         } else {
877             return str;
878         }
879     }
880
881     /**
882      * Handle a screen
883      * @param attributes the tag attributes
884      * @param contents the tag contents
885      * @return the HTML code
886      * @throws SAXEception if an error is encountered
887      */
888     public String handleScreen(final Map<String, String> attributes, final String contents) throws SAXException {
889         String id = attributes.get("id");
890         String str = encloseContents("div", "screen", encloseContents("pre", contents));
891         if (id != null) {
892             return "<a name=\"" + id + "\"></a>" + str;
893         } else {
894             return str;
895         }
896     }
897
898     /**
899      * Handle a pubdate
900      * @param attributes the tag attributes
901      * @param contents the tag contents
902      * @return the HTML code
903      * @throws SAXEception if an error is encountered
904      */
905     public String handlePubdate(final Map<String, String> attributes, final String contents) throws SAXException {
906         return null;
907     }
908
909     /**
910      * Handle a simplelist
911      * @param attributes the tag attributes
912      * @param contents the tag contents
913      * @return the HTML code
914      * @throws SAXEception if an error is encountered
915      */
916     public String handleSimplelist(final Map<String, String> attributes, final String contents) throws SAXException {
917         String style = "itemizedlist";
918
919         return encloseContents("ul", style, contents);
920     }
921
922     /**
923      * Handle a member
924      * @param attributes the tag attributes
925      * @param contents the tag contents
926      * @return the HTML code
927      * @throws SAXEception if an error is encountered
928      */
929     public String handleMember(final Map<String, String> attributes, final String contents) throws SAXException {
930         return encloseContents("li", "member", contents);
931     }
932
933     /**
934      * Handle a link
935      * @param attributes the tag attributes
936      * @param contents the tag contents
937      * @return the HTML code
938      * @throws SAXEception if an error is encountered
939      */
940     public String handleLink(final Map<String, String> attributes, final String contents) throws SAXException {
941         String link = attributes.get("linkend");
942         if (link == null) {
943             throw new SAXException("No linkend attribute in tag link");
944         }
945
946         String type = attributes.get("type");
947         String id;
948         if (type != null && type.equals("scilab")) {
949             id = resolvScilabLink(link);
950         } else if (type != null && type.equals("remote")) {
951             id = makeRemoteLink(link);
952         } else {
953             id = mapId.get(link);
954         }
955
956         if (id == null) {
957             warnings++;
958             System.err.println("Warning (should be fixed): invalid internal link to " + link + " in " + currentFileName + "\nat line " + locator.getLineNumber());
959             return null;
960         }
961
962         Stack<DocbookElement> stack = getStack();
963         int s = stack.size();
964         if (s >= 3) {
965             DocbookElement elem = stack.get(s - 3);
966             if (elem.getName().equals("refsection")) {
967                 String role = elem.getAttributes().get("role");
968                 if (role != null && role.equals("see also")) {
969                     String purpose = mapIdPurpose.get(link);
970                     if (purpose != null) {
971                         return encloseContents("a", new String[] {"href", id, "class", "link"}, contents) + " &#8212; " + purpose;
972                     } else {
973                         return encloseContents("a", new String[] {"href", id, "class", "link"}, contents);
974                     }
975                 }
976             }
977         }
978
979         return encloseContents("a", new String[] {"href", id, "class", "link"}, contents);
980     }
981
982     /**
983      * Rewrite a link when its type is "scilab"
984      * @param link the link
985      * @return the modified link with protocol scilab:// for example
986      */
987     protected String resolvScilabLink(String link) {
988         int pos = link.indexOf("/");
989         if (pos == -1) {
990             return null;
991         }
992         String first = link.substring(0, pos);
993         String second = link.substring(pos + 1);
994         String[] toks = first.split("\\.");
995         if (toks == null || toks.length != 2) {
996             return null;
997         }
998
999         if (!linkToTheWeb) {
1000             return urlBase + link;
1001         } else {
1002             if (toks[0].equals("scilab") && toks[1].equals("help")) {
1003                 return urlBase + second + ".html";
1004             } else {
1005                 return "#";
1006             }
1007         }
1008     }
1009
1010     /**
1011      * Make a remote link
1012      * @param link the link
1013      * @return the good link
1014      */
1015     protected String makeRemoteLink(String link) {
1016         return link;
1017     }
1018
1019     /**
1020      * Handle an ulink
1021      * @param attributes the tag attributes
1022      * @param contents the tag contents
1023      * @return the HTML code
1024      * @throws SAXEception if an error is encountered
1025      */
1026     public String handleUlink(final Map<String, String> attributes, final String contents) throws SAXException {
1027         String link = attributes.get("url");
1028         if (link == null) {
1029             throw new SAXException("No url attribute in tag ulink");
1030         }
1031
1032         return encloseContents("a", new String[] {"href", link, "class", "ulink"}, contents);
1033     }
1034
1035     /**
1036      * Handle a xref
1037      * @param attributes the tag attributes
1038      * @param contents the tag contents
1039      * @return the HTML code
1040      * @throws SAXEception if an error is encountered
1041      */
1042     public String handleXref(final Map<String, String> attributes, final String contents) throws SAXException {
1043         String link = attributes.get("linkend");
1044         if (link == null) {
1045             throw new SAXException("No linkend attribute in tag link");
1046         }
1047
1048         String id = mapId.get(link);
1049         if (id == null) {
1050             warnings++;
1051             System.err.println("Warning (should be fixed): invalid internal link to " + link + " in " + currentFileName + "\nat line " + locator.getLineNumber());
1052             return null;
1053         }
1054
1055         return encloseContents("a", new String[] {"href", id, "class", "xref"}, contents);
1056     }
1057
1058     /**
1059      * Handle a latex (not really a docbook tag...)
1060      * @param attributes the tag attributes
1061      * @param contents the tag contents
1062      * @return the HTML code
1063      * @throws SAXEception if an error is encountered
1064      */
1065     public String handleLatex(final Map<String, String> attributes, final String contents) throws SAXException {
1066         File f = new File(outName + imageDir, LATEXBASENAME + (latexCompt++) + ".png");
1067         String parent = getParentTagName();
1068         if (parent.equals("para") && !attributes.containsKey("style")) {
1069             attributes.put("style", "text");
1070         }
1071         String fs = attributes.get("fontsize");
1072         if (fs == null) {
1073             attributes.put("fontsize", "16");
1074         }
1075         return ImageConverter.getImageByCode(currentFileName, contents, attributes, "image/latex", f, imageDir + "/" + f.getName());
1076     }
1077
1078     /**
1079      * Handle a term
1080      * @param attributes the tag attributes
1081      * @param contents the tag contents
1082      * @return the HTML code
1083      * @throws SAXEception if an error is encountered
1084      */
1085     public String handleTerm(final Map<String, String> attributes, final String contents) throws SAXException {
1086         String id = attributes.get("id");
1087         if (id != null) {
1088             return "<a name=\"" + id + "\"></a>" + encloseContents("span", "term", contents);
1089         } else {
1090             return encloseContents("span", "term", contents);
1091         }
1092     }
1093
1094     /**
1095      * Handle a listitem
1096      * @param attributes the tag attributes
1097      * @param contents the tag contents
1098      * @return the HTML code
1099      * @throws SAXEception if an error is encountered
1100      */
1101     public String handleListitem(final Map<String, String> attributes, final String contents) throws SAXException {
1102         String parent = getParentTagName();
1103         if (parent.equals("varlistentry")) {
1104             return encloseContents("dd", contents);
1105         }
1106         return encloseContents("li", contents);
1107     }
1108
1109     /**
1110      * Handle a varlistentry
1111      * @param attributes the tag attributes
1112      * @param contents the tag contents
1113      * @return the HTML code
1114      * @throws SAXEception if an error is encountered
1115      */
1116     public String handleVarlistentry(final Map<String, String> attributes, final String contents) throws SAXException {
1117         return encloseContents("dt", contents);
1118     }
1119
1120     /**
1121      * Handle a variablelist
1122      * @param attributes the tag attributes
1123      * @param contents the tag contents
1124      * @return the HTML code
1125      * @throws SAXEception if an error is encountered
1126      */
1127     public String handleVariablelist(final Map<String, String> attributes, final String contents) throws SAXException {
1128         return encloseContents("dl", contents);
1129     }
1130
1131     /**
1132      * Handle an itemizedlist
1133      * @param attributes the tag attributes
1134      * @param contents the tag contents
1135      * @return the HTML code
1136      * @throws SAXEception if an error is encountered
1137      */
1138     public String handleItemizedlist(final Map<String, String> attributes, final String contents) throws SAXException {
1139         String id = attributes.get("id");
1140         if (id != null) {
1141             return "<a name=\"" + id + "\"></a>" + encloseContents("ul", "itemizedlist", contents);
1142         } else {
1143             return encloseContents("ul", "itemizedlist", contents);
1144         }
1145     }
1146
1147     /**
1148      * Handle an emphasis
1149      * @param attributes the tag attributes
1150      * @param contents the tag contents
1151      * @return the HTML code
1152      * @throws SAXEception if an error is encountered
1153      */
1154     public String handleEmphasis(final Map<String, String> attributes, final String contents) throws SAXException {
1155         String role = attributes.get("role");
1156         if (role != null) {
1157             if (role.equals("bold")) {
1158                 return encloseContents("b", contents);
1159             }
1160             if (role.equals("italic")) {
1161                 return encloseContents("i", contents);
1162             }
1163         }
1164
1165         return encloseContents("em", contents);
1166     }
1167
1168     /**
1169      * Handle a tr
1170      * @param attributes the tag attributes
1171      * @param contents the tag contents
1172      * @return the HTML code
1173      * @throws SAXEception if an error is encountered
1174      */
1175     public String handleTr(final Map<String, String> attributes, final String contents) throws SAXException {
1176         return encloseContents("tr", contents);
1177     }
1178
1179     /**
1180      * Handle a td
1181      * @param attributes the tag attributes
1182      * @param contents the tag contents
1183      * @return the HTML code
1184      * @throws SAXEception if an error is encountered
1185      */
1186     public String handleTd(final Map<String, String> attributes, final String contents) throws SAXException {
1187         String align = attributes.get("align");
1188         if (align == null) {
1189             return encloseContents("td", new String[] {"align", align}, contents);
1190         }
1191         return encloseContents("td", contents);
1192     }
1193
1194     /**
1195      * Handle an informaltable
1196      * @param attributes the tag attributes
1197      * @param contents the tag contents
1198      * @return the HTML code
1199      * @throws SAXEception if an error is encountered
1200      */
1201     public String handleInformaltable(final Map<String, String> attributes, final String contents) throws SAXException {
1202         String id = attributes.get("id");
1203         String border = attributes.get("border");
1204         if (border == null) {
1205             border = "";
1206         }
1207         String cellpadding = attributes.get("cellpadding");
1208         if (cellpadding == null) {
1209             cellpadding = "";
1210         }
1211         String width = attributes.get("width");
1212         if (width == null) {
1213             width = "";
1214         }
1215         if (id != null) {
1216             return "<a name=\"" + id + "\"></a>" + encloseContents("table", new String[] {"class", "informaltable", "border", border, "cellpadding", cellpadding, "width", width}, contents);
1217         } else {
1218             return encloseContents("table", new String[] {"class", "informaltable", "border", border, "cellpadding", cellpadding, "width", width}, contents);
1219         }
1220     }
1221
1222     /**
1223      * Handle an imagedata
1224      * @param attributes the tag attributes
1225      * @param contents the tag contents
1226      * @return the HTML code
1227      * @throws SAXEception if an error is encountered
1228      */
1229     public String handleImagedata(final Map<String, String> attributes, final String contents) throws SAXException {
1230         String fileref = attributes.get("fileref");
1231         if (fileref == null) {
1232             if (contents == null || contents.length() == 0) {
1233                 throw new SAXException("No fileref attribute or no data in tag imagedata");
1234             }
1235
1236             return contents;
1237         }
1238
1239         try {
1240             String path = new File(new URI(currentFileName)).getParent();
1241             if (!ImageConverter.imageExists(path, fileref)) {
1242                 throw new SAXException("The given fileref is not on an existing image file:\n" + fileref);
1243             }
1244
1245             return ImageConverter.getImageByFile(attributes, path, fileref, outName, imageDir);
1246         }  catch (URISyntaxException e) {
1247             System.err.println(e);
1248         }
1249
1250         return null;
1251     }
1252
1253     /**
1254      * Handle an imageobject
1255      * @param attributes the tag attributes
1256      * @param contents the tag contents
1257      * @return the HTML code
1258      * @throws SAXEception if an error is encountered
1259      */
1260     public String handleImageobject(final Map<String, String> attributes, final String contents) throws SAXException {
1261         return contents;
1262     }
1263
1264     /**
1265      * Handle an inlinemediaobject
1266      * @param attributes the tag attributes
1267      * @param contents the tag contents
1268      * @return the HTML code
1269      * @throws SAXEception if an error is encountered
1270      */
1271     public String handleInlinemediaobject(final Map<String, String> attributes, final String contents) throws SAXException {
1272         return encloseContents("span", contents);
1273     }
1274
1275     /**
1276      * Handle a screenshot
1277      * @param attributes the tag attributes
1278      * @param contents the tag contents
1279      * @return the HTML code
1280      * @throws SAXEception if an error is encountered
1281      */
1282     public String handleScreenshot(final Map<String, String> attributes, final String contents) throws SAXException {
1283         String id = attributes.get("id");
1284         if (id != null) {
1285             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "screenshot", contents);
1286         } else {
1287             return encloseContents("div", "screenshot", contents);
1288         }
1289     }
1290
1291     /**
1292      * Handle a mediaobject
1293      * @param attributes the tag attributes
1294      * @param contents the tag contents
1295      * @return the HTML code
1296      * @throws SAXEception if an error is encountered
1297      */
1298     public String handleMediaobject(final Map<String, String> attributes, final String contents) throws SAXException {
1299         String id = attributes.get("id");
1300         String c = contents.replaceFirst("top:([0-9]+)px;", "");
1301         if (id != null) {
1302             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "mediaobject", c);
1303         } else {
1304             return encloseContents("div", "mediaobject", c);
1305         }
1306     }
1307
1308     /**
1309      * Handle an informalequation
1310      * @param attributes the tag attributes
1311      * @param contents the tag contents
1312      * @return the HTML code
1313      * @throws SAXEception if an error is encountered
1314      */
1315     public String handleInformalequation(final Map<String, String> attributes, final String contents) throws SAXException {
1316         String id = attributes.get("id");
1317         if (id != null) {
1318             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "informalequation", contents);
1319         } else {
1320             return encloseContents("div", "informalequation", contents);
1321         }
1322     }
1323
1324     /**
1325      * Handle an orderedlist
1326      * @param attributes the tag attributes
1327      * @param contents the tag contents
1328      * @return the HTML code
1329      * @throws SAXEception if an error is encountered
1330      */
1331     public String handleOrderedlist(final Map<String, String> attributes, final String contents) throws SAXException {
1332         String numeration = "1";
1333         String numAttr = attributes.get("numeration");
1334         if (numAttr != null) {
1335             if (numAttr.equals("loweralpha")) {
1336                 numeration = "a";
1337             } else if (numAttr.equals("upperalpha")) {
1338                 numeration = "A";
1339             } else if (numAttr.equals("lowerroman")) {
1340                 numeration = "i";
1341             } else if (numAttr.equals("upperroman")) {
1342                 numeration = "I";
1343             }
1344         }
1345
1346         String id = attributes.get("id");
1347         if (id != null) {
1348             return "<a name=\"" + id + "\"></a>" + encloseContents("ol", new String[] {"type", numeration}, contents);
1349         } else {
1350             return encloseContents("ol", new String[] {"type", numeration}, contents);
1351         }
1352     }
1353
1354     /**
1355      * Handle a subscript
1356      * @param attributes the tag attributes
1357      * @param contents the tag contents
1358      * @return the HTML code
1359      * @throws SAXEception if an error is encountered
1360      */
1361     public String handleSubscript(final Map<String, String> attributes, final String contents) throws SAXException {
1362         return encloseContents("sub", contents);
1363     }
1364
1365     /**
1366      * Handle a superscript
1367      * @param attributes the tag attributes
1368      * @param contents the tag contents
1369      * @return the HTML code
1370      * @throws SAXEception if an error is encountered
1371      */
1372     public String handleSuperscript(final Map<String, String> attributes, final String contents) throws SAXException {
1373         return encloseContents("sup", contents);
1374     }
1375
1376     /**
1377      * Handle a replaceable
1378      * @param attributes the tag attributes
1379      * @param contents the tag contents
1380      * @return the HTML code
1381      * @throws SAXEception if an error is encountered
1382      */
1383     public String handleReplaceable(final Map<String, String> attributes, final String contents) throws SAXException {
1384         return encloseContents("span", "replaceable", contents);
1385     }
1386
1387     /**
1388      * Handle a question
1389      * @param attributes the tag attributes
1390      * @param contents the tag contents
1391      * @return the HTML code
1392      * @throws SAXEception if an error is encountered
1393      */
1394     public String handleQuestion(final Map<String, String> attributes, final String contents) throws SAXException {
1395         return encloseContents("dt", encloseContents("strong", contents));
1396     }
1397
1398     /**
1399      * Handle an answer
1400      * @param attributes the tag attributes
1401      * @param contents the tag contents
1402      * @return the HTML code
1403      * @throws SAXEception if an error is encountered
1404      */
1405     public String handleAnswer(final Map<String, String> attributes, final String contents) throws SAXException {
1406         return encloseContents("dd", contents);
1407     }
1408
1409     /**
1410      * Handle a qandaentry
1411      * @param attributes the tag attributes
1412      * @param contents the tag contents
1413      * @return the HTML code
1414      * @throws SAXEception if an error is encountered
1415      */
1416     public String handleQandaentry(final Map<String, String> attributes, final String contents) throws SAXException {
1417         return encloseContents("dl", contents);
1418     }
1419
1420     /**
1421      * Handle a qandaset
1422      * @param attributes the tag attributes
1423      * @param contents the tag contents
1424      * @return the HTML code
1425      * @throws SAXEception if an error is encountered
1426      */
1427     public String handleQandaset(final Map<String, String> attributes, final String contents) throws SAXException {
1428         return encloseContents("div", "qandaset", contents);
1429     }
1430
1431     /**
1432      * Handle a caption
1433      * @param attributes the tag attributes
1434      * @param contents the tag contents
1435      * @return the HTML code
1436      * @throws SAXEception if an error is encountered
1437      */
1438     public String handleCaption(final Map<String, String> attributes, final String contents) throws SAXException {
1439         return encloseContents("caption", encloseContents("b", contents));
1440     }
1441
1442     /**
1443      * Handle a tbody
1444      * @param attributes the tag attributes
1445      * @param contents the tag contents
1446      * @return the HTML code
1447      * @throws SAXEception if an error is encountered
1448      */
1449     public String handleTbody(final Map<String, String> attributes, final String contents) throws SAXException {
1450         return encloseContents("tbody", "tbody", contents);
1451     }
1452
1453     /**
1454      * Handle a table
1455      * @param attributes the tag attributes
1456      * @param contents the tag contents
1457      * @return the HTML code
1458      * @throws SAXEception if an error is encountered
1459      */
1460     public String handleTable(final Map<String, String> attributes, final String contents) throws SAXException {
1461         String id = attributes.get("id");
1462         if (id != null) {
1463             return "<a name=\"" + id + "\"></a>" + encloseContents("table", "doctable", contents);
1464         } else {
1465             return encloseContents("table", "doctable", contents);
1466         }
1467     }
1468
1469     /**
1470      * Handle a surname
1471      * @param attributes the tag attributes
1472      * @param contents the tag contents
1473      * @return the HTML code
1474      * @throws SAXEception if an error is encountered
1475      */
1476     public String handleSurname(final Map<String, String> attributes, final String contents) throws SAXException {
1477         return encloseContents("span", "surname", contents);
1478     }
1479
1480     /**
1481      * Handle a firstname
1482      * @param attributes the tag attributes
1483      * @param contents the tag contents
1484      * @return the HTML code
1485      * @throws SAXEception if an error is encountered
1486      */
1487     public String handleFirstname(final Map<String, String> attributes, final String contents) throws SAXException {
1488         return encloseContents("span", "firstname", contents);
1489     }
1490
1491     /**
1492      * Handle a bibliomset
1493      * @param attributes the tag attributes
1494      * @param contents the tag contents
1495      * @return the HTML code
1496      * @throws SAXEception if an error is encountered
1497      */
1498     public String handleBibliomset(final Map<String, String> attributes, final String contents) throws SAXException {
1499         String id = attributes.get("id");
1500         if (id != null) {
1501             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "bibliomset", contents);
1502         } else {
1503             return encloseContents("div", "bibliomset", contents);
1504         }
1505     }
1506
1507     /**
1508      * Handle a bibliomixed
1509      * @param attributes the tag attributes
1510      * @param contents the tag contents
1511      * @return the HTML code
1512      * @throws SAXEception if an error is encountered
1513      */
1514     public String handleBibliomixed(final Map<String, String> attributes, final String contents) throws SAXException {
1515         String id = attributes.get("id");
1516         if (id != null) {
1517             return "<a name=\"" + id + "\"></a>" + encloseContents("div", "bibliomixed", contents);
1518         } else {
1519             return encloseContents("div", "bibliomixed", contents);
1520         }
1521     }
1522
1523     /**
1524      * Handle a th
1525      * @param attributes the tag attributes
1526      * @param contents the tag contents
1527      * @return the HTML code
1528      * @throws SAXEception if an error is encountered
1529      */
1530     public String handleTh(final Map<String, String> attributes, final String contents) throws SAXException {
1531         return encloseContents("th", contents);
1532     }
1533
1534     /**
1535      * Handle a revhistory
1536      * @param attributes the tag attributes
1537      * @param contents the tag contents
1538      * @return the HTML code
1539      * @throws SAXEception if an error is encountered
1540      */
1541     public String handleRevhistory(final Map<String, String> attributes, final String contents) throws SAXException {
1542         String id = attributes.get("id");
1543         String str = "<table class=\"revhistory\"><tr class=\"title\"><td>" + VERSION + "</td><td>" + DESCRIPTION + "</td></tr>" + contents + "</table>";
1544         if (id != null) {
1545             return "<a name=\"" + id + "\"></a>" + str;
1546         } else {
1547             return str;
1548         }
1549     }
1550
1551     /**
1552      * Handle a revision
1553      * @param attributes the tag attributes
1554      * @param contents the tag contents
1555      * @return the HTML code
1556      * @throws SAXEception if an error is encountered
1557      */
1558     public String handleRevision(final Map<String, String> attributes, final String contents) throws SAXException {
1559         return encloseContents("tr", contents);
1560     }
1561
1562     /**
1563      * Handle a revnumber
1564      * @param attributes the tag attributes
1565      * @param contents the tag contents
1566      * @return the HTML code
1567      * @throws SAXEception if an error is encountered
1568      */
1569     public String handleRevnumber(final Map<String, String> attributes, final String contents) throws SAXException {
1570         return encloseContents("td", "revnumber", contents);
1571     }
1572
1573     /**
1574      * Handle a revremark
1575      * @param attributes the tag attributes
1576      * @param contents the tag contents
1577      * @return the HTML code
1578      * @throws SAXEception if an error is encountered
1579      */
1580     public String handleRevremark(final Map<String, String> attributes, final String contents) throws SAXException {
1581         return encloseContents("td", "revremark", contents);
1582     }
1583
1584     /**
1585      * Handle a revdescription
1586      * @param attributes the tag attributes
1587      * @param contents the tag contents
1588      * @return the HTML code
1589      * @throws SAXEception if an error is encountered
1590      */
1591     public String handleRevdescription(final Map<String, String> attributes, final String contents) throws SAXException {
1592         return encloseContents("td", "revdescription", contents);
1593     }
1594
1595     /**
1596      * Handle a note
1597      * @param attributes the tag attributes
1598      * @param contents the tag contents
1599      * @return the HTML code
1600      * @throws SAXEception if an error is encountered
1601      */
1602     public String handleNote(final Map<String, String> attributes, final String contents) throws SAXException {
1603         String id = attributes.get("id");
1604         String code = "<table><tr><td valign=\"top\"><img src=\"ScilabNote.png\"/></td><td valign=\"top\">" + encloseContents("div", "note", contents) + "</tr></table>";
1605         if (id != null) {
1606             return "<a name=\"" + id + "\"></a>" + code;
1607         } else {
1608             return code;
1609         }
1610     }
1611
1612     /**
1613      * Handle a warning
1614      * @param attributes the tag attributes
1615      * @param contents the tag contents
1616      * @return the HTML code
1617      * @throws SAXEception if an error is encountered
1618      */
1619     public String handleWarning(final Map<String, String> attributes, final String contents) throws SAXException {
1620         String id = attributes.get("id");
1621         String code = "<table><tr><td valign=\"top\"><img src=\"ScilabWarning.png\"/></td><td valign=\"top\">" + encloseContents("div", "warning", contents) + "</tr></table>";
1622         if (id != null) {
1623             return "<a name=\"" + id + "\"></a>" + code;
1624         } else {
1625             return code;
1626         }
1627     }
1628
1629     /**
1630      * Handle a caution
1631      * @param attributes the tag attributes
1632      * @param contents the tag contents
1633      * @return the HTML code
1634      * @throws SAXEception if an error is encountered
1635      */
1636     public String handleCaution(final Map<String, String> attributes, final String contents) throws SAXException {
1637         String id = attributes.get("id");
1638         String code = "<table><tr><td valign=\"top\"><img src=\"ScilabCaution.png\"/></td><td valign=\"top\">" + encloseContents("div", "caution", contents) + "</tr></table>";
1639         if (id != null) {
1640             return "<a name=\"" + id + "\"></a>" + code;
1641         } else {
1642             return code;
1643         }
1644     }
1645
1646     /**
1647      * Handle a tip
1648      * @param attributes the tag attributes
1649      * @param contents the tag contents
1650      * @return the HTML code
1651      * @throws SAXEception if an error is encountered
1652      */
1653     public String handleTip(final Map<String, String> attributes, final String contents) throws SAXException {
1654         String id = attributes.get("id");
1655         String code = "<table><tr><td valign=\"top\"><img src=\"ScilabTip.png\"/></td><td valign=\"top\">" + encloseContents("div", "tip", contents) + "</tr></table>";
1656         if (id != null) {
1657             return "<a name=\"" + id + "\"></a>" + code;
1658         } else {
1659             return code;
1660         }
1661     }
1662
1663     /**
1664      * Handle a important
1665      * @param attributes the tag attributes
1666      * @param contents the tag contents
1667      * @return the HTML code
1668      * @throws SAXEception if an error is encountered
1669      */
1670     public String handleImportant(final Map<String, String> attributes, final String contents) throws SAXException {
1671         String id = attributes.get("id");
1672         String code = "<table><tr><td valign=\"top\"><img src=\"ScilabImportant.png\"/></td><td valign=\"top\">" + encloseContents("div", "important", contents) + "</tr></table>";
1673         if (id != null) {
1674             return "<a name=\"" + id + "\"></a>" + code;
1675         } else {
1676             return code;
1677         }
1678     }
1679 }