?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Dont throw EncodingFoundException unless asked to. Should remove the occassional...
[beagle.git] / Filters / HtmlAgilityPack / HtmlNode.cs
blobf952c52a9367752256ab2b0093f9240c00d173c4
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 public bool StartTag
567 {
568 get
569 {
570 return _starttag;
571 }
572 }
573
574 /// <summary>
575 /// Gets the line number of this node in the document.
576 /// </summary>
577 public int Line
578 {
579 get
580 {
581 return _line;
582 }
583 }
584
585 /// <summary>
586 /// Gets the column number of this node in the document.
587 /// </summary>
588 public int LinePosition
589 {
590 get
591 {
592 return _lineposition;
593 }
594 }
595
596 /// <summary>
597 /// Gets the stream position of this node in the document, relative to the start of the document.
598 /// </summary>
599 public int StreamPosition
600 {
601 get
602 {
603 return _streamposition;
604 }
605 }
606
607 /// <summary>
608 /// Gets a value indicating if this node has been closed or not.
609 /// </summary>
610 public bool Closed
611 {
612 get
613 {
614 return (_endnode != null);
615 }
616 }
617
618 /// <summary>
619 /// Gets or sets this node's name.
620 /// </summary>
621 public string Name
622 {
623 get
624 {
625 if (_name == null)
626 {
627 _name = _ownerdocument._text.Substring(_namestartindex, _namelength).ToLower();
628 }
629 return _name;
630 }
631 set
632 {
633 _name = value;
634 }
635 }
636
637 /// <summary>
638 /// Gets or Sets the text between the start and end tags of the object.
639 /// </summary>
640 public virtual string InnerText
641 {
642 get
643 {
644 if (_nodetype == HtmlNodeType.Text)
645 {
646 return ((HtmlTextNode)this).Text;
647 }
648
649 if (_nodetype == HtmlNodeType.Comment)
650 {
651 return ((HtmlCommentNode)this).Comment;
652 }
653
654 // note: right now, this method is *slow*, because we recompute everything.
655 // it could be optimised like innerhtml
656 if (!HasChildNodes)
657 {
658 return string.Empty;
659 }
660
661 string s = null;
662 foreach(HtmlNode node in ChildNodes)
663 {
664 s += node.InnerText;
665 }
666 return s;
667 }
668 }
669
670 /// <summary>
671 /// Gets or Sets the HTML between the start and end tags of the object.
672 /// </summary>
673 public virtual string InnerHtml
674 {
675 get
676 {
677 if (_innerchanged)
678 {
679 _innerhtml = WriteContentTo();
680 _innerchanged = false;
681 return _innerhtml;
682 }
683 if (_innerhtml != null)
684 {
685 return _innerhtml;
686 }
687
688 if (_innerstartindex < 0)
689 {
690 return string.Empty;
691 }
692
693 return _ownerdocument._text.Substring(_innerstartindex, _innerlength);
694 }
695 set
696 {
697 HtmlDocument doc = new HtmlDocument();
698 doc.LoadHtml(value);
699
700 RemoveAllChildren();
701 AppendChildren(doc.DocumentNode.ChildNodes);
702 }
703 }
704
705 /// <summary>
706 /// Gets or Sets the object and its content in HTML.
707 /// </summary>
708 public virtual string OuterHtml
709 {
710 get
711 {
712 if (_outerchanged)
713 {
714 _outerhtml = WriteTo();
715 _outerchanged = false;
716 return _outerhtml;
717 }
718
719 if (_outerhtml != null)
720 {
721 return _outerhtml;
722 }
723
724 if (_outerstartindex < 0)
725 {
726 return string.Empty;
727 }
728
729 return _ownerdocument._text.Substring(_outerstartindex, _outerlength);
730 }
731 }
732
733 /// <summary>
734 /// Creates a duplicate of the node
735 /// </summary>
736 /// <returns></returns>
737 public HtmlNode Clone()
738 {
739 return CloneNode(true);
740 }
741
742 /// <summary>
743 /// Creates a duplicate of the node and changes its name at the same time.
744 /// </summary>
745 /// <param name="newName">The new name of the cloned node. May not be null.</param>
746 /// <returns>The cloned node.</returns>
747 public HtmlNode CloneNode(string newName)
748 {
749 return CloneNode(newName, true);
750 }
751
752 /// <summary>
753 /// Creates a duplicate of the node and changes its name at the same time.
754 /// </summary>
755 /// <param name="newName">The new name of the cloned node. May not be null.</param>
756 /// <param name="deep">true to recursively clone the subtree under the specified node; false to clone only the node itself.</param>
757 /// <returns>The cloned node.</returns>
758 public HtmlNode CloneNode(string newName, bool deep)
759 {
760 if (newName == null)
761 {
762 throw new ArgumentNullException("newName");
763 }
764
765 HtmlNode node = CloneNode(deep);
766 node._name = newName;
767 return node;
768 }
769
770 /// <summary>
771 /// Creates a duplicate of the node.
772 /// </summary>
773 /// <param name="deep">true to recursively clone the subtree under the specified node; false to clone only the node itself.</param>
774 /// <returns>The cloned node.</returns>
775 public HtmlNode CloneNode(bool deep)
776 {
777 HtmlNode node = _ownerdocument.CreateNode(_nodetype);
778 node._name = Name;
779
780 switch(_nodetype)
781 {
782 case HtmlNodeType.Comment:
783 ((HtmlCommentNode)node).Comment = ((HtmlCommentNode)this).Comment;
784 return node;
785
786 case HtmlNodeType.Text:
787 ((HtmlTextNode)node).Text = ((HtmlTextNode)this).Text;
788 return node;
789 }
790
791 // attributes
792 if (HasAttributes)
793 {
794 foreach(HtmlAttribute att in _attributes)
795 {
796 HtmlAttribute newatt = att.Clone();
797 node.Attributes.Append(newatt);
798 }
799 }
800
801 // closing attributes
802 if (HasClosingAttributes)
803 {
804 node._endnode = _endnode.CloneNode(false);
805 foreach(HtmlAttribute att in _endnode._attributes)
806 {
807 HtmlAttribute newatt = att.Clone();
808 node._endnode._attributes.Append(newatt);
809 }
810 }
811 if (!deep)
812 {
813 return node;
814 }
815
816 if (!HasChildNodes)
817 {
818 return node;
819 }
820
821 // child nodes
822 foreach(HtmlNode child in _childnodes)
823 {
824 HtmlNode newchild = child.Clone();
825 node.AppendChild(newchild);
826 }
827 return node;
828 }
829
830 /// <summary>
831 /// Gets the HTML node immediately following this element.
832 /// </summary>
833 public HtmlNode NextSibling
834 {
835 get
836 {
837 return _nextnode;
838 }
839 }
840
841 /// <summary>
842 /// Gets the node immediately preceding this node.
843 /// </summary>
844 public HtmlNode PreviousSibling
845 {
846 get
847 {
848 return _prevnode;
849 }
850 }
851
852 /// <summary>
853 /// Removes all the children and/or attributes of the current node.
854 /// </summary>
855 public void RemoveAll()
856 {
857 RemoveAllChildren();
858
859 if (HasAttributes)
860 {
861 _attributes.Clear();
862 }
863
864 if ((_endnode != null) && (_endnode != this))
865 {
866 if (_endnode._attributes != null)
867 {
868 _endnode._attributes.Clear();
869 }
870 }
871 _outerchanged = true;
872 _innerchanged = true;
873 }
874
875 /// <summary>
876 /// Removes all the children of the current node.
877 /// </summary>
878 public void RemoveAllChildren()
879 {
880 if (!HasChildNodes)
881 {
882 return;
883 }
884
885 if (_ownerdocument.OptionUseIdAttribute)
886 {
887 // remove nodes from id list
888 foreach(HtmlNode node in _childnodes)
889 {
890 _ownerdocument.SetIdForNode(null, node.GetId());
891 }
892 }
893 _childnodes.Clear();
894 _outerchanged = true;
895 _innerchanged = true;
896 }
897
898 /// <summary>
899 /// Removes the specified child node.
900 /// </summary>
901 /// <param name="oldChild">The node being removed. May not be null.</param>
902 /// <returns>The node removed.</returns>
903 public HtmlNode RemoveChild(HtmlNode oldChild)
904 {
905 if (oldChild == null)
906 {
907 throw new ArgumentNullException("oldChild");
908 }
909
910 int index = -1;
911
912 if (_childnodes != null)
913 {
914 index = _childnodes[oldChild];
915 }
916
917 if (index == -1)
918 {
919 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
920 }
921
922 _childnodes.Remove(index);
923
924 _ownerdocument.SetIdForNode(null, oldChild.GetId());
925 _outerchanged = true;
926 _innerchanged = true;
927 return oldChild;
928 }
929
930 /// <summary>
931 /// Removes the specified child node.
932 /// </summary>
933 /// <param name="oldChild">The node being removed. May not be null.</param>
934 /// <param name="keepGrandChildren">true to keep grand children of the node, false otherwise.</param>
935 /// <returns>The node removed.</returns>
936 public HtmlNode RemoveChild(HtmlNode oldChild, bool keepGrandChildren)
937 {
938 if (oldChild == null)
939 {
940 throw new ArgumentNullException("oldChild");
941 }
942
943 if ((oldChild._childnodes != null) && keepGrandChildren)
944 {
945 // get prev sibling
946 HtmlNode prev = oldChild.PreviousSibling;
947
948 // reroute grand children to ourselves
949 foreach(HtmlNode grandchild in oldChild._childnodes)
950 {
951 InsertAfter(grandchild, prev);
952 }
953 }
954 RemoveChild(oldChild);
955 _outerchanged = true;
956 _innerchanged = true;
957 return oldChild;
958 }
959
960 /// <summary>
961 /// Replaces the child node oldChild with newChild node.
962 /// </summary>
963 /// <param name="newChild">The new node to put in the child list.</param>
964 /// <param name="oldChild">The node being replaced in the list.</param>
965 /// <returns>The node replaced.</returns>
966 public HtmlNode ReplaceChild(HtmlNode newChild, HtmlNode oldChild)
967 {
968 if (newChild == null)
969 {
970 return RemoveChild(oldChild);
971 }
972
973 if (oldChild == null)
974 {
975 return AppendChild(newChild);
976 }
977
978 int index = -1;
979
980 if (_childnodes != null)
981 {
982 index = _childnodes[oldChild];
983 }
984
985 if (index == -1)
986 {
987 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
988 }
989
990 _childnodes.Replace(index, newChild);
991
992 _ownerdocument.SetIdForNode(null, oldChild.GetId());
993 _ownerdocument.SetIdForNode(newChild, newChild.GetId());
994 _outerchanged = true;
995 _innerchanged = true;
996 return newChild;
997 }
998
999 /// <summary>
1000 /// Inserts the specified node immediately before the specified reference node.
1001 /// </summary>
1002 /// <param name="newChild">The node to insert. May not be null.</param>
1003 /// <param name="refChild">The node that is the reference node. The newChild is placed before this node.</param>
1004 /// <returns>The node being inserted.</returns>
1005 public HtmlNode InsertBefore(HtmlNode newChild, HtmlNode refChild)
1006 {
1007 if (newChild == null)
1008 {
1009 throw new ArgumentNullException("newChild");
1010 }
1011
1012 if (refChild == null)
1013 {
1014 return AppendChild(newChild);
1015 }
1016
1017 if (newChild == refChild)
1018 {
1019 return newChild;
1020 }
1021
1022 int index = -1;
1023
1024 if (_childnodes != null)
1025 {
1026 index = _childnodes[refChild];
1027 }
1028
1029 if (index == -1)
1030 {
1031 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1032 }
1033
1034 _childnodes.Insert(index, newChild);
1035
1036 _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1037 _outerchanged = true;
1038 _innerchanged = true;
1039 return newChild;
1040 }
1041
1042 /// <summary>
1043 /// Inserts the specified node immediately after the specified reference node.
1044 /// </summary>
1045 /// <param name="newChild">The node to insert. May not be null.</param>
1046 /// <param name="refChild">The node that is the reference node. The newNode is placed after the refNode.</param>
1047 /// <returns>The node being inserted.</returns>
1048 public HtmlNode InsertAfter(HtmlNode newChild, HtmlNode refChild)
1049 {
1050 if (newChild == null)
1051 {
1052 throw new ArgumentNullException("newChild");
1053 }
1054
1055 if (refChild == null)
1056 {
1057 return PrependChild(newChild);
1058 }
1059
1060 if (newChild == refChild)
1061 {
1062 return newChild;
1063 }
1064
1065 int index = -1;
1066
1067 if (_childnodes != null)
1068 {
1069 index = _childnodes[refChild];
1070 }
1071 if (index == -1)
1072 {
1073 throw new ArgumentException(HtmlDocument.HtmlExceptionRefNotChild);
1074 }
1075
1076 _childnodes.Insert(index + 1, newChild);
1077
1078 _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1079 _outerchanged = true;
1080 _innerchanged = true;
1081 return newChild;
1082 }
1083
1084 /// <summary>
1085 /// Gets the first child of the node.
1086 /// </summary>
1087 public HtmlNode FirstChild
1088 {
1089 get
1090 {
1091 if (!HasChildNodes)
1092 {
1093 return null;
1094 }
1095 return _childnodes[0];
1096 }
1097 }
1098
1099 /// <summary>
1100 /// Gets the last child of the node.
1101 /// </summary>
1102 public HtmlNode LastChild
1103 {
1104 get
1105 {
1106 if (!HasChildNodes)
1107 {
1108 return null;
1109 }
1110 return _childnodes[_childnodes.Count-1];
1111 }
1112 }
1113
1114 /// <summary>
1115 /// Gets the type of this node.
1116 /// </summary>
1117 public HtmlNodeType NodeType
1118 {
1119 get
1120 {
1121 return _nodetype;
1122 }
1123 }
1124
1125 /// <summary>
1126 /// Gets the parent of this node (for nodes that can have parents).
1127 /// </summary>
1128 public HtmlNode ParentNode
1129 {
1130 get
1131 {
1132 return _parentnode;
1133 }
1134 }
1135
1136 /// <summary>
1137 /// Gets the HtmlDocument to which this node belongs.
1138 /// </summary>
1139 public HtmlDocument OwnerDocument
1140 {
1141 get
1142 {
1143 return _ownerdocument;
1144 }
1145 }
1146
1147 /// <summary>
1148 /// Gets all the children of the node.
1149 /// </summary>
1150 public HtmlNodeCollection ChildNodes
1151 {
1152 get
1153 {
1154 if (_childnodes == null)
1155 {
1156 _childnodes = new HtmlNodeCollection(this);
1157 }
1158 return _childnodes;
1159 }
1160 }
1161
1162 /// <summary>
1163 /// Adds the specified node to the beginning of the list of children of this node.
1164 /// </summary>
1165 /// <param name="newChild">The node to add. May not be null.</param>
1166 /// <returns>The node added.</returns>
1167 public HtmlNode PrependChild(HtmlNode newChild)
1168 {
1169 if (newChild == null)
1170 {
1171 throw new ArgumentNullException("newChild");
1172 }
1173 ChildNodes.Prepend(newChild);
1174 _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1175 _outerchanged = true;
1176 _innerchanged = true;
1177 return newChild;
1178 }
1179
1180 /// <summary>
1181 /// Adds the specified node list to the beginning of the list of children of this node.
1182 /// </summary>
1183 /// <param name="newChildren">The node list to add. May not be null.</param>
1184 public void PrependChildren(HtmlNodeCollection newChildren)
1185 {
1186 if (newChildren == null)
1187 {
1188 throw new ArgumentNullException("newChildren");
1189 }
1190
1191 foreach(HtmlNode newChild in newChildren)
1192 {
1193 PrependChild(newChild);
1194 }
1195 }
1196
1197 /// <summary>
1198 /// Adds the specified node to the end of the list of children of this node.
1199 /// </summary>
1200 /// <param name="newChild">The node to add. May not be null.</param>
1201 /// <returns>The node added.</returns>
1202 public HtmlNode AppendChild(HtmlNode newChild)
1203 {
1204 if (newChild == null)
1205 {
1206 throw new ArgumentNullException("newChild");
1207 }
1208
1209 ChildNodes.Append(newChild);
1210 _ownerdocument.SetIdForNode(newChild, newChild.GetId());
1211 _outerchanged = true;
1212 _innerchanged = true;
1213 return newChild;
1214 }
1215
1216 /// <summary>
1217 /// Adds the specified node to the end of the list of children of this node.
1218 /// </summary>
1219 /// <param name="newChildren">The node list to add. May not be null.</param>
1220 public void AppendChildren(HtmlNodeCollection newChildren)
1221 {
1222 if (newChildren == null)
1223 throw new ArgumentNullException("newChildrend");
1224
1225 foreach(HtmlNode newChild in newChildren)
1226 {
1227 AppendChild(newChild);
1228 }
1229 }
1230
1231 /// <summary>
1232 /// Gets a value indicating whether the current node has any attributes.
1233 /// </summary>
1234 public bool HasAttributes
1235 {
1236 get
1237 {
1238 if (_attributes == null)
1239 {
1240 return false;
1241 }
1242
1243 if (_attributes.Count <= 0)
1244 {
1245 return false;
1246 }
1247 return true;
1248 }
1249 }
1250
1251 /// <summary>
1252 /// Gets a value indicating whether the current node has any attributes on the closing tag.
1253 /// </summary>
1254 public bool HasClosingAttributes
1255 {
1256 get
1257 {
1258 if ((_endnode == null) || (_endnode == this))
1259 {
1260 return false;
1261 }
1262
1263 if (_endnode._attributes == null)
1264 {
1265 return false;
1266 }
1267
1268 if (_endnode._attributes.Count <= 0)
1269 {
1270 return false;
1271 }
1272 return true;
1273 }
1274 }
1275
1276 /// <summary>
1277 /// Gets a value indicating whether this node has any child nodes.
1278 /// </summary>
1279 public bool HasChildNodes
1280 {
1281 get
1282 {
1283 if (_childnodes == null)
1284 {
1285 return false;
1286 }
1287
1288 if (_childnodes.Count <= 0)
1289 {
1290 return false;
1291 }
1292 return true;
1293 }
1294 }
1295
1296 /// <summary>
1297 /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1298 /// </summary>
1299 /// <param name="name">The name of the attribute to get. May not be null.</param>
1300 /// <param name="def">The default value to return if not found.</param>
1301 /// <returns>The value of the attribute if found, the default value if not found.</returns>
1302 public string GetAttributeValue(string name, string def)
1303 {
1304 if (name == null)
1305 {
1306 throw new ArgumentNullException("name");
1307 }
1308
1309 if (!HasAttributes)
1310 {
1311 return def;
1312 }
1313 HtmlAttribute att = Attributes[name];
1314 if (att == null)
1315 {
1316 return def;
1317 }
1318 return att.Value;
1319 }
1320
1321 /// <summary>
1322 /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1323 /// </summary>
1324 /// <param name="name">The name of the attribute to get. May not be null.</param>
1325 /// <param name="def">The default value to return if not found.</param>
1326 /// <returns>The value of the attribute if found, the default value if not found.</returns>
1327 public int GetAttributeValue(string name, int def)
1328 {
1329 if (name == null)
1330 {
1331 throw new ArgumentNullException("name");
1332 }
1333
1334 if (!HasAttributes)
1335 {
1336 return def;
1337 }
1338 HtmlAttribute att = Attributes[name];
1339 if (att == null)
1340 {
1341 return def;
1342 }
1343 try
1344 {
1345 return Convert.ToInt32(att.Value);
1346 }
1347 catch
1348 {
1349 return def;
1350 }
1351 }
1352
1353 /// <summary>
1354 /// Helper method to get the value of an attribute of this node. If the attribute is not found, the default value will be returned.
1355 /// </summary>
1356 /// <param name="name">The name of the attribute to get. May not be null.</param>
1357 /// <param name="def">The default value to return if not found.</param>
1358 /// <returns>The value of the attribute if found, the default value if not found.</returns>
1359 public bool GetAttributeValue(string name, bool def)
1360 {
1361 if (name == null)
1362 {
1363 throw new ArgumentNullException("name");
1364 }
1365
1366 if (!HasAttributes)
1367 {
1368 return def;
1369 }
1370 HtmlAttribute att = Attributes[name];
1371 if (att == null)
1372 {
1373 return def;
1374 }
1375 try
1376 {
1377 return Convert.ToBoolean(att.Value);
1378 }
1379 catch
1380 {
1381 return def;
1382 }
1383 }
1384
1385 /// <summary>
1386 /// Helper method to set the value of an attribute of this node. If the attribute is not found, it will be created automatically.
1387 /// </summary>
1388 /// <param name="name">The name of the attribute to set. May not be null.</param>
1389 /// <param name="value">The value for the attribute.</param>
1390 /// <returns>The corresponding attribute instance.</returns>
1391 public HtmlAttribute SetAttributeValue(string name, string value)
1392 {
1393 if (name == null)
1394 {
1395 throw new ArgumentNullException("name");
1396 }
1397 HtmlAttribute att = Attributes[name];
1398 if (att == null)
1399 {
1400 return Attributes.Append(_ownerdocument.CreateAttribute(name, value));
1401 }
1402 att.Value = value;
1403 return att;
1404 }
1405
1406 /// <summary>
1407 /// Gets the collection of HTML attributes for this node. May not be null.
1408 /// </summary>
1409 public HtmlAttributeCollection Attributes
1410 {
1411 get
1412 {
1413 if (!HasAttributes)
1414 {
1415 _attributes = new HtmlAttributeCollection(this);
1416 }
1417 return _attributes;
1418 }
1419 }
1420
1421 /// <summary>
1422 /// Gets the collection of HTML attributes for the closing tag. May not be null.
1423 /// </summary>
1424 public HtmlAttributeCollection ClosingAttributes
1425 {
1426 get
1427 {
1428 if (!HasClosingAttributes)
1429 {
1430 return new HtmlAttributeCollection(this);
1431 }
1432 return _endnode.Attributes;
1433 }
1434 }
1435
1436 internal void WriteAttribute(TextWriter outText, HtmlAttribute att)
1437 {
1438 string name;
1439
1440 if (_ownerdocument.OptionOutputAsXml)
1441 {
1442 if (_ownerdocument.OptionOutputUpperCase)
1443 {
1444 name = att.XmlName.ToUpper();
1445 }
1446 else
1447 {
1448 name = att.XmlName;
1449 }
1450
1451 outText.Write(" " + name + "=\"" + HtmlDocument.HtmlEncode(att.XmlValue) + "\"");
1452 }
1453 else
1454 {
1455 if (_ownerdocument.OptionOutputUpperCase)
1456 {
1457 name = att.Name.ToUpper();
1458 }
1459 else
1460 {
1461 name = att.Name;
1462 }
1463
1464 if (att.Name.Length >= 4)
1465 {
1466 if ((att.Name[0] == '<') && (att.Name[1] == '%') &&
1467 (att.Name[att.Name.Length-1] == '>') && (att.Name[att.Name.Length-2] == '%'))
1468 {
1469 outText.Write(" " + name);
1470 return;
1471 }
1472 }
1473 if (_ownerdocument.OptionOutputOptimizeAttributeValues)
1474 {
1475 if (att.Value.IndexOfAny(new Char[]{(char)10, (char)13, (char)9, ' '}) < 0)
1476 {
1477 outText.Write(" " + name + "=" + att.Value);
1478 }
1479 else
1480 {
1481 outText.Write(" " + name + "=\"" + att.Value + "\"");
1482 }
1483 }
1484 else
1485 {
1486 outText.Write(" " + name + "=\"" + att.Value + "\"");
1487 }
1488 }
1489 }
1490
1491 internal static void WriteAttributes(XmlWriter writer, HtmlNode node)
1492 {
1493 if (!node.HasAttributes)
1494 {
1495 return;
1496 }
1497 // we use _hashitems to make sure attributes are written only once
1498 foreach(HtmlAttribute att in node.Attributes._hashitems.Values)
1499 {
1500 writer.WriteAttributeString(att.XmlName, att.Value);
1501 }
1502 }
1503
1504 internal void WriteAttributes(TextWriter outText, bool closing)
1505 {
1506 if (_ownerdocument.OptionOutputAsXml)
1507 {
1508 if (_attributes == null)
1509 {
1510 return;
1511 }
1512 // we use _hashitems to make sure attributes are written only once
1513 foreach(HtmlAttribute att in _attributes._hashitems.Values)
1514 {
1515 WriteAttribute(outText, att);
1516 }
1517 return;
1518 }
1519
1520 if (!closing)
1521 {
1522 if (_attributes != null)
1523 {
1524
1525 foreach(HtmlAttribute att in _attributes)
1526 {
1527 WriteAttribute(outText, att);
1528 }
1529 }
1530 if (_ownerdocument.OptionAddDebuggingAttributes)
1531 {
1532 WriteAttribute(outText, _ownerdocument.CreateAttribute("_closed", Closed.ToString()));
1533 WriteAttribute(outText, _ownerdocument.CreateAttribute("_children", ChildNodes.Count.ToString()));
1534
1535 int i = 0;
1536 foreach(HtmlNode n in ChildNodes)
1537 {
1538 WriteAttribute(outText, _ownerdocument.CreateAttribute("_child_" + i,
1539 n.Name));
1540 i++;
1541 }
1542 }
1543 }
1544 else
1545 {
1546 if (_endnode == null)
1547 {
1548 return;
1549 }
1550
1551 if (_endnode._attributes == null)
1552 {
1553 return;
1554 }
1555
1556 if (_endnode == this)
1557 {
1558 return;
1559 }
1560
1561 foreach(HtmlAttribute att in _endnode._attributes)
1562 {
1563 WriteAttribute(outText, att);
1564 }
1565 if (_ownerdocument.OptionAddDebuggingAttributes)
1566 {
1567 WriteAttribute(outText, _ownerdocument.CreateAttribute("_closed", Closed.ToString()));
1568 WriteAttribute(outText, _ownerdocument.CreateAttribute("_children", ChildNodes.Count.ToString()));
1569 }
1570 }
1571 }
1572
1573 internal static string GetXmlComment(HtmlCommentNode comment)
1574 {
1575 string s = comment.Comment;
1576 return s.Substring(4, s.Length-7).Replace("--", " - -");
1577 }
1578
1579 /// <summary>
1580 /// Saves the current node to the specified TextWriter.
1581 /// </summary>
1582 /// <param name="outText">The TextWriter to which you want to save.</param>
1583 public void WriteTo(TextWriter outText)
1584 {
1585 string html;
1586 switch(_nodetype)
1587 {
1588 case HtmlNodeType.Comment:
1589 html = ((HtmlCommentNode)this).Comment;
1590 if (_ownerdocument.OptionOutputAsXml)
1591 {
1592 outText.Write("<!--" + GetXmlComment((HtmlCommentNode)this) + " -->");
1593 }
1594 else
1595 {
1596 outText.Write(html);
1597 }
1598 break;
1599
1600 case HtmlNodeType.Document:
1601 if (_ownerdocument.OptionOutputAsXml)
1602 {
1603 outText.Write("<?xml version=\"1.0\" encoding=\"" + _ownerdocument.GetOutEncoding().BodyName + "\"?>");
1604
1605 // check there is a root element
1606 if (_ownerdocument.DocumentNode.HasChildNodes)
1607 {
1608 int rootnodes = _ownerdocument.DocumentNode._childnodes.Count;
1609 if (rootnodes > 0)
1610 {
1611 HtmlNode xml = _ownerdocument.GetXmlDeclaration();
1612 if (xml != null)
1613 {
1614 rootnodes --;
1615 }
1616
1617 if (rootnodes > 1)
1618 {
1619 if (_ownerdocument.OptionOutputUpperCase)
1620 {
1621 outText.Write("<SPAN>");
1622 WriteContentTo(outText);
1623 outText.Write("</SPAN>");
1624 }
1625 else
1626 {
1627 outText.Write("<span>");
1628 WriteContentTo(outText);
1629 outText.Write("</span>");
1630 }
1631 break;
1632 }
1633 }
1634 }
1635 }
1636 WriteContentTo(outText);
1637 break;
1638
1639 case HtmlNodeType.Text:
1640 html = ((HtmlTextNode)this).Text;
1641 if (_ownerdocument.OptionOutputAsXml)
1642 {
1643 outText.Write(HtmlDocument.HtmlEncode(html));
1644 }
1645 else
1646 {
1647 outText.Write(html);
1648 }
1649 break;
1650
1651 case HtmlNodeType.Element:
1652 string name;
1653 if (_ownerdocument.OptionOutputUpperCase)
1654 {
1655 name = Name.ToUpper();
1656 }
1657 else
1658 {
1659 name = Name;
1660 }
1661
1662 if (_ownerdocument.OptionOutputAsXml)
1663 {
1664 if (name.Length > 0)
1665 {
1666 if (name[0] == '?')
1667 {
1668 // forget this one, it's been done at the document level
1669 break;
1670 }
1671
1672 if (name.Trim().Length == 0)
1673 {
1674 break;
1675 }
1676 name = HtmlAttribute.GetXmlName(name);
1677 }
1678 else
1679 {
1680 break;
1681 }
1682 }
1683
1684 outText.Write("<" + name);
1685 WriteAttributes(outText, false);
1686
1687 if (!HasChildNodes)
1688 {
1689 if (HtmlNode.IsEmptyElement(Name))
1690 {
1691 if ((_ownerdocument.OptionWriteEmptyNodes) || (_ownerdocument.OptionOutputAsXml))
1692 {
1693 outText.Write(" />");
1694 }
1695 else
1696 {
1697 if (Name.Length > 0)
1698 {
1699 if (Name[0] == '?')
1700 {
1701 outText.Write("?");
1702 }
1703 }
1704
1705 outText.Write(">");
1706 }
1707 }
1708 else
1709 {
1710 outText.Write("></" + name + ">");
1711 }
1712 }
1713 else
1714 {
1715 outText.Write(">");
1716 bool cdata = false;
1717 if (_ownerdocument.OptionOutputAsXml)
1718 {
1719 if (HtmlNode.IsCDataElement(Name))
1720 {
1721 // this code and the following tries to output things as nicely as possible for old browsers.
1722 cdata = true;
1723 outText.Write("\r\n//<![CDATA[\r\n");
1724 }
1725 }
1726
1727 if (cdata)
1728 {
1729 if (HasChildNodes)
1730 {
1731 // child must be a text
1732 ChildNodes[0].WriteTo(outText);
1733 }
1734 outText.Write("\r\n//]]>//\r\n");
1735 }
1736 else
1737 {
1738 WriteContentTo(outText);
1739 }
1740
1741 outText.Write("</" + name);
1742 if (!_ownerdocument.OptionOutputAsXml)
1743 {
1744 WriteAttributes(outText, true);
1745 }
1746 outText.Write(">");
1747 }
1748 break;
1749 }
1750 }
1751
1752 /// <summary>
1753 /// Saves the current node to the specified XmlWriter.
1754 /// </summary>
1755 /// <param name="writer">The XmlWriter to which you want to save.</param>
1756 public void WriteTo(XmlWriter writer)
1757 {
1758 string html;
1759 switch(_nodetype)
1760 {
1761 case HtmlNodeType.Comment:
1762 writer.WriteComment(GetXmlComment((HtmlCommentNode)this));
1763 break;
1764
1765 case HtmlNodeType.Document:
1766 writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"" + _ownerdocument.GetOutEncoding().BodyName + "\"");
1767 if (HasChildNodes)
1768 {
1769 foreach(HtmlNode subnode in ChildNodes)
1770 {
1771 subnode.WriteTo(writer);
1772 }
1773 }
1774 break;
1775
1776 case HtmlNodeType.Text:
1777 html = ((HtmlTextNode)this).Text;
1778 writer.WriteString(html);
1779 break;
1780
1781 case HtmlNodeType.Element:
1782 string name;
1783 if (_ownerdocument.OptionOutputUpperCase)
1784 {
1785 name = Name.ToUpper();
1786 }
1787 else
1788 {
1789 name = Name;
1790 }
1791 writer.WriteStartElement(name);
1792 WriteAttributes(writer, this);
1793
1794 if (HasChildNodes)
1795 {
1796 foreach(HtmlNode subnode in ChildNodes)
1797 {
1798 subnode.WriteTo(writer);
1799 }
1800 }
1801 writer.WriteEndElement();
1802 break;
1803 }
1804 }
1805
1806 /// <summary>
1807 /// Saves all the children of the node to the specified TextWriter.
1808 /// </summary>
1809 /// <param name="outText">The TextWriter to which you want to save.</param>
1810 public void WriteContentTo(TextWriter outText)
1811 {
1812 if (_childnodes == null)
1813 {
1814 return;
1815 }
1816
1817 foreach(HtmlNode node in _childnodes)
1818 {
1819 node.WriteTo(outText);
1820 }
1821 }
1822
1823 /// <summary>
1824 /// Saves the current node to a string.
1825 /// </summary>
1826 /// <returns>The saved string.</returns>
1827 public string WriteTo()
1828 {
1829 StringWriter sw = new StringWriter();
1830 WriteTo(sw);
1831 sw.Flush();
1832 return sw.ToString();
1833 }
1834
1835 /// <summary>
1836 /// Saves all the children of the node to a string.
1837 /// </summary>
1838 /// <returns>The saved string.</returns>
1839 public string WriteContentTo()
1840 {
1841 StringWriter sw = new StringWriter();
1842 WriteContentTo(sw);
1843 sw.Flush();
1844 return sw.ToString();
1845 }
1846 }
1847
1848 /// <summary>
1849 /// Represents a combined list and collection of HTML nodes.
1850 /// </summary>
1851 public class HtmlNodeCollection: IEnumerable
1852 {
1853 private ArrayList _items = new ArrayList();
1854 private HtmlNode _parentnode;
1855
1856 internal HtmlNodeCollection(HtmlNode parentnode)
1857 {
1858 _parentnode = parentnode; // may be null
1859 }
1860
1861 /// <summary>
1862 /// Gets the number of elements actually contained in the list.
1863 /// </summary>
1864 public int Count
1865 {
1866 get
1867 {
1868 return _items.Count;
1869 }
1870 }
1871
1872 internal void Clear()
1873 {
1874 foreach(HtmlNode node in _items)
1875 {
1876 node._parentnode = null;
1877 node._nextnode = null;
1878 node._prevnode = null;
1879 }
1880 _items.Clear();
1881 }
1882
1883 internal void Remove(int index)
1884 {
1885 HtmlNode next = null;
1886 HtmlNode prev = null;
1887 HtmlNode oldnode = (HtmlNode)_items[index];
1888
1889 if (index > 0)
1890 {
1891 prev = (HtmlNode)_items[index-1];
1892 }
1893
1894 if (index < (_items.Count-1))
1895 {
1896 next = (HtmlNode)_items[index+1];
1897 }
1898
1899 _items.RemoveAt(index);
1900
1901 if (prev != null)
1902 {
1903 if (next == prev)
1904 {
1905 throw new InvalidProgramException("Unexpected error.");
1906 }
1907 prev._nextnode = next;
1908 }
1909
1910 if (next != null)
1911 {
1912 next._prevnode = prev;
1913 }
1914
1915 oldnode._prevnode = null;
1916 oldnode._nextnode = null;
1917 oldnode._parentnode = null;
1918 }
1919
1920 internal void Replace(int index, HtmlNode node)
1921 {
1922 HtmlNode next = null;
1923 HtmlNode prev = null;
1924 HtmlNode oldnode = (HtmlNode)_items[index];
1925
1926 if (index>0)
1927 {
1928 prev = (HtmlNode)_items[index-1];
1929 }
1930
1931 if (index<(_items.Count-1))
1932 {
1933 next = (HtmlNode)_items[index+1];
1934 }
1935
1936 _items[index] = node;
1937
1938 if (prev != null)
1939 {
1940 if (node == prev)
1941 {
1942 throw new InvalidProgramException("Unexpected error.");
1943 }
1944 prev._nextnode = node;
1945 }
1946
1947 if (next!=null)
1948 {
1949 next._prevnode = node;
1950 }
1951
1952 node._prevnode = prev;
1953 if (next == node)
1954 {
1955 throw new InvalidProgramException("Unexpected error.");
1956 }
1957 node._nextnode = next;
1958 node._parentnode = _parentnode;
1959
1960 oldnode._prevnode = null;
1961 oldnode._nextnode = null;
1962 oldnode._parentnode = null;
1963 }
1964
1965 internal void Insert(int index, HtmlNode node)
1966 {
1967 HtmlNode next = null;
1968 HtmlNode prev = null;
1969
1970 if (index>0)
1971 {
1972 prev = (HtmlNode)_items[index-1];
1973 }
1974
1975 if (index<_items.Count)
1976 {
1977 next = (HtmlNode)_items[index];
1978 }
1979
1980 _items.Insert(index, node);
1981
1982 if (prev != null)
1983 {
1984 if (node == prev)
1985 {
1986 throw new InvalidProgramException("Unexpected error.");
1987 }
1988 prev._nextnode = node;
1989 }
1990
1991 if (next != null)
1992 {
1993 next._prevnode = node;
1994 }
1995
1996 node._prevnode = prev;
1997
1998 if (next == node)
1999 {
2000 throw new InvalidProgramException("Unexpected error.");
2001 }
2002
2003 node._nextnode = next;
2004 node._parentnode = _parentnode;
2005 }
2006
2007 internal void Append(HtmlNode node)
2008 {
2009 HtmlNode last = null;
2010 if (_items.Count > 0)
2011 {
2012 last = (HtmlNode)_items[_items.Count-1];
2013 }
2014
2015 _items.Add(node);
2016 node._prevnode = last;
2017 node._nextnode = null;
2018 node._parentnode = _parentnode;
2019 if (last != null)
2020 {
2021 if (last == node)
2022 {
2023 throw new InvalidProgramException("Unexpected error.");
2024 }
2025 last._nextnode = node;
2026 }
2027 }
2028
2029 internal void Prepend(HtmlNode node)
2030 {
2031 HtmlNode first = null;
2032 if (_items.Count > 0)
2033 {
2034 first = (HtmlNode)_items[0];
2035 }
2036
2037 _items.Insert(0, node);
2038
2039 if (node == first)
2040 {
2041 throw new InvalidProgramException("Unexpected error.");
2042 }
2043 node._nextnode = first;
2044 node._prevnode = null;
2045 node._parentnode = _parentnode;
2046 if (first != null)
2047 {
2048 first._prevnode = node;
2049 }
2050 }
2051
2052 internal void Add(HtmlNode node)
2053 {
2054 _items.Add(node);
2055 }
2056
2057 /// <summary>
2058 /// Gets the node at the specified index.
2059 /// </summary>
2060 public HtmlNode this[int index]
2061 {
2062 get
2063 {
2064 return _items[index] as HtmlNode;
2065 }
2066 }
2067
2068 internal int GetNodeIndex(HtmlNode node)
2069 {
2070 // TODO: should we rewrite this? what would be the key of a node?
2071 for(int i=0;i<_items.Count;i++)
2072 {
2073 if (node == ((HtmlNode)_items[i]))
2074 {
2075 return i;
2076 }
2077 }
2078 return -1;
2079 }
2080
2081 /// <summary>
2082 /// Gets a given node from the list.
2083 /// </summary>
2084 public int this[HtmlNode node]
2085 {
2086 get
2087 {
2088 int index = GetNodeIndex(node);
2089 if (index == -1)
2090 {
2091 throw new ArgumentOutOfRangeException("node", "Node \"" + node.CloneNode(false).OuterHtml + "\" was not found in the collection");
2092 }
2093 return index;
2094 }
2095 }
2096
2097 /// <summary>
2098 /// Returns an enumerator that can iterate through the list.
2099 /// </summary>
2100 /// <returns>An IEnumerator for the entire list.</returns>
2101 public HtmlNodeEnumerator GetEnumerator()
2102 {
2103 return new HtmlNodeEnumerator(_items);
2104 }
2105
2106 IEnumerator IEnumerable.GetEnumerator()
2107 {
2108 return GetEnumerator();
2109 }
2110
2111 /// <summary>
2112 /// Represents an enumerator that can iterate through the list.
2113 /// </summary>
2114 public class HtmlNodeEnumerator: IEnumerator
2115 {
2116 int _index;
2117 ArrayList _items;
2118
2119 internal HtmlNodeEnumerator(ArrayList items)
2120 {
2121 _items = items;
2122 _index = -1;
2123 }
2124
2125 /// <summary>
2126 /// Sets the enumerator to its initial position, which is before the first element in the collection.
2127 /// </summary>
2128 public void Reset()
2129 {
2130 _index = -1;
2131 }
2132
2133 /// <summary>
2134 /// Advances the enumerator to the next element of the collection.
2135 /// </summary>
2136 /// <returns>true if the enumerator was successfully advanced to the next element, false if the enumerator has passed the end of the collection.</returns>
2137 public bool MoveNext()
2138 {
2139 _index++;
2140 return (_index<_items.Count);
2141 }
2142
2143 /// <summary>
2144 /// Gets the current element in the collection.
2145 /// </summary>
2146 public HtmlNode Current
2147 {
2148 get
2149 {
2150 return (HtmlNode)(_items[_index]);
2151 }
2152 }
2153
2154 /// <summary>
2155 /// Gets the current element in the collection.
2156 /// </summary>
2157 object IEnumerator.Current
2158 {
2159 get
2160 {
2161 return (Current);
2162 }
2163 }
2164 }
2165 }
2166
2167 /// <summary>
2168 /// Represents an HTML text node.
2169 /// </summary>
2170 public class HtmlTextNode: HtmlNode
2171 {
2172 private string _text;
2173
2174 internal HtmlTextNode(HtmlDocument ownerdocument, int index):
2175 base(HtmlNodeType.Text, ownerdocument, index)
2176 {
2177 }
2178
2179 /// <summary>
2180 /// 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.
2181 /// </summary>
2182 public override string InnerHtml
2183 {
2184 get
2185 {
2186 return OuterHtml;
2187 }
2188 set
2189 {
2190 _text = value;
2191 }
2192 }
2193
2194 /// <summary>
2195 /// Gets or Sets the object and its content in HTML.
2196 /// </summary>
2197 public override string OuterHtml
2198 {
2199 get
2200 {
2201 if (_text == null)
2202 {
2203 return base.OuterHtml;
2204 }
2205 return _text;
2206 }
2207 }
2208
2209 /// <summary>
2210 /// Gets or Sets the text of the node.
2211 /// </summary>
2212 public string Text
2213 {
2214 get
2215 {
2216 if (_text == null)
2217 {
2218 return base.OuterHtml;
2219 }
2220 return _text;
2221 }
2222 set
2223 {
2224 _text = value;
2225 }
2226 }
2227 }
2228
2229 /// <summary>
2230 /// Represents an HTML comment.
2231 /// </summary>
2232 public class HtmlCommentNode: HtmlNode
2233 {
2234 private string _comment;
2235
2236 internal HtmlCommentNode(HtmlDocument ownerdocument, int index):
2237 base(HtmlNodeType.Comment, ownerdocument, index)
2238 {
2239 }
2240
2241 /// <summary>
2242 /// 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.
2243 /// </summary>
2244 public override string InnerHtml
2245 {
2246 get
2247 {
2248 if (_comment == null)
2249 {
2250 return base.InnerHtml;
2251 }
2252 return _comment;
2253 }
2254 set
2255 {
2256 _comment = value;
2257 }
2258 }
2259
2260 /// <summary>
2261 /// Gets or Sets the object and its content in HTML.
2262 /// </summary>
2263 public override string OuterHtml
2264 {
2265 get
2266 {
2267 if (_comment == null)
2268 {
2269 return base.OuterHtml;
2270 }
2271 return "<!--" + _comment + "-->";
2272 }
2273 }
2274
2275 /// <summary>
2276 /// Gets or Sets the comment text of the node.
2277 /// </summary>
2278 public string Comment
2279 {
2280 get
2281 {
2282 if (_comment == null)
2283 {
2284 return base.InnerHtml;
2285 }
2286 return _comment;
2287 }
2288 set
2289 {
2290 _comment = value;
2291 }
2292 }
2293 }
2294
2295 }
A Beagle Git Repo