Uses of Class
org.w3c.tidy.Node

Packages that use Node
org.w3c.tidy   
 

Uses of Node in org.w3c.tidy
 

Fields in org.w3c.tidy declared as Node
private  Node PPrint.slidecontent
           
private  Node DOMNodeListImpl.parent
          Parent Node.
protected  Node Lexer.token
          current node.
protected  Node Lexer.inode
          Inline stack for compatibility with Mosaic.
protected  Node Lexer.root
          Root node is saved here.
protected  Node Node.parent
          parent node.
protected  Node Node.prev
          pevious node.
protected  Node Node.next
          next node.
protected  Node Node.last
          last node.
protected  Node Node.content
          Contained node.
protected  Node DOMNodeImpl.adaptee
          Wrapped tidy node.
private  Node DOMNodeListByTagNameImpl.first
          First node.
private  Node DOMNodeListByTagNameImpl.currNode
          Current node.
protected  Node AttVal.asp
          Asp node.
protected  Node AttVal.php
          Php node.
protected  Node Anchor.node
          linked node.
 

Methods in org.w3c.tidy that return Node
(package private)  Node TagTable.getNodeByAnchor(java.lang.String name)
          Return node associated with anchor.
 Node Lexer.newNode()
          Creates a new node and add it to nodelist.
 Node Lexer.newNode(short type, byte[] textarray, int start, int end)
          Creates a new node and add it to nodelist.
 Node Lexer.newNode(short type, byte[] textarray, int start, int end, java.lang.String element)
          Creates a new node and add it to nodelist.
 Node Lexer.cloneNode(Node node)
          Clones a node and add it to node list.
 Node Lexer.newLineNode()
          Adds a new line node.
(package private)  Node Lexer.newXhtmlDocTypeNode(Node root)
          Put DOCTYPE declaration between the <:?xml version "1.0" ...
 Node Lexer.inferredTag(java.lang.String name)
          Generates and inserts a new node.
 Node Lexer.getCDATA(Node container)
          Create a text node for the contents of a CDATA element like style or script which ends with </foo> for some foo.
 Node Lexer.getToken(short mode)
          Gets a token.
 Node Lexer.parseAsp()
          parser for ASP within start tags Some people use ASP for to customize attributes Tidy isn't really well suited to dealing with ASP This is a workaround for attributes, but won't deal with the case where the ASP is used to tailor the attribute value.
 Node Lexer.parsePhp()
          PHP is like ASP but is based upon XML processing instructions, e.g.
 Node Lexer.insertedToken()
           
 Node Node.findDocType()
          Find the doctype element.
static Node Node.discardElement(Node element)
          Remove node from markup tree and discard it.
protected static Node Node.escapeTag(Lexer lexer, Node element)
          Escapes the given tag.
 Node Node.findBody(TagTable tt)
          Find the body node.
 Node Node.findHTML(TagTable tt)
          Find the "html" element.
 Node Node.findHEAD(TagTable tt)
          Find the head tag.
protected  Node Node.cloneNode(boolean deep)
          Clone this node.
static Node ParserImpl.parseDocument(Lexer lexer)
          HTML is the top level element.
static Node ParserImpl.parseXMLDocument(Lexer lexer)
           
 Node AttVal.getAsp()
          Getter for asp.
 Node AttVal.getPhp()
          Getter for php.
 Node Tidy.parse(java.io.InputStream in, java.io.OutputStream out)
          Parses InputStream in and returns the root Node.
private  Node Tidy.parse(java.io.InputStream in, java.lang.String file, java.io.OutputStream out)
          Internal routine that actually does the parsing.
private  Node Clean.cleanNode(Lexer lexer, Node node)
          Applies all matching rules to a node.
private  Node Clean.createStyleProperties(Lexer lexer, Node node, Node[] prepl)
          Special case: if the current node is destroyed by CleanNode() lower in the tree, this node and its parent no longer exist.
(package private)  Node Clean.findEnclosingCell(Node node)
          Find the enclosing table cell for the given node.
 Node Clean.pruneSection(Lexer lexer, Node node)
          node is <![if ...]> prune up to <![endif]>.
 Node Clean.stripSpan(Lexer lexer, Node span)
          Word2000 uses span excessively, so we strip span out.
 

Methods in org.w3c.tidy with parameters of type Node
 boolean TagTable.findTag(Node node)
          Finds a tag by name.
 Parser TagTable.findParser(Node node)
          Finds a parser fo the given node.
(package private)  boolean TagTable.isAnchorElement(Node node)
          May id or name serve as anchor?
 void TagTable.freeAttrs(Node node)
          Free node's attributes.
(package private)  void TagTable.removeAnchorByNode(Node node)
          Removes anchor for specific node.
(package private)  Anchor TagTable.addAnchor(java.lang.String name, Node node)
          Adds a new anchor to namespace.
 void AttrCheckImpl.CheckUrl.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckScript.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckAlign.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckValign.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckBool.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckLength.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckTarget.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckFsubmit.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckClear.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckShape.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckScope.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckNumber.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckId.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckName.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckColor.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckVType.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckScroll.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckTextDir.check(Lexer lexer, Node node, AttVal attval)
           
 void AttrCheckImpl.CheckLang.check(Lexer lexer, Node node, AttVal attval)
           
private  void PPrint.printAttribute(Out fout, int indent, Node node, AttVal attr)
           
private  void PPrint.printAttrs(Out fout, int indent, Node node, AttVal attr)
           
private static boolean PPrint.afterSpace(Node node)
          Line can be wrapped immediately after inline start tag provided if follows a text node ending in a space, or it parent is an inline element that that rule applies to.
private  void PPrint.printTag(Lexer lexer, Out fout, short mode, int indent, Node node)
           
private  void PPrint.printEndTag(short mode, int indent, Node node)
           
private  void PPrint.printComment(Out fout, int indent, Node node)
           
private  void PPrint.printDocType(Out fout, int indent, Lexer lexer, Node node)
           
private  void PPrint.printPI(Out fout, int indent, Node node)
           
private  void PPrint.printXmlDecl(Out fout, int indent, Node node)
          Pretty print the xml declaration.
private  void PPrint.printAsp(Out fout, int indent, Node node)
          note ASP and JSTE share <% ...
private  void PPrint.printJste(Out fout, int indent, Node node)
          JSTE also supports <# ...
private  void PPrint.printPhp(Out fout, int indent, Node node)
          PHP is based on XML processing instructions.
private  void PPrint.printCDATA(Out fout, int indent, Node node)
           
private  void PPrint.printSection(Out fout, int indent, Node node)
           
private  boolean PPrint.insideHead(Node node)
          Is the current node inside HEAD?
private  int PPrint.textEndsWithNewline(Lexer lexer, Node node)
          Is text node and already ends w/ a newline? Used to pretty print CDATA/PRE text content.
(package private) static boolean PPrint.hasCDATA(Lexer lexer, Node node)
          Does the current node contain a CDATA section?
private  void PPrint.printScriptStyle(Out fout, short mode, int indent, Lexer lexer, Node node)
          Print script and style elements.
private  boolean PPrint.shouldIndent(Node node)
          Should tidy indent the give tag?
(package private)  void PPrint.printBody(Out fout, Lexer lexer, Node root, boolean xml)
          Print just the content of the body element.
 void PPrint.printTree(Out fout, short mode, int indent, Lexer lexer, Node node)
           
 void PPrint.printXMLTree(Out fout, short mode, int indent, Lexer lexer, Node node)
           
 int PPrint.countSlides(Node node)
          Split parse tree by h2 elements and output to separate files.
 void PPrint.addTransitionEffect(Lexer lexer, Node root, double duration)
          Add meta element for page transition effect, this works on IE but not NS.
 void PPrint.createSlides(Lexer lexer, Node root)
          Creates slides from h2.
 void TagCheck.check(Lexer lexer, Node node)
          Checks attributes in given Node.
 void AttrCheck.check(Lexer lexer, Node node, AttVal attval)
          Check the value of an attribute.
 void Parser.parse(Lexer lexer, Node node, short mode)
          Parse the given node.
 Node Lexer.cloneNode(Node node)
          Clones a node and add it to node list.
 boolean Lexer.addGenerator(Node root)
          Add meta element for Tidy.
 boolean Lexer.checkDocTypeKeyWords(Node doctype)
          Check system keywords (keywords should be uppercase).
 short Lexer.findGivenVersion(Node doctype)
          Examine DOCTYPE to identify version.
 void Lexer.fixHTMLNameSpace(Node root, java.lang.String profile)
          Fix xhtml namespace.
(package private)  Node Lexer.newXhtmlDocTypeNode(Node root)
          Put DOCTYPE declaration between the <:?xml version "1.0" ...
 boolean Lexer.setXHTMLDocType(Node root)
          Adds a new xhtml doctype to the document.
 boolean Lexer.fixDocType(Node root)
          Fixup doctype if missing.
 boolean Lexer.fixXmlDecl(Node root)
          Ensure XML document starts with <?XML version="1.0"?>.
 Node Lexer.getCDATA(Node container)
          Create a text node for the contents of a CDATA element like style or script which ends with </foo> for some foo.
 java.lang.String Lexer.parseAttribute(boolean[] isempty, Node[] asp, Node[] php)
          consumes the '>' terminating start tags.
 void Lexer.pushInline(Node node)
          Push a copy of an inline node onto stack but don't push if implicit or OBJECT or APPLET (implicit tags are ones generated from the istack) One issue arises with pushing inlines when the tag is already pushed.
 void Lexer.popInline(Node node)
          Pop a copy of an inline node from the stack.
 boolean Lexer.isPushed(Node node)
          Is the node in the stack?
 int Lexer.inlineDup(Node node)
          This has the effect of inserting "missing" inline elements around the contents of blocklevel elements such as P, TD, TH, DIV, PRE etc.
 boolean Lexer.canPrune(Node element)
          Can the given element be removed?
 void Lexer.fixId(Node node)
          duplicate name attribute as an id and check if id and name match.
protected  boolean Lexer.preContent(Node node)
          Is content acceptable for pre elements?
static Node Node.discardElement(Node element)
          Remove node from markup tree and discard it.
 void Node.insertNodeAtStart(Node node)
          Insert a node into markup tree.
 void Node.insertNodeAtEnd(Node node)
          Insert node into markup tree.
static void Node.insertNodeAsParent(Node element, Node node)
          Insert node into markup tree in pace of element which is moved to become the child of the node.
static void Node.insertNodeBeforeElement(Node element, Node node)
          Insert node into markup tree before element.
 void Node.insertNodeAfterElement(Node node)
          Insert node into markup tree after element.
static void Node.trimEmptyElement(Lexer lexer, Node element)
          Trim an empty element.
static void Node.trimTrailingSpace(Lexer lexer, Node element, Node last)
          This maps hello world to hello world .
protected static Node Node.escapeTag(Lexer lexer, Node element)
          Escapes the given tag.
static void Node.trimInitialSpace(Lexer lexer, Node element, Node text)
          This maps <p> hello <em> world </em> to <p> hello <em> world </em>.
static void Node.trimSpaces(Lexer lexer, Node element)
          Move initial and trailing space out.
static void Node.insertDocType(Lexer lexer, Node element, Node doctype)
          The doctype has been found after other tags, and needs moving to before the html element.
static void Node.moveBeforeTable(Node row, Node node, TagTable tt)
          Unexpected content in table row is moved to just before the table in accordance with Netscape and IE.
static void Node.fixEmptyRow(Lexer lexer, Node row)
          If a table row is empty then insert an empty cell.This practice is consistent with browser behavior and avoids potential problems with row spanning cells.
static void Node.coerceNode(Lexer lexer, Node node, Dict tag)
          Coerce a node.
static boolean Node.insertMisc(Node element, Node node)
          Insert a node at the end.
protected static void ParserImpl.parseTag(Lexer lexer, Node node, short mode)
           
protected static void ParserImpl.moveToHead(Lexer lexer, Node element, Node node)
          Move node to the head, where element is used as starting point in hunt for head.
(package private) static void ParserImpl.moveNodeToBody(Lexer lexer, Node node)
          moves given node to end of body element.
static boolean ParserImpl.XMLPreserveWhiteSpace(Node element, TagTable tt)
          Indicates whether or not whitespace should be preserved for this element.
static void ParserImpl.parseXMLElement(Lexer lexer, Node element, short mode)
          XML documents.
 void ParserImpl.ParseHTML.parse(Lexer lexer, Node html, short mode)
           
 void ParserImpl.ParseHead.parse(Lexer lexer, Node head, short mode)
           
 void ParserImpl.ParseTitle.parse(Lexer lexer, Node title, short mode)
           
 void ParserImpl.ParseScript.parse(Lexer lexer, Node script, short mode)
           
 void ParserImpl.ParseBody.parse(Lexer lexer, Node body, short mode)
           
 void ParserImpl.ParseFrameSet.parse(Lexer lexer, Node frameset, short mode)
           
 void ParserImpl.ParseInline.parse(Lexer lexer, Node element, short mode)
           
 void ParserImpl.ParseList.parse(Lexer lexer, Node list, short mode)
           
 void ParserImpl.ParseEmpty.parse(Lexer lexer, Node element, short mode)
           
 void ParserImpl.ParseDefList.parse(Lexer lexer, Node list, short mode)
           
 void ParserImpl.ParsePre.parse(Lexer lexer, Node pre, short mode)
           
 void ParserImpl.ParseBlock.parse(Lexer lexer, Node element, short mode)
           
 void ParserImpl.ParseTableTag.parse(Lexer lexer, Node table, short mode)
           
 void ParserImpl.ParseColGroup.parse(Lexer lexer, Node colgroup, short mode)
           
 void ParserImpl.ParseRowGroup.parse(Lexer lexer, Node rowgroup, short mode)
           
 void ParserImpl.ParseRow.parse(Lexer lexer, Node row, short mode)
           
 void ParserImpl.ParseNoFrames.parse(Lexer lexer, Node noframes, short mode)
           
 void ParserImpl.ParseSelect.parse(Lexer lexer, Node field, short mode)
           
 void ParserImpl.ParseText.parse(Lexer lexer, Node field, short mode)
           
 void ParserImpl.ParseOptGroup.parse(Lexer lexer, Node field, short mode)
           
protected  void DOMNodeListByTagNameImpl.preTraverse(Node node)
          Traverse the node list.
(package private)  void AttVal.checkLowerCaseAttrValue(Lexer lexer, Node node)
          Check the attribute value for uppercase letters (only if the value should be lowercase, required for literal values in xhtml).
 Attribute AttVal.checkAttribute(Lexer lexer, Node node)
          Check attribute name/value and report errors.
 void AttVal.setAsp(Node asp)
          Setter for asp.
 void AttVal.setPhp(Node php)
          Setter for php.
 void TagCheckImpl.CheckHTML.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckSCRIPT.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckTABLE.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckCaption.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckHR.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckIMG.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckAREA.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckAnchor.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckMap.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckSTYLE.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckForm.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckMeta.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckTableCell.check(Lexer lexer, Node node)
           
 void TagCheckImpl.CheckLINK.check(Lexer lexer, Node node)
           
private  void Tidy.pprint(Node node, java.io.OutputStream out)
          Pretty-prints a tidy Node.
private  java.lang.String Report.getTagName(Node tag)
          Returns a formatted tag name handling start and ent tags, nulls, doctypes, and text.
 void Report.attrError(Lexer lexer, Node node, AttVal attribute, short code)
          Prints error messages for attributes.
 void Report.warning(Lexer lexer, Node element, Node node, short code)
          Prints warnings.
 void Report.error(Lexer lexer, Node element, Node node, short code)
          Prints errors.
 void Report.reportVersion(java.io.PrintWriter errout, Lexer lexer, java.lang.String filename, Node doctype)
          Prints information for html version in input file.
private  void Clean.style2Rule(Lexer lexer, Node node)
          Find style attribute in node, and replace it by corresponding class attribute.
private  void Clean.cleanBodyAttrs(Lexer lexer, Node body)
          Move presentation attribs from body to style element.
private  boolean Clean.niceBody(Lexer lexer, Node doc)
          Check deprecated attributes in body tag.
private  void Clean.createStyleElement(Lexer lexer, Node doc)
          Create style element using rules from dictionary.
private  void Clean.fixNodeLinks(Node node)
          Ensure bidirectional links are consistent.
private  void Clean.stripOnlyChild(Node node)
          Used to strip child of node when the node has one and only one child.
private  void Clean.discardContainer(Node element, Node[] pnode)
          Used to strip font start and end tags.
private  void Clean.addStyleProperty(Node node, java.lang.String property)
          Add style property to element, creating style attribute as needed and adding ; delimiter.
private  void Clean.mergeClasses(Node node, Node child)
          Merge class attributes from 2 nodes.
private  void Clean.mergeStyles(Node node, Node child)
          Merge style from 2 nodes.
private  void Clean.addFontFace(Node node, java.lang.String face)
          Adds a font-family style.
private  void Clean.addFontSize(Node node, java.lang.String size)
          Adds a font size style.
private  void Clean.addFontColor(Node node, java.lang.String color)
          Adds a font color style.
private  void Clean.addAlign(Node node, java.lang.String align)
          Adds an align style.
private  void Clean.addFontStyles(Node node, AttVal av)
          Add style properties to node corresponding to the font face, size and color attributes.
private  void Clean.textAlign(Lexer lexer, Node node)
          Symptom: <p align=center>.
private  boolean Clean.dir2Div(Lexer lexer, Node node)
          Symptom: <dir><li> where <li> is only child.
private  boolean Clean.center2Div(Lexer lexer, Node node, Node[] pnode)
          Symptom:
private  boolean Clean.mergeDivs(Lexer lexer, Node node)
          Symptom: <div><div>...</div></div> Action: merge the two divs.
private  boolean Clean.nestedList(Lexer lexer, Node node, Node[] pnode)
          Symptom: ...
private  boolean Clean.blockStyle(Lexer lexer, Node node)
          Symptom: the only child of a block-level element is a presentation element such as B, I or FONT.
private  boolean Clean.inlineStyle(Lexer lexer, Node node, Node[] pnode)
          If the node has only one b, i, or font child remove the child node and add the appropriate style attributes to parent.
private  boolean Clean.font2Span(Lexer lexer, Node node, Node[] pnode)
          Replace font elements by span elements, deleting the font element's attributes and replacing them by a single style attribute.
private  Node Clean.cleanNode(Lexer lexer, Node node)
          Applies all matching rules to a node.
private  Node Clean.createStyleProperties(Lexer lexer, Node node, Node[] prepl)
          Special case: if the current node is destroyed by CleanNode() lower in the tree, this node and its parent no longer exist.
private  void Clean.defineStyleRules(Lexer lexer, Node node)
          Find style attribute in node content, and replace it by corresponding class attribute.
 void Clean.cleanTree(Lexer lexer, Node doc)
          Clean an html tree.
 void Clean.nestedEmphasis(Node node)
          simplifies ...
 void Clean.emFromI(Node node)
          Replace i by em and b by strong.
 void Clean.list2BQ(Node node)
          Some people use dir or ul without an li to indent the content.
 void Clean.bQ2Div(Node node)
          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.
(package private)  Node Clean.findEnclosingCell(Node node)
          Find the enclosing table cell for the given node.
 Node Clean.pruneSection(Lexer lexer, Node node)
          node is <![if ...]> prune up to <![endif]>.
 void Clean.dropSections(Lexer lexer, Node node)
          Drop if/endif sections inserted by word2000.
 void Clean.purgeWord2000Attributes(Node node)
          Remove word2000 attributes from node.
 Node Clean.stripSpan(Lexer lexer, Node span)
          Word2000 uses span excessively, so we strip span out.
private  void Clean.normalizeSpaces(Lexer lexer, Node node)
          Map non-breaking spaces to regular spaces.
(package private)  boolean Clean.noMargins(Node node)
          Used to hunt for hidden preformatted sections.
(package private)  boolean Clean.singleSpace(Lexer lexer, Node node)
          Does element have a single space as its content?
 void Clean.cleanWord2000(Lexer lexer, Node node)
          This is a major clean up to strip out all the extra stuff you get when you save as web page from Word 2000.
 boolean Clean.isWord2000(Node root)
          Check if the current document is a converted Word document.
(package private) static void Clean.bumpObject(Lexer lexer, Node html)
          Where appropriate move object elements from head to body.
 

Constructors in org.w3c.tidy with parameters of type Node
DOMNodeListImpl(Node parent)
          Instantiates a new DOM node list.
DOMTextImpl(Node adaptee)
          Instantiates a new DOM text node.
DOMDocumentTypeImpl(Node adaptee)
          Instantiates a new DOM document type.
DOMElementImpl(Node adaptee)
          Instantiates a new DOM element.
DOMDocumentImpl(Node adaptee)
          Instantiates a new Dom document with a default tag table.
DOMCommentImpl(Node adaptee)
          Instantiates a new DOMCommentImpl which wraps the given Node.
DOMProcessingInstructionImpl(Node adaptee)
          Instantiates a new DOM processing instruction.
DOMNodeImpl(Node adaptee)
          Intantiates a new DOM node.
DOMCDATASectionImpl(Node adaptee)
          Instantiates a new DOMCDATASectionImpl which wraps the given Node.
DOMNodeListByTagNameImpl(Node first, java.lang.String tagName)
          Instantiates a new DOMNodeListByTagName.
AttVal(AttVal next, Attribute dict, Node asp, Node php, int delim, java.lang.String attribute, java.lang.String value)
          Instantiates a new AttVal.
DOMCharacterDataImpl(Node adaptee)
          Instantiates a new DOMCharacterDataImpl which wraps the given Node.