docs/HtmlAgilityPack/HtmlNode.cs

   1 // HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>
   2 using System;
   3 using System.Collections;
   4 using System.Collections.Generic;
   5 using System.Diagnostics;
   6 using System.IO;
   7 using System.Xml;
   8 using System.Xml.XPath;
   9
  10 namespace HtmlAgilityPack
  11 {
  12     /// <summary>
  13     /// Represents an HTML node.
  14     /// </summary>
  15     [DebuggerDisplay("Name: {OriginalName}}")]
  16     public class HtmlNode : IXPathNavigable
  17     {
  18         #region Fields
  19
  20         internal HtmlAttributeCollection _attributes;
  21         internal HtmlNodeCollection _childnodes;
  22         internal HtmlNode _endnode;
  23
  24         internal bool _innerchanged;
  25         internal string _innerhtml;
  26         internal int _innerlength;
  27         internal int _innerstartindex;
  28         internal int _line;
  29         internal int _lineposition;
  30         private string _name;
  31         internal int _namelength;
  32         internal int _namestartindex;
  33         internal HtmlNode _nextnode;
  34         internal HtmlNodeType _nodetype;
  35         internal bool _outerchanged;
  36         internal string _outerhtml;
  37         internal int _outerlength;
  38         internal int _outerstartindex;
  39         internal HtmlDocument _ownerdocument;
  40         internal HtmlNode _parentnode;
  41         internal HtmlNode _prevnode;
  42         internal HtmlNode _prevwithsamename;
  43         internal bool _starttag;
  44         internal int _streamposition;
  45
  46         #endregion
  47
  48         #region Static Members
  49
  50         /// <summary>
  51         /// Gets the name of a comment node. It is actually defined as '#comment'.
  52         /// </summary>
  53         public static readonly string HtmlNodeTypeNameComment = "#comment";
  54
  55         /// <summary>
  56         /// Gets the name of the document node. It is actually defined as '#document'.
  57         /// </summary>
  58         public static readonly string HtmlNodeTypeNameDocument = "#document";
  59
  60         /// <summary>
  61         /// Gets the name of a text node. It is actually defined as '#text'.
  62         /// </summary>
  63         public static readonly string HtmlNodeTypeNameText = "#text";
  64
  65         /// <summary>
  66         /// Gets a collection of flags that define specific behaviors for specific element nodes.
  67         /// The table contains a DictionaryEntry list with the lowercase tag name as the Key, and a combination of HtmlElementFlags as the Value.
  68         /// </summary>
  69         public static Hashtable ElementsFlags;
  70
  71         #endregion
  72
  73         #region Constructors
  74
  75         /// <summary>
  76         /// Initialize HtmlNode. Builds a list of all tags that have special allowances
  77         /// </summary>
  78         static HtmlNode()
  79         {
  80             // tags whose content may be anything
  81             ElementsFlags = new Hashtable();
  82             ElementsFlags.Add("script", HtmlElementFlag.CData);
  83             ElementsFlags.Add("style", HtmlElementFlag.CData);
  84             ElementsFlags.Add("noxhtml", HtmlElementFlag.CData);
  85
  86             // tags that can not contain other tags
  87             ElementsFlags.Add("base", HtmlElementFlag.Empty);
  88             ElementsFlags.Add("link", HtmlElementFlag.Empty);
  89             ElementsFlags.Add("meta", HtmlElementFlag.Empty);
  90             ElementsFlags.Add("isindex", HtmlElementFlag.Empty);
  91             ElementsFlags.Add("hr", HtmlElementFlag.Empty);
  92             ElementsFlags.Add("col", HtmlElementFlag.Empty);
  93             ElementsFlags.Add("img", HtmlElementFlag.Empty);
  94             ElementsFlags.Add("param", HtmlElementFlag.Empty);
  95             ElementsFlags.Add("embed", HtmlElementFlag.Empty);
  96             ElementsFlags.Add("frame", HtmlElementFlag.Empty);
  97             ElementsFlags.Add("wbr", HtmlElementFlag.Empty);
  98             ElementsFlags.Add("bgsound", HtmlElementFlag.Empty);
  99             ElementsFlags.Add("spacer", HtmlElementFlag.Empty);
 100             ElementsFlags.Add("keygen", HtmlElementFlag.Empty);
 101             ElementsFlags.Add("area", HtmlElementFlag.Empty);
 102             ElementsFlags.Add("input", HtmlElementFlag.Empty);
 103             ElementsFlags.Add("basefont", HtmlElementFlag.Empty);
 104
 105             ElementsFlags.Add("form", HtmlElementFlag.CanOverlap | HtmlElementFlag.Empty);
 106
 107             // they sometimes contain, and sometimes they don 't...
 108             ElementsFlags.Add("option", HtmlElementFlag.Empty);
 109
 110             // tag whose closing tag is equivalent to open tag:
 111             // <p>bla</p>bla will be transformed into <p>bla</p>bla
 112             // <p>bla<p>bla will be transformed into <p>bla<p>bla and not <p>bla></p><p>bla</p> or <p>bla<p>bla</p></p>
 113             //<br> see above
 114             ElementsFlags.Add("br", HtmlElementFlag.Empty | HtmlElementFlag.Closed);
 115             ElementsFlags.Add("p", HtmlElementFlag.Empty | HtmlElementFlag.Closed);
 116         }
 117
 118         /// <summary>
 119         /// Initializes HtmlNode, providing type, owner and where it exists in a collection
 120         /// </summary>
 121         /// <param name="type"></param>
 122         /// <param name="ownerdocument"></param>
 123         /// <param name="index"></param>
 124         public HtmlNode(HtmlNodeType type, HtmlDocument ownerdocument, int index)
 125         {
 126             _nodetype = type;
 127             _ownerdocument = ownerdocument;
 128             _outerstartindex = index;
 129
 130             switch (type)
 131             {
 132                 case HtmlNodeType.Comment:
 133                     Name = HtmlNodeTypeNameComment;
 134                     _endnode = this;
 135                     break;
 136
 137                 case HtmlNodeType.Document:
 138                     Name = HtmlNodeTypeNameDocument;
 139                     _endnode = this;
 140                     break;
 141
 142                 case HtmlNodeType.Text:
 143                     Name = HtmlNodeTypeNameText;
 144                     _endnode = this;
 145                     break;
 146             }
 147
 148             if (_ownerdocument._openednodes != null)
 149             {
 150                 if (!Closed)
 151                 {
 152                     // we use the index as the key
 153
 154                     // -1 means the node comes from public
 155                     if (-1 != index)
 156                     {
 157                         _ownerdocument._openednodes.Add(index, this);
 158                     }
 159                 }
 160             }
 161
 162             if ((-1 != index) || (type == HtmlNodeType.Comment) || (type == HtmlNodeType.Text)) return;
 163             // innerhtml and outerhtml must be calculated
 164             _outerchanged = true;
 165             _innerchanged = true;
 166         }
 167
 168         #endregion
 169
 170         #region Properties
 171
 172         /// <summary>
 173         /// Gets the collection of HTML attributes for this node. May not be null.
 174         /// </summary>
 175         public HtmlAttributeCollection Attributes
 176         {
 177             get
 178             {
 179                 if (!HasAttributes)
 180                 {
 181                     _attributes = new HtmlAttributeCollection(this);
 182                 }
 183                 return _attributes;
 184             }
 185             internal set { _attributes = value; }
 186         }
 187
 188         /// <summary>
 189         /// Gets all the children of the node.
 190         /// </summary>
 191         public HtmlNodeCollection ChildNodes
 192         {
 193             get
 194             {
 195                 if (_childnodes == null)
 196                 {
 197                     _childnodes = new HtmlNodeCollection(this);
 198                 }
 199                 return _childnodes;
 200             }
 201             internal set { _childnodes = value; }
 202         }
 203
 204         /// <summary>
 205         /// Gets a value indicating if this node has been closed or not.
 206         /// </summary>
 207         public bool Closed
 208         {
 209             get { return (_endnode != null); }
 210         }
 211
 212         /// <summary>
 213         /// Gets the collection of HTML attributes for the closing tag. May not be null.
 214         /// </summary>
 215         public HtmlAttributeCollection ClosingAttributes
 216         {
 217             get
 218             {
 219                 if (!HasClosingAttributes)
 220                 {
 221                     return new HtmlAttributeCollection(this);
 222                 }
 223                 return _endnode.Attributes;
 224             }
 225         }
 226
 227         internal HtmlNode EndNode
 228         {
 229             get { return _endnode; }
 230         }
 231
 232         /// <summary>
 233         /// Gets the first child of the node.
 234         /// </summary>
 235         public HtmlNode FirstChild
 236         {
 237             get
 238             {
 239                 if (!HasChildNodes)
 240                 {
 241                     return null;
 242                 }
 243                 return _childnodes[0];
 244             }
 245         }
 246
 247         /// <summary>
 248         /// Gets a value indicating whether the current node has any attributes.
 249         /// </summary>
 250         public bool HasAttributes
 251         {
 252             get
 253             {
 254                 if (_attributes == null)
 255                 {
 256                     return false;
 257                 }
 258
 259                 if (_attributes.Count <= 0)
 260                 {
 261                     return false;
 262                 }
 263                 return true;
 264             }
 265         }
 266
 267         /// <summary>
 268         /// Gets a value indicating whether this node has any child nodes.
 269         /// </summary>
 270         public bool HasChildNodes
 271         {
 272             get
 273             {
 274                 if (_childnodes == null)
 275                 {
 276                     return false;
 277                 }
 278
 279                 if (_childnodes.Count <= 0)
 280                 {
 281                     return false;
 282                 }
 283                 return true;
 284             }
 285         }
 286
 287         /// <summary>
 288         /// Gets a value indicating whether the current node has any attributes on the closing tag.
 289         /// </summary>
 290         public bool HasClosingAttributes
 291         {
 292             get
 293             {
 294                 if ((_endnode == null) || (_endnode == this))
 295                 {
 296                     return false;
 297                 }
 298
 299                 if (_endnode._attributes == null)
 300                 {
 301                     return false;
 302                 }
 303
 304                 if (_endnode._attributes.Count <= 0)
 305                 {
 306                     return false;
 307                 }
 308                 return true;
 309             }
 310         }
 311
 312         /// <summary>
 313         /// Gets or sets the value of the 'id' HTML attribute. The document must have been parsed using the OptionUseIdAttribute set to true.
 314         /// </summary>
 315         public string Id
 316         {
 317             get
 318             {
 319                 if (_ownerdocument._nodesid == null)
 320                 {
 321                     throw new Exception(HtmlDocument.HtmlExceptionUseIdAttributeFalse);
 322                 }
 323                 return GetId();
 324             }
 325             set
 326             {
 327                 if (_ownerdocument._nodesid == null)
 328                 {
 329                     throw new Exception(HtmlDocument.HtmlExceptionUseIdAttributeFalse);
 330                 }
 331
 332                 if (value == null)
 333                 {
 334                     throw new ArgumentNullException("value");
 335                 }
 336                 SetId(value);
 337             }
 338         }
 339
 340         /// <summary>
 341         /// Gets or Sets the HTML between the start and end tags of the object.
 342         /// </summary>
 343         public virtual string InnerHtml
 344         {
 345             get
 346             {
 347                 if (_innerchanged)
 348                 {
 349                     _innerhtml = WriteContentTo();
 350                     _innerchanged = false;
 351                     return _innerhtml;
 352                 }
 353                 if (_innerhtml != null)
 354                 {
 355                     return _innerhtml;
 356                 }
 357
 358                 if (_innerstartindex < 0)
 359                 {
 360                     return string.Empty;
 361                 }
 362
 363                 return _ownerdocument._text.Substring(_innerstartindex, _innerlength);
 364             }
 365             set
 366             {
 367                 HtmlDocument doc = new HtmlDocument();
 368                 doc.LoadHtml(value);
 369
 370                 RemoveAllChildren();
 371                 AppendChildren(doc.DocumentNode.ChildNodes);
 372             }
 373         }
 374
 375         /// <summary>
 376         /// Gets or Sets the text between the start and end tags of the object.
 377         /// </summary>
 378         public virtual string InnerText
 379         {
 380             get
 381             {
 382                 if (_nodetype == HtmlNodeType.Text)
 383                 {
 384                     return ((HtmlTextNode) this).Text;
 385                 }
 386
 387                 if (_nodetype == HtmlNodeType.Comment)
 388                 {
 389                     return ((HtmlCommentNode) this).Comment;
 390                 }
 391
 392                 // note: right now, this method is *slow*, because we recompute everything.
 393                 // it could be optimised like innerhtml
 394                 if (!HasChildNodes)
 395                 {
 396                     return string.Empty;
 397                 }
 398
 399                 string s = null;
 400                 foreach (HtmlNode node in ChildNodes)
 401                 {
 402                     s += node.InnerText;
 403                 }
 404                 return s;
 405             }
 406         }
 407
 408         /// <summary>
 409         /// Gets the last child of the node.
 410         /// </summary>
 411         public HtmlNode LastChild
 412         {
 413             get
 414             {
 415                 return !HasChildNodes ? null : _childnodes[_childnodes.Count - 1];
 416             }
 417         }
 418
 419         /// <summary>
 420         /// Gets the line number of this node in the document.
 421         /// </summary>
 422         public int Line
 423         {
 424             get { return _line; }
 425             internal set { _line = value; }
 426         }
 427
 428         /// <summary>
 429         /// Gets the column number of this node in the document.
 430         /// </summary>
 431         public int LinePosition
 432         {
 433             get { return _lineposition; }
 434             internal set { _lineposition = value; }
 435         }
 436
 437         /// <summary>
 438         /// Gets or sets this node's name.
 439         /// </summary>
 440         public string Name
 441         {
 442             get
 443             {
 444                 if (_name == null)
 445                 {
 446                     Name = _ownerdocument._text.Substring(_namestartindex, _namelength);
 447                 }
 448                 return _name != null ? _name.ToLower() : string.Empty;
 449             }
 450             set { _name = value; }
 451         }
 452
 453         /// <summary>
 454         /// Gets the HTML node immediately following this element.
 455         /// </summary>
 456         public HtmlNode NextSibling
 457         {
 458             get { return _nextnode; }
 459             internal set { _nextnode = value; }
 460         }
 461
 462         /// <summary>
 463         /// Gets the type of this node.
 464         /// </summary>
 465         public HtmlNodeType NodeType
 466         {
 467             get { return _nodetype; }
 468             internal set { _nodetype = value; }
 469         }
 470
 471         /// <summary>
 472         /// The original unaltered name of the tag
 473         /// </summary>
 474         public string OriginalName
 475         {
 476             get { return _name; }
 477         }
 478
 479         /// <summary>
 480         /// Gets or Sets the object and its content in HTML.
 481         /// </summary>
 482         public virtual string OuterHtml
 483         {
 484             get
 485             {
 486                 if (_outerchanged)
 487                 {
 488                     _outerhtml = WriteTo();
 489                     _outerchanged = false;
 490                     return _outerhtml;
 491                 }
 492
 493                 if (_outerhtml != null)
 494                 {
 495                     return _outerhtml;
 496                 }
 497
 498                 if (_outerstartindex < 0)
 499                 {
 500                     return string.Empty;
 501                 }
 502
 503                 return _ownerdocument._text.Substring(_outerstartindex, _outerlength);
 504             }
 505         }
 506
 507         /// <summary>
 508         /// Gets the <see cref="HtmlDocument"/> to which this node belongs.
 509         /// </summary>
 510         public HtmlDocument OwnerDocument
 511         {
 512             get { return _ownerdocument; }
 513             internal set { _ownerdocument = value; }
 514         }
 515
 516         /// <summary>
 517         /// Gets the parent of this node (for nodes that can have parents).
 518         /// </summary>
 519         public HtmlNode ParentNode
 520         {
 521             get { return _parentnode; }
 522             internal set { _parentnode = value; }
 523         }
 524
 525         /// <summary>
 526         /// Gets the node immediately preceding this node.
 527         /// </summary>
 528         public HtmlNode PreviousSibling
 529         {
 530             get { return _prevnode; }
 531             internal set { _prevnode = value; }
 532         }
 533
 534         /// <summary>
 535         /// Gets the stream position of this node in the document, relative to the start of the document.
 536         /// </summary>
 537         public int StreamPosition
 538         {
 539             get { return _streamposition; }
 540         }
 541
 542         /// <summary>
 543         /// Gets a valid XPath string that points to this node
 544         /// </summary>
 545         public string XPath
 546         {
 547             get
 548             {
 549                 string basePath = (ParentNode == null || ParentNode.NodeType == HtmlNodeType.Document)
 550                                       ? "/"
 551                                       : ParentNode.XPath + "/";
 552                 return basePath + GetRelativeXpath();
 553             }
 554         }
 555
 556         #endregion
 557
 558         #region IXPathNavigable Members
 559
 560         /// <summary>
 561         /// Creates a new XPathNavigator object for navigating this HTML node.
 562         /// </summary>
 563         /// <returns>An XPathNavigator object. The XPathNavigator is positioned on the node from which the method was called. It is not positioned on the root of the document.</returns>
 564         public XPathNavigator CreateNavigator()
 565         {
 566             return new HtmlNodeNavigator(_ownerdocument, this);
 567         }
 568
 569         #endregion
 570
 571         #region Public Methods
 572
 573         /// <summary>
 574         /// Determines if an element node can be kept overlapped.
 575         /// </summary>
 576         /// <param name="name">The name of the element node to check. May not be <c>null</c>.</param>
 577         /// <returns>true if the name is the name of an element node that can be kept overlapped, <c>false</c> otherwise.</returns>
 578         public static bool CanOverlapElement(string name)
 579         {
 580             if (name == null)
 581             {
 582                 throw new ArgumentNullException("name");
 583             }
 584
 585             object flag = ElementsFlags[name.ToLower()];
 586             if (flag == null)
 587             {
 588                 return false;
 589             }
 590             return (((HtmlElementFlag) flag) & HtmlElementFlag.CanOverlap) != 0;
 591         }
 592
 593         /// <summary>
 594         /// Creates an HTML node from a string representing literal HTML.
 595         /// </summary>
 596         /// <param name="html">The HTML text.</param>
 597         /// <returns>The newly created node instance.</returns>
 598         public static HtmlNode CreateNode(string html)
 599         {
 600             // REVIEW: this is *not* optimum...
 601             HtmlDocument doc = new HtmlDocument();
 602             doc.LoadHtml(html);
 603             return doc.DocumentNode.FirstChild;
 604         }
 605
 606         /// <summary>
 607         /// Determines if an element node is a CDATA element node.
 608         /// </summary>
 609         /// <param name="name">The name of the element node to check. May not be null.</param>
 610         /// <returns>true if the name is the name of a CDATA element node, false otherwise.</returns>
 611         public static bool IsCDataElement(string name)
 612         {
 613             if (name == null)
 614             {
 615                 throw new ArgumentNullException("name");
 616             }
 617
 618             object flag = ElementsFlags[name.ToLower()];
 619             if (flag == null)
 620             {
 621                 return false;
 622             }
 623             return (((HtmlElementFlag) flag) & HtmlElementFlag.CData) != 0;
 624         }
 625
 626         /// <summary>
 627         /// Determines if an element node is closed.
 628         /// </summary>
 629         /// <param name="name">The name of the element node to check. May not be null.</param>
 630         /// <returns>true if the name is the name of a closed element node, false otherwise.</returns>
 631         public static bool IsClosedElement(string name)
 632         {
 633             if (name == null)
 634             {
 635                 throw new ArgumentNullException("name");
 636             }
 637
 638             object flag = ElementsFlags[name.ToLower()];
 639             if (flag == null)
 640             {
 641                 return false;
 642             }
 643             return (((HtmlElementFlag) flag) & HtmlElementFlag.Closed) != 0;
 644         }
 645
 646         /// <summary>
 647         /// Determines if an element node is defined as empty.
 648         /// </summary>
 649         /// <param name="name">The name of the element node to check. May not be null.</param>
 650         /// <returns>true if the name is the name of an empty element node, false otherwise.</returns>
 651         public static bool IsEmptyElement(string name)
 652         {
 653             if (name == null)
 654             {
 655                 throw new ArgumentNullException("name");
 656             }
 657
 658             if (name.Length == 0)
 659             {
 660                 return true;
 661             }
 662
 663             // <!DOCTYPE ...
 664             if ('!' == name[0])
 665             {
 666                 return true;
 667             }
 668
 669             // <?xml ...
 670             if ('?' == name[0])
 671             {
 672                 return true;
 673             }
 674
 675             object flag = ElementsFlags[name.ToLower()];
 676             if (flag == null)
 677             {
 678                 return false;
 679             }
 680             return (((HtmlElementFlag) flag) & HtmlElementFlag.Empty) != 0;
 681         }
 682
 683         /// <summary>
 684         /// Determines if a text corresponds to the closing tag of an node that can be kept overlapped.
 685         /// </summary>
 686         /// <param name="text">The text to check. May not be null.</param>
 687         /// <returns>true or false.</returns>
 688         public static bool IsOverlappedClosingElement(string text)
 689         {
 690             if (text == null)
 691             {
 692                 throw new ArgumentNullException("text");
 693             }
 694             // min is </x>: 4
 695             if (text.Length <= 4)
 696                 return false;
 697
 698             if ((text[0] != '<') ||
 699                 (text[text.Length - 1] != '>') ||
 700                 (text[1] != '/'))
 701                 return false;
 702
 703             string name = text.Substring(2, text.Length - 3);
 704             return CanOverlapElement(name);
 705         }
 706
 707         /// <summary>
 708         /// Returns a collection of all ancestor nodes of this element.
 709         /// </summary>
 710         /// <returns></returns>
 711         public IEnumerable<HtmlNode> Ancestors()
 712         {
 713             HtmlNode node = ParentNode;
 714             while (node.ParentNode != null)
 715             {
 716                 yield return node.ParentNode;
 717                 node = node.ParentNode;
 718             }
 719         }
 720
 721         /// <summary>
 722         /// Get Ancestors with matching name
 723         /// </summary>
 724         /// <param name="name"></param>
 725         /// <returns></returns>
 726         public IEnumerable<HtmlNode> Ancestors(string name)
 727         {
 728             for (HtmlNode n = ParentNode; n != null; n = n.ParentNode)
 729                 if (n.Name == name)
 730                     yield return n;
 731         }
 732
 733         /// <summary>
 734         /// Returns a collection of all ancestor nodes of this element.
 735         /// </summary>
 736         /// <returns></returns>
 737         public IEnumerable<HtmlNode> AncestorsAndSelf()
 738         {
 739             for (HtmlNode n = this; n != null; n = n.ParentNode)
 740                 yield return n;
 741         }
 742
 743         /// <summary>
 744         /// Gets all anscestor nodes and the current node
 745         /// </summary>
 746         /// <param name="name"></param>
 747         /// <returns></returns>
 748         public IEnumerable<HtmlNode> AncestorsAndSelf(string name)
 749         {
 750             for (HtmlNode n = this; n != null; n = n.ParentNode)
 751                 if (n.Name == name)
 752                     yield return n;
 753         }
 754
 755         /// <summary>
 756         /// Adds the specified node to the end of the list of children of this node.
 757         /// </summary>
 758         /// <param name="newChild">The node to add. May not be null.</param>
 759         /// <returns>The node added.</returns>
 760         public HtmlNode AppendChild(HtmlNode newChild)
 761         {
 762             if (newChild == null)
 763             {
 764                 throw new ArgumentNullException("newChild");
 765             }
 766
 767             ChildNodes.Append(newChild);
 768             _ownerdocument.SetIdForNode(newChild, newChild.GetId());
 769             _outerchanged = true;
 770             _innerchanged = true;
 771             return newChild;
 772         }
 773
 774         /// <summary>
 775         /// Adds the specified node to the end of the list of children of this node.
 776         /// </summary>
 777         /// <param name="newChildren">The node list to add. May not be null.</param>
 778         public void AppendChildren(HtmlNodeCollection newChildren)
 779         {
 780             if (newChildren == null)
 781                 throw new ArgumentNullException("newChildrend");
 782
 783             foreach (HtmlNode newChild in newChildren)
 784             {
 785                 AppendChild(newChild);
 786             }
 787         }
 788
 789         /// <summary>
 790         /// Gets all Attributes with name
 791         /// </summary>
 792         /// <param name="name"></param>
 793         /// <returns></returns>
 794         public IEnumerable<HtmlAttribute> ChildAttributes(string name)
 795         {
 796             return Attributes.AttributesWithName(name);
 797         }
 798
 799         /// <summary>
 800         /// Creates a duplicate of the node
 801         /// </summary>
 802         /// <returns></returns>
 803         public HtmlNode Clone()
 804         {
 805             return CloneNode(true);
 806         }
 807
 808         /// <summary>
 809         /// Creates a duplicate of the node and changes its name at the same time.
 810         /// </summary>
 811         /// <param name="newName">The new name of the cloned node. May not be <c>null</c>.</param>
 812         /// <returns>The cloned node.</returns>
 813         public HtmlNode CloneNode(string newName)
 814         {
 815             return CloneNode(newName, true);
 816         }
 817
 818         /// <summary>
 819         /// Creates a duplicate of the node and changes its name at the same time.
 820         /// </summary>
 821         /// <param name="newName">The new name of the cloned node. May not be null.</param>
 822         /// <param name="deep">true to recursively clone the subtree under the specified node; false to clone only the node itself.</param>
 823         /// <returns>The cloned node.</returns>
 824         public HtmlNode CloneNode(string newName, bool deep)
 825         {
 826             if (newName == null)
 827             {
 828                 throw new ArgumentNullException("newName");
 829             }
 830
 831             HtmlNode node = CloneNode(deep);
 832             node.Name = newName;
 833             return node;
 834         }
 835
 836         /// <summary>
 837         /// Creates a duplicate of the node.
 838         /// </summary>
 839         /// <param name="deep">true to recursively clone the subtree under the specified node; false to clone only the node itself.</param>
 840         /// <returns>The cloned node.</returns>
 841         public HtmlNode CloneNode(bool deep)
 842         {
 843             HtmlNode node = _ownerdocument.CreateNode(_nodetype);
 844             node.Name = Name;
 845
 846             switch (_nodetype)
 847             {
 848                 case HtmlNodeType.Comment:
 849                     ((HtmlCommentNode) node).Comment = ((HtmlCommentNode) this).Comment;
 850                     return node;
 851
 852                 case HtmlNodeType.Text:
 853                     ((HtmlTextNode) node).Text = ((HtmlTextNode) this).Text;
 854                     return node;
 855             }
 856
 857             // attributes
 858             if (HasAttributes)
 859             {
 860                 foreach (HtmlAttribute att in _attributes)
 861                 {
 862                     HtmlAttribute newatt = att.Clone();
 863                     node.Attributes.Append(newatt);
 864                 }
 865             }
 866
 867             // closing attributes
 868             if (HasClosingAttributes)
 869             {
 870                 node._endnode = _endnode.CloneNode(false);
 871                 foreach (HtmlAttribute att in _endnode._attributes)
 872                 {
 873                     HtmlAttribute newatt = att.Clone();
 874                     node._endnode._attributes.Append(newatt);
 875                 }
 876             }
 877             if (!deep)
 878             {
 879                 return node;
 880             }
 881
 882             if (!HasChildNodes)
 883             {
 884                 return node;
 885             }
 886
 887             // child nodes
 888             foreach (HtmlNode child in _childnodes)
 889             {
 890                 HtmlNode newchild = child.Clone();
 891                 node.AppendChild(newchild);
 892             }
 893             return node;
 894         }
 895
 896         /// <summary>
 897         /// Creates a duplicate of the node and the subtree under it.
 898         /// </summary>
 899         /// <param name="node">The node to duplicate. May not be <c>null</c>.</param>
 900         public void CopyFrom(HtmlNode node)
 901         {
 902             CopyFrom(node, true);
 903         }
 904
 905         /// <summary>
 906         /// Creates a duplicate of the node.
 907         /// </summary>
 908         /// <param name="node">The node to duplicate. May not be <c>null</c>.</param>
 909         /// <param name="deep">true to recursively clone the subtree under the specified node, false to clone only the node itself.</param>
 910         public void CopyFrom(HtmlNode node, bool deep)
 911         {
 912             if (node == null)
 913             {
 914                 throw new ArgumentNullException("node");
 915             }
 916
 917             Attributes.RemoveAll();
 918             if (node.HasAttributes)
 919             {
 920                 foreach (HtmlAttribute att in node.Attributes)
 921                 {
 922                     SetAttributeValue(att.Name, att.Value);
 923                 }
 924             }
 925
 926             if (!deep)
 927             {
 928                 RemoveAllChildren();
 929                 if (node.HasChildNodes)
 930                 {
 931                     foreach (HtmlNode child in node.ChildNodes)
 932                     {
 933                         AppendChild(child.CloneNode(true));
 934                     }
 935                 }
 936             }
 937         }
 938
 939         /// <summary>
 940         /// Creates an XPathNavigator using the root of this document.
 941         /// </summary>
 942         /// <returns></returns>
 943         public XPathNavigator CreateRootNavigator()
 944         {
 945             return new HtmlNodeNavigator(_ownerdocument, _ownerdocument.DocumentNode);
 946         }
 947
 948         /// <summary>
 949         /// Gets all Descendant nodes for this node and each of child nodes
 950         /// </summary>
 951         /// <returns></returns>
 952         public IEnumerable<HtmlNode> DescendantNodes()
 953         {
 954             foreach (HtmlNode node in ChildNodes)
 955             {
 956                 yield return node;
 957                 foreach (HtmlNode descendant in node.DescendantNodes())
 958                     yield return descendant;
 959             }
 960         }
 961
 962         /// <summary>
 963         /// Returns a collection of all descendant nodes of this element, in document order
 964         /// </summary>
 965         /// <returns></returns>
 966         public IEnumerable<HtmlNode> DescendantNodesAndSelf()
 967         {
 968             return DescendantsAndSelf();
 969         }
 970
 971         /// <summary>
 972         /// Gets all Descendant nodes in enumerated list
 973         /// </summary>
 974         /// <returns></returns>
 975         public IEnumerable<HtmlNode> Descendants()
 976         {
 977             foreach (HtmlNode node in DescendantNodes())
 978             {
 979                 yield return node;
 980             }
 981         }
 982
 983         /// <summary>
 984         /// Get all descendant nodes with matching name
 985         /// </summary>
 986         /// <param name="name"></param>
 987         /// <returns></returns>
 988         public IEnumerable<HtmlNode> Descendants(string name)
 989         {
 990             foreach (HtmlNode node in Descendants())
 991                 if (node.Name == name)
 992                     yield return node;
 993         }
 994
 995         /// <summary>
 996         /// Returns a collection of all descendant nodes of this element, in document order
 997         /// </summary>
 998         /// <returns></returns>
 999         public IEnumerable<HtmlNode> DescendantsAndSelf()
1000         {
1001             yield return this;
1002             foreach (HtmlNode n in DescendantNodes())
1003             {
1004                 HtmlNode el = n;
1005                 if (el != null)
1006                     yield return el;
1007             }
1008         }
1009
1010         /// <summary>
1011         /// Gets all descendant nodes including this node
1012         /// </summary>
1013         /// <param name="name"></param>
1014         /// <returns></returns>
1015         public IEnumerable<HtmlNode> DescendantsAndSelf(string name)
1016         {
1017             yield return this;
1018             foreach (HtmlNode node in Descendants())
1019                 if (node.Name == name)
1020                     yield return node;
1021         }
1022
1023         /// <summary>
1024         /// Gets first generation child node matching name
1025         /// </summary>
1026         /// <param name="name"></param>
1027         /// <returns></returns>
1028         public HtmlNode Element(string name)
1029         {
1030             foreach (HtmlNode node in ChildNodes)
1031                 if (node.Name == name)
1032                     return node;
1033             return null;
1034         }
1035
1036         /// <summary>
1037         /// Gets matching first generation child nodes matching name
1038         /// </summary>
1039         /// <param name="name"></param>
1040         /// <returns></returns>
1041         public IEnumerable<HtmlNode> Elements(string name)
1042         {
1043             foreach (HtmlNode node in ChildNodes)
1044                 if (node.Name == name)
1045                     yield return node;
1046         }
1047
1048         /// <summary>
1049         /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1050         /// </summary>
1051         /// <param name="name">The name of the attribute to get. May not be <c>null</c>.</param>
1052         /// <param name="def">The default value to return if not found.</param>
1053         /// <returns>The value of the attribute if found, the default value if not found.</returns>
1054         public string GetAttributeValue(string name, string def)
1055         {
1056             if (name == null)
1057             {
1058                 throw new ArgumentNullException("name");
1059             }
1060
1061             if (!HasAttributes)
1062             {
1063                 return def;
1064             }
1065             HtmlAttribute att = Attributes[name];
1066             if (att == null)
1067             {
1068                 return def;
1069             }
1070             return att.Value;
1071         }
1072
1073         /// <summary>
1074         /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1075         /// </summary>
1076         /// <param name="name">The name of the attribute to get. May not be <c>null</c>.</param>
1077         /// <param name="def">The default value to return if not found.</param>
1078         /// <returns>The value of the attribute if found, the default value if not found.</returns>
1079         public int GetAttributeValue(string name, int def)
1080         {
1081             if (name == null)
1082             {
1083                 throw new ArgumentNullException("name");
1084             }
1085
1086             if (!HasAttributes)
1087             {
1088                 return def;
1089             }
1090             HtmlAttribute att = Attributes[name];
1091             if (att == null)
1092             {
1093                 return def;
1094             }
1095             try
1096             {
1097                 return Convert.ToInt32(att.Value);
1098             }
1099             catch
1100             {
1101                 return def;
1102             }
1103         }
1104
1105         /// <summary>
1106         /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1107         /// </summary>
1108         /// <param name="name">The name of the attribute to get. May not be <c>null</c>.</param>
1109         /// <param name="def">The default value to return if not found.</param>
1110         /// <returns>The value of the attribute if found, the default value if not found.</returns>
1111         public bool GetAttributeValue(string name, bool def)
1112         {
1113             if (name == null)
1114             {
1115                 throw new ArgumentNullException("name");
1116             }
1117
1118             if (!HasAttributes)
1119             {
1120                 return def;
1121             }
1122             HtmlAttribute att = Attributes[name];
1123             if (att == null)
1124             {
1125                 return def;
1126             }
1127             try
1128             {
1129                 return Convert.ToBoolean(att.Value);
1130             }
1131             catch
1132             {
1133                 return def;
1134             }
1135         }
1136
1137         /// <summary>
1138         /// Inserts the specified node immediately after the specified reference node.
1139         /// </summary>
1140         /// <param name="newChild">The node to insert. May not be <c>null</c>.</param>
1141         /// <param name="refChild">The node that is the reference node. The newNode is placed after the refNode.</param>
1142         /// <returns>The node being inserted.</returns>
1143         public HtmlNode InsertAfter(HtmlNode newChild, HtmlNode refChild)
1144         {
1145             if (newChild == null)
1146             {
1147                 throw new ArgumentNullException("newChild");
1148             }
1149
1150             if (refChild == null)
1151             {
1152                 return PrependChild(newChild);
1153             }
1154
1155             if (newChild == refChild)
1156             {
1157                 return newChild;
1158             }
1159
1160             int index = -1;
1161
1162             if (_childnodes != null)
1163             {
1164                 index = _childnodes[refChild];
1165             }
1166             if (index == -1)
1167             {
1168                 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1169             }
1170
1171             if (_childnodes != null) _childnodes.Insert(index + 1, newChild);
1172
1173             _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1174             _outerchanged = true;
1175             _innerchanged = true;
1176             return newChild;
1177         }
1178
1179         /// <summary>
1180         /// Inserts the specified node immediately before the specified reference node.
1181         /// </summary>
1182         /// <param name="newChild">The node to insert. May not be <c>null</c>.</param>
1183         /// <param name="refChild">The node that is the reference node. The newChild is placed before this node.</param>
1184         /// <returns>The node being inserted.</returns>
1185         public HtmlNode InsertBefore(HtmlNode newChild, HtmlNode refChild)
1186         {
1187             if (newChild == null)
1188             {
1189                 throw new ArgumentNullException("newChild");
1190             }
1191
1192             if (refChild == null)
1193             {
1194                 return AppendChild(newChild);
1195             }
1196
1197             if (newChild == refChild)
1198             {
1199                 return newChild;
1200             }
1201
1202             int index = -1;
1203
1204             if (_childnodes != null)
1205             {
1206                 index = _childnodes[refChild];
1207             }
1208
1209             if (index == -1)
1210             {
1211                 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1212             }
1213
1214             if (_childnodes != null) _childnodes.Insert(index, newChild);
1215
1216             _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1217             _outerchanged = true;
1218             _innerchanged = true;
1219             return newChild;
1220         }
1221
1222         /// <summary>
1223         /// Adds the specified node to the beginning of the list of children of this node.
1224         /// </summary>
1225         /// <param name="newChild">The node to add. May not be <c>null</c>.</param>
1226         /// <returns>The node added.</returns>
1227         public HtmlNode PrependChild(HtmlNode newChild)
1228         {
1229             if (newChild == null)
1230             {
1231                 throw new ArgumentNullException("newChild");
1232             }
1233             ChildNodes.Prepend(newChild);
1234             _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1235             _outerchanged = true;
1236             _innerchanged = true;
1237             return newChild;
1238         }
1239
1240         /// <summary>
1241         /// Adds the specified node list to the beginning of the list of children of this node.
1242         /// </summary>
1243         /// <param name="newChildren">The node list to add. May not be <c>null</c>.</param>
1244         public void PrependChildren(HtmlNodeCollection newChildren)
1245         {
1246             if (newChildren == null)
1247             {
1248                 throw new ArgumentNullException("newChildren");
1249             }
1250
1251             foreach (HtmlNode newChild in newChildren)
1252             {
1253                 PrependChild(newChild);
1254             }
1255         }
1256
1257         /// <summary>
1258         /// Removes node from parent collection
1259         /// </summary>
1260         public void Remove()
1261         {
1262             if (ParentNode != null)
1263                 ParentNode.ChildNodes.Remove(this);
1264         }
1265
1266         /// <summary>
1267         /// Removes all the children and/or attributes of the current node.
1268         /// </summary>
1269         public void RemoveAll()
1270         {
1271             RemoveAllChildren();
1272
1273             if (HasAttributes)
1274             {
1275                 _attributes.Clear();
1276             }
1277
1278             if ((_endnode != null) && (_endnode != this))
1279             {
1280                 if (_endnode._attributes != null)
1281                 {
1282                     _endnode._attributes.Clear();
1283                 }
1284             }
1285             _outerchanged = true;
1286             _innerchanged = true;
1287         }
1288
1289         /// <summary>
1290         /// Removes all the children of the current node.
1291         /// </summary>
1292         public void RemoveAllChildren()
1293         {
1294             if (!HasChildNodes)
1295             {
1296                 return;
1297             }
1298
1299             if (_ownerdocument.OptionUseIdAttribute)
1300             {
1301                 // remove nodes from id list
1302                 foreach (HtmlNode node in _childnodes)
1303                 {
1304                     _ownerdocument.SetIdForNode(null, node.GetId());
1305                 }
1306             }
1307             _childnodes.Clear();
1308             _outerchanged = true;
1309             _innerchanged = true;
1310         }
1311
1312         /// <summary>
1313         /// Removes the specified child node.
1314         /// </summary>
1315         /// <param name="oldChild">The node being removed. May not be <c>null</c>.</param>
1316         /// <returns>The node removed.</returns>
1317         public HtmlNode RemoveChild(HtmlNode oldChild)
1318         {
1319             if (oldChild == null)
1320             {
1321                 throw new ArgumentNullException("oldChild");
1322             }
1323
1324             int index = -1;
1325
1326             if (_childnodes != null)
1327             {
1328                 index = _childnodes[oldChild];
1329             }
1330
1331             if (index == -1)
1332             {
1333                 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1334             }
1335
1336             if (_childnodes != null)
1337                 _childnodes.Remove(index);
1338
1339             _ownerdocument.SetIdForNode(null, oldChild.GetId());
1340             _outerchanged = true;
1341             _innerchanged = true;
1342             return oldChild;
1343         }
1344
1345         /// <summary>
1346         /// Removes the specified child node.
1347         /// </summary>
1348         /// <param name="oldChild">The node being removed. May not be <c>null</c>.</param>
1349         /// <param name="keepGrandChildren">true to keep grand children of the node, false otherwise.</param>
1350         /// <returns>The node removed.</returns>
1351         public HtmlNode RemoveChild(HtmlNode oldChild, bool keepGrandChildren)
1352         {
1353             if (oldChild == null)
1354             {
1355                 throw new ArgumentNullException("oldChild");
1356             }
1357
1358             if ((oldChild._childnodes != null) && keepGrandChildren)
1359             {
1360                 // get prev sibling
1361                 HtmlNode prev = oldChild.PreviousSibling;
1362
1363                 // reroute grand children to ourselves
1364                 foreach (HtmlNode grandchild in oldChild._childnodes)
1365                 {
1366                     InsertAfter(grandchild, prev);
1367                 }
1368             }
1369             RemoveChild(oldChild);
1370             _outerchanged = true;
1371             _innerchanged = true;
1372             return oldChild;
1373         }
1374
1375         /// <summary>
1376         /// Replaces the child node oldChild with newChild node.
1377         /// </summary>
1378         /// <param name="newChild">The new node to put in the child list.</param>
1379         /// <param name="oldChild">The node being replaced in the list.</param>
1380         /// <returns>The node replaced.</returns>
1381         public HtmlNode ReplaceChild(HtmlNode newChild, HtmlNode oldChild)
1382         {
1383             if (newChild == null)
1384             {
1385                 return RemoveChild(oldChild);
1386             }
1387
1388             if (oldChild == null)
1389             {
1390                 return AppendChild(newChild);
1391             }
1392
1393             int index = -1;
1394
1395             if (_childnodes != null)
1396             {
1397                 index = _childnodes[oldChild];
1398             }
1399
1400             if (index == -1)
1401             {
1402                 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1403             }
1404
1405             if (_childnodes != null) _childnodes.Replace(index, newChild);
1406
1407             _ownerdocument.SetIdForNode(null, oldChild.GetId());
1408             _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1409             _outerchanged = true;
1410             _innerchanged = true;
1411             return newChild;
1412         }
1413
1414         /// <summary>
1415         /// Selects a list of nodes matching the <see cref="XPath"/> expression.
1416         /// </summary>
1417         /// <param name="xpath">The XPath expression.</param>
1418         /// <returns>An <see cref="HtmlNodeCollection"/> containing a collection of nodes matching the <see cref="XPath"/> query, or <c>null</c> if no node matched the XPath expression.</returns>
1419         public HtmlNodeCollection SelectNodes(string xpath)
1420         {
1421             HtmlNodeCollection list = new HtmlNodeCollection(null);
1422
1423             HtmlNodeNavigator nav = new HtmlNodeNavigator(_ownerdocument, this);
1424             XPathNodeIterator it = nav.Select(xpath);
1425             while (it.MoveNext())
1426             {
1427                 HtmlNodeNavigator n = (HtmlNodeNavigator) it.Current;
1428                 list.Add(n.CurrentNode);
1429             }
1430             if (list.Count == 0)
1431             {
1432                 return null;
1433             }
1434             return list;
1435         }
1436
1437         /// <summary>
1438         /// Selects the first XmlNode that matches the XPath expression.
1439         /// </summary>
1440         /// <param name="xpath">The XPath expression. May not be null.</param>
1441         /// <returns>The first <see cref="HtmlNode"/> that matches the XPath query or a null reference if no matching node was found.</returns>
1442         public HtmlNode SelectSingleNode(string xpath)
1443         {
1444             if (xpath == null)
1445             {
1446                 throw new ArgumentNullException("xpath");
1447             }
1448
1449             HtmlNodeNavigator nav = new HtmlNodeNavigator(_ownerdocument, this);
1450             XPathNodeIterator it = nav.Select(xpath);
1451             if (!it.MoveNext())
1452             {
1453                 return null;
1454             }
1455
1456             HtmlNodeNavigator node = (HtmlNodeNavigator) it.Current;
1457             return node.CurrentNode;
1458         }
1459
1460         /// <summary>
1461         /// Helper method to set the value of an attribute of this node. If the attribute is not found, it will be created automatically.
1462         /// </summary>
1463         /// <param name="name">The name of the attribute to set. May not be null.</param>
1464         /// <param name="value">The value for the attribute.</param>
1465         /// <returns>The corresponding attribute instance.</returns>
1466         public HtmlAttribute SetAttributeValue(string name, string value)
1467         {
1468             if (name == null)
1469             {
1470                 throw new ArgumentNullException("name");
1471             }
1472             HtmlAttribute att = Attributes[name];
1473             if (att == null)
1474             {
1475                 return Attributes.Append(_ownerdocument.CreateAttribute(name, value));
1476             }
1477             att.Value = value;
1478             return att;
1479         }
1480
1481         /// <summary>
1482         /// Saves all the children of the node to the specified TextWriter.
1483         /// </summary>
1484         /// <param name="outText">The TextWriter to which you want to save.</param>
1485         public void WriteContentTo(TextWriter outText)
1486         {
1487             if (_childnodes == null)
1488             {
1489                 return;
1490             }
1491
1492             foreach (HtmlNode node in _childnodes)
1493             {
1494                 node.WriteTo(outText);
1495             }
1496         }
1497
1498         /// <summary>
1499         /// Saves all the children of the node to a string.
1500         /// </summary>
1501         /// <returns>The saved string.</returns>
1502         public string WriteContentTo()
1503         {
1504             StringWriter sw = new StringWriter();
1505             WriteContentTo(sw);
1506             sw.Flush();
1507             return sw.ToString();
1508         }
1509
1510         /// <summary>
1511         /// Saves the current node to the specified TextWriter.
1512         /// </summary>
1513         /// <param name="outText">The TextWriter to which you want to save.</param>
1514         public void WriteTo(TextWriter outText)
1515         {
1516             string html;
1517             switch (_nodetype)
1518             {
1519                 case HtmlNodeType.Comment:
1520                     html = ((HtmlCommentNode) this).Comment;
1521                     if (_ownerdocument.OptionOutputAsXml)
1522                     {
1523                         outText.Write("<!--" + GetXmlComment((HtmlCommentNode) this) + " -->");
1524                     }
1525                     else
1526                     {
1527                         outText.Write(html);
1528                     }
1529                     break;
1530
1531                 case HtmlNodeType.Document:
1532                     if (_ownerdocument.OptionOutputAsXml)
1533                     {
1534                         outText.Write("<?xml version=\"1.0\" encoding=\"" + _ownerdocument.GetOutEncoding().BodyName +
1535                                       "\"?>");
1536
1537                         // check there is a root element
1538                         if (_ownerdocument.DocumentNode.HasChildNodes)
1539                         {
1540                             int rootnodes = _ownerdocument.DocumentNode._childnodes.Count;
1541                             if (rootnodes > 0)
1542                             {
1543                                 HtmlNode xml = _ownerdocument.GetXmlDeclaration();
1544                                 if (xml != null)
1545                                 {
1546                                     rootnodes --;
1547                                 }
1548
1549                                 if (rootnodes > 1)
1550                                 {
1551                                     if (_ownerdocument.OptionOutputUpperCase)
1552                                     {
1553                                         outText.Write("<SPAN>");
1554                                         WriteContentTo(outText);
1555                                         outText.Write("</SPAN>");
1556                                     }
1557                                     else
1558                                     {
1559                                         outText.Write("<span>");
1560                                         WriteContentTo(outText);
1561                                         outText.Write("</span>");
1562                                     }
1563                                     break;
1564                                 }
1565                             }
1566                         }
1567                     }
1568                     WriteContentTo(outText);
1569                     break;
1570
1571                 case HtmlNodeType.Text:
1572                     html = ((HtmlTextNode) this).Text;
1573                     if (_ownerdocument.OptionOutputAsXml)
1574                     {
1575                         outText.Write(HtmlDocument.HtmlEncode(html));
1576                     }
1577                     else
1578                     {
1579                         outText.Write(html);
1580                     }
1581                     break;
1582
1583                 case HtmlNodeType.Element:
1584                     string name;
1585                     if (_ownerdocument.OptionOutputUpperCase)
1586                     {
1587                         name = Name.ToUpper();
1588                     }
1589                     else
1590                     {
1591                         name = Name;
1592                     }
1593
1594                     if (_ownerdocument.OptionOutputOriginalCase)
1595                         name = OriginalName;
1596
1597                     if (_ownerdocument.OptionOutputAsXml)
1598                     {
1599                         if (name.Length > 0)
1600                         {
1601                             if (name[0] == '?')
1602                             {
1603                                 // forget this one, it's been done at the document level
1604                                 break;
1605                             }
1606
1607                             if (name.Trim().Length == 0)
1608                             {
1609                                 break;
1610                             }
1611                             name = HtmlDocument.GetXmlName(name);
1612                         }
1613                         else
1614                         {
1615                             break;
1616                         }
1617                     }
1618
1619                     outText.Write("<" + name);
1620                     WriteAttributes(outText, false);
1621
1622                     if (!HasChildNodes)
1623                     {
1624                         if (IsEmptyElement(Name))
1625                         {
1626                             if ((_ownerdocument.OptionWriteEmptyNodes) || (_ownerdocument.OptionOutputAsXml))
1627                             {
1628                                 outText.Write(" />");
1629                             }
1630                             else
1631                             {
1632                                 if (Name.Length > 0)
1633                                 {
1634                                     if (Name[0] == '?')
1635                                     {
1636                                         outText.Write("?");
1637                                     }
1638                                 }
1639
1640                                 outText.Write(">");
1641                             }
1642                         }
1643                         else
1644                         {
1645                             outText.Write("></" + name + ">");
1646                         }
1647                     }
1648                     else
1649                     {
1650                         outText.Write(">");
1651                         bool cdata = false;
1652                         if (_ownerdocument.OptionOutputAsXml)
1653                         {
1654                             if (IsCDataElement(Name))
1655                             {
1656                                 // this code and the following tries to output things as nicely as possible for old browsers.
1657                                 cdata = true;
1658                                 outText.Write("\r\n//<![CDATA[\r\n");
1659                             }
1660                         }
1661
1662                         if (cdata)
1663                         {
1664                             if (HasChildNodes)
1665                             {
1666                                 // child must be a text
1667                                 ChildNodes[0].WriteTo(outText);
1668                             }
1669                             outText.Write("\r\n//]]>//\r\n");
1670                         }
1671                         else
1672                         {
1673                             WriteContentTo(outText);
1674                         }
1675
1676                         outText.Write("</" + name);
1677                         if (!_ownerdocument.OptionOutputAsXml)
1678                         {
1679                             WriteAttributes(outText, true);
1680                         }
1681                         outText.Write(">");
1682                     }
1683                     break;
1684             }
1685         }
1686
1687         /// <summary>
1688         /// Saves the current node to the specified XmlWriter.
1689         /// </summary>
1690         /// <param name="writer">The XmlWriter to which you want to save.</param>
1691         public void WriteTo(XmlWriter writer)
1692         {
1693             switch (_nodetype)
1694             {
1695                 case HtmlNodeType.Comment:
1696                     writer.WriteComment(GetXmlComment((HtmlCommentNode) this));
1697                     break;
1698
1699                 case HtmlNodeType.Document:
1700                     writer.WriteProcessingInstruction("xml",
1701                                                       "version=\"1.0\" encoding=\"" +
1702                                                       _ownerdocument.GetOutEncoding().BodyName + "\"");
1703                     if (HasChildNodes)
1704                     {
1705                         foreach (HtmlNode subnode in ChildNodes)
1706                         {
1707                             subnode.WriteTo(writer);
1708                         }
1709                     }
1710                     break;
1711
1712                 case HtmlNodeType.Text:
1713                     string html = ((HtmlTextNode) this).Text;
1714                     writer.WriteString(html);
1715                     break;
1716
1717                 case HtmlNodeType.Element:
1718                     string name = _ownerdocument.OptionOutputUpperCase ? Name.ToUpper() : Name;
1719
1720                     if (_ownerdocument.OptionOutputOriginalCase)
1721                         name = OriginalName;
1722
1723                     writer.WriteStartElement(name);
1724                     WriteAttributes(writer, this);
1725
1726                     if (HasChildNodes)
1727                     {
1728                         foreach (HtmlNode subnode in ChildNodes)
1729                         {
1730                             subnode.WriteTo(writer);
1731                         }
1732                     }
1733                     writer.WriteEndElement();
1734                     break;
1735             }
1736         }
1737
1738         /// <summary>
1739         /// Saves the current node to a string.
1740         /// </summary>
1741         /// <returns>The saved string.</returns>
1742         public string WriteTo()
1743         {
1744             using (StringWriter sw = new StringWriter())
1745             {
1746                 WriteTo(sw);
1747                 sw.Flush();
1748                 return sw.ToString();
1749             }
1750         }
1751
1752         #endregion
1753
1754         #region Internal Methods
1755
1756         internal static string GetXmlComment(HtmlCommentNode comment)
1757         {
1758             string s = comment.Comment;
1759             return s.Substring(4, s.Length - 7).Replace("--", " - -");
1760         }
1761
1762         internal static void WriteAttributes(XmlWriter writer, HtmlNode node)
1763         {
1764             if (!node.HasAttributes)
1765             {
1766                 return;
1767             }
1768             // we use Hashitems to make sure attributes are written only once
1769             foreach (HtmlAttribute att in node.Attributes.Hashitems.Values)
1770             {
1771                 writer.WriteAttributeString(att.XmlName, att.Value);
1772             }
1773         }
1774
1775         internal void CloseNode(HtmlNode endnode)
1776         {
1777             if (!_ownerdocument.OptionAutoCloseOnEnd)
1778             {
1779                 // close all children
1780                 if (_childnodes != null)
1781                 {
1782                     foreach (HtmlNode child in _childnodes)
1783                     {
1784                         if (child.Closed)
1785                             continue;
1786
1787                         // create a fake closer node
1788                         HtmlNode close = new HtmlNode(NodeType, _ownerdocument, -1);
1789                         close._endnode = close;
1790                         child.CloseNode(close);
1791                     }
1792                 }
1793             }
1794
1795             if (!Closed)
1796             {
1797                 _endnode = endnode;
1798
1799                 if (_ownerdocument._openednodes != null)
1800                 {
1801                     _ownerdocument._openednodes.Remove(_outerstartindex);
1802                 }
1803
1804                 HtmlNode self = _ownerdocument._lastnodes[Name] as HtmlNode;
1805                 if (self == this)
1806                 {
1807                     _ownerdocument._lastnodes.Remove(Name);
1808                     _ownerdocument.UpdateLastParentNode();
1809                 }
1810
1811                 if (endnode == this)
1812                     return;
1813
1814                 // create an inner section
1815                 _innerstartindex = _outerstartindex + _outerlength;
1816                 _innerlength = endnode._outerstartindex - _innerstartindex;
1817
1818                 // update full length
1819                 _outerlength = (endnode._outerstartindex + endnode._outerlength) - _outerstartindex;
1820             }
1821         }
1822
1823         internal string GetId()
1824         {
1825             HtmlAttribute att = Attributes["id"];
1826             if (att == null)
1827             {
1828                 return null;
1829             }
1830             return att.Value;
1831         }
1832
1833         internal void SetId(string id)
1834         {
1835             HtmlAttribute att = Attributes["id"];
1836             if (att == null)
1837             {
1838                 att = _ownerdocument.CreateAttribute("id");
1839             }
1840             att.Value = id;
1841             _ownerdocument.SetIdForNode(this, att.Value);
1842             _outerchanged = true;
1843         }
1844
1845         internal void WriteAttribute(TextWriter outText, HtmlAttribute att)
1846         {
1847             string name;
1848             string quote = att.QuoteType == AttributeValueQuote.DoubleQuote ? "\"" : "'";
1849             if (_ownerdocument.OptionOutputAsXml)
1850             {
1851                 if (_ownerdocument.OptionOutputUpperCase)
1852                 {
1853                     name = att.XmlName.ToUpper();
1854                 }
1855                 else
1856                 {
1857                     name = att.XmlName;
1858                 }
1859                 if (_ownerdocument.OptionOutputOriginalCase)
1860                     name = att.OriginalName;
1861
1862                 outText.Write(" " + name + "=" + quote + HtmlDocument.HtmlEncode(att.XmlValue) + quote);
1863             }
1864             else
1865             {
1866                 if (_ownerdocument.OptionOutputUpperCase)
1867                 {
1868                     name = att.Name.ToUpper();
1869                 }
1870                 else
1871                 {
1872                     name = att.Name;
1873                 }
1874
1875                 if (att.Name.Length >= 4)
1876                 {
1877                     if ((att.Name[0] == '<') && (att.Name[1] == '%') &&
1878                         (att.Name[att.Name.Length - 1] == '>') && (att.Name[att.Name.Length - 2] == '%'))
1879                     {
1880                         outText.Write(" " + name);
1881                         return;
1882                     }
1883                 }
1884                 if (_ownerdocument.OptionOutputOptimizeAttributeValues)
1885                 {
1886                     if (att.Value.IndexOfAny(new Char[] {(char) 10, (char) 13, (char) 9, ' '}) < 0)
1887                     {
1888                         outText.Write(" " + name + "=" + att.Value);
1889                     }
1890                     else
1891                     {
1892                         outText.Write(" " + name + "=" + quote + att.Value + quote);
1893                     }
1894                 }
1895                 else
1896                 {
1897                     outText.Write(" " + name + "=" + quote + att.Value + quote);
1898                 }
1899             }
1900         }
1901
1902         internal void WriteAttributes(TextWriter outText, bool closing)
1903         {
1904             if (_ownerdocument.OptionOutputAsXml)
1905             {
1906                 if (_attributes == null)
1907                 {
1908                     return;
1909                 }
1910                 // we use Hashitems to make sure attributes are written only once
1911                 foreach (HtmlAttribute att in _attributes.Hashitems.Values)
1912                 {
1913                     WriteAttribute(outText, att);
1914                 }
1915                 return;
1916             }
1917
1918             if (!closing)
1919             {
1920                 if (_attributes != null)
1921                 {
1922                     foreach (HtmlAttribute att in _attributes)
1923                     {
1924                         WriteAttribute(outText, att);
1925                     }
1926                 }
1927                 if (_ownerdocument.OptionAddDebuggingAttributes)
1928                 {
1929                     WriteAttribute(outText, _ownerdocument.CreateAttribute("_closed", Closed.ToString()));
1930                     WriteAttribute(outText, _ownerdocument.CreateAttribute("_children", ChildNodes.Count.ToString()));
1931
1932                     int i = 0;
1933                     foreach (HtmlNode n in ChildNodes)
1934                     {
1935                         WriteAttribute(outText, _ownerdocument.CreateAttribute("_child_" + i,
1936                                                                                n.Name));
1937                         i++;
1938                     }
1939                 }
1940             }
1941             else
1942             {
1943                 if (_endnode == null)
1944                 {
1945                     return;
1946                 }
1947
1948                 if (_endnode._attributes == null)
1949                 {
1950                     return;
1951                 }
1952
1953                 if (_endnode == this)
1954                 {
1955                     return;
1956                 }
1957
1958                 foreach (HtmlAttribute att in _endnode._attributes)
1959                 {
1960                     WriteAttribute(outText, att);
1961                 }
1962                 if (_ownerdocument.OptionAddDebuggingAttributes)
1963                 {
1964                     WriteAttribute(outText, _ownerdocument.CreateAttribute("_closed", Closed.ToString()));
1965                     WriteAttribute(outText, _ownerdocument.CreateAttribute("_children", ChildNodes.Count.ToString()));
1966                 }
1967             }
1968         }
1969
1970         #endregion
1971
1972         #region Private Methods
1973
1974         private string GetRelativeXpath()
1975         {
1976             if (ParentNode == null)
1977                 return Name;
1978             if (NodeType == HtmlNodeType.Document)
1979                 return string.Empty;
1980
1981             int i = 1;
1982             foreach (HtmlNode node in ParentNode.ChildNodes)
1983             {
1984                 if (node.Name != Name) continue;
1985
1986                 if (node == this)
1987                     break;
1988
1989                 i++;
1990             }
1991             return Name + "[" + i + "]";
1992         }
1993
1994         #endregion
1995     }
1996 }