/*
* @(#)Clean.java 1.11 2000/08/16
*
*/
package net.sourceforge.phpdt.tidy.w3c;
/**
*
* Clean up misuse of presentation markup
*
* (c) 1998-2000 (W3C) MIT, INRIA, Keio University
* See Tidy.java for the copyright notice.
* Derived from <a href="http://www.w3.org/People/Raggett/tidy">
* HTML Tidy Release 4 Aug 2000</a>
*
* @author Dave Raggett <dsr@w3.org>
* @author Andy Quick <ac.quick@sympatico.ca> (translation to Java)
* @version 1.0, 1999/05/22
* @version 1.0.1, 1999/05/29
* @version 1.1, 1999/06/18 Java Bean
* @version 1.2, 1999/07/10 Tidy Release 7 Jul 1999
* @version 1.3, 1999/07/30 Tidy Release 26 Jul 1999
* @version 1.4, 1999/09/04 DOM support
* @version 1.5, 1999/10/23 Tidy Release 27 Sep 1999
* @version 1.6, 1999/11/01 Tidy Release 22 Oct 1999
* @version 1.7, 1999/12/06 Tidy Release 30 Nov 1999
* @version 1.8, 2000/01/22 Tidy Release 13 Jan 2000
* @version 1.9, 2000/06/03 Tidy Release 30 Apr 2000
* @version 1.10, 2000/07/22 Tidy Release 8 Jul 2000
* @version 1.11, 2000/08/16 Tidy Release 4 Aug 2000
*/
/*
Filters from other formats such as Microsoft Word
often make excessive use of presentation markup such
as font tags, B, I, and the align attribute. By applying
a set of production rules, it is straight forward to
transform this to use CSS.
Some rules replace some of the children of an element by
style properties on the element, e.g.
<p><b>...</b></p> -> <p style="font-weight: bold">...</p>
Such rules are applied to the element's content and then
to the element itself until none of the rules more apply.
Having applied all the rules to an element, it will have
a style attribute with one or more properties.
Other rules strip the element they apply to, replacing
it by style properties on the contents, e.g.
<dir><li><p>...</li></dir> -> <p style="margin-left 1em">...
These rules are applied to an element before processing
its content and replace the current element by the first
element in the exposed content.
After applying both sets of rules, you can replace the
style attribute by a class value and style rule in the
document head. To support this, an association of styles
and class names is built.
A naive approach is to rely on string matching to test
when two property lists are the same. A better approach
would be to first sort the properties before matching.
*/
public class Clean {
private int classNum = 1;
private TagTable tt;
public Clean(TagTable tt) {
this.tt = tt;
}
private StyleProp insertProperty(StyleProp props, String name, String value) {
StyleProp first, prev, prop;
int cmp;
prev = null;
first = props;
while (props != null) {
cmp = props.name.compareTo(name);
if (cmp == 0) {
/* this property is already defined, ignore new value */
return first;
}
if (cmp > 0) // props.name > name
{
/* insert before this */
prop = new StyleProp(name, value, props);
if (prev != null)
prev.next = prop;
else
first = prop;
return first;
}
prev = props;
props = props.next;
}
prop = new StyleProp(name, value);
if (prev != null)
prev.next = prop;
else
first = prop;
return first;
}
/*
Create sorted linked list of properties from style string
It temporarily places nulls in place of ':' and ';' to
delimit the strings for the property name and value.
Some systems don't allow you to null literal strings,
so to avoid this, a copy is made first.
*/
private StyleProp createProps(StyleProp prop, String style) {
int name_end;
int value_end;
int value_start = 0;
int name_start = 0;
boolean more;
name_start = 0;
while (name_start < style.length()) {
while (name_start < style.length() && style.charAt(name_start) == ' ')
++name_start;
name_end = name_start;
while (name_end < style.length()) {
if (style.charAt(name_end) == ':') {
value_start = name_end + 1;
break;
}
++name_end;
}
if (name_end >= style.length() || style.charAt(name_end) != ':')
break;
while (value_start < style.length() && style.charAt(value_start) == ' ')
++value_start;
value_end = value_start;
more = false;
while (value_end < style.length()) {
if (style.charAt(value_end) == ';') {
more = true;
break;
}
++value_end;
}
prop = insertProperty(prop, style.substring(name_start, name_end), style.substring(value_start, value_end));
if (more) {
name_start = value_end + 1;
continue;
}
break;
}
return prop;
}
private String createPropString(StyleProp props) {
String style = "";
int len;
StyleProp prop;
/* compute length */
for (len = 0, prop = props; prop != null; prop = prop.next) {
len += prop.name.length() + 2;
len += prop.value.length() + 2;
}
for (prop = props; prop != null; prop = prop.next) {
style = style.concat(prop.name);
style = style.concat(": ");
style = style.concat(prop.value);
if (prop.next == null)
break;
style = style.concat("; ");
}
return style;
}
/*
create string with merged properties
*/
private String addProperty(String style, String property) {
StyleProp prop;
prop = createProps(null, style);
prop = createProps(prop, property);
style = createPropString(prop);
return style;
}
private String gensymClass(String tag) {
String str;
str = "c" + classNum;
classNum++;
return str;
}
private String findStyle(Lexer lexer, String tag, String properties) {
Style style;
for (style = lexer.styles; style != null; style = style.next) {
if (style.tag.equals(tag) && style.properties.equals(properties))
return style.tagClass;
}
style = new Style(tag, gensymClass(tag), properties, lexer.styles);
lexer.styles = style;
return style.tagClass;
}
/*
Find style attribute in node, and replace it
by corresponding class attribute. Search for
class in style dictionary otherwise gensym
new class and add to dictionary.
Assumes that node doesn't have a class attribute
*/
private void style2Rule(Lexer lexer, Node node) {
AttVal styleattr, classattr;
String classname;
styleattr = node.getAttrByName("style");
if (styleattr != null) {
classname = findStyle(lexer, node.element, styleattr.value);
classattr = node.getAttrByName("class");
/*
if there already is a class attribute
then append class name after a space
*/
if (classattr != null) {
classattr.value = classattr.value + " " + classname;
node.removeAttribute(styleattr);
} else /* reuse style attribute for class attribute */ {
styleattr.attribute = "class";
styleattr.value = classname;
}
}
}
private void addColorRule(Lexer lexer, String selector, String color) {
if (color != null) {
lexer.addStringLiteral(selector);
lexer.addStringLiteral(" { color: ");
lexer.addStringLiteral(color);
lexer.addStringLiteral(" }\n");
}
}
/*
move presentation attribs from body to style element
background="foo" -> body { background-image: url(foo) }
bgcolor="foo" -> body { background-color: foo }
text="foo" -> body { color: foo }
link="foo" -> :link { color: foo }
vlink="foo" -> :visited { color: foo }
alink="foo" -> :active { color: foo }
*/
private void cleanBodyAttrs(Lexer lexer, Node body) {
AttVal attr;
String bgurl = null;
String bgcolor = null;
String color = null;
attr = body.getAttrByName("background");
if (attr != null) {
bgurl = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
attr = body.getAttrByName("bgcolor");
if (attr != null) {
bgcolor = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
attr = body.getAttrByName("text");
if (attr != null) {
color = attr.value;
attr.value = null;
body.removeAttribute(attr);
}
if (bgurl != null || bgcolor != null || color != null) {
lexer.addStringLiteral(" body {\n");
if (bgurl != null) {
lexer.addStringLiteral(" background-image: url(");
lexer.addStringLiteral(bgurl);
lexer.addStringLiteral(");\n");
}
if (bgcolor != null) {
lexer.addStringLiteral(" background-color: ");
lexer.addStringLiteral(bgcolor);
lexer.addStringLiteral(";\n");
}
if (color != null) {
lexer.addStringLiteral(" color: ");
lexer.addStringLiteral(color);
lexer.addStringLiteral(";\n");
}
lexer.addStringLiteral(" }\n");
}
attr = body.getAttrByName("link");
if (attr != null) {
addColorRule(lexer, " :link", attr.value);
body.removeAttribute(attr);
}
attr = body.getAttrByName("vlink");
if (attr != null) {
addColorRule(lexer, " :visited", attr.value);
body.removeAttribute(attr);
}
attr = body.getAttrByName("alink");
if (attr != null) {
addColorRule(lexer, " :active", attr.value);
body.removeAttribute(attr);
}
}
private boolean niceBody(Lexer lexer, Node doc) {
Node body = doc.findBody(lexer.configuration.tt);
if (body != null) {
if (body.getAttrByName("background") != null
|| body.getAttrByName("bgcolor") != null
|| body.getAttrByName("text") != null
|| body.getAttrByName("link") != null
|| body.getAttrByName("vlink") != null
|| body.getAttrByName("alink") != null) {
lexer.badLayout |= Report.USING_BODY;
return false;
}
}
return true;
}
/* create style element using rules from dictionary */
private void createStyleElement(Lexer lexer, Node doc) {
Node node, head, body;
Style style;
AttVal av;
if (lexer.styles == null && niceBody(lexer, doc))
return;
node = lexer.newNode(Node.StartTag, null, 0, 0, "style");
node.implicit = true;
/* insert type attribute */
av = new AttVal(null, null, '"', "type", "text/css");
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
body = doc.findBody(lexer.configuration.tt);
lexer.txtstart = lexer.lexsize;
if (body != null)
cleanBodyAttrs(lexer, body);
for (style = lexer.styles; style != null; style = style.next) {
lexer.addCharToLexer(' ');
lexer.addStringLiteral(style.tag);
lexer.addCharToLexer('.');
lexer.addStringLiteral(style.tagClass);
lexer.addCharToLexer(' ');
lexer.addCharToLexer('{');
lexer.addStringLiteral(style.properties);
lexer.addCharToLexer('}');
lexer.addCharToLexer('\n');
}
lexer.txtend = lexer.lexsize;
Node.insertNodeAtEnd(node, lexer.newNode(Node.TextNode, lexer.lexbuf, lexer.txtstart, lexer.txtend));
/*
now insert style element into document head
doc is root node. search its children for html node
the head node should be first child of html node
*/
head = doc.findHEAD(lexer.configuration.tt);
if (head != null)
Node.insertNodeAtEnd(head, node);
}
/* ensure bidirectional links are consistent */
private void fixNodeLinks(Node node) {
Node child;
if (node.prev != null)
node.prev.next = node;
else
node.parent.content = node;
if (node.next != null)
node.next.prev = node;
else
node.parent.last = node;
for (child = node.content; child != null; child = child.next)
child.parent = node;
}
/*
used to strip child of node when
the node has one and only one child
*/
private void stripOnlyChild(Node node) {
Node child;
child = node.content;
node.content = child.content;
node.last = child.last;
child.content = null;
for (child = node.content; child != null; child = child.next)
child.parent = node;
}
/* used to strip font start and end tags */
private void discardContainer(Node element, MutableObject pnode) {
Node node;
Node parent = element.parent;
if (element.content != null) {
element.last.next = element.next;
if (element.next != null) {
element.next.prev = element.last;
element.last.next = element.next;
} else
parent.last = element.last;
if (element.prev != null) {
element.content.prev = element.prev;
element.prev.next = element.content;
} else
parent.content = element.content;
for (node = element.content; node != null; node = node.next)
node.parent = parent;
pnode.setObject(element.content);
} else {
if (element.next != null)
element.next.prev = element.prev;
else
parent.last = element.prev;
if (element.prev != null)
element.prev.next = element.next;
else
parent.content = element.next;
pnode.setObject(element.next);
}
element.next = null;
element.content = null;
}
/*
Add style property to element, creating style
attribute as needed and adding ; delimiter
*/
private void addStyleProperty(Node node, String property) {
AttVal av;
for (av = node.attributes; av != null; av = av.next) {
if (av.attribute.equals("style"))
break;
}
/* if style attribute already exists then insert property */
if (av != null) {
String s;
s = addProperty(av.value, property);
av.value = s;
} else /* else create new style attribute */ {
av = new AttVal(node.attributes, null, '"', "style", property);
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
}
}
/*
Create new string that consists of the
combined style properties in s1 and s2
To merge property lists, we build a linked
list of property/values and insert properties
into the list in order, merging values for
the same property name.
*/
private String mergeProperties(String s1, String s2) {
String s;
StyleProp prop;
prop = createProps(null, s1);
prop = createProps(prop, s2);
s = createPropString(prop);
return s;
}
private void mergeStyles(Node node, Node child) {
AttVal av;
String s1, s2, style;
for (s2 = null, av = child.attributes; av != null; av = av.next) {
if (av.attribute.equals("style")) {
s2 = av.value;
break;
}
}
for (s1 = null, av = node.attributes; av != null; av = av.next) {
if (av.attribute.equals("style")) {
s1 = av.value;
break;
}
}
if (s1 != null) {
if (s2 != null) /* merge styles from both */ {
style = mergeProperties(s1, s2);
av.value = style;
}
} else if (s2 != null) /* copy style of child */ {
av = new AttVal(node.attributes, null, '"', "style", s2);
av.dict = AttributeTable.getDefaultAttributeTable().findAttribute(av);
node.attributes = av;
}
}
private String fontSize2Name(String size) {
/*
String[] sizes =
{
"50%",
"60%",
"80%",
null,
"120%",
"150%",
"200%"
};
*/
String[] sizes = { "60%", "70%", "80%", null, "120%", "150%", "200%" };
String buf;
if (size.length() > 0 && '0' <= size.charAt(0) && size.charAt(0) <= '6') {
int n = size.charAt(0) - '0';
return sizes[n];
}
if (size.length() > 0 && size.charAt(0) == '-') {
if (size.length() > 1 && '0' <= size.charAt(1) && size.charAt(1) <= '6') {
int n = size.charAt(1) - '0';
double x;
for (x = 1.0; n > 0; --n)
x *= 0.8;
x *= 100.0;
buf = "" + (int) x + "%";
return buf;
}
return "smaller"; /*"70%"; */
}
if (size.length() > 1 && '0' <= size.charAt(1) && size.charAt(1) <= '6') {
int n = size.charAt(1) - '0';
double x;
for (x = 1.0; n > 0; --n)
x *= 1.2;
x *= 100.0;
buf = "" + (int) x + "%";
return buf;
}
return "larger"; /* "140%" */
}
private void addFontFace(Node node, String face) {
addStyleProperty(node, "font-family: " + face);
}
private void addFontSize(Node node, String size) {
String value;
if (size.equals("6") && node.tag == tt.tagP) {
node.element = "h1";
tt.findTag(node);
return;
}
if (size.equals("5") && node.tag == tt.tagP) {
node.element = "h2";
tt.findTag(node);
return;
}
if (size.equals("4") && node.tag == tt.tagP) {
node.element = "h3";
tt.findTag(node);
return;
}
value = fontSize2Name(size);
if (value != null) {
addStyleProperty(node, "font-size: " + value);
}
}
private void addFontColor(Node node, String color) {
addStyleProperty(node, "color: " + color);
}
private void addAlign(Node node, String align) {
/* force alignment value to lower case */
addStyleProperty(node, "text-align: " + align.toLowerCase());
}
/*
add style properties to node corresponding to
the font face, size and color attributes
*/
private void addFontStyles(Node node, AttVal av) {
while (av != null) {
if (av.attribute.equals("face"))
addFontFace(node, av.value);
else if (av.attribute.equals("size"))
addFontSize(node, av.value);
else if (av.attribute.equals("color"))
addFontColor(node, av.value);
av = av.next;
}
}
/*
Symptom: <p align=center>
Action: <p style="text-align: center">
*/
private void textAlign(Lexer lexer, Node node) {
AttVal av, prev;
prev = null;
for (av = node.attributes; av != null; av = av.next) {
if (av.attribute.equals("align")) {
if (prev != null)
prev.next = av.next;
else
node.attributes = av.next;
if (av.value != null) {
addAlign(node, av.value);
}
break;
}
prev = av;
}
}
/*
The clean up rules use the pnode argument to return the
next node when the orignal node has been deleted
*/
/*
Symptom: <dir> <li> where <li> is only child
Action: coerce <dir> <li> to <div> with indent.
*/
private boolean dir2Div(Lexer lexer, Node node, MutableObject pnode) {
Node child;
if (node.tag == tt.tagDir || node.tag == tt.tagUl || node.tag == tt.tagOl) {
child = node.content;
if (child == null)
return false;
/* check child has no peers */
if (child.next != null)
return false;
if (child.tag != tt.tagLi)
return false;
if (!child.implicit)
return false;
/* coerce dir to div */
node.tag = tt.tagDiv;
node.element = "div";
addStyleProperty(node, "margin-left: 2em");
stripOnlyChild(node);
return true;
//#if 0
//Node content;
//Node last;
//content = child.content;
//last = child.last;
//child.content = null;
/* adjust parent and set margin on contents of <li> */
//for (child = content; child != null; child = child.next)
//{
// child.parent = node.parent;
// addStyleProperty(child, "margin-left: 1em");
//}
/* hook first/last into sequence */
//if (content != null)
//{
// content.prev = node.prev;
// last.next = node.next;
// fixNodeLinks(content);
// fixNodeLinks(last);
//}
//node.next = null;
/* ensure that new node is cleaned */
//pnode.setObject(cleanNode(lexer, content));
//return true;
//#endif
}
return false;
}
/*
Symptom: <center>
Action: replace <center> by <div style="text-align: center">
*/
private boolean center2Div(Lexer lexer, Node node, MutableObject pnode) {
if (node.tag == tt.tagCenter) {
if (lexer.configuration.DropFontTags) {
if (node.content != null) {
Node last = node.last;
Node parent = node.parent;
discardContainer(node, pnode);
node = lexer.inferredTag("br");
if (last.next != null)
last.next.prev = node;
node.next = last.next;
last.next = node;
node.prev = last;
if (parent.last == last)
parent.last = node;
node.parent = parent;
} else {
Node prev = node.prev;
Node next = node.next;
Node parent = node.parent;
discardContainer(node, pnode);
node = lexer.inferredTag("br");
node.next = next;
node.prev = prev;
node.parent = parent;
if (next != null)
next.prev = node;
else
parent.last = node;
if (prev != null)
prev.next = node;
else
parent.content = node;
}
return true;
}
node.tag = tt.tagDiv;
node.element = "div";
addStyleProperty(node, "text-align: center");
return true;
}
return false;
}
/*
Symptom <div><div>...</div></div>
Action: merge the two divs
This is useful after nested <dir>s used by Word
for indenting have been converted to <div>s
*/
private boolean mergeDivs(Lexer lexer, Node node, MutableObject pnode) {
Node child;
if (node.tag != tt.tagDiv)
return false;
child = node.content;
if (child == null)
return false;
if (child.tag != tt.tagDiv)
return false;
if (child.next != null)
return false;
mergeStyles(node, child);
stripOnlyChild(node);
return true;
}
/*
Symptom: <ul><li><ul>...</ul></li></ul>
Action: discard outer list
*/
private boolean nestedList(Lexer lexer, Node node, MutableObject pnode) {
Node child, list;
if (node.tag == tt.tagUl || node.tag == tt.tagOl) {
child = node.content;
if (child == null)
return false;
/* check child has no peers */
if (child.next != null)
return false;
list = child.content;
if (list == null)
return false;
if (list.tag != node.tag)
return false;
pnode.setObject(node.next);
/* move inner list node into position of outer node */
list.prev = node.prev;
list.next = node.next;
list.parent = node.parent;
fixNodeLinks(list);
/* get rid of outer ul and its li */
child.content = null;
node.content = null;
node.next = null;
/*
If prev node was a list the chances are this node
should be appended to that list. Word has no way of
recognizing nested lists and just uses indents
*/
if (list.prev != null) {
node = list;
list = node.prev;
if (list.tag == tt.tagUl || list.tag == tt.tagOl) {
list.next = node.next;
if (list.next != null)
list.next.prev = list;
child = list.last; /* <li> */
node.parent = child;
node.next = null;
node.prev = child.last;
fixNodeLinks(node);
}
}
cleanNode(lexer, node);
return true;
}
return false;
}
/*
Symptom: the only child of a block-level element is a
presentation element such as B, I or FONT
Action: add style "font-weight: bold" to the block and
strip the <b> element, leaving its children.
example:
<p>
<b><font face="Arial" size="6">Draft Recommended Practice</font></b>
</p>
becomes:
<p style="font-weight: bold; font-family: Arial; font-size: 6">
Draft Recommended Practice
</p>
This code also replaces the align attribute by a style attribute.
However, to avoid CSS problems with Navigator 4, this isn't done
for the elements: caption, tr and table
*/
private boolean blockStyle(Lexer lexer, Node node, MutableObject pnode) {
Node child;
if ((node.tag.model & (Dict.CM_BLOCK | Dict.CM_LIST | Dict.CM_DEFLIST | Dict.CM_TABLE)) != 0) {
if (node.tag != tt.tagTable && node.tag != tt.tagTr && node.tag != tt.tagLi) {
/* check for align attribute */
if (node.tag != tt.tagCaption)
textAlign(lexer, node);
child = node.content;
if (child == null)
return false;
/* check child has no peers */
if (child.next != null)
return false;
if (child.tag == tt.tagB) {
mergeStyles(node, child);
addStyleProperty(node, "font-weight: bold");
stripOnlyChild(node);
return true;
}
if (child.tag == tt.tagI) {
mergeStyles(node, child);
addStyleProperty(node, "font-style: italic");
stripOnlyChild(node);
return true;
}
if (child.tag == tt.tagFont) {
mergeStyles(node, child);
addFontStyles(node, child.attributes);
stripOnlyChild(node);
return true;
}
}
}
return false;
}
/* the only child of table cell or an inline element such as em */
private boolean inlineStyle(Lexer lexer, Node node, MutableObject pnode) {
Node child;
if (node.tag != tt.tagFont && (node.tag.model & (Dict.CM_INLINE | Dict.CM_ROW)) != 0) {
child = node.content;
if (child == null)
return false;
/* check child has no peers */
if (child.next != null)
return false;
if (child.tag == tt.tagB && lexer.configuration.LogicalEmphasis) {
mergeStyles(node, child);
addStyleProperty(node, "font-weight: bold");
stripOnlyChild(node);
return true;
}
if (child.tag == tt.tagI && lexer.configuration.LogicalEmphasis) {
mergeStyles(node, child);
addStyleProperty(node, "font-style: italic");
stripOnlyChild(node);
return true;
}
if (child.tag == tt.tagFont) {
mergeStyles(node, child);
addFontStyles(node, child.attributes);
stripOnlyChild(node);
return true;
}
}
return false;
}
/*
Replace font elements by span elements, deleting
the font element's attributes and replacing them
by a single style attribute.
*/
private boolean font2Span(Lexer lexer, Node node, MutableObject pnode) {
AttVal av, style, next;
if (node.tag == tt.tagFont) {
if (lexer.configuration.DropFontTags) {
discardContainer(node, pnode);
return false;
}
/* if FONT is only child of parent element then leave alone */
if (node.parent.content == node && node.next == null)
return false;
addFontStyles(node, node.attributes);
/* extract style attribute and free the rest */
av = node.attributes;
style = null;
while (av != null) {
next = av.next;
if (av.attribute.equals("style")) {
av.next = null;
style = av;
}
av = next;
}
node.attributes = style;
node.tag = tt.tagSpan;
node.element = "span";
return true;
}
return false;
}
/*
Applies all matching rules to a node.
*/
private Node cleanNode(Lexer lexer, Node node) {
Node next = null;
MutableObject o = new MutableObject();
boolean b = false;
for (next = node; node.isElement(); node = next) {
o.setObject(next);
b = dir2Div(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = nestedList(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = center2Div(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = mergeDivs(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = blockStyle(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = inlineStyle(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
b = font2Span(lexer, node, o);
next = (Node) o.getObject();
if (b)
continue;
break;
}
return next;
}
private Node createStyleProperties(Lexer lexer, Node node) {
Node child;
if (node.content != null) {
for (child = node.content; child != null; child = child.next) {
child = createStyleProperties(lexer, child);
}
}
return cleanNode(lexer, node);
}
private void defineStyleRules(Lexer lexer, Node node) {
Node child;
if (node.content != null) {
for (child = node.content; child != null; child = child.next) {
defineStyleRules(lexer, child);
}
}
style2Rule(lexer, node);
}
public void cleanTree(Lexer lexer, Node doc) {
doc = createStyleProperties(lexer, doc);
if (!lexer.configuration.MakeClean) {
defineStyleRules(lexer, doc);
createStyleElement(lexer, doc);
}
}
/* simplifies <b><b> ... </b> ...</b> etc. */
public void nestedEmphasis(Node node) {
MutableObject o = new MutableObject();
Node next;
while (node != null) {
next = node.next;
if ((node.tag == tt.tagB || node.tag == tt.tagI) && node.parent != null && node.parent.tag == node.tag) {
/* strip redundant inner element */
o.setObject(next);
discardContainer(node, o);
next = (Node) o.getObject();
node = next;
continue;
}
if (node.content != null)
nestedEmphasis(node.content);
node = next;
}
}
/* replace i by em and b by strong */
public void emFromI(Node node) {
while (node != null) {
if (node.tag == tt.tagI) {
node.element = tt.tagEm.name;
node.tag = tt.tagEm;
} else if (node.tag == tt.tagB) {
node.element = tt.tagStrong.name;
node.tag = tt.tagStrong;
}
if (node.content != null)
emFromI(node.content);
node = node.next;
}
}
/*
Some people use dir or ul without an li
to indent the content. The pattern to
look for is a list with a single implicit
li. This is recursively replaced by an
implicit blockquote.
*/
public void list2BQ(Node node) {
while (node != null) {
if (node.content != null)
list2BQ(node.content);
if (node.tag != null && node.tag.parser == ParserImpl.getParseList() && node.hasOneChild() && node.content.implicit) {
stripOnlyChild(node);
node.element = tt.tagBlockquote.name;
node.tag = tt.tagBlockquote;
node.implicit = true;
}
node = node.next;
}
}
/*
Replace implicit blockquote by div with an indent
taking care to reduce nested blockquotes to a single
div with the indent set to match the nesting depth
*/
public void bQ2Div(Node node) {
int indent;
String indent_buf;
while (node != null) {
if (node.tag == tt.tagBlockquote && node.implicit) {
indent = 1;
while (node.hasOneChild() && node.content.tag == tt.tagBlockquote && node.implicit) {
++indent;
stripOnlyChild(node);
}
if (node.content != null)
bQ2Div(node.content);
indent_buf = "margin-left: " + (new Integer(2 * indent)).toString() + "em";
node.element = tt.tagDiv.name;
node.tag = tt.tagDiv;
node.addAttribute("style", indent_buf);
} else if (node.content != null)
bQ2Div(node.content);
node = node.next;
}
}
/* node is <![if ...]> prune up to <![endif]> */
public Node pruneSection(Lexer lexer, Node node) {
for (;;) {
/* discard node and returns next */
node = Node.discardElement(node);
if (node == null)
return null;
if (node.type == Node.SectionTag) {
if ((Lexer.getString(node.textarray, node.start, 2)).equals("if")) {
node = pruneSection(lexer, node);
continue;
}
if ((Lexer.getString(node.textarray, node.start, 5)).equals("endif")) {
node = Node.discardElement(node);
break;
}
}
}
return node;
}
public void dropSections(Lexer lexer, Node node) {
while (node != null) {
if (node.type == Node.SectionTag) {
/* prune up to matching endif */
if ((Lexer.getString(node.textarray, node.start, 2)).equals("if")) {
node = pruneSection(lexer, node);
continue;
}
/* discard others as well */
node = Node.discardElement(node);
continue;
}
if (node.content != null)
dropSections(lexer, node.content);
node = node.next;
}
}
// gschadow patch start
/** Get rid of all this pseudo-XML crap, sections, Asp tags, JSP tags, etc.
**/
public void dropPseudoXMLCrap(Lexer lexer, Node node) {
while (node != null) {
switch (node.type) {
case Node.AspTag :
case Node.JsteTag :
case Node.PhpTag :
case Node.SectionTag :
node = Node.discardElement(node);
break;
default :
if (node.content != null)
dropPseudoXMLCrap(lexer, node.content);
node = node.next;
break;
}
}
}
// gschadow patch end
public void purgeAttributes(Node node) {
AttVal attr = node.attributes;
AttVal next = null;
AttVal prev = null;
while (attr != null) {
next = attr.next;
/* special check for class="Code" denoting pre text */
if (attr.attribute != null && attr.value != null && attr.attribute.equals("class") && attr.value.equals("Code")) {
prev = attr;
} else if (
attr.attribute != null
&& (attr.attribute.equals("class")
|| attr.attribute.equals("style")
|| attr.attribute.equals("lang")
|| attr.attribute.startsWith("x:")
|| ((attr.attribute.equals("height") || attr.attribute.equals("width"))
&& (node.tag == tt.tagTd || node.tag == tt.tagTr || node.tag == tt.tagTh)))) {
if (prev != null)
prev.next = next;
else
node.attributes = next;
} else
prev = attr;
attr = next;
}
}
/* Word2000 uses span excessively, so we strip span out */
public Node stripSpan(Lexer lexer, Node span) {
Node node;
Node prev = null;
Node content;
/*
deal with span elements that have content
by splicing the content in place of the span
after having processed it
*/
cleanWord2000(lexer, span.content);
content = span.content;
if (span.prev != null)
prev = span.prev;
else if (content != null) {
node = content;
content = content.next;
Node.removeNode(node);
Node.insertNodeBeforeElement(span, node);
prev = node;
}
while (content != null) {
node = content;
content = content.next;
Node.removeNode(node);
Node.insertNodeAfterElement(prev, node);
prev = node;
}
if (span.next == null)
span.parent.last = prev;
node = span.next;
span.content = null;
Node.discardElement(span);
return node;
}
/* map non-breaking spaces to regular spaces */
private void normalizeSpaces(Lexer lexer, Node node) {
while (node != null) {
if (node.content != null)
normalizeSpaces(lexer, node.content);
if (node.type == Node.TextNode) {
int i;
MutableInteger c = new MutableInteger();
int p = node.start;
for (i = node.start; i < node.end; ++i) {
c.value = (int) node.textarray[i];
/* look for UTF-8 multibyte character */
if (c.value > 0x7F)
i += PPrint.getUTF8(node.textarray, i, c);
if (c.value == 160)
c.value = ' ';
p = PPrint.putUTF8(node.textarray, p, c.value);
}
}
node = node.next;
}
}
/*
This is a major clean up to strip out all the extra stuff you get
when you save as web page from Word 2000. It doesn't yet know what
to do with VML tags, but these will appear as errors unless you
declare them as new tags, such as o:p which needs to be declared
as inline.
*/
public void cleanWord2000(Lexer lexer, Node node) {
/* used to a list from a sequence of bulletted p's */
Node list = null;
while (node != null) {
/* discard Word's style verbiage */
if (node.tag == tt.tagStyle || node.tag == tt.tagMeta || node.type == Node.CommentTag) {
node = Node.discardElement(node);
continue;
}
/* strip out all span tags Word scatters so liberally! */
if (node.tag == tt.tagSpan) {
node = stripSpan(lexer, node);
continue;
}
/* get rid of Word's xmlns attributes */
if (node.tag == tt.tagHtml) {
/* check that it's a Word 2000 document */
if (node.getAttrByName("xmlns:o") == null)
return;
}
if (node.tag == tt.tagLink) {
AttVal attr = node.getAttrByName("rel");
if (attr != null && attr.value != null && attr.value.equals("File-List")) {
node = Node.discardElement(node);
continue;
}
}
/* discard empty paragraphs */
if (node.content == null && node.tag == tt.tagP) {
node = Node.discardElement(node);
continue;
}
if (node.tag == tt.tagP) {
AttVal attr = node.getAttrByName("class");
/* map sequence of <p class="MsoListBullet"> to <ul>...</ul> */
if (attr != null && attr.value != null && attr.value.equals("MsoListBullet")) {
Node.coerceNode(lexer, node, tt.tagLi);
if (list == null || list.tag != tt.tagUl) {
list = lexer.inferredTag("ul");
Node.insertNodeBeforeElement(node, list);
}
purgeAttributes(node);
if (node.content != null)
cleanWord2000(lexer, node.content);
/* remove node and append to contents of list */
Node.removeNode(node);
Node.insertNodeAtEnd(list, node);
node = list.next;
}
/* map sequence of <p class="Code"> to <pre>...</pre> */
else if (attr != null && attr.value != null && attr.value.equals("Code")) {
Node br = lexer.newLineNode();
normalizeSpaces(lexer, node);
if (list == null || list.tag != tt.tagPre) {
list = lexer.inferredTag("pre");
Node.insertNodeBeforeElement(node, list);
}
/* remove node and append to contents of list */
Node.removeNode(node);
Node.insertNodeAtEnd(list, node);
stripSpan(lexer, node);
Node.insertNodeAtEnd(list, br);
node = list.next;
} else
list = null;
} else
list = null;
/* strip out style and class attributes */
if (node.type == Node.StartTag || node.type == Node.StartEndTag)
purgeAttributes(node);
if (node.content != null)
cleanWord2000(lexer, node.content);
node = node.next;
}
}
public boolean isWord2000(Node root, TagTable tt) {
Node html = root.findHTML(tt);
return (html != null && html.getAttrByName("xmlns:o") != null);
}
}