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