Java > Open Source Codes > org > w3c > tidy > Clean


1 /*
2  * @(#)Clean.java 1.11 2000/08/16
3  *
4  */
5
6 package org.w3c.tidy;
7
8 /**
9  *
10  * Clean up misuse of presentation markup
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   Filters from other formats such as Microsoft Word
36   often make excessive use of presentation markup such
37   as font tags, B, I, and the align attribute. By applying
38   a set of production rules, it is straight forward to
39   transform this to use CSS.
40
41   Some rules replace some of the children of an element by
42   style properties on the element, e.g.
43
44   <p><b>...</b></p> -> <p style="font-weight: bold">...</p>
45
46   Such rules are applied to the element's content and then
47   to the element itself until none of the rules more apply.
48   Having applied all the rules to an element, it will have
49   a style attribute with one or more properties.
50
51   Other rules strip the element they apply to, replacing
52   it by style properties on the contents, e.g.
53   
54   <dir><li><p>...</li></dir> -> <p style="margin-left 1em">...
55       
56   These rules are applied to an element before processing
57   its content and replace the current element by the first
58   element in the exposed content.
59
60   After applying both sets of rules, you can replace the
61   style attribute by a class value and style rule in the
62   document head. To support this, an association of styles
63   and class names is built.
64
65   A naive approach is to rely on string matching to test
66   when two property lists are the same. A better approach
67   would be to first sort the properties before matching.
68 */
69
70 public class Clean {
71
72     private int classNum = 1;
73
74     private TagTable tt;
75
76     public Clean(TagTable tt)
77     {
78       this.tt = tt;
79     }
80
81     private StyleProp insertProperty(StyleProp props, String name,
82                                             String value)
83     {
84         StyleProp first, prev, prop;
85         int cmp;
86
87         prev = null;
88         first = props;
89
90         while (props != null)
91         {
92             cmp = props.name.compareTo(name);
93
94             if (cmp == 0)
95             {
96                 /* this property is already defined, ignore new value */
97                 return first;
98             }
99
100             if (cmp > 0) // props.name > name
101 {
102                 /* insert before this */
103
104                 prop = new StyleProp(name, value, props);
105
106                 if (prev != null)
107                     prev.next = prop;
108                 else
109                     first = prop;
110
111                 return first;
112             }
113
114             prev = props;
115             props = props.next;
116         }
117
118         prop = new StyleProp(name, value);
119
120         if (prev != null)
121             prev.next = prop;
122         else
123             first = prop;
124
125         return first;
126     }
127
128     /*
129      Create sorted linked list of properties from style string
130      It temporarily places nulls in place of ':' and ';' to
131      delimit the strings for the property name and value.
132      Some systems don't allow you to null literal strings,
133      so to avoid this, a copy is made first.
134     */
135     private StyleProp createProps(StyleProp prop, String style)
136     {
137         int name_end;
138         int value_end;
139         int value_start = 0;
140         int name_start = 0;
141         boolean more;
142
143         name_start = 0;
144         while (name_start < style.length())
145         {
146             while (name_start < style.length() &&
147                        style.charAt(name_start) == ' ')
148                 ++name_start;
149
150             name_end = name_start;
151
152             while (name_end < style.length())
153             {
154                 if (style.charAt(name_end) == ':')
155                 {
156                     value_start = name_end + 1;
157                     break;
158                 }
159
160                 ++name_end;
161             }
162
163             if (name_end >= style.length() || style.charAt(name_end) != ':')
164                 break;
165
166             while (value_start < style.length() &&
167                        style.charAt(value_start) == ' ')
168                 ++value_start;
169
170             value_end = value_start;
171             more = false;
172
173             while (value_end < style.length())
174             {
175                 if (style.charAt(value_end) == ';')
176                 {
177                     more = true;
178                     break;
179                 }
180
181                 ++value_end;
182             }
183
184             prop = insertProperty(prop,
185                                   style.substring(name_start, name_end),
186                                   style.substring(value_start, value_end));
187
188             if (more)
189             {
190                 name_start = value_end + 1;
191                 continue;
192             }
193
194             break;
195         }
196
197         return prop;
198     }
199
200     private String createPropString(StyleProp props)
201     {
202         String style = "";
203         int len;
204         StyleProp prop;
205
206         /* compute length */
207
208         for (len = 0, prop = props; prop != null; prop = prop.next)
209         {
210             len += prop.name.length() + 2;
211             len += prop.value.length() + 2;
212         }
213
214         for (prop = props; prop != null; prop = prop.next)
215         {
216             style = style.concat(prop.name);
217             style = style.concat(": ");
218
219             style = style.concat(prop.value);
220
221             if (prop.next == null)
222                 break;
223
224             style = style.concat("; ");
225         }
226
227         return style;
228     }
229
230     /*
231       create string with merged properties
232     */
233     private String addProperty(String style, String property)
234     {
235         StyleProp prop;
236
237         prop = createProps(null, style);
238         prop = createProps(prop, property);
239         style = createPropString(prop);
240         return style;
241     }
242
243     private String gensymClass(String tag)
244     {
245         String str;
246
247         str = "c" + classNum;
248         classNum++;
249         return str;
250     }
251
252     private String findStyle(Lexer lexer, String tag, String properties)
253     {
254         Style style;
255
256         for (style = lexer.styles; style != null; style=style.next)
257         {
258             if (style.tag.equals(tag) &&
259                 style.properties.equals(properties))
260                 return style.tagClass;
261         }
262
263         style = new Style(tag, gensymClass(tag), properties, lexer.styles);
264         lexer.styles = style;
265         return style.tagClass;
266     }
267
268     /*
269      Find style attribute in node, and replace it
270      by corresponding class attribute. Search for
271      class in style dictionary otherwise gensym
272      new class and add to dictionary.
273
274      Assumes that node doesn't have a class attribute
275     */
276     private void style2Rule(Lexer lexer, Node node)
277     {
278         AttVal styleattr, classattr;
279         String classname;
280
281         styleattr = node.getAttrByName("style");
282
283         if (styleattr != null)
284         {
285                 classname = findStyle(lexer, node.element, styleattr.value);
286                 classattr = node.getAttrByName("class");
287
288                 /*
289          if there already is a class attribute
290          then append class name after a space
291         */
292                 if (classattr != null)
293         {
294                         classattr.value = classattr.value + " " + classname;
295                         node.removeAttribute(styleattr);
296         }
297         else /* reuse style attribute for class attribute */
298         {
299                         styleattr.attribute = "class";
300                         styleattr.value = classname;
301         }
302         }
303     }
304
305     private void addColorRule(Lexer lexer, String selector, String color)
306     {
307         if (color != null)
308         {
309             lexer.addStringLiteral(selector);
310             lexer.addStringLiteral(" { color: ");
311             lexer.addStringLiteral(color);
312             lexer.addStringLiteral(" }\n");
313         }
314     }
315
316     /*
317      move presentation attribs from body to style element
318
319      background="foo" -> body { background-image: url(foo) }
320      bgcolor="foo" -> body { background-color: foo }
321      text="foo" -> body { color: foo }
322      link="foo" -> :link { color: foo }
323      vlink="foo" -> :visited { color: foo }
324      alink="foo" -> :active { color: foo }
325     */
326     private void cleanBodyAttrs(Lexer lexer, Node body)
327     {
328         AttVal attr;
329         String bgurl = null;
330         String bgcolor = null;
331         String color = null;
332     
333         attr = body.getAttrByName("background");
334
335         if (attr != null)
336         {
337             bgurl = attr.value;
338             attr.value = null;
339             body.removeAttribute(attr);
340         }
341
342         attr = body.getAttrByName("bgcolor");
343
344         if (attr != null)
345         {
346             bgcolor = attr.value;
347             attr.value = null;
348             body.removeAttribute(attr);
349         }
350
351         attr = body.getAttrByName("text");
352
353         if (attr != null)
354         {
355             color = attr.value;
356             attr.value = null;
357             body.removeAttribute(attr);
358         }
359
360         if (bgurl != null || bgcolor != null || color != null)
361         {
362             lexer.addStringLiteral(" body {\n");
363
364             if (bgurl != null)
365             {
366                 lexer.addStringLiteral(" background-image: url(");
367                 lexer.addStringLiteral(bgurl);
368                 lexer.addStringLiteral(");\n");
369             }
370
371             if (bgcolor != null)
372             {
373                 lexer.addStringLiteral(" background-color: ");
374                 lexer.addStringLiteral(bgcolor);
375                 lexer.addStringLiteral(";\n");
376             }
377
378             if (color != null)
379             {
380                 lexer.addStringLiteral(" color: ");
381                 lexer.addStringLiteral(color);
382                 lexer.addStringLiteral(";\n");
383             }
384
385             lexer.addStringLiteral(" }\n");
386         }
387
388         attr = body.getAttrByName("link");
389
390         if (attr != null)
391         {
392             addColorRule(lexer, " :link", attr.value);
393             body.removeAttribute(attr);
394         }
395
396         attr = body.getAttrByName("vlink");
397
398         if (attr != null)
399         {
400             addColorRule(lexer, " :visited", attr.value);
401             body.removeAttribute(attr);
402         }
403
404         attr = body.getAttrByName("alink");
405
406         if (attr != null)
407         {
408             addColorRule(lexer, " :active", attr.value);
409             body.removeAttribute(attr);
410         }
411     }
412
413     private boolean niceBody(Lexer lexer, Node doc)
414     {
415         Node body = doc.findBody(lexer.configuration.tt);
416
417         if (body != null)
418         {
419             if (
420                 body.getAttrByName("background") != null ||
421                 body.getAttrByName("bgcolor") != null ||
422                 body.getAttrByName("text") != null ||
423                 body.getAttrByName("link") != null ||
424                 body.getAttrByName("vlink") != null ||
425                 body.getAttrByName("alink") != null
426                )
427             {
428                 lexer.badLayout |= Report.USING_BODY;
429                 return false;
430             }
431         }
432
433         return true;
434     }
435
436     /* create style element using rules from dictionary */
437     private void createStyleElement(Lexer lexer, Node doc)
438     {
439         Node node, head, body;
440         Style style;
441         AttVal av;
442
443         if (lexer.styles == null && niceBody(lexer, doc))
444             return;
445
446         node = lexer.newNode(Node.StartTag, null, 0, 0, "style");
447         node.implicit = true;
448
449         /* insert type attribute */
450         av = new AttVal(null, null, '"', "type", "text/css");
451         av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
452         node.attributes = av;
453
454         body = doc.findBody(lexer.configuration.tt);
455
456         lexer.txtstart = lexer.lexsize;
457
458         if (body != null)
459             cleanBodyAttrs(lexer, body);
460
461         for (style = lexer.styles; style != null; style = style.next)
462         {
463             lexer.addCharToLexer(' ');
464             lexer.addStringLiteral(style.tag);
465             lexer.addCharToLexer('.');
466             lexer.addStringLiteral(style.tagClass);
467             lexer.addCharToLexer(' ');
468             lexer.addCharToLexer('{');
469             lexer.addStringLiteral(style.properties);
470             lexer.addCharToLexer('}');
471             lexer.addCharToLexer('\n');
472         }
473
474         lexer.txtend = lexer.lexsize;
475
476         Node.insertNodeAtEnd(node,
477                              lexer.newNode(Node.TextNode,
478                                       lexer.lexbuf,
479                                       lexer.txtstart,
480                                       lexer.txtend));
481
482         /*
483          now insert style element into document head
484
485          doc is root node. search its children for html node
486          the head node should be first child of html node
487         */
488
489         head = doc.findHEAD(lexer.configuration.tt);
490     
491         if (head != null)
492             Node.insertNodeAtEnd(head, node);
493     }
494
495     /* ensure bidirectional links are consistent */
496     private void fixNodeLinks(Node node)
497     {
498         Node child;
499
500         if (node.prev != null)
501             node.prev.next = node;
502         else
503             node.parent.content = node;
504
505         if (node.next != null)
506             node.next.prev = node;
507         else
508             node.parent.last = node;
509
510         for (child = node.content; child != null; child = child.next)
511             child.parent = node;
512     }
513
514     /*
515      used to strip child of node when
516      the node has one and only one child
517     */
518     private void stripOnlyChild(Node node)
519     {
520         Node child;
521
522         child = node.content;
523         node.content = child.content;
524         node.last = child.last;
525         child.content = null;
526
527         for (child = node.content; child != null; child = child.next)
528             child.parent = node;
529     }
530
531     /* used to strip font start and end tags */
532     private void discardContainer(Node element, MutableObject pnode)
533     {
534         Node node;
535         Node parent = element.parent;
536
537         if (element.content != null)
538         {
539             element.last.next = element.next;
540
541             if (element.next != null)
542             {
543                 element.next.prev = element.last;
544                 element.last.next = element.next;
545             }
546             else
547                 parent.last = element.last;
548
549             if (element.prev != null)
550             {
551                 element.content.prev = element.prev;
552                 element.prev.next = element.content;
553             }
554             else
555                 parent.content = element.content;
556
557             for (node = element.content; node != null; node = node.next)
558                 node.parent = parent;
559
560             pnode.setObject(element.content);
561         }
562         else
563         {
564             if (element.next != null)
565                 element.next.prev = element.prev;
566             else
567                 parent.last = element.prev;
568
569             if (element.prev != null)
570                 element.prev.next = element.next;
571             else
572                 parent.content = element.next;
573
574             pnode.setObject(element.next);
575         }
576
577         element.next = null;
578         element.content = null;
579     }
580
581     /*
582      Add style property to element, creating style
583      attribute as needed and adding ; delimiter
584     */
585     private void addStyleProperty(Node node, String property)
586     {
587         AttVal av;
588
589         for (av = node.attributes; av != null; av = av.next)
590         {
591             if (av.attribute.equals("style"))
592                 break;
593         }
594
595         /* if style attribute already exists then insert property */
596
597         if (av != null)
598         {
599             String s;
600
601             s = addProperty(av.value, property);
602             av.value = s;
603         }
604         else /* else create new style attribute */
605         {
606             av = new AttVal(node.attributes, null, '"', "style", property);
607             av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
608             node.attributes = av;
609         }
610     }
611
612     /*
613       Create new string that consists of the
614       combined style properties in s1 and s2
615
616       To merge property lists, we build a linked
617       list of property/values and insert properties
618       into the list in order, merging values for
619       the same property name.
620     */
621     private String mergeProperties(String s1, String s2)
622     {
623         String s;
624         StyleProp prop;
625
626         prop = createProps(null, s1);
627         prop = createProps(prop, s2);
628         s = createPropString(prop);
629         return s;
630     }
631
632     private void mergeStyles(Node node, Node child)
633     {
634         AttVal av;
635         String s1, s2, style;
636
637         for (s2 = null, av = child.attributes; av != null; av = av.next)
638         {
639             if (av.attribute.equals("style"))
640             {
641                 s2 = av.value;
642                 break;
643             }
644         }
645
646         for (s1 = null, av = node.attributes; av != null; av = av.next)
647         {
648             if (av.attribute.equals("style"))
649             {
650                 s1 = av.value;
651                 break;
652             }
653         }
654
655         if (s1 != null)
656         {
657             if (s2 != null) /* merge styles from both */
658             {
659                 style = mergeProperties(s1, s2);
660                 av.value = style;
661             }
662         }
663         else if (s2 != null) /* copy style of child */
664         {
665             av = new AttVal(node.attributes, null, '"', "style", s2);
666             av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
667             node.attributes = av;
668         }
669     }
670
671     private String fontSize2Name(String size)
672     {
673         /*
674         String[] sizes =
675         {
676             "50%",
677             "60%",
678             "80%",
679             null,
680             "120%",
681             "150%",
682             "200%"
683         };
684         */
685
686         String [] sizes =
687         {
688             "60%",
689             "70%",
690             "80%",
691             null,
692             "120%",
693             "150%",
694             "200%"
695         };
696         String buf;
697
698         if (size.length() > 0 &&
699             '0' <= size.charAt(0) && size.charAt(0) <= '6')
700         {
701             int n = size.charAt(0) - '0';
702             return sizes[n];
703         }
704
705         if (size.length() > 0 && size.charAt(0) == '-')
706         {
707             if (size.length() > 1 &&
708                 '0' <= size.charAt(1) && size.charAt(1) <= '6')
709             {
710                 int n = size.charAt(1) - '0';
711                 double x;
712
713                 for (x = 1.0; n > 0; --n)
714                     x *= 0.8;
715
716                 x *= 100.0;
717                 buf = "" + (int)x + "%";
718
719                 return buf;
720             }
721
722             return "smaller"; /*"70%"; */
723         }
724
725         if (size.length() > 1 &&
726             '0' <= size.charAt(1) && size.charAt(1) <= '6')
727         {
728             int n = size.charAt(1) - '0';
729             double x;
730
731             for (x = 1.0; n > 0; --n)
732                 x *= 1.2;
733
734             x *= 100.0;
735             buf = "" + (int)x + "%";
736
737             return buf;
738         }
739
740         return "larger"; /* "140%" */
741     }
742
743     private void addFontFace(Node node, String face)
744     {
745         addStyleProperty(node, "font-family: " + face);
746     }
747
748     private void addFontSize(Node node, String size)
749     {
750         String value;
751
752         if (size.equals("6") && node.tag == tt.tagP)
753         {
754             node.element = "h1";
755             tt.findTag(node);
756             return;
757         }
758
759         if (size.equals("5") && node.tag == tt.tagP)
760         {
761             node.element = "h2";
762             tt.findTag(node);
763             return;
764         }
765
766         if (size.equals("4") && node.tag == tt.tagP)
767         {
768             node.element = "h3";
769             tt.findTag(node);
770             return;
771         }
772
773         value = fontSize2Name(size);
774
775         if (value != null)
776         {
777             addStyleProperty(node, "font-size: " + value);
778         }
779     }
780
781     private void addFontColor(Node node, String color)
782     {
783         addStyleProperty(node, "color: " + color);
784     }
785
786     private void addAlign(Node node, String align)
787     {
788         /* force alignment value to lower case */
789         addStyleProperty(node, "text-align: " + align.toLowerCase());
790     }
791
792     /*
793      add style properties to node corresponding to
794      the font face, size and color attributes
795     */
796     private void addFontStyles(Node node, AttVal av)
797     {
798         while (av != null)
799         {
800             if (av.attribute.equals("face"))
801                 addFontFace(node, av.value);
802             else if (av.attribute.equals("size"))
803                 addFontSize(node, av.value);
804             else if (av.attribute.equals("color"))
805                 addFontColor(node, av.value);
806
807             av = av.next;
808         }
809     }
810
811     /*
812         Symptom: <p align=center>
813         Action: <p style="text-align: center">
814     */
815     private void textAlign(Lexer lexer, Node node)
816     {
817         AttVal av, prev;
818
819         prev = null;
820
821         for (av = node.attributes; av != null; av = av.next)
822         {
823             if (av.attribute.equals("align"))
824             {
825                 if (prev != null)
826                     prev.next = av.next;
827                 else
828                     node.attributes = av.next;
829
830                 if (av.value != null)
831                 {
832                     addAlign(node, av.value);
833                 }
834
835                 break;
836             }
837
838             prev = av;
839         }
840     }
841
842     /*
843        The clean up rules use the pnode argument to return the
844        next node when the orignal node has been deleted
845     */
846
847     /*
848         Symptom: <dir> <li> where <li> is only child
849         Action: coerce <dir> <li> to <div> with indent.
850     */
851
852     private boolean dir2Div(Lexer lexer, Node node, MutableObject pnode)
853     {
854         Node child;
855
856         if (node.tag == tt.tagDir ||
857             node.tag == tt.tagUl ||
858             node.tag == tt.tagOl)
859         {
860             child = node.content;
861
862             if (child == null)
863                 return false;
864
865             /* check child has no peers */
866
867             if (child.next != null)
868                 return false;
869
870             if (child.tag != tt.tagLi)
871                 return false;
872
873             if (!child.implicit)
874                 return false;
875
876             /* coerce dir to div */
877
878             node.tag = tt.tagDiv;
879             node.element = "div";
880             addStyleProperty(node, "margin-left: 2em");
881             stripOnlyChild(node);
882             return true;
883
884 //#if 0
885 //Node content;
886 //Node last;
887 //content = child.content;
888 //last = child.last;
889 //child.content = null;
890
891             /* adjust parent and set margin on contents of <li> */
892
893             //for (child = content; child != null; child = child.next)
894 //{
895 // child.parent = node.parent;
896 // addStyleProperty(child, "margin-left: 1em");
897 //}
898
899             /* hook first/last into sequence */
900
901             //if (content != null)
902 //{
903 // content.prev = node.prev;
904 // last.next = node.next;
905 // fixNodeLinks(content);
906 // fixNodeLinks(last);
907 //}
908
909             //node.next = null;
910
911             /* ensure that new node is cleaned */
912             //pnode.setObject(cleanNode(lexer, content));
913 //return true;
914 //#endif
915 }
916
917         return false;
918     }
919
920     /*
921         Symptom: <center>
922         Action: replace <center> by <div style="text-align: center">
923     */
924
925     private boolean center2Div(Lexer lexer, Node node, MutableObject pnode)
926     {
927         if (node.tag == tt.tagCenter)
928         {
929             if (lexer.configuration.DropFontTags)
930             {
931                 if (node.content != null)
932                 {
933                     Node last = node.last;
934                     Node parent = node.parent;
935
936                     discardContainer(node, pnode);
937
938                     node = lexer.inferredTag("br");
939
940                     if (last.next != null)
941                         last.next.prev = node;
942
943                     node.next = last.next;
944                     last.next = node;
945                     node.prev = last;
946
947                     if (parent.last == last)
948                         parent.last = node;
949
950                     node.parent = parent;
951                 }
952                 else
953                 {
954                     Node prev = node.prev;
955                     Node next = node.next;
956                     Node parent = node.parent;
957                     discardContainer(node, pnode);
958
959                     node = lexer.inferredTag("br");
960                     node.next = next;
961                     node.prev = prev;
962                     node.parent = parent;
963
964                     if (next != null)
965                         next.prev = node;
966                     else
967                         parent.last = node;
968
969                     if (prev != null)
970                         prev.next = node;
971                     else
972                         parent.content = node;
973                 }
974
975                 return true;
976             }
977             node.tag = tt.tagDiv;
978             node.element = "div";
979             addStyleProperty(node, "text-align: center");
980             return true;
981         }
982
983         return false;
984     }
985
986     /*
987         Symptom <div><div>...</div></div>
988         Action: merge the two divs
989
990       This is useful after nested <dir>s used by Word
991       for indenting have been converted to <div>s
992     */
993     private boolean mergeDivs(Lexer lexer, Node node, MutableObject pnode)
994     {
995         Node child;
996
997         if (node.tag != tt.tagDiv)
998             return false;
999
1000        child = node.content;
1001
1002        if (child == null)
1003            return false;
1004
1005        if (child.tag != tt.tagDiv)
1006            return false;
1007
1008        if (child.next != null)
1009            return false;
1010
1011        mergeStyles(node, child);
1012        stripOnlyChild(node);
1013        return true;
1014    }
1015
1016    /*
1017        Symptom: <ul><li><ul>...</ul></li></ul>
1018        Action: discard outer list
1019    */
1020
1021    private boolean nestedList(Lexer lexer, Node node, MutableObject pnode)
1022    {
1023        Node child, list;
1024
1025        if (node.tag == tt.tagUl || node.tag == tt.tagOl)
1026        {
1027            child = node.content;
1028
1029            if (child == null)
1030                return false;
1031
1032            /* check child has no peers */
1033
1034            if (child.next != null)
1035                return false;
1036
1037            list = child.content;
1038
1039            if (list == null)
1040                return false;
1041
1042            if (list.tag != node.tag)
1043                return false;
1044
1045            pnode.setObject(node.next);
1046
1047            /* move inner list node into position of outer node */
1048            list.prev = node.prev;
1049            list.next = node.next;
1050            list.parent = node.parent;
1051            fixNodeLinks(list);
1052
1053            /* get rid of outer ul and its li */
1054            child.content = null;
1055            node.content = null;
1056            node.next = null;
1057
1058            /*
1059              If prev node was a list the chances are this node
1060              should be appended to that list. Word has no way of
1061              recognizing nested lists and just uses indents
1062            */
1063
1064            if (list.prev != null)
1065            {
1066                node = list;
1067                list = node.prev;
1068
1069                if (list.tag == tt.tagUl || list.tag == tt.tagOl)
1070                {
1071                    list.next = node.next;
1072
1073                    if (list.next != null)
1074                        list.next.prev = list;
1075
1076                    child = list.last; /* <li> */
1077
1078                    node.parent = child;
1079                    node.next = null;
1080                    node.prev = child.last;
1081                    fixNodeLinks(node);
1082                }
1083            }
1084
1085            cleanNode(lexer, node);
1086            return true;
1087        }
1088
1089        return false;
1090    }
1091
1092    /*
1093        Symptom: the only child of a block-level element is a
1094        presentation element such as B, I or FONT
1095
1096        Action: add style "font-weight: bold" to the block and
1097        strip the <b> element, leaving its children.
1098
1099      example:
1100
1101        <p>
1102          <b><font face="Arial" size="6">Draft Recommended Practice</font></b>
1103        </p>
1104
1105      becomes:
1106
1107          <p style="font-weight: bold; font-family: Arial; font-size: 6">
1108            Draft Recommended Practice
1109          </p>
1110
1111      This code also replaces the align attribute by a style attribute.
1112      However, to avoid CSS problems with Navigator 4, this isn't done
1113      for the elements: caption, tr and table
1114    */
1115    private boolean blockStyle(Lexer lexer, Node node, MutableObject pnode)
1116    {
1117        Node child;
1118
1119        if ((node.tag.model & (Dict.CM_BLOCK | Dict.CM_LIST | Dict.CM_DEFLIST | Dict.CM_TABLE)) != 0)
1120        {
1121            if (node.tag != tt.tagTable
1122                    && node.tag != tt.tagTr
1123                    && node.tag != tt.tagLi)
1124            {
1125                /* check for align attribute */
1126                if (node.tag != tt.tagCaption)
1127                    textAlign(lexer, node);
1128
1129                child = node.content;
1130
1131                if (child == null)
1132                    return false;
1133
1134                /* check child has no peers */
1135
1136                if (child.next != null)
1137                    return false;
1138
1139                if (child.tag == tt.tagB)
1140                {
1141                    mergeStyles(node, child);
1142                    addStyleProperty(node, "font-weight: bold");
1143                    stripOnlyChild(node);
1144                    return true;
1145                }
1146
1147                if (child.tag == tt.tagI)
1148                {
1149                    mergeStyles(node, child);
1150                    addStyleProperty(node, "font-style: italic");
1151                    stripOnlyChild(node);
1152                    return true;
1153                }
1154
1155                if (child.tag == tt.tagFont)
1156                {
1157                    mergeStyles(node, child);
1158                    addFontStyles(node, child.attributes);
1159                    stripOnlyChild(node);
1160                    return true;
1161                }
1162            }
1163        }
1164
1165        return false;
1166    }
1167
1168    /* the only child of table cell or an inline element such as em */
1169    private boolean inlineStyle(Lexer lexer, Node node, MutableObject pnode)
1170    {
1171        Node child;
1172
1173        if (node.tag != tt.tagFont && (node.tag.model & (Dict.CM_INLINE|Dict.CM_ROW)) != 0)
1174        {
1175            child = node.content;
1176
1177            if (child == null)
1178                return false;
1179
1180            /* check child has no peers */
1181
1182            if (child.next != null)
1183                return false;
1184
1185            if (child.tag == tt.tagB && lexer.configuration.LogicalEmphasis)
1186            {
1187                mergeStyles(node, child);
1188                addStyleProperty(node, "font-weight: bold");
1189                stripOnlyChild(node);
1190                return true;
1191            }
1192
1193            if (child.tag == tt.tagI && lexer.configuration.LogicalEmphasis)
1194            {
1195                mergeStyles(node, child);
1196                addStyleProperty(node, "font-style: italic");
1197                stripOnlyChild(node);
1198                return true;
1199            }
1200
1201            if (child.tag == tt.tagFont)
1202            {
1203                mergeStyles(node, child);
1204                addFontStyles(node, child.attributes);
1205                stripOnlyChild(node);
1206                return true;
1207            }
1208        }
1209
1210        return false;
1211    }
1212
1213    /*
1214      Replace font elements by span elements, deleting
1215      the font element's attributes and replacing them
1216      by a single style attribute.
1217    */
1218    private boolean font2Span(Lexer lexer, Node node, MutableObject pnode)
1219    {
1220        AttVal av, style, next;
1221
1222        if (node.tag == tt.tagFont)
1223        {
1224            if (lexer.configuration.DropFontTags)
1225            {
1226                discardContainer(node, pnode);
1227                return false;
1228            }
1229
1230            /* if FONT is only child of parent element then leave alone */
1231            if (node.parent.content == node
1232                && node.next == null)
1233                return false;
1234
1235            addFontStyles(node, node.attributes);
1236
1237            /* extract style attribute and free the rest */
1238            av = node.attributes;
1239            style = null;
1240
1241            while (av != null)
1242            {
1243                next = av.next;
1244
1245                if (av.attribute.equals("style"))
1246                {
1247                    av.next = null;
1248                    style = av;
1249                }
1250
1251                av = next;
1252            }
1253
1254            node.attributes = style;
1255
1256            node.tag = tt.tagSpan;
1257            node.element = "span";
1258
1259            return true;
1260        }
1261
1262        return false;
1263    }
1264
1265    /*
1266      Applies all matching rules to a node.
1267    */
1268    private Node cleanNode(Lexer lexer, Node node)
1269    {
1270        Node next = null;
1271        MutableObject o = new MutableObject();
1272        boolean b = false;
1273
1274        for (next = node; node.isElement(); node = next)
1275        {
1276            o.setObject(next);
1277
1278            b = dir2Div(lexer, node, o);
1279            next = (Node)o.getObject();
1280            if (b)
1281                continue;
1282
1283            b = nestedList(lexer, node, o);
1284            next = (Node)o.getObject();
1285            if (b)
1286                continue;
1287
1288            b = center2Div(lexer, node, o);
1289            next = (Node)o.getObject();
1290            if (b)
1291                continue;
1292
1293            b = mergeDivs(lexer, node, o);
1294            next = (Node)o.getObject();
1295            if (b)
1296                continue;
1297
1298            b = blockStyle(lexer, node, o);
1299            next = (Node)o.getObject();
1300            if (b)
1301                continue;
1302
1303            b = inlineStyle(lexer, node, o);
1304            next = (Node)o.getObject();
1305            if (b)
1306                continue;
1307
1308            b = font2Span(lexer, node, o);
1309            next = (Node)o.getObject();
1310            if (b)
1311                continue;
1312
1313            break;
1314        }
1315
1316        return next;
1317    }
1318
1319    private Node createStyleProperties(Lexer lexer, Node node)
1320    {
1321        Node child;
1322
1323        if (node.content != null)
1324        {
1325            for (child = node.content; child != null; child = child.next)
1326            {
1327                child = createStyleProperties(lexer, child);
1328            }
1329        }
1330
1331        return cleanNode(lexer, node);
1332    }
1333
1334    private void defineStyleRules(Lexer lexer, Node node)
1335    {
1336        Node child;
1337
1338        if (node.content != null)
1339        {
1340            for (child = node.content;
1341                    child != null; child = child.next)
1342            {
1343                defineStyleRules(lexer, child);
1344            }
1345        }
1346
1347        style2Rule(lexer, node);
1348    }
1349
1350    public void cleanTree(Lexer lexer, Node doc)
1351    {
1352        doc = createStyleProperties(lexer, doc);
1353
1354        if (!lexer.configuration.MakeClean)
1355        {
1356            defineStyleRules(lexer, doc);
1357            createStyleElement(lexer, doc);
1358        }
1359    }
1360
1361    /* simplifies <b><b> ... </b> ...</b> etc. */
1362    public void nestedEmphasis(Node node)
1363    {
1364        MutableObject o = new MutableObject();
1365        Node next;
1366
1367        while (node != null)
1368        {
1369            next = node.next;
1370
1371            if ((node.tag == tt.tagB || node.tag == tt.tagI)
1372                && node.parent != null && node.parent.tag == node.tag)
1373            {
1374                /* strip redundant inner element */
1375                o.setObject(next);
1376                discardContainer(node, o);
1377                next = (Node)o.getObject();
1378                node = next;
1379                continue;
1380            }
1381
1382            if (node.content != null)
1383                nestedEmphasis(node.content);
1384
1385            node = next;
1386        }
1387    }
1388
1389    /* replace i by em and b by strong */
1390    public void emFromI(Node node)
1391    {
1392        while (node != null)
1393        {
1394            if (node.tag == tt.tagI)
1395            {
1396                node.element = tt.tagEm.name;
1397                node.tag = tt.tagEm;
1398            }
1399            else if (node.tag == tt.tagB)
1400            {
1401                node.element = tt.tagStrong.name;
1402                node.tag = tt.tagStrong;
1403            }
1404
1405            if (node.content != null)
1406                emFromI(node.content);
1407
1408            node = node.next;
1409        }
1410    }
1411
1412    /*
1413     Some people use dir or ul without an li
1414     to indent the content. The pattern to
1415     look for is a list with a single implicit
1416     li. This is recursively replaced by an
1417     implicit blockquote.
1418    */
1419    public void list2BQ(Node node)
1420    {
1421        while (node != null)
1422        {
1423            if (node.content != null)
1424                list2BQ(node.content);
1425
1426            if (node.tag != null && node.tag.parser == ParserImpl.getParseList() &&
1427                node.hasOneChild() && node.content.implicit)
1428            {
1429                stripOnlyChild(node);
1430                node.element = tt.tagBlockquote.name;
1431                node.tag = tt.tagBlockquote;
1432                node.implicit = true;
1433            }
1434
1435            node = node.next;
1436        }
1437    }
1438
1439    /*
1440     Replace implicit blockquote by div with an indent
1441     taking care to reduce nested blockquotes to a single
1442     div with the indent set to match the nesting depth
1443    */
1444    public void bQ2Div(Node node)
1445    {
1446        int indent;
1447        String indent_buf;
1448
1449        while (node != null)
1450        {
1451            if (node.tag == tt.tagBlockquote && node.implicit)
1452            {
1453                indent = 1;
1454
1455                while(node.hasOneChild() &&
1456                      node.content.tag == tt.tagBlockquote &&
1457                      node.implicit)
1458                {
1459                    ++indent;
1460                    stripOnlyChild(node);
1461                }
1462
1463                if (node.content != null)
1464                    bQ2Div(node.content);
1465
1466                indent_buf = "margin-left: " +
1467                             (new Integer (2*indent)).toString() + "em";
1468
1469                node.element = tt.tagDiv.name;
1470                node.tag = tt.tagDiv;
1471                node.addAttribute("style", indent_buf);
1472            }
1473            else if (node.content != null)
1474                bQ2Div(node.content);
1475
1476
1477            node = node.next;
1478        }
1479    }
1480
1481    /* node is <![if ...]> prune up to <![endif]> */
1482    public Node pruneSection(Lexer lexer, Node node)
1483    {
1484        for (;;)
1485        {
1486            /* discard node and returns next */
1487            node = Node.discardElement(node);
1488
1489            if (node == null)
1490                return null;
1491        
1492            if (node.type == Node.SectionTag)
1493            {
1494                if ((Lexer.getString(node.textarray, node.start, 2)).equals("if"))
1495                {
1496                    node = pruneSection(lexer, node);
1497                    continue;
1498                }
1499
1500                if ((Lexer.getString(node.textarray, node.start, 5)).equals("endif"))
1501                {
1502                    node = Node.discardElement(node);
1503                    break;
1504                }
1505            }
1506        }
1507
1508        return node;
1509    }
1510
1511    public void dropSections(Lexer lexer, Node node)
1512    {
1513        while (node != null)
1514        {
1515            if (node.type == Node.SectionTag)
1516            {
1517                /* prune up to matching endif */
1518                if ((Lexer.getString(node.textarray, node.start, 2)).equals("if"))
1519                {
1520                    node = pruneSection(lexer, node);
1521                    continue;
1522                }
1523
1524                /* discard others as well */
1525                node = Node.discardElement(node);
1526                continue;
1527            }
1528
1529            if (node.content != null)
1530                dropSections(lexer, node.content);
1531
1532            node = node.next;
1533        }
1534    }
1535
1536    public void purgeAttributes(Node node)
1537    {
1538        AttVal attr = node.attributes;
1539        AttVal next = null;
1540        AttVal prev = null;
1541
1542        while (attr != null)
1543        {
1544            next = attr.next;
1545
1546            /* special check for class="Code" denoting pre text */
1547            if (attr.attribute != null &&
1548                attr.value != null &&
1549                attr.attribute.equals("class") &&
1550                attr.value.equals("Code"))
1551            {
1552                prev = attr;
1553            }
1554            else if (attr.attribute != null &&
1555                (attr.attribute.equals("class") ||
1556                 attr.attribute.equals("style") ||
1557                 attr.attribute.equals("lang") ||
1558                 attr.attribute.startsWith("x:") ||
1559                 ((attr.attribute.equals("height") || attr.attribute.equals("width")) &&
1560                    (node.tag == tt.tagTd || node.tag == tt.tagTr || node.tag == tt.tagTh))))
1561            {
1562                if (prev != null)
1563                    prev.next = next;
1564                else
1565                    node.attributes = next;
1566
1567            }
1568            else
1569                prev = attr;
1570
1571            attr = next;
1572        }
1573    }
1574
1575    /* Word2000 uses span excessively, so we strip span out */
1576    public Node stripSpan(Lexer lexer, Node span)
1577    {
1578        Node node;
1579        Node prev = null;
1580        Node content;
1581
1582        /*
1583         deal with span elements that have content
1584         by splicing the content in place of the span
1585         after having processed it
1586        */
1587
1588        cleanWord2000(lexer, span.content);
1589        content = span.content;
1590
1591        if (span.prev != null)
1592            prev = span.prev;
1593        else if (content != null)
1594        {
1595            node = content;
1596            content = content.next;
1597            Node.removeNode(node);
1598            Node.insertNodeBeforeElement(span, node);
1599            prev = node;
1600        }
1601
1602        while (content != null)
1603        {
1604            node = content;
1605            content = content.next;
1606            Node.removeNode(node);
1607            Node.insertNodeAfterElement(prev, node);
1608            prev = node;
1609        }
1610
1611        if (span.next == null)
1612            span.parent.last = prev;
1613
1614        node = span.next;
1615        span.content = null;
1616        Node.discardElement(span);
1617        return node;
1618    }
1619
1620    /* map non-breaking spaces to regular spaces */
1621    private void normalizeSpaces(Lexer lexer, Node node)
1622    {
1623        while (node != null)
1624        {
1625            if (node.content != null)
1626                normalizeSpaces(lexer, node.content);
1627
1628            if (node.type == Node.TextNode)
1629            {
1630                int i;
1631                MutableInteger c = new MutableInteger();
1632                int p = node.start;
1633
1634                for (i = node.start; i < node.end; ++i)
1635                {
1636                    c.value = (int)node.textarray[i];
1637
1638                    /* look for UTF-8 multibyte character */
1639                    if (c.value > 0x7F)
1640                        i += PPrint.getUTF8(node.textarray, i, c);
1641
1642                    if (c.value == 160)
1643                        c.value = ' ';
1644
1645                    p = PPrint.putUTF8(node.textarray, p, c.value);
1646                }
1647            }
1648
1649            node = node.next;
1650        }
1651    }
1652
1653    /*
1654     This is a major clean up to strip out all the extra stuff you get
1655     when you save as web page from Word 2000. It doesn't yet know what
1656     to do with VML tags, but these will appear as errors unless you
1657     declare them as new tags, such as o:p which needs to be declared
1658     as inline.
1659    */
1660    public void cleanWord2000(Lexer lexer, Node node)
1661    {
1662        /* used to a list from a sequence of bulletted p's */
1663        Node list = null;
1664
1665        while (node != null)
1666        {
1667            /* discard Word's style verbiage */
1668            if (node.tag == tt.tagStyle ||
1669                node.tag == tt.tagMeta ||
1670                node.type == Node.CommentTag)
1671            {
1672                node = Node.discardElement(node);
1673                continue;
1674            }
1675
1676            /* strip out all span tags Word scatters so liberally! */
1677            if (node.tag == tt.tagSpan)
1678            {
1679                node = stripSpan(lexer, node);
1680                continue;
1681            }
1682
1683            /* get rid of Word's xmlns attributes */
1684            if (node.tag == tt.tagHtml)
1685            {
1686                /* check that it's a Word 2000 document */
1687                if (node.getAttrByName("xmlns:o") == null)
1688                    return;
1689            }
1690
1691            if (node.tag == tt.tagLink)
1692            {
1693                AttVal attr = node.getAttrByName("rel");
1694
1695                if (attr != null && attr.value != null &&
1696                    attr.value.equals("File-List"))
1697                {
1698                    node = Node.discardElement(node);
1699                    continue;
1700                }
1701            }
1702
1703            /* discard empty paragraphs */
1704            if (node.content == null && node.tag == tt.tagP)
1705            {
1706                node = Node.discardElement(node);
1707                continue;
1708            }
1709
1710            if (node.tag == tt.tagP)
1711            {
1712                AttVal attr = node.getAttrByName("class");
1713
1714                /* map sequence of <p class="MsoListBullet"> to <ul>...</ul> */
1715                if (attr != null && attr.value != null &&
1716                    attr.value.equals("MsoListBullet"))
1717                {
1718                    Node.coerceNode(lexer, node, tt.tagLi);
1719
1720                    if (list == null || list.tag != tt.tagUl)
1721                    {
1722                        list = lexer.inferredTag("ul");
1723                        Node.insertNodeBeforeElement(node, list);
1724                    }
1725
1726                    purgeAttributes(node);
1727
1728                    if (node.content != null)
1729                        cleanWord2000(lexer, node.content);
1730
1731                    /* remove node and append to contents of list */
1732                    Node.removeNode(node);
1733                    Node.insertNodeAtEnd(list, node);
1734                    node = list.next;
1735                }
1736                /* map sequence of <p class="Code"> to <pre>...</pre> */
1737                else if (attr != null && attr.value != null &&
1738                         attr.value.equals("Code"))
1739                {
1740                    Node br = lexer.newLineNode();
1741                    normalizeSpaces(lexer, node);
1742
1743                    if (list == null || list.tag != tt.tagPre)
1744                    {
1745                        list = lexer.inferredTag("pre");
1746                        Node.insertNodeBeforeElement(node, list);
1747                    }
1748
1749                    /* remove node and append to contents of list */
1750                    Node.removeNode(node);
1751                    Node.insertNodeAtEnd(list, node);
1752                    stripSpan(lexer, node);
1753                    Node.insertNodeAtEnd(list, br);
1754                    node = list.next;
1755                }
1756                else
1757                    list = null;
1758            }
1759            else
1760                list = null;
1761
1762            /* strip out style and class attributes */
1763            if (node.type == Node.StartTag || node.type == Node.StartEndTag)
1764                purgeAttributes(node);
1765
1766            if (node.content != null)
1767                cleanWord2000(lexer, node.content);
1768
1769            node = node.next;
1770        }
1771    }
1772
1773    public boolean isWord2000(Node root, TagTable tt)
1774    {
1775        Node html = root.findHTML(tt);
1776
1777        return (html != null && html.getAttrByName("xmlns:o") != null);
1778    }
1779}
1780

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags