Fix #680.
[phpeclipse.git] / archive / net.sourceforge.phpeclipse.jtidy / src / net / sourceforge / phpdt / tidy / w3c / PPrint.java
1 /*
2  * @(#)PPrint.java   1.11 2000/08/16
3  *
4  */
5
6 package net.sourceforge.phpdt.tidy.w3c;
7
8 /**
9  *
10  * Pretty print parse tree
11  *
12  * (c) 1998-2000 (W3C) MIT, INRIA, Keio University
13  * See Tidy.java for the copyright notice.
14  * Derived from <a href="http://www.w3.org/People/Raggett/tidy">
15  * HTML Tidy Release 4 Aug 2000</a>
16  *
17  * @author  Dave Raggett <dsr@w3.org>
18  * @author  Andy Quick <ac.quick@sympatico.ca> (translation to Java)
19  * @version 1.0, 1999/05/22
20  * @version 1.0.1, 1999/05/29
21  * @version 1.1, 1999/06/18 Java Bean
22  * @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
23  * @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
24  * @version 1.4, 1999/09/04 DOM support
25  * @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
26  * @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
27  * @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
28  * @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
29  * @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
30  * @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
31  * @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
32  */
33
34 /*
35   Block-level and unknown elements are printed on
36   new lines and their contents indented 2 spaces
37
38   Inline elements are printed inline.
39
40   Inline content is wrapped on spaces (except in
41   attribute values or preformatted text, after
42   start tags and before end tags
43 */
44
45 import java.io.File;
46 import java.io.FileOutputStream;
47 import java.io.IOException;
48
49 public class PPrint {
50
51     /* page transition effects */
52
53     public static final short EFFECT_BLEND               = -1;
54     public static final short EFFECT_BOX_IN              = 0;
55     public static final short EFFECT_BOX_OUT             = 1;
56     public static final short EFFECT_CIRCLE_IN           = 2;
57     public static final short EFFECT_CIRCLE_OUT          = 3;
58     public static final short EFFECT_WIPE_UP             = 4;
59     public static final short EFFECT_WIPE_DOWN           = 5;
60     public static final short EFFECT_WIPE_RIGHT          = 6;
61     public static final short EFFECT_WIPE_LEFT           = 7;
62     public static final short EFFECT_VERT_BLINDS         = 8;
63     public static final short EFFECT_HORZ_BLINDS         = 9;
64     public static final short EFFECT_CHK_ACROSS          = 10;
65     public static final short EFFECT_CHK_DOWN            = 11;
66     public static final short EFFECT_RND_DISSOLVE        = 12;
67     public static final short EFFECT_SPLIT_VIRT_IN       = 13;
68     public static final short EFFECT_SPLIT_VIRT_OUT      = 14;
69     public static final short EFFECT_SPLIT_HORZ_IN       = 15;
70     public static final short EFFECT_SPLIT_HORZ_OUT      = 16;
71     public static final short EFFECT_STRIPS_LEFT_DOWN    = 17;
72     public static final short EFFECT_STRIPS_LEFT_UP      = 18;
73     public static final short EFFECT_STRIPS_RIGHT_DOWN   = 19;
74     public static final short EFFECT_STRIPS_RIGHT_UP     = 20;
75     public static final short EFFECT_RND_BARS_HORZ       = 21;
76     public static final short EFFECT_RND_BARS_VERT       = 22;
77     public static final short EFFECT_RANDOM              = 23;
78
79     private static final short NORMAL        = 0;
80     private static final short PREFORMATTED  = 1;
81     private static final short COMMENT       = 2;
82     private static final short ATTRIBVALUE   = 4;
83     private static final short NOWRAP        = 8;
84     private static final short CDATA         = 16;
85
86     private int[] linebuf = null;
87     private int lbufsize = 0;
88     private int linelen = 0;
89     private int wraphere = 0;
90     private boolean inAttVal = false;
91     private boolean InString = false;
92
93     private int slide = 0;
94     private int count = 0;
95     private Node slidecontent = null;
96
97     private Configuration configuration;
98
99     public PPrint(Configuration configuration)
100     {
101         this.configuration = configuration;
102     }
103
104     /*
105       1010  A
106       1011  B
107       1100  C
108       1101  D
109       1110  E
110       1111  F
111     */
112
113     /* return one less that the number of bytes used by UTF-8 char */
114     /* str points to 1st byte, *ch initialized to 1st byte */
115     public static int getUTF8(byte[] str, int start, MutableInteger ch)
116     {
117         int c, n, i, bytes;
118
119         c = ((int)str[start]) & 0xFF;  // Convert to unsigned.
120
121         if ((c & 0xE0) == 0xC0)  /* 110X XXXX  two bytes */
122         {
123             n = c & 31;
124             bytes = 2;
125         }
126         else if ((c & 0xF0) == 0xE0)  /* 1110 XXXX  three bytes */
127         {
128             n = c & 15;
129             bytes = 3;
130         }
131         else if ((c & 0xF8) == 0xF0)  /* 1111 0XXX  four bytes */
132         {
133             n = c & 7;
134             bytes = 4;
135         }
136         else if ((c & 0xFC) == 0xF8)  /* 1111 10XX  five bytes */
137         {
138             n = c & 3;
139             bytes = 5;
140         }
141         else if ((c & 0xFE) == 0xFC)       /* 1111 110X  six bytes */
142
143         {
144             n = c & 1;
145             bytes = 6;
146         }
147         else  /* 0XXX XXXX one byte */
148         {
149             ch.value = c;
150             return 0;
151         }
152
153         /* successor bytes should have the form 10XX XXXX */
154         for (i = 1; i < bytes; ++i)
155         {
156             c = ((int)str[start + i])  & 0xFF;  // Convert to unsigned.
157             n = (n << 6) | (c & 0x3F);
158         }
159
160         ch.value = n;
161         return bytes - 1;
162     }
163
164     /* store char c as UTF-8 encoded byte stream */
165     public static int putUTF8(byte[] buf, int start, int c)
166     {
167         if (c < 128)
168             buf[start++] = (byte)c;
169         else if (c <= 0x7FF)
170         {
171             buf[start++] = (byte)(0xC0 | (c >> 6));
172             buf[start++] = (byte)(0x80 | (c & 0x3F));
173         }
174         else if (c <= 0xFFFF)
175         {
176             buf[start++] =  (byte)(0xE0 | (c >> 12));
177             buf[start++] =  (byte)(0x80 | ((c >> 6) & 0x3F));
178             buf[start++] =  (byte)(0x80 | (c & 0x3F));
179         }
180         else if (c <= 0x1FFFFF)
181         {
182             buf[start++] =  (byte)(0xF0 | (c >> 18));
183             buf[start++] =  (byte)(0x80 | ((c >> 12) & 0x3F));
184             buf[start++] =  (byte)(0x80 | ((c >> 6) & 0x3F));
185             buf[start++] =  (byte)(0x80 | (c & 0x3F));
186         }
187         else
188         {
189             buf[start++] =  (byte)(0xF8 | (c >> 24));
190             buf[start++] =  (byte)(0x80 | ((c >> 18) & 0x3F));
191             buf[start++] =  (byte)(0x80 | ((c >> 12) & 0x3F));
192             buf[start++] =  (byte)(0x80 | ((c >> 6) & 0x3F));
193             buf[start++] =  (byte)(0x80 | (c & 0x3F));
194         }
195
196         return start;
197     }
198
199     private void addC(int c, int index)
200     {
201         if (index + 1 >= lbufsize)
202         {
203             while (index + 1 >= lbufsize)
204             {
205                 if (lbufsize == 0)
206                     lbufsize = 256;
207                 else
208                     lbufsize = lbufsize * 2;
209             }
210
211            int[] temp = new int[ lbufsize ];
212            if (linebuf != null)
213                System.arraycopy(linebuf, 0, temp, 0, index);
214            linebuf = temp;
215         }
216
217         linebuf[index] = c;
218     }
219
220     private void wrapLine(Out fout, int indent)
221     {
222         int i, p, q;
223
224         if (wraphere == 0)
225             return;
226
227         for (i = 0; i < indent; ++i)
228             fout.outc((int)' ');
229
230         for (i = 0; i < wraphere; ++i)
231             fout.outc(linebuf[i]);
232
233         if (InString)
234         {
235             fout.outc((int)' ');
236             fout.outc((int)'\\');
237         }
238
239         fout.newline();
240
241         if (linelen > wraphere)
242         {
243             p = 0;
244
245             if (linebuf[wraphere] == ' ')
246                 ++wraphere;
247
248             q = wraphere;
249             addC('\0', linelen);
250
251             while (true)
252             {
253                 linebuf[p] = linebuf[q];
254                 if (linebuf[q] == 0) break;
255                 p++;
256                 q++;
257             }
258             linelen -= wraphere;
259         }
260         else
261             linelen = 0;
262
263         wraphere = 0;
264     }
265
266     private void wrapAttrVal(Out fout, int indent, boolean inString)
267     {
268         int i, p, q;
269
270         for (i = 0; i < indent; ++i)
271             fout.outc((int)' ');
272
273         for (i = 0; i < wraphere; ++i)
274             fout.outc(linebuf[i]);
275
276         fout.outc((int)' ');
277
278         if (inString)
279             fout.outc((int)'\\');
280
281         fout.newline();
282
283         if (linelen > wraphere)
284         {
285             p = 0;
286
287             if (linebuf[wraphere] == ' ')
288                 ++wraphere;
289
290             q = wraphere;
291             addC('\0', linelen);
292
293             while (true)
294             {
295                 linebuf[p] = linebuf[q];
296                 if (linebuf[q] == 0) break;
297                 p++;
298                 q++;
299             }
300             linelen -= wraphere;
301         }
302         else
303             linelen = 0;
304
305         wraphere = 0;
306     }
307
308     public void flushLine(Out fout, int indent)
309     {
310         int i;
311
312         if (linelen > 0)
313         {
314             if (indent + linelen >= this.configuration.wraplen)
315                 wrapLine(fout, indent);
316
317             if (!inAttVal || this.configuration.IndentAttributes)
318             {
319                 for (i = 0; i < indent; ++i)
320                     fout.outc((int)' ');
321             }
322
323             for (i = 0; i < linelen; ++i)
324                 fout.outc(linebuf[i]);
325         }
326
327         fout.newline();
328         linelen = 0;
329         wraphere = 0;
330         inAttVal = false;
331     }
332
333     public void condFlushLine(Out fout, int indent)
334     {
335         int i;
336
337         if (linelen > 0)
338         {
339             if (indent + linelen >= this.configuration.wraplen)
340                 wrapLine(fout, indent);
341
342             if (!inAttVal || this.configuration.IndentAttributes)
343             {
344                 for (i = 0; i < indent; ++i)
345                     fout.outc((int)' ');
346             }
347
348             for (i = 0; i < linelen; ++i)
349                 fout.outc(linebuf[i]);
350
351             fout.newline();
352             linelen = 0;
353             wraphere = 0;
354             inAttVal = false;
355         }
356     }
357
358     private void printChar(int c, short mode)
359     {
360         String entity;
361
362         if (c == ' ' && !((mode & (PREFORMATTED | COMMENT | ATTRIBVALUE)) != 0))
363         {
364             /* coerce a space character to a non-breaking space */
365             if ((mode & NOWRAP) != 0)
366             {
367                 /* by default XML doesn't define &nbsp; */
368                 if (this.configuration.NumEntities || this.configuration.XmlTags)
369                 {
370                     addC('&', linelen++);
371                     addC('#', linelen++);
372                     addC('1', linelen++);
373                     addC('6', linelen++);
374                     addC('0', linelen++);
375                     addC(';', linelen++);
376                 }
377                 else /* otherwise use named entity */
378                 {
379                     addC('&', linelen++);
380                     addC('n', linelen++);
381                     addC('b', linelen++);
382                     addC('s', linelen++);
383                     addC('p', linelen++);
384                     addC(';', linelen++);
385                 }
386                 return;
387             }
388             else
389                 wraphere = linelen;
390         }
391
392         /* comment characters are passed raw */
393         if ((mode & COMMENT) != 0)
394         {
395             addC(c, linelen++);
396             return;
397         }
398
399         /* except in CDATA map < to &lt; etc. */
400         if (! ((mode & CDATA) != 0) )
401         {
402             if (c == '<')
403             {
404                 addC('&', linelen++);
405                 addC('l', linelen++);
406                 addC('t', linelen++);
407                 addC(';', linelen++);
408                 return;
409             }
410             
411             if (c == '>')
412             {
413                 addC('&', linelen++);
414                 addC('g', linelen++);
415                 addC('t', linelen++);
416                 addC(';', linelen++);
417                 return;
418             }
419
420             /*
421               naked '&' chars can be left alone or
422               quoted as &amp; The latter is required
423               for XML where naked '&' are illegal.
424             */
425             if (c == '&' && this.configuration.QuoteAmpersand)
426             {
427                 addC('&', linelen++);
428                 addC('a', linelen++);
429                 addC('m', linelen++);
430                 addC('p', linelen++);
431                 addC(';', linelen++);
432                 return;
433             }
434
435             if (c == '"' && this.configuration.QuoteMarks)
436             {
437                 addC('&', linelen++);
438                 addC('q', linelen++);
439                 addC('u', linelen++);
440                 addC('o', linelen++);
441                 addC('t', linelen++);
442                 addC(';', linelen++);
443                 return;
444             }
445
446             if (c == '\'' && this.configuration.QuoteMarks)
447             {
448                 addC('&', linelen++);
449                 addC('#', linelen++);
450                 addC('3', linelen++);
451                 addC('9', linelen++);
452                 addC(';', linelen++);
453                 return;
454             }
455
456             if (c == 160 && this.configuration.CharEncoding != Configuration.RAW)
457             {
458                 if (this.configuration.QuoteNbsp)
459                 {
460                     addC('&', linelen++);
461
462                     if (this.configuration.NumEntities)
463                     {
464                         addC('#', linelen++);
465                         addC('1', linelen++);
466                         addC('6', linelen++);
467                         addC('0', linelen++);
468                     }
469                     else
470                     {
471                         addC('n', linelen++);
472                         addC('b', linelen++);
473                         addC('s', linelen++);
474                         addC('p', linelen++);
475                     }
476
477                     addC(';', linelen++);
478                 }
479                 else
480                     addC(c, linelen++);
481
482                 return;
483             }
484         }
485
486         /* otherwise ISO 2022 characters are passed raw */
487         if (this.configuration.CharEncoding == Configuration.ISO2022 ||
488             this.configuration.CharEncoding == Configuration.RAW)
489         {
490             addC(c, linelen++);
491             return;
492         }
493
494         /* if preformatted text, map &nbsp; to space */
495         if (c == 160 && ((mode & PREFORMATTED) != 0))
496         {
497             addC(' ', linelen++);
498             return;
499         }
500
501         /*
502          Filters from Word and PowerPoint often use smart
503          quotes resulting in character codes between 128
504          and 159. Unfortunately, the corresponding HTML 4.0
505          entities for these are not widely supported. The
506          following converts dashes and quotation marks to
507          the nearest ASCII equivalent. My thanks to
508          Andrzej Novosiolov for his help with this code.
509         */
510
511         if (this.configuration.MakeClean)
512         {
513             if (c >= 0x2013 && c <= 0x201E)
514             {
515                 switch (c) {
516                 case 0x2013:
517                 case 0x2014:
518                   c = '-';
519                   break;
520                 case 0x2018:
521                 case 0x2019:
522                 case 0x201A:
523                   c = '\'';
524                   break;
525                 case 0x201C:
526                 case 0x201D:
527                 case 0x201E:
528                   c = '"';
529                   break;
530                 }
531             }
532         }
533
534         /* don't map latin-1 chars to entities */
535         if (this.configuration.CharEncoding == Configuration.LATIN1)
536         {
537             if (c > 255)  /* multi byte chars */
538             {
539                 if (!this.configuration.NumEntities)
540                 {
541                     entity = EntityTable.getDefaultEntityTable().entityName((short)c);
542                     if (entity != null)
543                         entity = "&" + entity + ";";
544                     else
545                         entity = "&#" + c + ";";
546                 }
547                 else
548                     entity = "&#" + c + ";";
549
550                 for (int i = 0; i < entity.length(); i++)
551                     addC((int)entity.charAt(i), linelen++);
552
553                 return;
554             }
555
556             if (c > 126 && c < 160)
557             {
558                 entity = "&#" + c + ";";
559
560                 for (int i = 0; i < entity.length(); i++)
561                     addC((int)entity.charAt(i), linelen++);
562
563                 return;
564             }
565
566             addC(c, linelen++);
567             return;
568         }
569
570         /* don't map utf8 chars to entities */
571         if (this.configuration.CharEncoding == Configuration.UTF8)
572         {
573             addC(c, linelen++);
574             return;
575         }
576
577         /* use numeric entities only  for XML */
578         if (this.configuration.XmlTags)
579         {
580             /* if ASCII use numeric entities for chars > 127 */
581             if (c > 127 && this.configuration.CharEncoding == Configuration.ASCII)
582             {
583                 entity = "&#" + c + ";";
584
585                 for (int i = 0; i < entity.length(); i++)
586                     addC((int)entity.charAt(i), linelen++);
587
588                 return;
589             }
590
591             /* otherwise output char raw */
592             addC(c, linelen++);
593             return;
594         }
595
596         /* default treatment for ASCII */
597         if (c > 126 || (c < ' ' && c != '\t'))
598         {
599             if (!this.configuration.NumEntities)
600             {
601                 entity = EntityTable.getDefaultEntityTable().entityName((short)c);
602                 if (entity != null)
603                     entity = "&" + entity + ";";
604                 else
605                     entity = "&#" + c + ";";
606             }
607             else
608                 entity = "&#" + c + ";";
609
610             for (int i = 0; i < entity.length(); i++)
611                 addC((int)entity.charAt(i), linelen++);
612
613             return;
614         }
615
616         addC(c, linelen++);
617     }
618
619     /* 
620       The line buffer is uint not char so we can
621       hold Unicode values unencoded. The translation
622       to UTF-8 is deferred to the outc routine called
623       to flush the line buffer.
624     */
625     private void printText(Out fout, short mode, int indent,
626                            byte[] textarray, int start, int end)
627     {
628         int i, c;
629         MutableInteger ci = new MutableInteger();
630
631         for (i = start; i < end; ++i)
632         {
633             if (indent + linelen >= this.configuration.wraplen)
634                 wrapLine(fout, indent);
635
636             c = ((int)textarray[i]) & 0xFF;  // Convert to unsigned.
637
638             /* look for UTF-8 multibyte character */
639             if (c > 0x7F)
640             {
641                  i += getUTF8(textarray, i, ci);
642                  c = ci.value;
643             }
644
645             if (c == '\n')
646             {
647                 flushLine(fout, indent);
648                 continue;
649             }
650
651             printChar(c, mode);
652         }
653     }
654
655     private void printString(Out fout, int indent, String str)
656     {
657         for (int i = 0; i < str.length(); i++ )
658             addC((int)str.charAt(i), linelen++);
659     }
660
661     private void printAttrValue(Out fout, int indent, String value, int delim, boolean wrappable)
662     {
663         int c;
664         MutableInteger ci = new MutableInteger();
665         boolean wasinstring = false;
666         byte[] valueChars = null;
667         int i;
668         short mode = (wrappable ? (short)(NORMAL | ATTRIBVALUE) :
669                                   (short)(PREFORMATTED | ATTRIBVALUE));
670
671         if (value != null)
672         {
673             valueChars = Lexer.getBytes(value);
674         }
675
676         /* look for ASP, Tango or PHP instructions for computed attribute value */
677         if (valueChars != null && valueChars.length >= 5 && valueChars[0] == '<')
678         {
679             if (valueChars[1] == '%' || valueChars[1] == '@'||
680                 (new String(valueChars, 0, 5)).equals("<?php"))
681                 mode |= CDATA;
682         }
683
684         if (delim == 0)
685             delim = '"';
686
687         addC('=', linelen++);
688
689         /* don't wrap after "=" for xml documents */
690         if (!this.configuration.XmlOut) {
691
692             if (indent + linelen < this.configuration.wraplen)
693                 wraphere = linelen;
694
695             if (indent + linelen >= this.configuration.wraplen)
696                 wrapLine(fout, indent);
697
698             if (indent + linelen < this.configuration.wraplen)
699                 wraphere = linelen;
700             else
701                 condFlushLine(fout, indent);
702         }
703
704         addC(delim, linelen++);
705
706         if (value != null)
707         {
708             InString = false;
709
710             i = 0;
711             while (i < valueChars.length)
712             {
713                 c = ((int)valueChars[i]) & 0xFF;  // Convert to unsigned.
714
715                 if (wrappable && c == ' ' && indent + linelen < this.configuration.wraplen)
716                 {
717                     wraphere = linelen;
718                     wasinstring = InString;
719                 }
720
721                 if (wrappable && wraphere > 0 && indent + linelen >= this.configuration.wraplen)
722                     wrapAttrVal(fout, indent, wasinstring);
723
724                 if (c == delim)
725                 {
726                     String entity;
727
728                     entity = (c == '"' ? "&quot;" : "&#39;");
729
730                     for (int j = 0; j < entity.length(); j++ )
731                         addC(entity.charAt(j), linelen++);
732
733                     ++i;
734                     continue;
735                 }
736                 else if (c == '"')
737                 {
738                     if (this.configuration.QuoteMarks)
739                     {
740                         addC('&', linelen++);
741                         addC('q', linelen++);
742                         addC('u', linelen++);
743                         addC('o', linelen++);
744                         addC('t', linelen++);
745                         addC(';', linelen++);
746                     }
747                     else
748                         addC('"', linelen++);
749
750                     if (delim == '\'')
751                         InString = !InString;
752
753                     ++i;
754                     continue;
755                 }
756                 else if (c == '\'')
757                 {
758                     if (this.configuration.QuoteMarks)
759                     {
760                         addC('&', linelen++);
761                         addC('#', linelen++);
762                         addC('3', linelen++);
763                         addC('9', linelen++);
764                         addC(';', linelen++);
765                     }
766                     else
767                         addC('\'', linelen++);
768
769                     if (delim == '"')
770                         InString = !InString;
771
772                     ++i;
773                     continue;
774                 }
775
776                 /* look for UTF-8 multibyte character */
777                 if (c > 0x7F)
778                 {
779                      i += getUTF8(valueChars, i, ci);
780                      c = ci.value;
781                 }
782
783                 ++i;
784
785                 if (c == '\n')
786                 {
787                     flushLine(fout, indent);
788                     continue;
789                 }
790
791                 printChar(c, mode);
792             }
793         }
794
795         InString = false;
796         addC(delim, linelen++);
797     }
798
799     private void printAttribute(Out fout, int indent, Node node, AttVal attr)
800     {
801         String name;
802         boolean wrappable = false;
803
804         if (this.configuration.IndentAttributes)
805         {
806             flushLine(fout, indent);
807             indent += this.configuration.spaces;
808         }
809
810         name = attr.attribute;
811
812         if (indent + linelen >= this.configuration.wraplen)
813             wrapLine(fout, indent);
814
815         if (!this.configuration.XmlTags && !this.configuration.XmlOut && attr.dict != null)
816         {
817             if (AttributeTable.getDefaultAttributeTable().isScript(name))
818                 wrappable = this.configuration.WrapScriptlets;
819             else if (!attr.dict.nowrap && this.configuration.WrapAttVals)
820                 wrappable = true;
821         }
822
823         if (indent + linelen < this.configuration.wraplen)
824         {
825             wraphere = linelen;
826             addC(' ', linelen++);
827         }
828         else
829         {
830             condFlushLine(fout, indent);
831             addC(' ', linelen++);
832         }
833
834         for (int i = 0; i < name.length(); i++ )
835             addC((int)Lexer.foldCase(name.charAt(i),
836                                      this.configuration.UpperCaseAttrs,
837                                      this.configuration.XmlTags),
838                  linelen++);
839
840         if (indent + linelen >= this.configuration.wraplen)
841             wrapLine(fout, indent);
842  
843         if (attr.value == null)
844         {
845             if (this.configuration.XmlTags || this.configuration.XmlOut)
846                 printAttrValue(fout, indent, attr.attribute, attr.delim, true);
847             else if (!attr.isBoolAttribute() && !Node.isNewNode(node))
848                 printAttrValue(fout, indent, "", attr.delim, true);
849             else if (indent + linelen < this.configuration.wraplen)
850                 wraphere = linelen;
851
852         }
853         else
854             printAttrValue(fout, indent, attr.value, attr.delim, wrappable);
855     }
856
857     private void printAttrs(Out fout, int indent,
858                             Node node, AttVal attr)
859     {
860         if (attr != null)
861         {
862             if (attr.next != null)
863                 printAttrs(fout, indent, node, attr.next);
864
865             if (attr.attribute != null)
866                 printAttribute(fout, indent, node, attr);
867             else if (attr.asp != null)
868             {
869                 addC(' ', linelen++);
870                 printAsp(fout, indent, attr.asp);
871             }
872             else if (attr.php != null)
873             {
874                 addC(' ', linelen++);
875                 printPhp(fout, indent, attr.php);
876             }
877         }
878
879         /* add xml:space attribute to pre and other elements */
880         if (configuration.XmlOut &&
881                 configuration.XmlSpace &&
882                 ParserImpl.XMLPreserveWhiteSpace(node, configuration.tt) &&
883                 node.getAttrByName("xml:space") == null)
884             printString(fout, indent, " xml:space=\"preserve\"");
885     }
886
887     /*
888      Line can be wrapped immediately after inline start tag provided
889      if follows a text node ending in a space, or it parent is an
890      inline element that that rule applies to. This behaviour was
891      reverse engineered from Netscape 3.0
892     */
893     private static boolean afterSpace(Node node)
894     {
895         Node prev;
896         int c;
897
898         if (node == null || node.tag == null || !((node.tag.model & Dict.CM_INLINE) != 0))
899             return true;
900
901         prev = node.prev;
902
903         if (prev != null)
904         {
905             if (prev.type == Node.TextNode && prev.end > prev.start)
906             {
907                 c = ((int)prev.textarray[prev.end - 1]) & 0xFF;  // Convert to unsigned.
908
909                 if (c == 160 || c == ' ' || c == '\n')
910                     return true;
911             }
912
913             return false;
914         }
915
916         return afterSpace(node.parent);
917     }
918
919     private void printTag(Lexer lexer, Out fout, short mode, int indent, Node node)
920     {
921         char c;
922         String p;
923         TagTable tt = this.configuration.tt;
924
925         addC('<', linelen++);
926
927         if (node.type == Node.EndTag)
928             addC('/', linelen++);
929
930         p = node.element;
931         for (int i = 0; i < p.length(); i++ )
932             addC((int)Lexer.foldCase(p.charAt(i),
933                                      this.configuration.UpperCaseTags,
934                                      this.configuration.XmlTags),
935                  linelen++);
936
937         printAttrs(fout, indent, node, node.attributes);
938
939         if ((this.configuration.XmlOut || lexer != null && lexer.isvoyager) &&
940                 (node.type == Node.StartEndTag || (node.tag.model & Dict.CM_EMPTY) != 0))
941         {
942             addC(' ', linelen++);   /* compatibility hack */
943             addC('/', linelen++);
944         }
945
946         addC('>', linelen++);;
947
948         if (node.type != Node.StartEndTag && !((mode & PREFORMATTED) != 0))
949         {
950             if (indent + linelen >= this.configuration.wraplen)
951                 wrapLine(fout, indent);
952
953             if (indent + linelen < this.configuration.wraplen)
954             {
955                 /*
956                  wrap after start tag if is <br/> or if it's not
957                  inline or it is an empty tag followed by </a>
958                 */
959                 if (afterSpace(node))
960                 {
961                     if (!((mode & NOWRAP) != 0) &&
962                         (!((node.tag.model & Dict.CM_INLINE) != 0) ||
963                           (node.tag == tt.tagBr) ||
964                           (((node.tag.model & Dict.CM_EMPTY) != 0) && 
965                           node.next == null &&
966                           node.parent.tag == tt.tagA)))
967                     {
968                         wraphere = linelen;
969                     }
970                 }
971             }
972             else
973                 condFlushLine(fout, indent);
974         }
975     }
976
977     private void printEndTag(Out fout, short mode, int indent, Node node)
978     {
979         char c;
980         String p;
981
982        /*
983          Netscape ignores SGML standard by not ignoring a
984          line break before </A> or </U> etc. To avoid rendering 
985          this as an underlined space, I disable line wrapping
986          before inline end tags by the #if 0 ... #endif
987        */
988 if (false) {
989         if (indent + linelen < this.configuration.wraplen && !((mode & NOWRAP) != 0))
990             wraphere = linelen;
991 }
992
993         addC('<', linelen++);
994         addC('/', linelen++);
995
996         p = node.element;
997         for (int i = 0; i < p.length(); i++ )
998             addC((int)Lexer.foldCase(p.charAt(i),
999                                      this.configuration.UpperCaseTags,
1000                                      this.configuration.XmlTags),
1001                  linelen++);
1002
1003         addC('>', linelen++);
1004     }
1005
1006     private void printComment(Out fout, int indent, Node node)
1007     {
1008         if (indent + linelen < this.configuration.wraplen)
1009             wraphere = linelen;
1010
1011         addC('<', linelen++);
1012         addC('!', linelen++);
1013         addC('-', linelen++);
1014         addC('-', linelen++);
1015 if (false) {
1016         if (linelen < this.configuration.wraplen)
1017             wraphere = linelen;
1018 }
1019         printText(fout, COMMENT, indent,
1020                         node.textarray, node.start, node.end);
1021 if (false) {
1022         if (indent + linelen < this.configuration.wraplen)
1023             wraphere = linelen;
1024 }
1025         // See Lexer.java: AQ 8Jul2000
1026         addC('-', linelen++);
1027         addC('-', linelen++);
1028         addC('>', linelen++);
1029
1030         if (node.linebreak)
1031             flushLine(fout, indent);
1032     }
1033
1034     private void printDocType(Out fout, int indent, Node node)
1035     {
1036         boolean q = this.configuration.QuoteMarks;
1037
1038         this.configuration.QuoteMarks = false;
1039
1040         if (indent + linelen < this.configuration.wraplen)
1041             wraphere = linelen;
1042
1043         condFlushLine(fout, indent);
1044
1045         addC('<', linelen++);
1046         addC('!', linelen++);
1047         addC('D', linelen++);
1048         addC('O', linelen++);
1049         addC('C', linelen++);
1050         addC('T', linelen++);
1051         addC('Y', linelen++);
1052         addC('P', linelen++);
1053         addC('E', linelen++);
1054         addC(' ', linelen++);
1055
1056         if (indent + linelen < this.configuration.wraplen)
1057             wraphere = linelen;
1058
1059         printText(fout, (short)0, indent,
1060                         node.textarray, node.start, node.end);
1061
1062         if (linelen < this.configuration.wraplen)
1063             wraphere = linelen;
1064
1065         addC('>', linelen++);
1066         this.configuration.QuoteMarks = q;
1067         condFlushLine(fout, indent);
1068     }
1069
1070     private void printPI(Out fout, int indent, Node node)
1071     {
1072         if (indent + linelen < this.configuration.wraplen)
1073             wraphere = linelen;
1074
1075         addC('<', linelen++);
1076         addC('?', linelen++);
1077
1078         /* set CDATA to pass < and > unescaped */
1079         printText(fout, CDATA, indent,
1080                     node.textarray, node.start, node.end);
1081
1082         if (node.textarray[node.end - 1] != (byte)'?')
1083             addC('?', linelen++);
1084
1085         addC('>', linelen++);
1086         condFlushLine(fout, indent);
1087     }
1088
1089     /* note ASP and JSTE share <% ... %> syntax */
1090     private void printAsp(Out fout, int indent, Node node)
1091     {
1092         int savewraplen = this.configuration.wraplen;
1093
1094         /* disable wrapping if so requested */
1095
1096         if (!this.configuration.WrapAsp || !this.configuration.WrapJste)
1097             this.configuration.wraplen = 0xFFFFFF;  /* a very large number */
1098 if (false) { //#if 0
1099         if (indent + linelen < this.configuration.wraplen)
1100             wraphere = linelen;
1101 } //#endif
1102
1103         addC('<', linelen++);
1104         addC('%', linelen++);
1105
1106         printText(fout, (this.configuration.WrapAsp ? CDATA : COMMENT), indent,
1107                     node.textarray, node.start, node.end);
1108
1109         addC('%', linelen++);
1110         addC('>', linelen++);
1111         /* condFlushLine(fout, indent); */
1112         this.configuration.wraplen = savewraplen;
1113     }
1114
1115     /* JSTE also supports <# ... #> syntax */
1116     private void printJste(Out fout, int indent, Node node)
1117     {
1118         int savewraplen = this.configuration.wraplen;
1119
1120         /* disable wrapping if so requested */
1121
1122         if (!this.configuration.WrapJste)
1123             this.configuration.wraplen = 0xFFFFFF;  /* a very large number */
1124
1125         addC('<', linelen++);
1126         addC('#', linelen++);
1127
1128         printText(fout, (this.configuration.WrapJste ? CDATA : COMMENT), indent,
1129                     node.textarray, node.start, node.end);
1130
1131         addC('#', linelen++);
1132         addC('>', linelen++);
1133         /* condFlushLine(fout, indent); */
1134         this.configuration.wraplen = savewraplen;
1135     }
1136
1137     /* PHP is based on XML processing instructions */
1138     private void printPhp(Out fout, int indent, Node node)
1139     {
1140         int savewraplen = this.configuration.wraplen;
1141
1142         /* disable wrapping if so requested */
1143
1144         if (!this.configuration.WrapPhp)
1145             this.configuration.wraplen = 0xFFFFFF;  /* a very large number */
1146
1147 if (false) { //#if 0
1148         if (indent + linelen < this.configuration.wraplen)
1149             wraphere = linelen;
1150 } //#endif
1151         addC('<', linelen++);
1152         addC('?', linelen++);
1153
1154         printText(fout, (this.configuration.WrapPhp ? CDATA : COMMENT), indent,
1155                         node.textarray, node.start, node.end);
1156
1157         addC('?', linelen++);
1158         addC('>', linelen++);
1159         /* PCondFlushLine(fout, indent); */
1160         this.configuration.wraplen = savewraplen;
1161     }
1162
1163     private void printCDATA(Out fout, int indent, Node node)
1164     {
1165         int savewraplen = this.configuration.wraplen;
1166
1167         condFlushLine(fout, indent);
1168
1169         /* disable wrapping */
1170
1171         this.configuration.wraplen = 0xFFFFFF;  /* a very large number */
1172
1173         addC('<', linelen++);
1174         addC('!', linelen++);
1175         addC('[', linelen++);
1176         addC('C', linelen++);
1177         addC('D', linelen++);
1178         addC('A', linelen++);
1179         addC('T', linelen++);
1180         addC('A', linelen++);
1181         addC('[', linelen++);
1182
1183         printText(fout, COMMENT, indent,
1184                         node.textarray, node.start, node.end);
1185
1186         addC(']', linelen++);
1187         addC(']', linelen++);
1188         addC('>', linelen++);
1189         condFlushLine(fout, indent);
1190         this.configuration.wraplen = savewraplen;
1191     }
1192
1193     private void printSection(Out fout, int indent, Node node)
1194     {
1195         int savewraplen = this.configuration.wraplen;
1196
1197         /* disable wrapping if so requested */
1198
1199         if (!this.configuration.WrapSection)
1200             this.configuration.wraplen = 0xFFFFFF;  /* a very large number */
1201
1202 if (false) { //#if 0
1203         if (indent + linelen < this.configuration.wraplen)
1204             wraphere = linelen;
1205 } //#endif
1206         addC('<', linelen++);
1207         addC('!', linelen++);
1208         addC('[', linelen++);
1209
1210         printText(fout, (this.configuration.WrapSection ? CDATA : COMMENT), indent,
1211                         node.textarray, node.start, node.end);
1212
1213         addC(']', linelen++);
1214         addC('>', linelen++);
1215         /* PCondFlushLine(fout, indent); */
1216         this.configuration.wraplen = savewraplen;
1217     }
1218
1219     private boolean shouldIndent(Node node)
1220     {
1221         TagTable tt = this.configuration.tt;
1222
1223         if (!this.configuration.IndentContent)
1224             return false;
1225
1226         if (this.configuration.SmartIndent)
1227         {
1228             if (node.content != null && ((node.tag.model & Dict.CM_NO_INDENT) != 0))
1229             {
1230                 for (node = node.content; node != null; node = node.next)
1231                     if (node.tag != null && (node.tag.model & Dict.CM_BLOCK) != 0)
1232                         return true;
1233
1234                 return false;
1235             }
1236
1237             if ((node.tag.model & Dict.CM_HEADING) != 0)
1238                 return false;
1239
1240             if (node.tag == tt.tagP)
1241                 return false;
1242
1243             if (node.tag == tt.tagTitle)
1244                 return false;
1245         }
1246
1247         if ((node.tag.model & (Dict.CM_FIELD | Dict.CM_OBJECT)) != 0)
1248             return true;
1249
1250         if (node.tag == tt.tagMap)
1251             return true;
1252
1253         return !((node.tag.model & Dict.CM_INLINE) != 0);
1254     }
1255
1256     public void printTree(Out fout, short mode, int indent,
1257                           Lexer lexer, Node node)
1258     {
1259         Node content, last;
1260         TagTable tt = this.configuration.tt;
1261
1262         if (node == null)
1263             return;
1264
1265         if (node.type == Node.TextNode)
1266             printText(fout, mode, indent,
1267                         node.textarray, node.start, node.end);
1268         else if (node.type == Node.CommentTag)
1269         {
1270             printComment(fout, indent, node);
1271         }
1272         else if (node.type == Node.RootNode)
1273         {
1274             for (content = node.content;
1275                     content != null;
1276                     content = content.next)
1277                printTree(fout, mode, indent, lexer, content);
1278         }
1279         else if (node.type == Node.DocTypeTag)
1280             printDocType(fout, indent, node);
1281         else if (node.type == Node.ProcInsTag)
1282             printPI(fout, indent, node);
1283         else if (node.type == Node.CDATATag)
1284             printCDATA(fout, indent, node);
1285         else if (node.type == Node.SectionTag)
1286             printSection(fout, indent, node);
1287         else if (node.type == Node.AspTag)
1288             printAsp(fout, indent, node);
1289         else if (node.type == Node.JsteTag)
1290             printJste(fout, indent, node);
1291         else if (node.type == Node.PhpTag)
1292             printPhp(fout, indent, node);
1293         else if ((node.tag.model & Dict.CM_EMPTY) != 0 || node.type == Node.StartEndTag)
1294         {
1295             if (!((node.tag.model & Dict.CM_INLINE) != 0))
1296                 condFlushLine(fout, indent);
1297
1298             if (node.tag == tt.tagBr && node.prev != null &&
1299                 node.prev.tag != tt.tagBr && this.configuration.BreakBeforeBR)
1300                 flushLine(fout, indent);
1301
1302             if (this.configuration.MakeClean && node.tag == tt.tagWbr)
1303                 printString(fout, indent, " ");
1304             else
1305                 printTag(lexer, fout, mode, indent, node);
1306
1307             if (node.tag == tt.tagParam || node.tag == tt.tagArea)
1308                 condFlushLine(fout, indent);
1309             else if (node.tag == tt.tagBr || node.tag == tt.tagHr)
1310                 flushLine(fout, indent);
1311         }
1312         else /* some kind of container element */
1313         {
1314             if (node.tag != null && node.tag.parser == ParserImpl.getParsePre())
1315             {
1316                 condFlushLine(fout, indent);
1317
1318                 indent = 0;
1319                 condFlushLine(fout, indent);
1320                 printTag(lexer, fout, mode, indent, node);
1321                 flushLine(fout, indent);
1322
1323                 for (content = node.content;
1324                         content != null;
1325                         content = content.next)
1326                     printTree(fout, (short)(mode | PREFORMATTED | NOWRAP), indent, lexer, content);
1327
1328                 condFlushLine(fout, indent);
1329                 printEndTag(fout, mode, indent, node);
1330                 flushLine(fout, indent);
1331
1332                 if (this.configuration.IndentContent == false && node.next != null)
1333                     flushLine(fout, indent);
1334             }
1335             else if (node.tag == tt.tagStyle || node.tag == tt.tagScript)
1336             {
1337                 condFlushLine(fout, indent);
1338
1339                 indent = 0;
1340                 condFlushLine(fout, indent);
1341                 printTag(lexer, fout, mode, indent, node);
1342                 flushLine(fout, indent);
1343
1344                 for (content = node.content;
1345                         content != null;
1346                         content = content.next)
1347                     printTree(fout, (short)(mode | PREFORMATTED | NOWRAP |CDATA), indent, lexer, content);
1348
1349                 condFlushLine(fout, indent);
1350                 printEndTag(fout, mode, indent, node);
1351                 flushLine(fout, indent);
1352
1353                 if (this.configuration.IndentContent == false && node.next != null)
1354                     flushLine(fout, indent);
1355             }
1356             else if ((node.tag.model & Dict.CM_INLINE) != 0)
1357             {
1358                 if (this.configuration.MakeClean)
1359                 {
1360                     /* discards <font> and </font> tags */
1361                     if (node.tag == tt.tagFont)
1362                     {
1363                         for (content = node.content;
1364                                 content != null;
1365                                 content = content.next)
1366                             printTree(fout, mode, indent, lexer, content);
1367                         return;
1368                     }
1369
1370                     /* replace <nobr>...</nobr> by &nbsp; or &#160; etc. */
1371                     if (node.tag == tt.tagNobr)
1372                     {
1373                         for (content = node.content;
1374                                 content != null;
1375                                 content = content.next)
1376                             printTree(fout, (short)(mode|NOWRAP), indent, lexer, content);
1377                         return;
1378                     }
1379                 }
1380
1381                 /* otherwise a normal inline element */
1382
1383                 printTag(lexer, fout, mode, indent, node);
1384
1385                 /* indent content for SELECT, TEXTAREA, MAP, OBJECT and APPLET */
1386
1387                 if (shouldIndent(node))
1388                 {
1389                     condFlushLine(fout, indent);
1390                     indent += this.configuration.spaces;
1391
1392                     for (content = node.content;
1393                             content != null;
1394                             content = content.next)
1395                         printTree(fout, mode, indent, lexer, content);
1396
1397                     condFlushLine(fout, indent);
1398                     indent -= this.configuration.spaces;
1399                     condFlushLine(fout, indent);
1400                 }
1401                 else
1402                 {
1403
1404                     for (content = node.content;
1405                             content != null;
1406                             content = content.next)
1407                         printTree(fout, mode, indent, lexer, content);
1408                 }
1409
1410                 printEndTag(fout, mode, indent, node);
1411             }
1412             else /* other tags */
1413             {
1414                 condFlushLine(fout, indent);
1415
1416                 if (this.configuration.SmartIndent && node.prev != null)
1417                     flushLine(fout, indent);
1418
1419                 if (this.configuration.HideEndTags == false ||
1420                     !(node.tag != null && ((node.tag.model & Dict.CM_OMITST) != 0)))
1421                 {
1422                     printTag(lexer, fout, mode, indent, node);
1423
1424                     if (shouldIndent(node))
1425                         condFlushLine(fout, indent);
1426                     else if ((node.tag.model & Dict.CM_HTML) != 0 ||
1427                              node.tag == tt.tagNoframes ||
1428                                 ((node.tag.model & Dict.CM_HEAD) != 0 &&
1429                                 !(node.tag == tt.tagTitle)))
1430                         flushLine(fout, indent);
1431                 }
1432
1433                 if (node.tag == tt.tagBody && this.configuration.BurstSlides)
1434                     printSlide(fout, mode, (this.configuration.IndentContent ? indent+this.configuration.spaces : indent), lexer);
1435                 else
1436                 {
1437                     last = null;
1438
1439                     for (content = node.content;
1440                             content != null; content = content.next)
1441                     {
1442                         /* kludge for naked text before block level tag */
1443                         if (last != null && !this.configuration.IndentContent && last.type == Node.TextNode &&
1444                             content.tag != null && (content.tag.model & Dict.CM_BLOCK) != 0)
1445                         {
1446                             flushLine(fout, indent);
1447                             flushLine(fout, indent);
1448                         }
1449
1450                         printTree(fout, mode,
1451                             (shouldIndent(node) ? indent+this.configuration.spaces : indent), lexer, content);
1452
1453                         last = content;
1454                     }
1455                 }
1456
1457                 /* don't flush line for td and th */
1458                 if (shouldIndent(node) ||
1459                     (((node.tag.model & Dict.CM_HTML) != 0 || node.tag == tt.tagNoframes ||
1460                         ((node.tag.model & Dict.CM_HEAD) != 0 && !(node.tag == tt.tagTitle)))
1461                         && this.configuration.HideEndTags == false))
1462                 {
1463                     condFlushLine(fout, (this.configuration.IndentContent ? indent+this.configuration.spaces : indent));
1464
1465                     if (this.configuration.HideEndTags == false || !((node.tag.model & Dict.CM_OPT) != 0))
1466                     {
1467                         printEndTag(fout, mode, indent, node);
1468                         flushLine(fout, indent);
1469                     }
1470                 }
1471                 else
1472                 {
1473                     if (this.configuration.HideEndTags == false || !((node.tag.model & Dict.CM_OPT) != 0))
1474                         printEndTag(fout, mode, indent, node);
1475
1476                     flushLine(fout, indent);
1477                 }
1478
1479                 if (this.configuration.IndentContent == false &&
1480                     node.next != null &&
1481                     this.configuration.HideEndTags == false &&
1482                     (node.tag.model & (Dict.CM_BLOCK|Dict.CM_LIST|Dict.CM_DEFLIST|Dict.CM_TABLE)) != 0)
1483                 {
1484                     flushLine(fout, indent);
1485                 }
1486             }
1487         }
1488     }
1489
1490     public void printXMLTree(Out fout, short mode, int indent,
1491                              Lexer lexer, Node node)
1492     {
1493         TagTable tt = this.configuration.tt;
1494
1495         if (node == null)
1496             return;
1497
1498         if (node.type == Node.TextNode)
1499         {
1500             printText(fout, mode, indent,
1501                         node.textarray, node.start, node.end);
1502         }
1503         else if (node.type == Node.CommentTag)
1504         {
1505             condFlushLine(fout, indent);
1506             printComment(fout, 0, node);
1507             condFlushLine(fout, 0);
1508         }
1509         else if (node.type == Node.RootNode)
1510         {
1511             Node content;
1512
1513             for (content = node.content;
1514                     content != null;
1515                     content = content.next)
1516                printXMLTree(fout, mode, indent, lexer, content);
1517         }
1518         else if (node.type == Node.DocTypeTag)
1519             printDocType(fout, indent, node);
1520         else if (node.type == Node.ProcInsTag)
1521             printPI(fout, indent, node);
1522         else if (node.type == Node.SectionTag)
1523             printSection(fout, indent, node);
1524         else if (node.type == Node.AspTag)
1525             printAsp(fout, indent, node);
1526         else if (node.type == Node.JsteTag)
1527             printJste(fout, indent, node);
1528         else if (node.type == Node.PhpTag)
1529             printPhp(fout, indent, node);
1530         else if ((node.tag.model & Dict.CM_EMPTY) != 0 || node.type == Node.StartEndTag)
1531         {
1532             condFlushLine(fout, indent);
1533             printTag(lexer, fout, mode, indent, node);
1534             flushLine(fout, indent);
1535
1536             if (node.next != null)
1537                 flushLine(fout, indent);
1538         }
1539         else /* some kind of container element */
1540         {
1541             Node content;
1542             boolean mixed = false;
1543             int cindent;
1544
1545             for (content = node.content; content != null; content = content.next)
1546             {
1547                 if (content.type == Node.TextNode)
1548                 {
1549                     mixed = true;
1550                     break;
1551                 }
1552             }
1553
1554             condFlushLine(fout, indent);
1555
1556             if (ParserImpl.XMLPreserveWhiteSpace(node, tt))
1557             {
1558                 indent = 0;
1559                 cindent = 0;
1560                 mixed = false;
1561             }
1562             else if (mixed)
1563                 cindent = indent;
1564             else
1565                 cindent = indent + this.configuration.spaces;
1566
1567             printTag(lexer, fout, mode, indent, node);
1568
1569             if (!mixed)
1570                 flushLine(fout, indent);
1571  
1572             for (content = node.content;
1573                     content != null;
1574                     content = content.next)
1575                 printXMLTree(fout, mode, cindent, lexer, content);
1576
1577             if (!mixed)
1578                 condFlushLine(fout, cindent);
1579             printEndTag(fout, mode, indent, node);
1580             condFlushLine(fout, indent);
1581
1582             if (node.next != null)
1583                 flushLine(fout, indent);
1584         }
1585     }
1586
1587
1588     /* split parse tree by h2 elements and output to separate files */
1589
1590     /* counts number of h2 children belonging to node */
1591     public int countSlides(Node node)
1592     {
1593         int n = 1;
1594         TagTable tt = this.configuration.tt;
1595
1596         for (node = node.content; node != null; node = node.next)
1597             if (node.tag == tt.tagH2)
1598                 ++n;
1599
1600         return n;
1601     }
1602
1603     /*
1604        inserts a space gif called "dot.gif" to ensure
1605        that the  slide is at least n pixels high
1606      */
1607     private void printVertSpacer(Out fout, int indent)
1608     {
1609         condFlushLine(fout, indent);
1610         printString(fout, indent , 
1611         "<img width=\"0\" height=\"0\" hspace=\"1\" src=\"dot.gif\" vspace=\"%d\" align=\"left\">");
1612         condFlushLine(fout, indent);
1613     }
1614
1615     private void printNavBar(Out fout, int indent)
1616     {
1617         String buf;
1618
1619         condFlushLine(fout, indent);
1620         printString(fout, indent , "<center><small>");
1621
1622         if (slide > 1)
1623         {
1624             buf = "<a href=\"slide" +
1625                   (new Integer(slide - 1)).toString() +
1626                   ".html\">previous</a> | ";
1627             printString(fout, indent , buf);
1628             condFlushLine(fout, indent);
1629
1630             if (slide < count)
1631                 printString(fout, indent , "<a href=\"slide1.html\">start</a> | ");
1632             else
1633                 printString(fout, indent , "<a href=\"slide1.html\">start</a>");
1634
1635             condFlushLine(fout, indent);
1636         }
1637
1638         if (slide < count)
1639         {
1640             buf = "<a href=\"slide" +
1641                   (new Integer(slide + 1)).toString() +
1642                   ".html\">next</a>";
1643             printString(fout, indent , buf);
1644         }
1645
1646         printString(fout, indent , "</small></center>");
1647         condFlushLine(fout, indent);
1648     }
1649
1650     /*
1651       Called from printTree to print the content of a slide from
1652       the node slidecontent. On return slidecontent points to the
1653       node starting the next slide or null. The variables slide
1654       and count are used to customise the navigation bar.
1655     */
1656     public void printSlide(Out fout, short mode, int indent, Lexer lexer)
1657     {
1658         Node content, last;
1659         TagTable tt = this.configuration.tt;
1660
1661         /* insert div for onclick handler */
1662         String s;
1663         s = "<div onclick=\"document.location='slide" +
1664             (new Integer(slide < count ? slide + 1 : 1)).toString() +
1665             ".html'\">";
1666         printString(fout, indent, s);
1667         condFlushLine(fout, indent);
1668
1669         /* first print the h2 element and navbar */
1670         if (slidecontent.tag == tt.tagH2)
1671         {
1672             printNavBar(fout, indent);
1673
1674             /* now print an hr after h2 */
1675
1676             addC('<', linelen++);
1677
1678
1679             addC((int)Lexer.foldCase('h',
1680                                      this.configuration.UpperCaseTags,
1681                                      this.configuration.XmlTags),
1682                  linelen++);
1683             addC((int)Lexer.foldCase('r',
1684                                      this.configuration.UpperCaseTags,
1685                                      this.configuration.XmlTags),
1686                  linelen++);
1687
1688             if (this.configuration.XmlOut == true)
1689                 printString(fout, indent , " />");
1690             else
1691                 addC('>', linelen++);
1692
1693
1694             if (this.configuration.IndentContent == true)
1695                 condFlushLine(fout, indent);
1696
1697             /* PrintVertSpacer(fout, indent); */
1698
1699             /*condFlushLine(fout, indent); */
1700
1701             /* print the h2 element */
1702             printTree(fout, mode,
1703                 (this.configuration.IndentContent ? indent+this.configuration.spaces : indent), lexer, slidecontent);
1704
1705             slidecontent = slidecontent.next;
1706         }
1707     
1708         /* now continue until we reach the next h2 */
1709
1710         last = null;
1711         content = slidecontent;
1712
1713         for (; content != null; content = content.next)
1714         {
1715             if (content.tag == tt.tagH2)
1716                 break;
1717
1718             /* kludge for naked text before block level tag */
1719             if (last != null && !this.configuration.IndentContent && last.type == Node.TextNode &&
1720                 content.tag != null && (content.tag.model & Dict.CM_BLOCK) != 0)
1721             {
1722                 flushLine(fout, indent);
1723                 flushLine(fout, indent);
1724             }
1725
1726             printTree(fout, mode,
1727                 (this.configuration.IndentContent ? indent+this.configuration.spaces : indent), lexer, content);
1728
1729             last = content;
1730         }
1731
1732         slidecontent = content;
1733
1734         /* now print epilog */
1735
1736         condFlushLine(fout, indent);
1737
1738         printString(fout, indent , "<br clear=\"all\">");
1739         condFlushLine(fout, indent);
1740
1741         addC('<', linelen++);
1742
1743
1744         addC((int)Lexer.foldCase('h',
1745                                  this.configuration.UpperCaseTags,
1746                                  this.configuration.XmlTags),
1747              linelen++);
1748         addC((int)Lexer.foldCase('r',
1749                                  this.configuration.UpperCaseTags,
1750                                  this.configuration.XmlTags),
1751              linelen++);
1752
1753         if (this.configuration.XmlOut == true)
1754             printString(fout, indent , " />");
1755         else
1756             addC('>', linelen++);
1757
1758
1759         if (this.configuration.IndentContent == true)
1760             condFlushLine(fout, indent);
1761
1762         printNavBar(fout, indent);
1763
1764         /* end tag for div */
1765         printString(fout, indent, "</div>");
1766         condFlushLine(fout, indent);
1767     }
1768
1769
1770     /*
1771     Add meta element for page transition effect, this works on IE but not NS
1772     */
1773
1774     public void addTransitionEffect(Lexer lexer, Node root, short effect, double duration)
1775     {
1776         Node head = root.findHEAD(lexer.configuration.tt);
1777         String transition;
1778
1779         if (0 <= effect && effect <= 23)
1780             transition = "revealTrans(Duration=" +
1781                          (new Double(duration)).toString() +
1782                          ",Transition=" + effect + ")";
1783         else
1784             transition = "blendTrans(Duration=" +
1785                          (new Double(duration)).toString() + ")";
1786
1787         if (head != null)
1788         {
1789             Node meta = lexer.inferredTag("meta");
1790             meta.addAttribute("http-equiv", "Page-Enter");
1791             meta.addAttribute("content", transition);
1792             Node.insertNodeAtStart(head, meta);
1793         }
1794     }
1795
1796     public void createSlides(Lexer lexer, Node root)
1797     {
1798         Node body;
1799         String buf;
1800         Out out = new OutImpl();
1801
1802         body = root.findBody(lexer.configuration.tt);
1803         count = countSlides(body);
1804         slidecontent = body.content;
1805         addTransitionEffect(lexer, root, EFFECT_BLEND, 3.0);
1806
1807         for (slide = 1; slide <= count; ++slide)
1808         {
1809             buf = "slide" + slide + ".html";
1810             out.state = StreamIn.FSM_ASCII;
1811             out.encoding = this.configuration.CharEncoding;
1812
1813             try
1814             {
1815                 out.out = new FileOutputStream(buf);
1816                 printTree(out, (short)0, 0, lexer, root);
1817                 flushLine(out, 0);
1818                 out.out.close();
1819             }
1820             catch (IOException e)
1821             {
1822                 System.err.println(buf + e.toString() );
1823             }
1824         }
1825
1826         /*
1827          delete superfluous slides by deleting slideN.html
1828          for N = count+1, count+2, etc. until no such file
1829          is found.     
1830         */
1831
1832         for (;;)
1833         {
1834             buf = "slide" + slide + "html";
1835
1836             if (!(new File(buf)).delete())
1837                 break;
1838
1839             ++slide;
1840         }
1841     }
1842
1843 }