The XML Tree can now display and edit xml comments.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@2128 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/DisplayBindings/XmlEditor/Project/Src/AddChildCommentCommand.cs

@@ -0,0 +1,27 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Adds a new comment to the selected element.
+	/// </summary>
+	public class AddChildCommentCommand : AbstractMenuCommand
+	{		
+		public override void Run()
+		{
+			XmlTreeViewContainerControl view = Owner as XmlTreeViewContainerControl;
+			if (view != null) {
+				view.AppendChildComment();
+			}
+		}
+	}
+}
+

src/AddIns/DisplayBindings/XmlEditor/Project/Src/IXmlTreeView.cs

@@ -26,9 +26,9 @@ namespace ICSharpCode.XmlEditor
 		bool IsDirty {get; set;}
 		
 		/// <summary>
-		/// Gets or sets the xml document element.
+		/// Gets or sets the xml document.
 		/// </summary>
-		XmlElement DocumentElement {get; set;}
+		XmlDocument Document {get; set;}
 		
 		/// <summary>
 		/// Gets the xml element selected.
@@ -51,9 +51,11 @@ namespace ICSharpCode.XmlEditor
 		void ShowTextContent(string text);
 		
 		/// <summary>
-		/// Gets the text content currently on display.
+		/// Gets or sets the text content currently on display. The
+		/// text content will not be displayed unless 
+		/// ShowTextContent has been called.
 		/// </summary>
-		string TextContent {get;}
+		string TextContent {get; set;}
 		
 		/// <summary>
 		/// Gets the xml element text node.
@@ -139,5 +141,38 @@ namespace ICSharpCode.XmlEditor
 		/// needs to be updated.
 		/// </summary>
 		void UpdateTextNode(XmlText textNode);
+		
+		/// <summary>
+		/// Gets the currently selected comment node.
+		/// </summary>
+		XmlComment SelectedComment {get;}
+		
+		/// <summary>
+		/// Informs the xml tree view that the comment node
+		/// has changed and the corresponding tree node
+		/// needs to be updated.
+		/// </summary>
+		void UpdateComment(XmlComment comment);
+		
+		/// <summary>
+		/// Appends a new child comment to the currently selected
+		/// element.
+		/// </summary>
+		void AppendChildComment(XmlComment comment);
+		
+		/// <summary>
+		/// Removes the specified comment node from the view.
+		/// </summary>
+		void RemoveComment(XmlComment comment);
+		
+		/// <summary>
+		/// Inserts the comment before the currently selected node.
+		/// </summary>
+		void InsertCommentBefore(XmlComment comment);
+		
+		/// <summary>
+		/// Inserts the comment after the currently selected node.
+		/// </summary>
+		void InsertCommentAfter(XmlComment comment);
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Project/Src/InsertCommentAfterCommand.cs

@@ -0,0 +1,26 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Inserts a new comment node after the selected node.
+	/// </summary>
+	public class InsertCommentAfterCommand : AbstractMenuCommand
+	{		
+		public override void Run()
+		{
+			XmlTreeViewContainerControl view = Owner as XmlTreeViewContainerControl;
+			if (view != null) {
+				view.InsertCommentAfter();
+			}
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Project/Src/InsertCommentBeforeCommand.cs

@@ -0,0 +1,27 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Inserts a new comment node before the selected node.
+	/// </summary>
+	public class InsertCommentBeforeCommand : AbstractMenuCommand
+	{		
+		public override void Run()
+		{
+			XmlTreeViewContainerControl view = Owner as XmlTreeViewContainerControl;
+			if (view != null) {
+				view.InsertCommentBefore();
+			}
+		}
+	}
+}
+

src/AddIns/DisplayBindings/XmlEditor/Project/Src/RemoveCommentCommand.cs

@@ -0,0 +1,26 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Removes the currently selected comment node from the XML tree.
+	/// </summary>
+	public class RemoveCommentCommand : AbstractMenuCommand
+	{
+		public override void Run()
+		{
+			XmlTreeViewContainerControl view = Owner as XmlTreeViewContainerControl;
+			if (view != null) {
+				view.RemoveComment();
+			}
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlCharacterDataTreeNode.cs

@@ -0,0 +1,60 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Xml;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Base class for XmlTextTreeNodes and XmlCommentTreeNodes
+	/// </summary>
+	public abstract class XmlCharacterDataTreeNode : ExtTreeNode
+	{
+		XmlCharacterData characterData;
+		
+		public XmlCharacterDataTreeNode(XmlCharacterData characterData)
+		{
+			this.characterData = characterData;
+		}
+		
+		/// <summary>
+		/// Updates the display text based on changes in the
+		/// XmlCharacterData's InnerText associated with this node.
+		/// </summary>
+		public void Update()
+		{
+			Text = GetDisplayText(characterData.InnerText);
+		}
+		
+		/// <summary>
+		/// Gets the text to display for this tree node.
+		/// </summary>
+		/// <remarks>If the text is a single line then it is returned, but
+		/// trimmed. If the text has multiple lines then the first line that
+		/// is not empty is returned. This line may have "..." appended to indicate 
+		/// there is more text for this node that is not being displayed. The
+		/// "..." will be appended only if there are multiple lines containing 
+		/// text.</remarks>
+		static string GetDisplayText(string s)
+		{
+			string[] lines = s.Trim().Split('\n');
+			for (int i = 0; i < lines.Length; ++i) {
+				string line = lines[i].Trim();
+				if (line.Length > 0) {
+					if (lines.Length == 1) {
+						return line;
+					} else {
+						return String.Concat(line, "...");
+					}
+				}
+			}
+			return String.Empty;
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlCommentTreeNode.cs

@@ -0,0 +1,41 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Xml;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.XmlEditor
+{
+	/// <summary>
+	/// Represents an xml comment in the tree.
+	/// </summary>
+	public class XmlCommentTreeNode : XmlCharacterDataTreeNode
+	{
+		public const string XmlCommentTreeNodeImageKey = "XmlCommentTreeNodeImage";
+
+		XmlComment comment;
+		
+		public XmlCommentTreeNode(XmlComment comment)
+			: base(comment)
+		{
+			this.comment = comment;
+			ImageKey = XmlCommentTreeNodeImageKey;
+			SelectedImageKey = ImageKey;
+			Update();
+		}
+		
+		/// <summary>
+		/// Gets the XmlComment associated with this tree node.
+		/// </summary>
+		public XmlComment XmlComment {
+			get {
+				return comment;
+			}
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementTreeNode.cs

@@ -11,6 +11,9 @@ using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.XmlEditor
 {
+	/// <summary>
+	/// Represents an XmlElement in the Xml Tree.
+	/// </summary>
 	public class XmlElementTreeNode : ExtTreeNode
 	{
 		public const string XmlElementTreeNodeImageKey = "XmlElementTreeNodeImage";
@@ -49,12 +52,16 @@ namespace ICSharpCode.XmlEditor
 			foreach (XmlNode childNode in element.ChildNodes) {
 				XmlElement childElement = childNode as XmlElement;
 				XmlText text = childNode as XmlText;
+				XmlComment comment = childNode as XmlComment;
 				if (childElement != null) {
 					XmlElementTreeNode treeNode = new XmlElementTreeNode(childElement);
 					treeNode.AddTo(this);
 				} else if (text != null) {
 					XmlTextTreeNode treeNode = new XmlTextTreeNode(text);
 					treeNode.AddTo(this);
+				} else if (comment != null) {
+					XmlCommentTreeNode treeNode = new XmlCommentTreeNode(comment);
+					treeNode.AddTo(this);
 				}
 			}
 		}

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlTextTreeNode.cs

@@ -11,13 +11,17 @@ using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.XmlEditor
 {
-	public class XmlTextTreeNode : ExtTreeNode
+	/// <summary>
+	/// Represents an XmlText node in the tree.
+	/// </summary>
+	public class XmlTextTreeNode : XmlCharacterDataTreeNode
 	{
 		public const string XmlTextTreeNodeImageKey = "XmlTextTreeNodeImage";
 		
 		XmlText xmlText;
 		
 		public XmlTextTreeNode(XmlText xmlText)
+			: base(xmlText)
 		{
 			this.xmlText = xmlText;
 			ImageKey = XmlTextTreeNodeImageKey;
@@ -25,44 +29,13 @@ namespace ICSharpCode.XmlEditor
 			Update();
 		}
 		
+		/// <summary>
+		/// Gets the XmlText associated with this tree node.
+		/// </summary>
 		public XmlText XmlText {
 			get {
 				return xmlText;
 			}
 		}
-		
-		/// <summary>
-		/// Updates the display text based on changes in the
-		/// XmlText associated with this node.
-		/// </summary>
-		public void Update()
-		{
-			Text = GetDisplayText(xmlText.InnerText);
-		}
-		
-		/// <summary>
-		/// Gets the text to display for this tree node.
-		/// </summary>
-		/// <remarks>If the text is a single line then it is returned, but
-		/// trimmed. If the text has multiple lines then the first line that
-		/// is not empty is returned. This line may have "..." appended to indicate 
-		/// there is more text for this node that is not being displayed. The
-		/// "..." will be appended only if there are multiple lines containing 
-		/// text.</remarks>
-		static string GetDisplayText(string s)
-		{
-			string[] lines = s.Trim().Split('\n');
-			for (int i = 0; i < lines.Length; ++i) {
-				string line = lines[i].Trim();
-				if (line.Length > 0) {
-					if (lines.Length == 1) {
-						return line;
-					} else {
-						return String.Concat(line, "...");
-					}
-				}
-			}
-			return String.Empty;
-		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlTreeEditor.cs

@@ -37,8 +37,7 @@ namespace ICSharpCode.XmlEditor
 			try {
 				document = new XmlDocument();
 				document.LoadXml(xml);
-				XmlElement documentElement = document.DocumentElement;
-				view.DocumentElement = documentElement;
+				view.Document = document;
 			} catch (XmlException ex) {
 				view.ShowXmlIsNotWellFormedMessage(ex);
 			}
@@ -54,28 +53,25 @@ namespace ICSharpCode.XmlEditor
 		}
 		
 		/// <summary>
-		/// The selected xml element in the view has changed.
+		/// The selected tree node in the view has changed.
 		/// </summary>
-		public void SelectedElementChanged()
+		public void SelectedNodeChanged()
 		{
 			XmlElement selectedElement = view.SelectedElement;
-			if (selectedElement != null) {
-				view.ShowAttributes(selectedElement.Attributes);
-			} else {
-				view.ClearAttributes();
-			}
-		}
-		
-		/// <summary>
-		/// The selected xml text node in the view has changed.
-		/// </summary>
-		public void SelectedTextNodeChanged()
-		{
 			XmlText selectedTextNode = view.SelectedTextNode;
+			XmlComment selectedComment = view.SelectedComment;
 			if (selectedTextNode != null) {
+				view.ClearAttributes();
 				view.ShowTextContent(selectedTextNode.InnerText);
+			} else if (selectedElement != null) {
+				view.TextContent = String.Empty;
+				view.ShowAttributes(selectedElement.Attributes);
+			} else if (selectedComment != null) {
+				view.ClearAttributes();
+				view.ShowTextContent(selectedComment.InnerText);
 			} else {
-				view.ShowTextContent(String.Empty);
+				view.ClearAttributes();
+				view.TextContent = String.Empty;
 			}
 		}
 		
@@ -128,17 +124,22 @@ namespace ICSharpCode.XmlEditor
 		public void TextContentChanged()
 		{
 			XmlText textNode = view.SelectedTextNode;
+			XmlComment comment = view.SelectedComment;
 			if (textNode != null) {
 				view.IsDirty = true;
-				textNode.Value = view.TextContent;
+				textNode.InnerText = view.TextContent;
 				view.UpdateTextNode(textNode);
+			} else if (comment != null) {
+				view.IsDirty = true;
+				comment.InnerText = view.TextContent;
+				view.UpdateComment(comment);
 			}
 		}
 		
 		/// <summary>
 		/// Adds a new child element to the selected element.
 		/// </summary>
-		public void AddChildElement()
+		public void AppendChildElement()
 		{
 			XmlElement selectedElement = view.SelectedElement;
 			if (selectedElement != null) {
@@ -160,19 +161,24 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void InsertElementBefore()
 		{
-			XmlElement selectedElement = view.SelectedElement;
-			if (selectedElement != null) {
-				XmlElement parentElement = selectedElement.ParentNode as XmlElement;
-				if (parentElement != null) {
-					string[] elementNames = GetChildElements(parentElement);
-					string[] selectedElementNames = view.SelectNewElements(elementNames);
-					if (selectedElementNames.Length > 0) {
-						view.IsDirty = true;
-						foreach (string elementName in selectedElementNames) {
-							XmlElement newElement = document.CreateElement(elementName, parentElement.NamespaceURI);
-							parentElement.InsertBefore(newElement, selectedElement);
-							view.InsertElementBefore(newElement);
-						}
+			XmlElement parentElement = null;
+			XmlNode selectedNode = view.SelectedElement;
+			if (selectedNode == null) {
+				selectedNode = view.SelectedComment;
+			}
+			if (selectedNode != null) {
+				parentElement = selectedNode.ParentNode as XmlElement;
+			}
+			
+			if (parentElement != null) {
+				string[] elementNames = GetChildElements(parentElement);
+				string[] selectedElementNames = view.SelectNewElements(elementNames);
+				if (selectedElementNames.Length > 0) {
+					view.IsDirty = true;
+					foreach (string elementName in selectedElementNames) {
+						XmlElement newElement = document.CreateElement(elementName, parentElement.NamespaceURI);
+						parentElement.InsertBefore(newElement, selectedNode);
+						view.InsertElementBefore(newElement);
 					}
 				}
 			}
@@ -183,19 +189,24 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void InsertElementAfter()
 		{
-			XmlElement selectedElement = view.SelectedElement;
-			if (selectedElement != null) {
-				XmlElement parentElement = selectedElement.ParentNode as XmlElement;
-				if (parentElement != null) {
-					string[] elementNames = GetChildElements(parentElement);
-					string[] selectedElementNames = view.SelectNewElements(elementNames);
-					if (selectedElementNames.Length > 0) {
-						view.IsDirty = true;
-						foreach (string elementName in selectedElementNames) {
-							XmlElement newElement = document.CreateElement(elementName, parentElement.NamespaceURI);
-							parentElement.InsertAfter(newElement, selectedElement);
-							view.InsertElementAfter(newElement);
-						}
+			XmlElement parentElement = null;
+			XmlNode selectedNode = view.SelectedElement;
+			if (selectedNode == null) {
+				selectedNode = view.SelectedComment;
+			}
+			if (selectedNode != null) {
+				parentElement = selectedNode.ParentNode as XmlElement;
+			}
+			
+			if (parentElement != null) {
+				string[] elementNames = GetChildElements(parentElement);
+				string[] selectedElementNames = view.SelectNewElements(elementNames);
+				if (selectedElementNames.Length > 0) {
+					view.IsDirty = true;
+					foreach (string elementName in selectedElementNames) {
+						XmlElement newElement = document.CreateElement(elementName, parentElement.NamespaceURI);
+						parentElement.InsertAfter(newElement, selectedNode);
+						view.InsertElementAfter(newElement);
 					}
 				}
 			}
@@ -232,7 +243,7 @@ namespace ICSharpCode.XmlEditor
 		/// <summary>
 		/// Adds a child text node to the current selected element.
 		/// </summary>
-		public void AddChildTextNode()
+		public void AppendChildTextNode()
 		{
 			XmlElement selectedElement = view.SelectedElement;
 			if (selectedElement != null) {
@@ -249,10 +260,7 @@ namespace ICSharpCode.XmlEditor
 		public void InsertTextNodeBefore()
 		{
 			// Get the currently selected text node or element.
-			XmlNode selectedNode = view.SelectedTextNode;
-			if (selectedNode == null) {
-				selectedNode = view.SelectedElement;
-			}
+			XmlNode selectedNode = GetSelectedCommentOrElementOrTextNode();
 
 			// Insert the text node before the selected node.
 			if (selectedNode != null) {
@@ -272,10 +280,7 @@ namespace ICSharpCode.XmlEditor
 		public void InsertTextNodeAfter()
 		{
 			// Get the currently selected text node or element.
-			XmlNode selectedNode = view.SelectedTextNode;
-			if (selectedNode == null) {
-				selectedNode = view.SelectedElement;
-			}
+			XmlNode selectedNode = GetSelectedCommentOrElementOrTextNode();
 
 			// Insert the text node after the selected node.
 			if (selectedNode != null) {
@@ -289,6 +294,64 @@ namespace ICSharpCode.XmlEditor
 			}
 		}
 		
+		/// <summary>
+		/// Adds a child comment node to the current selected element.
+		/// </summary>
+		public void AppendChildComment()
+		{
+			XmlElement selectedElement = view.SelectedElement;
+			if (selectedElement != null) {
+				XmlComment comment = document.CreateComment(String.Empty);
+				selectedElement.AppendChild(comment);
+				view.IsDirty = true;
+				view.AppendChildComment(comment);
+			}
+		}
+		
+		/// <summary>
+		/// Removes the currently select comment.
+		/// </summary>
+		public void RemoveComment()
+		{
+			XmlComment comment = view.SelectedComment;
+			if (comment != null) {
+				XmlNode parentNode = comment.ParentNode;
+				parentNode.RemoveChild(comment);
+				view.IsDirty = true;
+				view.RemoveComment(comment);
+			}
+		}
+		
+		/// <summary>
+		/// Inserts a comment before the selected node.
+		/// </summary>
+		public void InsertCommentBefore()
+		{
+			XmlNode node = GetSelectedCommentOrElementOrTextNode();
+			if (node != null) {
+				XmlNode parentNode = node.ParentNode;
+				XmlComment comment = document.CreateComment(String.Empty);
+				parentNode.InsertBefore(comment, node);
+				view.IsDirty = true;
+				view.InsertCommentBefore(comment);
+			}
+		}
+		
+		/// <summary>
+		/// Inserts a comment after the selected node.
+		/// </summary>
+		public void InsertCommentAfter()
+		{
+			XmlNode node = GetSelectedCommentOrElementOrTextNode();
+			if (node != null) {
+				XmlNode parentNode = node.ParentNode;
+				XmlComment comment = document.CreateComment(String.Empty);
+				parentNode.InsertAfter(comment, node);
+				view.IsDirty = true;
+				view.InsertCommentAfter(comment);
+			}
+		}
+		
 		/// <summary>
 		/// Gets the missing attributes for the specified element based 
 		/// on its associated schema.
@@ -348,5 +411,30 @@ namespace ICSharpCode.XmlEditor
 			}
 			return elements.ToArray();	
 		}
+		
+		/// <summary>
+		/// Gets the current comment or element or text node
+		/// from the view.
+		/// </summary>
+		XmlNode GetSelectedCommentOrElementOrTextNode()
+		{
+			XmlNode node = view.SelectedComment;
+			if (node != null) {
+				return node;
+			}
+			return GetSelectedElementOrTextNode();
+		}
+		
+		/// <summary>
+		/// Gets the currently selected element or text node.
+		/// </summary>
+		XmlNode GetSelectedElementOrTextNode()
+		{
+			XmlNode node = view.SelectedTextNode;
+			if (node != null) {
+				return node;
+			}
+			return view.SelectedElement;
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlTreeView.cs

@@ -86,15 +86,6 @@ namespace ICSharpCode.XmlEditor
 			}
 		}
 		
-		public XmlElement DocumentElement {
-			get {
-				return treeViewContainer.TreeView.DocumentElement;
-			}
-			set {
-				treeViewContainer.DocumentElement = value;
-			}
-		}
-		
 		void TreeViewContainerDirtyChanged(object source, EventArgs e)
 		{
 			if (!ignoreDirtyChange) {

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlTreeViewContainerControl.cs

@@ -34,7 +34,8 @@ namespace ICSharpCode.XmlEditor
 			ElementSelected     = 1,
 			RootElementSelected = 2,
 			AttributeSelected   = 4,
-			TextNodeSelected    = 8
+			TextNodeSelected    = 8,
+			CommentSelected     = 16
 		}
 		
 		public event EventHandler DirtyChanged;
@@ -53,7 +54,7 @@ namespace ICSharpCode.XmlEditor
 				XmlTreeViewContainerControlState state = XmlTreeViewContainerControlState.Nothing;
 				if (SelectedElement != null) {
 					state |= XmlTreeViewContainerControlState.ElementSelected;
-					if (SelectedElement == DocumentElement) {
+					if (SelectedElement == Document.DocumentElement) {
 						state |= XmlTreeViewContainerControlState.RootElementSelected;
 					}
 				}
@@ -63,10 +64,17 @@ namespace ICSharpCode.XmlEditor
 				if (SelectedTextNode != null) {
 					state = XmlTreeViewContainerControlState.TextNodeSelected;
 				}
+				if (SelectedComment != null) {
+					state = XmlTreeViewContainerControlState.CommentSelected;
+				}
 				return state;
 			}
 		}
 		
+		/// <summary>
+		/// Gets the property grid that displays attributes for the
+		/// selected xml element.
+		/// </summary>
 		public PropertyGrid AttributesGrid {
 			get {
 				return attributesGrid;
@@ -121,6 +129,9 @@ namespace ICSharpCode.XmlEditor
 			}
 		}
 		
+		/// <summary>
+		/// Gets the XmlTreeView in the container.
+		/// </summary>
 		public XmlTreeViewControl TreeView {
 			get {
 				return xmlElementTreeView;
@@ -133,16 +144,7 @@ namespace ICSharpCode.XmlEditor
 			ErrorMessage = ex.Message;
 			IsErrorMessageTextBoxVisible = true;
 		}
-		
-		public XmlElement DocumentElement {
-			get {
-				return xmlElementTreeView.DocumentElement;
-			}
-			set {
-				xmlElementTreeView.DocumentElement = value;
-			}
-		}
-		
+	
 		/// <summary>
 		/// Displays the specified xml as a tree.
 		/// </summary>
@@ -162,12 +164,16 @@ namespace ICSharpCode.XmlEditor
 		}
 		
 		/// <summary>
-		/// Gets the xml document created from the loaded Xml.
+		/// Gets or sets the xml document to be shown in this
+		/// container control.
 		/// </summary>
 		public XmlDocument Document {
 			get {
 				return editor.Document;
 			}
+			set {
+				xmlElementTreeView.Document = value;
+			}
 		}
 		
 		/// <summary>
@@ -198,12 +204,16 @@ namespace ICSharpCode.XmlEditor
 		}
 		
 		/// <summary>
-		/// Gets the text node text currently on display.
+		/// Gets or sets the text of the text node or 
+		/// comment node currently on display.
 		/// </summary>
 		public string TextContent {
 			get {
 				return textBox.Text;
 			}
+			set {
+				textBox.Text = value;
+			}
 		}
 		
 		/// <summary>
@@ -216,7 +226,7 @@ namespace ICSharpCode.XmlEditor
 		}
 		
 		/// <summary>
-		/// Gets the element text node currently selected.
+		/// Gets the text node currently selected.
 		/// </summary>
 		public XmlText SelectedTextNode {
 			get {
@@ -224,6 +234,15 @@ namespace ICSharpCode.XmlEditor
 			}
 		}
 		
+		/// <summary>
+		/// Gets the comment node currently selected.
+		/// </summary>
+		public XmlComment SelectedComment {
+			get {
+				return xmlElementTreeView.SelectedComment;
+			}
+		}
+		
 		/// <summary>
 		/// Gets the name of the attribute currently selected.
 		/// </summary>
@@ -301,7 +320,7 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void AddChildElement()
 		{
-			editor.AddChildElement();
+			editor.AppendChildElement();
 		}
 		
 		/// <summary>
@@ -369,7 +388,7 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>		
 		public void AppendChildTextNode()
 		{
-			editor.AddChildTextNode();
+			editor.AppendChildTextNode();
 		}
 		
 		/// <summary>
@@ -432,6 +451,80 @@ namespace ICSharpCode.XmlEditor
 			xmlElementTreeView.UpdateTextNode(textNode);
 		}
 		
+		/// <summary>
+		/// Updates the corresponding tree node's text.
+		/// </summary>
+		public void UpdateComment(XmlComment comment)
+		{
+			xmlElementTreeView.UpdateComment(comment);
+		}
+		
+		/// <summary>
+		/// Appends a new child comment node to the currently selected
+		/// element.
+		/// </summary>
+		public void AppendChildComment(XmlComment comment)
+		{
+			xmlElementTreeView.AppendChildComment(comment);
+		}
+		
+		/// <summary>
+		/// Appends a new child comment node to the currently selected
+		/// element.
+		/// </summary>
+		public void AppendChildComment()
+		{
+			editor.AppendChildComment();
+		}
+		
+		/// <summary>
+		/// Removes the selected comment node from the tree.
+		/// </summary>
+		public void RemoveComment()
+		{
+			editor.RemoveComment();
+		}
+		
+		/// <summary>
+		/// Removes the specified xml comment from the tree.
+		/// </summary>
+		public void RemoveComment(XmlComment comment)
+		{
+			xmlElementTreeView.RemoveComment(comment);
+		}
+		
+		/// <summary>
+		/// Inserts the comment before the currently selected node.
+		/// </summary>
+		public void InsertCommentBefore(XmlComment comment)
+		{
+			xmlElementTreeView.InsertCommentBefore(comment);
+		}
+		
+		/// <summary>
+		/// Inserts a comment before the currently selected node.
+		/// </summary>
+		public void InsertCommentBefore()
+		{
+			editor.InsertCommentBefore();
+		}
+		
+		/// <summary>
+		/// Inserts the comment after the currently selected node.
+		/// </summary>
+		public void InsertCommentAfter(XmlComment comment)
+		{
+			xmlElementTreeView.InsertCommentAfter(comment);
+		}
+		
+		/// <summary>
+		/// Inserts a comment after the currently selected node.
+		/// </summary>
+		public void InsertCommentAfter()
+		{
+			editor.InsertCommentAfter();
+		}
+		
 		/// <summary>
 		/// Disposes resources used by the control.
 		/// </summary>
@@ -518,7 +611,6 @@ namespace ICSharpCode.XmlEditor
 			this.xmlElementTreeView.AllowDrop = true;
 			this.xmlElementTreeView.CanClearSelection = true;
 			this.xmlElementTreeView.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.xmlElementTreeView.DocumentElement = null;
 			this.xmlElementTreeView.DrawMode = System.Windows.Forms.TreeViewDrawMode.OwnerDrawText;
 			this.xmlElementTreeView.HideSelection = false;
 			this.xmlElementTreeView.ImageIndex = 0;
@@ -600,11 +692,7 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		protected void XmlElementTreeViewAfterSelect(object sender, TreeViewEventArgs e)
 		{
-			if (xmlElementTreeView.IsTextNodeSelected) {
-				editor.SelectedTextNodeChanged();
-			} else {
-				editor.SelectedElementChanged();
-			}
+			editor.SelectedNodeChanged();
 		}
 		
 		/// <summary>
@@ -630,11 +718,11 @@ namespace ICSharpCode.XmlEditor
 			images.Images.Add(XmlElementTreeNode.XmlElementTreeNodeImageKey, xmlElementImage);
 			Image xmlTextImage = Image.FromStream(typeof(XmlTreeViewContainerControl).Assembly.GetManifestResourceStream("ICSharpCode.XmlEditor.Resources.XmlTextTreeNodeIcon.png"));
 			images.Images.Add(XmlTextTreeNode.XmlTextTreeNodeImageKey, xmlTextImage);
+			Image xmlCommentImage = Image.FromStream(typeof(XmlTreeViewContainerControl).Assembly.GetManifestResourceStream("ICSharpCode.XmlEditor.Resources.XmlCommentTreeNodeIcon.png"));
+			images.Images.Add(XmlCommentTreeNode.XmlCommentTreeNodeImageKey, xmlCommentImage);
 			xmlElementTreeView.ImageList = images;
 		}
 		
-
-		
 		/// <summary>
 		/// Raises the dirty changed event if the dirty flag has changed.
 		/// </summary>

src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlTreeViewControl.cs

@@ -24,7 +24,7 @@ namespace ICSharpCode.XmlEditor
 	{			
 		const string ViewStatePropertyName = "XmlTreeViewControl.ViewState";
 
-		XmlElement documentElement;
+		XmlDocument document;
 
 		enum InsertionMode {
 			Before = 0,
@@ -36,20 +36,20 @@ namespace ICSharpCode.XmlEditor
 		}
 		
 		/// <summary>
-		/// Gets or sets the root element currently being displayed.
+		/// Gets or sets the xml document currently being displayed.
 		/// </summary>
 		[Browsable(false)]
-		public XmlElement DocumentElement {
+		public XmlDocument Document {
 			get {
-				return documentElement;
+				return document;
 			}
 			set {
-				documentElement = value;
+				document = value;
 				
 				// Update display.
 				BeginUpdate();
 				try {
-					ShowDocumentElement();
+					ShowDocument();
 				} finally {
 					EndUpdate();
 				}
@@ -87,7 +87,19 @@ namespace ICSharpCode.XmlEditor
 				if (xmlTextTreeNode != null) {
 					return xmlTextTreeNode.XmlText;
 				}
-
+				return null;
+			}
+		}
+				
+		/// <summary>
+		/// Gets the selected comment node in the tree.
+		/// </summary>
+		public XmlComment SelectedComment {
+			get {				
+				XmlCommentTreeNode commentTreeNode = SelectedNode as XmlCommentTreeNode;
+				if (commentTreeNode != null) {
+					return commentTreeNode.XmlComment;
+				}
 				return null;
 			}
 		}
@@ -166,15 +178,9 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void RemoveElement(XmlElement element)
 		{
-			XmlElementTreeNode selectedElementTreeNode = SelectedNode as XmlElementTreeNode;
-			if (selectedElementTreeNode != null && selectedElementTreeNode.XmlElement == element) {
-				// Remove selected tree node.
-				selectedElementTreeNode.Remove();
-			} else {
-				XmlElementTreeNode elementTreeNode = FindElementNode(element, Nodes);
-				if (elementTreeNode != null) {
-					elementTreeNode.Remove();
-				}
+			XmlElementTreeNode node = FindElement(element);
+			if (node != null) {
+				node.Remove();
 			}
 		}
 		
@@ -183,14 +189,9 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void RemoveTextNode(XmlText textNode)
 		{
-			XmlTextTreeNode selectedTextTreeNode = SelectedNode as XmlTextTreeNode;
-			if (selectedTextTreeNode != null && selectedTextTreeNode.XmlText == textNode) {
-				selectedTextTreeNode.Remove();
-			} else {
-				XmlTextTreeNode textTreeNode = FindTextNode(textNode, Nodes);
-				if (textTreeNode != null) {
-					textTreeNode.Remove();
-				}
+			XmlTextTreeNode node = FindTextNode(textNode);
+			if (node != null) {
+				node.Remove();
 			}
 		}
 		
@@ -218,16 +219,65 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public void UpdateTextNode(XmlText textNode)
 		{
-			XmlTextTreeNode selectedTextTreeNode = SelectedNode as XmlTextTreeNode;
-			if (selectedTextTreeNode != null && selectedTextTreeNode.XmlText == textNode) {
-				selectedTextTreeNode.Update();
-			} else {
-				XmlTextTreeNode textTreeNode = FindTextNode(textNode, Nodes);
-				if (textTreeNode != null) {
-					textTreeNode.Update();
-				}
+			XmlTextTreeNode node = FindTextNode(textNode);
+			if (node != null) {
+				node.Update();
 			}
 		}
+				
+		/// <summary>
+		/// Updates the corresponding tree node's text based on 
+		/// the comment's value.
+		/// </summary>
+		public void UpdateComment(XmlComment comment)
+		{
+			XmlCommentTreeNode node = FindComment(comment);
+			if (node != null) {
+				node.Update();
+			}
+		}
+		
+		/// <summary>
+		/// Appends a new child comment node to the currently selected element.
+		/// </summary>
+		public void AppendChildComment(XmlComment comment)
+		{
+			XmlElementTreeNode selectedNode = SelectedElementNode;
+			if (selectedNode != null) {
+				XmlCommentTreeNode newNode = new XmlCommentTreeNode(comment);
+				newNode.AddTo(selectedNode);
+				selectedNode.Expand();
+			}
+		}
+		
+		/// <summary>
+		/// Removes the specified comment from the tree.
+		/// </summary>
+		public void RemoveComment(XmlComment comment)
+		{
+			XmlCommentTreeNode node = FindComment(comment);
+			if (node != null) {
+				node.Remove();
+			}
+		}
+		
+		/// <summary>
+		/// Inserts a comment node before the currently selected
+		/// node.
+		/// </summary>
+		public void InsertCommentBefore(XmlComment comment)
+		{
+			InsertComment(comment, InsertionMode.Before);
+		}
+		
+		/// <summary>
+		/// Inserts a comment node after the currently selected
+		/// node.
+		/// </summary>
+		public void InsertCommentAfter(XmlComment comment)
+		{
+			InsertComment(comment, InsertionMode.After);
+		}
 		
 		/// <summary>
 		/// If no node is selected after a mouse click then we make 
@@ -246,12 +296,22 @@ namespace ICSharpCode.XmlEditor
 		/// <summary>
 		/// Displays the document in the xml tree.
 		/// </summary>
-		void ShowDocumentElement()
+		void ShowDocument()
 		{
 			Nodes.Clear();
-			if (documentElement != null) {
-				XmlElementTreeNode node = new XmlElementTreeNode(documentElement);
-				node.AddTo(this);
+			if (document != null) {
+				foreach (XmlNode node in document.ChildNodes) {
+					switch (node.NodeType) {
+						case XmlNodeType.Element:
+							XmlElementTreeNode elementNode = new XmlElementTreeNode((XmlElement)node);
+							elementNode.AddTo(this);
+							break;
+						case XmlNodeType.Comment:
+							XmlCommentTreeNode commentNode = new XmlCommentTreeNode((XmlComment)node);
+							commentNode.AddTo(this);
+							break;
+					}
+				}
 			}
 		}
 		
@@ -270,7 +330,7 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		void InsertElement(XmlElement element, InsertionMode insertionMode)
 		{
-			XmlElementTreeNode selectedNode = SelectedElementNode;
+			ExtTreeNode selectedNode = (ExtTreeNode)SelectedNode;
 			if (selectedNode != null) {
 				XmlElementTreeNode parentNode = (XmlElementTreeNode)selectedNode.Parent;
 				XmlElementTreeNode newNode = new XmlElementTreeNode(element);
@@ -300,11 +360,38 @@ namespace ICSharpCode.XmlEditor
 			}
 		}
 		
+		/// <summary>
+		/// Inserts a new comment node either before or after the 
+		/// currently selected node.
+		/// </summary>
+		void InsertComment(XmlComment comment, InsertionMode insertionMode)
+		{
+			ExtTreeNode selectedNode = (ExtTreeNode)SelectedNode;
+			if (selectedNode != null) {
+				ExtTreeNode parentNode = (ExtTreeNode)selectedNode.Parent;
+				XmlCommentTreeNode newNode = new XmlCommentTreeNode(comment);
+				int index = 0;
+				if (parentNode != null) {
+					index = parentNode.Nodes.IndexOf(selectedNode);
+				} else {
+					index = Nodes.IndexOf(selectedNode);
+				}
+				if (insertionMode == InsertionMode.After) {
+					index++;
+				}
+				if (parentNode != null) {
+					newNode.Insert(index, parentNode);
+				} else {
+					newNode.Insert(index, this);
+				}
+			}
+		}
+		
 		/// <summary>
 		/// Looks at all the nodes in the tree view and returns the
 		/// tree node that represents the specified element.
 		/// </summary>
-		XmlElementTreeNode FindElementNode(XmlElement element, TreeNodeCollection nodes)
+		XmlElementTreeNode FindElement(XmlElement element, TreeNodeCollection nodes)
 		{
 			foreach (ExtTreeNode node in nodes) {
 				XmlElementTreeNode elementTreeNode = node as XmlElementTreeNode;
@@ -314,7 +401,7 @@ namespace ICSharpCode.XmlEditor
 					}
 					
 					// Look for a match in the element's child nodes.
-					XmlElementTreeNode childElementTreeNode = FindElementNode(element, elementTreeNode.Nodes);
+					XmlElementTreeNode childElementTreeNode = FindElement(element, elementTreeNode.Nodes);
 					if (childElementTreeNode != null) {
 						return childElementTreeNode;
 					}
@@ -323,6 +410,19 @@ namespace ICSharpCode.XmlEditor
 			return null;
 		}
 		
+		/// <summary>
+		/// Finds the corresponding XmlElementTreeNode.
+		/// </summary>
+		XmlElementTreeNode FindElement(XmlElement element)
+		{
+			XmlElementTreeNode selectedElementTreeNode = SelectedNode as XmlElementTreeNode;
+			if (selectedElementTreeNode != null && selectedElementTreeNode.XmlElement == element) {
+				return selectedElementTreeNode;
+			} else {
+				return FindElement(element, Nodes);
+			}
+		}
+		
 		/// <summary>
 		/// Looks at all the nodes in the tree view and returns the
 		/// tree node that represents the specified text node.
@@ -345,5 +445,54 @@ namespace ICSharpCode.XmlEditor
 			}
 			return null;
 		}
+		
+		/// <summary>
+		/// Finds the specified text node in the tree.
+		/// </summary>
+		XmlTextTreeNode FindTextNode(XmlText textNode)
+		{
+			XmlTextTreeNode selectedTextTreeNode = SelectedNode as XmlTextTreeNode;
+			if (selectedTextTreeNode != null && selectedTextTreeNode.XmlText == textNode) {
+				return selectedTextTreeNode;
+			} else {
+				return FindTextNode(textNode, Nodes);
+			}
+		}
+		
+		/// <summary>
+		/// Looks at all the nodes in the tree view and returns the
+		/// tree node that represents the specified comment node.
+		/// </summary>
+		XmlCommentTreeNode FindComment(XmlComment comment, TreeNodeCollection nodes)
+		{
+			foreach (ExtTreeNode node in nodes) {
+				XmlCommentTreeNode commentTreeNode = node as XmlCommentTreeNode;
+				if (commentTreeNode != null) {
+					if (commentTreeNode.XmlComment == comment) {
+						return commentTreeNode;
+					}
+				} else {
+					// Look for a match in the node's child nodes.
+					XmlCommentTreeNode childCommentTreeNode = FindComment(comment, node.Nodes);
+					if (childCommentTreeNode != null) {
+						return childCommentTreeNode;
+					}
+				}
+			}
+			return null;
+		}
+		
+		/// <summary>
+		/// Locates the specified comment in the tree.
+		/// </summary>
+		XmlCommentTreeNode FindComment(XmlComment comment)
+		{
+			XmlCommentTreeNode selectedCommentTreeNode = SelectedNode as XmlCommentTreeNode;
+			if (selectedCommentTreeNode != null && selectedCommentTreeNode.XmlComment == comment) {
+				return selectedCommentTreeNode;
+			} else {
+				return FindComment(comment, Nodes);
+			}
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.addin

@@ -199,12 +199,15 @@
 
 	<Path name = "/AddIns/XmlEditor/XmlTree/ContextMenu">
 		<ComplexCondition action = "Disable">
-			<And>
-				<Condition name = "Ownerstate" ownerstate = "ElementSelected"/>
-				<Not>
-					<Condition name = "Ownerstate" ownerstate = "RootElementSelected"/>
-				</Not>
-			</And>
+			<Or>
+				<Condition name = "Ownerstate" ownerstate = "CommentSelected"/>
+				<And>
+					<Condition name = "Ownerstate" ownerstate = "ElementSelected"/>
+					<Not>
+						<Condition name = "Ownerstate" ownerstate = "RootElementSelected"/>
+					</Not>
+				</And>
+			</Or>
 			<MenuItem id = "InsertElementBefore"
 				label = "${res:ICSharpCode.XmlEditor.XmlTreeView.InsertElementBeforeMenuLabel}"
 				class = "ICSharpCode.XmlEditor.InsertElementBeforeCommand"/>
@@ -220,6 +223,7 @@
 		<ComplexCondition action = "Disable">
 			<Or>
 				<Condition name = "Ownerstate" ownerstate = "TextNodeSelected"/>
+				<Condition name = "Ownerstate" ownerstate = "CommentSelected"/>
 				<And>
 					<Condition name = "Ownerstate" ownerstate = "ElementSelected"/>
 					<Not>
@@ -240,6 +244,32 @@
 				label = "${res:ICSharpCode.XmlEditor.XmlTreeView.AddChildTextNodeAfterMenuLabel}"
 				class = "ICSharpCode.XmlEditor.AddChildTextNodeCommand"/>			
 		</Condition>
+		<ComplexCondition action = "Disable">
+			<Or>
+				<Condition name = "Ownerstate" ownerstate = "TextNodeSelected"/>
+				<Condition name = "Ownerstate" ownerstate = "ElementSelected"/>
+				<Condition name = "Ownerstate" ownerstate = "CommentSelected"/>
+			</Or>
+			<MenuItem id = "CommentNodeCommandsSeparator" type = "Separator"/>
+			<MenuItem id = "InsertCommentBefore"
+				label = "${res:ICSharpCode.XmlEditor.XmlTreeView.InsertCommentBeforeMenuLabel}"
+				class = "ICSharpCode.XmlEditor.InsertCommentBeforeCommand"/>
+			<MenuItem id = "InsertCommentAfter"
+				label = "${res:ICSharpCode.XmlEditor.XmlTreeView.InsertCommentAfterMenuLabel}"
+				class = "ICSharpCode.XmlEditor.InsertCommentAfterCommand"/>
+		</ComplexCondition>
+		<Condition name = "Ownerstate" ownerstate = "ElementSelected" action = "Disable">
+			<MenuItem id = "AddChildCommentNode"
+				label = "${res:ICSharpCode.XmlEditor.XmlTreeView.AddChildCommentMenuLabel}"
+				class = "ICSharpCode.XmlEditor.AddChildCommentCommand"/>			
+		</Condition>
+		<Condition name = "Ownerstate" ownerstate = "CommentSelected" action = "Exclude">
+			<MenuItem id = "RemoveCommentSeparator" type = "Separator"/>
+			<MenuItem id = "RemoveComment"
+				label = "${res:XML.MainMenu.EditMenu.Delete}"
+				icon = "Icons.16x16.DeleteIcon"
+				class = "ICSharpCode.XmlEditor.RemoveCommentCommand"/>
+		</Condition>
 		<Condition name = "Ownerstate" ownerstate = "TextNodeSelected" action = "Exclude">
 			<MenuItem id = "RemoveTextNodeSeparator" type = "Separator"/>
 			<MenuItem id = "RemoveTextNode"

src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.csproj

@@ -54,13 +54,19 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Configuration\AssemblyInfo.cs" />
+    <Compile Include="Src\AddChildCommentCommand.cs" />
     <Compile Include="Src\AddChildTextNodeCommand.cs" />
     <Compile Include="Src\IAddAttributeDialog.cs" />
     <Compile Include="Src\IAddElementDialog.cs" />
+    <Compile Include="Src\InsertCommentAfterCommand.cs" />
+    <Compile Include="Src\InsertCommentBeforeCommand.cs" />
     <Compile Include="Src\InsertTextNodeAfterCommand.cs" />
     <Compile Include="Src\InsertTextNodeBeforeCommand.cs" />
+    <Compile Include="Src\RemoveCommentCommand.cs" />
     <Compile Include="Src\RemoveElementCommand.cs" />
     <Compile Include="Src\RemoveTextNodeCommand.cs" />
+    <Compile Include="Src\XmlCharacterDataTreeNode.cs" />
+    <Compile Include="Src\XmlCommentTreeNode.cs" />
     <Compile Include="Src\XmlEditorControl.cs">
       <SubType>UserControl</SubType>
     </Compile>
@@ -102,6 +108,7 @@
     <EmbeddedResource Include="Resources\XmlSchemasPanel.xfrm" />
     <EmbeddedResource Include="Resources\SelectXmlSchema.xfrm" />
     <EmbeddedResource Include="Resources\XmlEditorOptionsPanel.xfrm" />
+    <EmbeddedResource Include="Resources\XmlCommentTreeNodeIcon.png" />
     <None Include="XmlEditor.addin">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/AddChildElementTestFixture.cs

@@ -32,7 +32,7 @@ namespace XmlEditor.Tests.Tree
 			mockXmlTreeView.SelectedNewElementsToReturn.Add("h1");
 			mockXmlTreeView.SelectedNewElementsToReturn.Add("p");
 
-			editor.AddChildElement();
+			editor.AppendChildElement();
 		}
 		
 		[Test]
@@ -46,7 +46,7 @@ namespace XmlEditor.Tests.Tree
 		{
 			mockXmlTreeView.SelectedElement = null;
 			mockXmlTreeView.IsSelectNewElementsCalled = false;
-			editor.AddChildElement();
+			editor.AppendChildElement();
 			Assert.IsFalse(mockXmlTreeView.IsSelectNewElementsCalled);
 		}
 		
@@ -61,7 +61,7 @@ namespace XmlEditor.Tests.Tree
 		{
 			mockXmlTreeView.SelectedNewElementsToReturn.Clear();
 			mockXmlTreeView.IsDirty = false;
-			editor.AddChildElement();
+			editor.AppendChildElement();
 			Assert.IsFalse(mockXmlTreeView.IsDirty);
 		}
 		

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/AddChildTextNodeTestFixture.cs

@@ -29,7 +29,7 @@ namespace XmlEditor.Tests.Tree
 			base.InitFixture();
 			paragraphElement = (XmlElement)editor.Document.SelectSingleNode("/html/body/p");
 			mockXmlTreeView.SelectedElement = paragraphElement;
-			editor.AddChildTextNode();
+			editor.AppendChildTextNode();
 		}
 		
 		[Test]
@@ -56,7 +56,7 @@ namespace XmlEditor.Tests.Tree
 		{
 			mockXmlTreeView.SelectedElement = null;
 			mockXmlTreeView.IsDirty = false;
-			editor.AddChildTextNode();
+			editor.AppendChildTextNode();
 			Assert.IsFalse(mockXmlTreeView.IsDirty);
 		}
 		

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/AttributeChangedTestFixture.cs

@@ -23,9 +23,9 @@ namespace XmlEditor.Tests.Tree
 		public void SetUpFixture()
 		{
 			base.InitFixture();
-			mockXmlTreeView.SelectedElement = mockXmlTreeView.DocumentElement;
-			editor.SelectedElementChanged();
-			XmlAttribute attribute = mockXmlTreeView.DocumentElement.Attributes["first"];
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
+			XmlAttribute attribute = mockXmlTreeView.Document.DocumentElement.Attributes["first"];
 			attribute.Value = "new value";
 			editor.AttributeValueChanged();
 		}

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/DocumentElementOnlyTestFixture.cs

@@ -25,13 +25,13 @@ namespace XmlEditor.Tests.Tree
 		[Test]
 		public void RootElementAdded()
 		{
-			Assert.AreEqual("root", mockXmlTreeView.DocumentElement.Name);
+			Assert.AreEqual("root", mockXmlTreeView.Document.DocumentElement.Name);
 		}
 		
 		[Test]
 		public void RootElementInDocument()
 		{
-			Assert.IsTrue(Object.ReferenceEquals(editor.Document.DocumentElement, mockXmlTreeView.DocumentElement));
+			Assert.IsTrue(Object.ReferenceEquals(editor.Document.DocumentElement, mockXmlTreeView.Document.DocumentElement));
 		}
 				
 		protected override string GetXml()

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/EditCommentNodesInTreeControlTestFixture.cs

@@ -0,0 +1,281 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Windows.Forms;
+using System.Xml;
+using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.XmlEditor;
+using NUnit.Framework;
+using XmlEditor.Tests.Utils;
+
+namespace XmlEditor.Tests.Tree
+{
+	/// <summary>
+	/// Tests the display of XmlComment nodes in the Xml Tree
+	/// and the removal and addition of new xml comment nodes.
+	/// </summary>
+	[TestFixture]
+	public class EditCommentNodesInTreeControlTestFixture
+	{
+		XmlDocument doc;
+		DerivedXmlTreeViewContainerControl treeViewContainer; 
+		XmlTreeViewControl treeView;
+		XmlCommentTreeNode rootCommentTreeNode;
+		XmlComment rootCommentNode;
+		XmlCommentTreeNode childCommentTreeNode;
+		XmlComment childCommentNode;
+		XmlElementTreeNode childElementTreeNode;
+		XmlElement childElement;
+		XmlElementTreeNode rootElementTreeNode;
+		XmlElement rootElement;
+		
+		[SetUp]
+		public void SetUp()
+		{
+			XmlCompletionDataProvider completionDataProvider = new XmlCompletionDataProvider(new XmlSchemaCompletionDataCollection(), null, String.Empty);
+			treeViewContainer = new DerivedXmlTreeViewContainerControl();
+			treeViewContainer.LoadXml("<!-- Root comment --><root><!-- Child comment --><child></child></root>", completionDataProvider);
+			
+			doc = treeViewContainer.Document;
+			treeView = treeViewContainer.TreeView;
+			
+			// Get the root comment node in the tree.
+			rootCommentNode = (XmlComment)doc.FirstChild;
+			rootCommentTreeNode = treeView.Nodes[0] as XmlCommentTreeNode;
+			
+			// Get the child comment node in the tree.
+			rootElementTreeNode = (XmlElementTreeNode)treeView.Nodes[1];
+			rootElementTreeNode.Expanding();
+			rootElement = rootElementTreeNode.XmlElement;
+			
+			childCommentTreeNode = rootElementTreeNode.Nodes[0] as XmlCommentTreeNode;
+			childCommentNode = (XmlComment)rootElementTreeNode.XmlElement.FirstChild;
+			
+			childElementTreeNode = rootElementTreeNode.Nodes[1] as XmlElementTreeNode;
+			childElement = childElementTreeNode.XmlElement;
+		}
+		
+		[TearDown]
+		public void TearDown()
+		{
+			if (treeViewContainer != null) {
+				treeViewContainer.Dispose();
+			}
+		}
+		
+		/// <summary>
+		/// Should have an xml element and xml comment as root
+		/// nodes in the XmlTreeViewControl.
+		/// </summary>
+		[Test]
+		public void TwoRootNodes()
+		{
+			Assert.AreEqual(2, treeView.Nodes.Count);
+		}
+		
+		[Test]
+		public void RootCommentNodeExists()
+		{
+			Assert.IsNotNull(rootCommentTreeNode);
+		}
+		
+		[Test]
+		public void RootCommentNodeText()
+		{
+			Assert.AreEqual("Root comment", rootCommentTreeNode.Text);
+		}
+		
+		[Test]
+		public void RootCommentXmlNode()
+		{
+			Assert.AreSame(rootCommentNode, rootCommentTreeNode.XmlComment);
+		}
+		
+		[Test]
+		public void ChildCommentNodeExists()
+		{
+			Assert.IsNotNull(childCommentTreeNode);
+		}
+		
+		[Test]
+		public void ChildCommentNodeText()
+		{
+			Assert.AreEqual("Child comment", childCommentTreeNode.Text);
+		}
+		
+		[Test]
+		public void ChildCommentXmlNode()
+		{
+			Assert.AreSame(childCommentNode, childCommentTreeNode.XmlComment);
+		}
+		
+		[Test]
+		public void CommentTextChanged()
+		{
+			// Select the comment node.
+			treeView.SelectedNode = rootCommentTreeNode;
+			
+			string newText = "changed text";
+			treeViewContainer.TextContent = newText;
+			
+			treeViewContainer.CallTextBoxTextChanged();
+			
+			Assert.AreEqual(newText, rootCommentTreeNode.XmlComment.InnerText);
+			Assert.AreEqual(newText, rootCommentTreeNode.Text, "Tree node text should be updated with new XmlComment's inner text");
+		}
+		
+		/// <summary>
+		/// Updates the comment node when no text node is selected in the
+		/// tree.
+		/// </summary>
+		[Test]
+		public void UpdateCommentNodeText()
+		{
+			treeView.SelectedNode = null;
+			
+			rootCommentNode.InnerText = "New value";
+			treeView.UpdateComment(rootCommentNode);
+			Assert.AreEqual("New value", rootCommentTreeNode.Text);
+		}
+		
+		/// <summary>
+		/// Tests that when the XmlTreeView's UpdateCommentNode method
+		/// is called we do not get a null exception if the
+		/// text node cannot be found in the tree.
+		/// </summary>
+		[Test]
+		public void UpdateUnknownTextNodeText()
+		{
+			// Select the root comment node.
+			treeView.SelectedNode = rootCommentTreeNode;
+			
+			XmlComment comment = doc.CreateComment(String.Empty);
+			treeView.UpdateComment(comment);
+		}
+		
+		[Test]
+		public void UpdateChildCommentNodeText()
+		{
+			treeView.SelectedNode = null;
+			
+			childCommentNode.InnerText = "New value";
+			treeView.UpdateComment(childCommentNode);
+			Assert.AreEqual("New value", childCommentTreeNode.Text);
+		}
+		
+		/// <summary>
+		/// Makes sure that nothing happens if we try to add a text
+		/// node to the currently selected element node when there
+		/// is no selected element node.
+		/// </summary>
+		[Test]
+		public void AddChildCommentNodeWhenNoElementSelected()
+		{
+			treeView.SelectedNode = null;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.AppendChildComment(newCommentNode);
+			
+			Assert.IsFalse(treeViewContainer.IsDirty);
+		}
+		
+		[Test]
+		public void RemoveCommentWhenNoNodeSelected()
+		{
+			treeView.SelectedNode = null;
+			treeView.RemoveComment(rootCommentNode);
+			
+			Assert.AreEqual(1, treeView.Nodes.Count);
+			Assert.IsInstanceOfType(typeof(XmlElementTreeNode), treeView.Nodes[0]);
+		}
+		
+		[Test]
+		public void RemoveUnknownCommentNode()
+		{
+			treeView.SelectedNode = rootCommentTreeNode;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.RemoveComment(newCommentNode);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeRootComment()
+		{
+			treeView.SelectedNode = rootCommentTreeNode;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.InsertCommentBefore(newCommentNode);
+			
+			XmlCommentTreeNode commentNode = treeView.Nodes[0] as XmlCommentTreeNode;
+			XmlCommentTreeNode originalCommentNode = treeView.Nodes[1] as XmlCommentTreeNode;
+			Assert.AreEqual(3, treeView.Nodes.Count);
+			Assert.AreEqual(String.Empty, commentNode.Text);
+			Assert.AreEqual(newCommentNode, commentNode.XmlComment);
+			Assert.AreSame(rootCommentTreeNode, originalCommentNode);
+			Assert.IsNull(commentNode.Parent);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeChildElement()
+		{
+			treeView.SelectedNode = childElementTreeNode;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.InsertCommentBefore(newCommentNode);
+			
+			XmlCommentTreeNode commentNode = childElementTreeNode.PrevNode as XmlCommentTreeNode;
+			Assert.AreEqual(String.Empty, commentNode.Text);
+			Assert.AreEqual(newCommentNode, commentNode.XmlComment);
+			Assert.IsNotNull(commentNode.Parent);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeWhenNothingSelected()
+		{
+			treeView.SelectedNode = null;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.InsertCommentBefore(newCommentNode);
+		}
+		
+		[Test]
+		public void InsertCommentAfterRootComment()
+		{
+			treeView.SelectedNode = rootCommentTreeNode;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.InsertCommentAfter(newCommentNode);
+			
+			XmlCommentTreeNode commentNode = treeView.Nodes[1] as XmlCommentTreeNode;
+			XmlCommentTreeNode originalCommentNode = treeView.Nodes[0] as XmlCommentTreeNode;
+			Assert.AreEqual(3, treeView.Nodes.Count);
+			Assert.AreEqual(String.Empty, commentNode.Text);
+			Assert.AreEqual(newCommentNode, commentNode.XmlComment);
+			Assert.AreSame(rootCommentTreeNode, originalCommentNode);
+			Assert.IsNull(commentNode.Parent);
+		}
+		
+		[Test]
+		public void InsertCommentAfterChildElement()
+		{
+			treeView.SelectedNode = childElementTreeNode;
+			XmlComment newCommentNode = doc.CreateComment(String.Empty);
+			treeView.InsertCommentAfter(newCommentNode);
+			
+			XmlCommentTreeNode commentNode = childElementTreeNode.NextNode as XmlCommentTreeNode;
+			Assert.AreEqual(String.Empty, commentNode.Text);
+			Assert.AreEqual(newCommentNode, commentNode.XmlComment);
+		}
+		
+		[Test]
+		public void InsertElementAfterWhenCommentSelected()
+		{
+			treeView.SelectedNode = childCommentTreeNode;
+			XmlElement element = doc.CreateElement("new");
+			treeView.InsertElementAfter(element);
+			
+			XmlElementTreeNode node = childCommentTreeNode.NextNode as XmlElementTreeNode;
+			Assert.AreEqual("new", node.Text);
+			Assert.AreEqual(element, node.XmlElement);
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/EditCommentNodesTestFixture.cs

@@ -0,0 +1,362 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Xml;
+using ICSharpCode.XmlEditor;
+using NUnit.Framework;
+
+namespace XmlEditor.Tests.Tree
+{
+	/// <summary>
+	/// Tests the XmlTreeEditor when editing xml comments.
+	/// </summary>
+	[TestFixture]
+	public class EditCommentNodesTestFixture : XmlTreeViewTestFixtureBase
+	{
+		XmlComment rootComment;
+		XmlElement childElement;
+		
+		[SetUp]
+		public void SetUpFixture()
+		{
+			base.InitFixture();
+			rootComment = (XmlComment)mockXmlTreeView.Document.FirstChild;
+			childElement = (XmlElement)mockXmlTreeView.Document.SelectSingleNode("root/child");
+			mockXmlTreeView.SelectedComment = rootComment;
+			editor.SelectedNodeChanged();
+		}
+		
+		[Test]
+		public void IsViewShowingText()
+		{
+			Assert.AreEqual(" Root comment ", mockXmlTreeView.TextContent);
+		}
+		
+		[Test]
+		public void AttributesClearedAfterCommentSelected()
+		{
+			mockXmlTreeView.SelectedComment = null;
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
+			Assert.IsTrue(mockXmlTreeView.AttributesDisplayed.Count > 0);
+			
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = rootComment;
+			editor.SelectedNodeChanged();
+			Assert.IsFalse(mockXmlTreeView.AttributesDisplayed.Count > 0);
+		}
+		
+		[Test]
+		public void CommentTextChanged()
+		{
+			mockXmlTreeView.TextContent = "new value";
+			editor.TextContentChanged();
+			
+			Assert.AreEqual("new value", rootComment.InnerText);
+		}
+		
+		[Test]
+		public void IsDirtyAfterTextChanged()
+		{
+			editor.TextContentChanged();
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+		}
+		
+		/// <summary>
+		/// Check that the Xml tree editor calls the XmlTreeView's
+		/// UpdateCommentNode method.
+		/// </summary>
+		[Test]
+		public void TreeNodeTextUpdated()
+		{			
+			mockXmlTreeView.TextContent = "new value";
+			editor.TextContentChanged();
+
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesUpdated.Count);
+			Assert.AreEqual(rootComment, mockXmlTreeView.CommentNodesUpdated[0]);
+		}
+		
+		[Test]
+		public void AddChildCommentNodeWhenNothingSelected()
+		{
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedComment = null;
+			mockXmlTreeView.IsDirty = false;
+			editor.AppendChildComment();
+			Assert.IsFalse(mockXmlTreeView.IsDirty);
+		}
+		
+		[Test]
+		public void AddChildCommentToChildElement()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedComment = null;
+			mockXmlTreeView.SelectedElement = childElement;
+			editor.AppendChildComment();
+			
+			// The second child node should be the comment.
+			// The first child is the existing text node.
+			XmlComment comment = childElement.ChildNodes[1] as XmlComment;
+			Assert.AreEqual(2, childElement.ChildNodes.Count);
+			Assert.IsNotNull(comment);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.ChildCommentNodesAdded.Count);
+		}
+		
+		[Test]
+		public void RemoveComment()
+		{
+			mockXmlTreeView.SelectedComment = rootComment;
+			editor.RemoveComment();
+			
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesRemoved.Count);
+			Assert.AreSame(rootComment, mockXmlTreeView.CommentNodesRemoved[0]);
+			Assert.AreEqual(1, mockXmlTreeView.Document.ChildNodes.Count);
+			Assert.IsInstanceOfType(typeof(XmlElement), mockXmlTreeView.Document.FirstChild);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+		}
+		
+		[Test]
+		public void RemoveCommentWhenNoNodeSelected()
+		{
+			mockXmlTreeView.SelectedComment = null;
+			editor.RemoveComment();
+			
+			Assert.IsFalse(mockXmlTreeView.IsDirty);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeWhenNoNodeSelected()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentBefore();
+			
+			Assert.IsFalse(mockXmlTreeView.IsDirty);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeComment()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = rootComment;
+			
+			editor.InsertCommentBefore();
+			
+			XmlNode parentNode = rootComment.ParentNode;
+			XmlComment comment = (XmlComment)parentNode.FirstChild;
+			XmlComment secondComment = parentNode.ChildNodes[1] as XmlComment;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.AreSame(rootComment, secondComment);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedBefore.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedBefore[0]);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeElement()
+		{
+			XmlDocument doc = mockXmlTreeView.Document;
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = doc.DocumentElement;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentBefore();
+			
+			XmlComment comment = (XmlComment)doc.DocumentElement.PreviousSibling;
+			XmlComment originalComment = (XmlComment)comment.PreviousSibling;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.AreSame(rootComment, originalComment);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedBefore.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedBefore[0]);
+		}
+
+		[Test]
+		public void InsertCommentBeforeTextNode()
+		{
+			XmlText textNode = (XmlText)mockXmlTreeView.Document.SelectSingleNode("/root/child/text()");
+			mockXmlTreeView.SelectedTextNode = textNode;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentBefore();
+			
+			XmlComment comment = (XmlComment)textNode.PreviousSibling;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedBefore.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedBefore[0]);
+		}
+		
+				[Test]
+		public void InsertCommentAfterWhenNoNodeSelected()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentAfter();
+			
+			Assert.IsFalse(mockXmlTreeView.IsDirty);
+		}
+		
+		[Test]
+		public void InsertCommentAfterComment()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = rootComment;
+			
+			editor.InsertCommentAfter();
+			
+			XmlComment comment = rootComment.NextSibling as XmlComment;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedAfter.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedAfter[0]);
+		}
+		
+		[Test]
+		public void InsertCommentAfterElement()
+		{
+			XmlDocument doc = mockXmlTreeView.Document;
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = doc.DocumentElement;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentAfter();
+			
+			XmlComment comment = (XmlComment)doc.DocumentElement.NextSibling;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedAfter.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedAfter[0]);
+		}
+
+		[Test]
+		public void InsertCommentAfterTextNode()
+		{
+			XmlText textNode = (XmlText)mockXmlTreeView.Document.SelectSingleNode("/root/child/text()");
+			mockXmlTreeView.SelectedTextNode = textNode;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = null;
+			
+			editor.InsertCommentAfter();
+			
+			XmlComment comment = (XmlComment)textNode.NextSibling;
+			
+			Assert.AreEqual(String.Empty, comment.InnerText);
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.AreEqual(1, mockXmlTreeView.CommentNodesInsertedAfter.Count);
+			Assert.AreSame(comment, mockXmlTreeView.CommentNodesInsertedAfter[0]);
+		}
+		
+		[Test]
+		public void InsertTextNodeBeforeWhenCommentSelected()
+		{
+			AddChildCommentToChildElement();
+			
+			XmlComment comment = childElement.ChildNodes[1] as XmlComment;
+
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = comment;
+			
+			mockXmlTreeView.IsDirty = false;
+			editor.InsertTextNodeBefore();
+			
+			XmlText text = comment.PreviousSibling as XmlText;
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.IsNotNull(text);
+			Assert.AreEqual(1, mockXmlTreeView.TextNodesInsertedBefore.Count);
+			Assert.AreEqual(text, mockXmlTreeView.TextNodesInsertedBefore[0]);
+		}
+		
+		[Test]
+		public void InsertTextNodeAfterWhenCommentSelected()
+		{
+			AddChildCommentToChildElement();
+			
+			XmlComment comment = childElement.ChildNodes[1] as XmlComment;
+
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = comment;
+			
+			mockXmlTreeView.IsDirty = false;
+			editor.InsertTextNodeAfter();
+			
+			XmlText text = comment.NextSibling as XmlText;
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.IsNotNull(text);
+			Assert.AreEqual(1, mockXmlTreeView.TextNodesInsertedAfter.Count);
+			Assert.AreEqual(text, mockXmlTreeView.TextNodesInsertedAfter[0]);
+		}
+		
+		[Test]
+		public void InsertElementBeforeWhenCommentSelected()
+		{
+			AddChildCommentToChildElement();
+			
+			XmlComment comment = childElement.ChildNodes[1] as XmlComment;
+
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = comment;
+			
+			mockXmlTreeView.SelectedNewElementsToReturn.Add("new");
+			mockXmlTreeView.IsDirty = false;
+			editor.InsertElementBefore();
+			
+			XmlElement element = comment.PreviousSibling as XmlElement;
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.IsNotNull(element);
+			Assert.AreEqual("new", element.LocalName);
+			Assert.AreEqual(1, mockXmlTreeView.ElementsInsertedBefore.Count);
+			Assert.AreEqual(element, mockXmlTreeView.ElementsInsertedBefore[0]);
+		}
+		
+		[Test]
+		public void InsertElementAfterWhenCommentSelected()
+		{
+			AddChildCommentToChildElement();
+			
+			XmlComment comment = childElement.ChildNodes[1] as XmlComment;
+
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedComment = comment;
+			
+			mockXmlTreeView.SelectedNewElementsToReturn.Add("new");
+			mockXmlTreeView.IsDirty = false;
+			editor.InsertElementAfter();
+			
+			XmlElement element = comment.NextSibling as XmlElement;
+			Assert.IsTrue(mockXmlTreeView.IsDirty);
+			Assert.IsNotNull(element);
+			Assert.AreEqual("new", element.LocalName);
+			Assert.AreEqual(1, mockXmlTreeView.ElementsInsertedAfter.Count);
+			Assert.AreEqual(element, mockXmlTreeView.ElementsInsertedAfter[0]);
+		}
+		
+		protected override string GetXml()
+		{
+			return "<!-- Root comment --><root a='b'><!-- Child comment --><child>text</child></root>";
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/ExpandChildNodesInTreeControlTestFixture.cs

@@ -39,7 +39,7 @@ namespace XmlEditor.Tests.Tree
 			doc = new XmlDocument();
 			doc.LoadXml("<root><firstChild><secondChild/></firstChild><textChild>some text</textChild></root>");
 			using (XmlTreeViewControl treeView = new XmlTreeViewControl()) {
-				treeView.DocumentElement = doc.DocumentElement;
+				treeView.Document = doc;
 				treeView.SelectedNode = treeView.Nodes[0];
 				rootNodeElement = treeView.SelectedElement;
 				isRootElementSelected = treeView.IsElementSelected;

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/ExplicitNamespaceTestFixture.cs

@@ -33,7 +33,7 @@ namespace XmlEditor.Tests.Tree
 			mockXmlTreeView.SelectedElement = bodyElement;
 			mockXmlTreeView.SelectedNewElementsToReturn.Add("h1");
 
-			editor.AddChildElement();
+			editor.AppendChildElement();
 		}
 		
 		[Test]

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/MenuCommandsTestFixture.cs

@@ -267,8 +267,7 @@ namespace XmlEditor.Tests.Tree
 			XmlText newTextNode = doc.CreateTextNode(String.Empty);
 			treeView.AppendChildTextNode(newTextNode);
 			
-			XmlText textNode = bodyElement.SelectSingleNode("text()") as XmlText;
-			Assert.IsNull(textNode);
+			Assert.IsFalse(treeViewContainer.IsDirty);
 		}
 		
 		/// <summary>
@@ -396,5 +395,96 @@ namespace XmlEditor.Tests.Tree
 			Assert.IsFalse(bodyElement.HasChildNodes);
 			Assert.AreEqual(0, bodyTreeNode.Nodes.Count);
 		}
+		
+		[Test]
+		public void AddChildCommentNodeWithNullOwner()
+		{
+			AddChildCommentCommand command = new AddChildCommentCommand();
+			command.Run();
+		}
+		
+		[Test]
+		public void AddChildCommentNode()
+		{
+			treeView.SelectedNode = bodyTreeNode;
+			AddChildCommentCommand command = new AddChildCommentCommand();
+			command.Owner = treeViewContainer;
+			command.Run();
+			
+			XmlComment comment = bodyElement.SelectSingleNode("comment()") as XmlComment;
+			Assert.IsTrue(bodyElement.HasChildNodes);
+			Assert.IsNotNull(comment, "Expected a new comment node to be appended.");
+			
+			XmlCommentTreeNode treeNode = bodyTreeNode.Nodes[0] as XmlCommentTreeNode;
+			Assert.IsNotNull(treeNode);
+		}
+		
+		[Test]
+		public void RemoveCommentWithNullOwner()
+		{
+			RemoveCommentCommand command = new RemoveCommentCommand();
+			command.Run();
+		}
+		
+		[Test]
+		public void RemoveComment()
+		{
+			AddChildCommentNode();
+			
+			treeView.SelectedNode = bodyTreeNode.Nodes[0];
+
+			RemoveCommentCommand command = new RemoveCommentCommand();
+			command.Owner = treeViewContainer;
+			command.Run();
+
+			Assert.IsFalse(bodyElement.HasChildNodes);
+			Assert.AreEqual(0, bodyTreeNode.Nodes.Count);
+		}
+		
+		[Test]
+		public void InsertCommentBeforeWithNullOwner()
+		{
+			InsertCommentBeforeCommand command = new InsertCommentBeforeCommand();
+			command.Run();
+		}
+		
+		[Test]
+		public void InsertCommentAfterWithNullOwner()
+		{
+			InsertCommentAfterCommand command = new InsertCommentAfterCommand();
+			command.Run();
+		}
+		
+		[Test]
+		public void InsertCommentBefore()
+		{
+			treeView.SelectedNode = bodyTreeNode;
+			InsertCommentBeforeCommand command = new InsertCommentBeforeCommand();
+			command.Owner = treeViewContainer;
+			command.Run();
+			
+			XmlComment comment = bodyElement.PreviousSibling as XmlComment;
+			Assert.IsNotNull(comment, "Expected a new comment node to be inserted.");
+			
+			XmlCommentTreeNode treeNode = bodyTreeNode.PrevNode as XmlCommentTreeNode;
+			Assert.IsNotNull(treeNode);
+			Assert.AreSame(comment, treeNode.XmlComment);
+		}
+		
+		[Test]
+		public void InsertCommentAfter()
+		{
+			treeView.SelectedNode = bodyTreeNode;
+			InsertCommentAfterCommand command = new InsertCommentAfterCommand();
+			command.Owner = treeViewContainer;
+			command.Run();
+			
+			XmlComment comment = bodyElement.NextSibling as XmlComment;
+			Assert.IsNotNull(comment, "Expected a new comment node to be inserted.");
+			
+			XmlCommentTreeNode treeNode = bodyTreeNode.NextNode as XmlCommentTreeNode;
+			Assert.IsNotNull(treeNode);
+			Assert.AreSame(comment, treeNode.XmlComment);
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/NoMatchingSchemaTestFixture.cs

@@ -31,7 +31,7 @@ namespace XmlEditor.Tests.Tree
 			mockXmlTreeView.SelectedElement = bodyElement;
 
 			editor.AddAttribute();
-			editor.AddChildElement();
+			editor.AppendChildElement();
 		}
 		
 		/// <summary>

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/OwnerStatusTestFixture.cs

@@ -27,6 +27,7 @@ namespace XmlEditor.Tests.Tree
 		XmlElementTreeNode bodyTreeNode;
 		XmlElementTreeNode paraTreeNode;
 		XmlTextTreeNode textTreeNode;
+		XmlCommentTreeNode commentTreeNode;
 		
 		[SetUp]
 		public void Init()
@@ -38,11 +39,12 @@ namespace XmlEditor.Tests.Tree
 			XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
 			XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xhtmlSchema, String.Empty);
 			
-			treeViewContainer.LoadXml("<html><body class='a'><p>Text</p></body></html>", provider);
+			treeViewContainer.LoadXml("<!-- comment --><html><body class='a'><p>Text</p></body></html>", provider);
 			doc = treeViewContainer.Document;
 			treeView = treeViewContainer.TreeView;
 			
-			htmlTreeNode = (XmlElementTreeNode)treeView.Nodes[0];
+			commentTreeNode = (XmlCommentTreeNode)treeView.Nodes[0];
+			htmlTreeNode = (XmlElementTreeNode)treeView.Nodes[1];
 			htmlTreeNode.Expanding();
 			
 			bodyTreeNode = (XmlElementTreeNode)htmlTreeNode.Nodes[0];
@@ -115,5 +117,15 @@ namespace XmlEditor.Tests.Tree
 				treeViewContainer.InternalState,
 				"OwnerState should be TextNodeSelected.");
 		}
+		
+		[Test]
+		public void CommentNodeSelected()
+		{
+			treeView.SelectedNode = commentTreeNode;
+			
+			Assert.AreEqual(XmlTreeViewContainerControl.XmlTreeViewContainerControlState.CommentSelected, 
+				treeViewContainer.InternalState,
+				"OwnerState should be CommentSelected.");
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/RootNodeAddedToTreeControlTestFixture.cs

@@ -35,16 +35,16 @@ namespace XmlEditor.Tests.Tree
 				doc = treeViewContainer.Document;
 				XmlTreeViewControl treeView = treeViewContainer.TreeView;
 				
-				treeViewContainer.DocumentElement = doc.DocumentElement;
+				treeViewContainer.Document = doc;
 				initialElementSelected = treeView.SelectedElement;
 				initialIsElementSelected = treeView.IsElementSelected;
 				
 				// Set the document element again to make sure the existing node 
 				// is removed.
 				doc.LoadXml("<root/>");
-				treeViewContainer.DocumentElement = null;
-				treeViewContainer.DocumentElement = doc.DocumentElement;
-				documentElement = treeViewContainer.DocumentElement;
+				treeViewContainer.Document = null;
+				treeViewContainer.Document = doc;
+				documentElement = treeViewContainer.Document.DocumentElement;
 				
 				rootNode = (XmlElementTreeNode)treeView.Nodes[0];
 				nodeCount = treeView.Nodes.Count;

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/TextNodeTextChangedTestFixture.cs

@@ -27,19 +27,19 @@ namespace XmlEditor.Tests.Tree
 			base.InitFixture();
 			
 			// User selects text node and alters its text.
-			textNode = (XmlText)mockXmlTreeView.DocumentElement.FirstChild;
+			textNode = (XmlText)mockXmlTreeView.Document.DocumentElement.FirstChild;
 			mockXmlTreeView.SelectedTextNode = textNode;
-			editor.SelectedTextNodeChanged();
-			mockXmlTreeView.TextContentDisplayed = "new value";
+			editor.SelectedNodeChanged();
+			mockXmlTreeView.TextContent = "new value";
 			editor.TextContentChanged();
 			
 			// The user then selects another element and then switches
 			// back to the text node.
-			mockXmlTreeView.SelectedElement = mockXmlTreeView.DocumentElement;
-			editor.SelectedElementChanged();
-			mockXmlTreeView.TextContentDisplayed = String.Empty;
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
+			mockXmlTreeView.TextContent = String.Empty;
 			mockXmlTreeView.SelectedTextNode = textNode;
-			editor.SelectedTextNodeChanged();
+			editor.SelectedNodeChanged();
 		}
 		
 		[Test]
@@ -51,7 +51,7 @@ namespace XmlEditor.Tests.Tree
 		[Test]
 		public void TextContentDisplayed()
 		{
-			Assert.AreEqual("new value", mockXmlTreeView.TextContentDisplayed);
+			Assert.AreEqual("new value", mockXmlTreeView.TextContent);
 		}
 		
 		[Test]
@@ -85,9 +85,33 @@ namespace XmlEditor.Tests.Tree
 			Assert.AreEqual(textNode, mockXmlTreeView.TextNodesUpdated[0]);
 		}
 		
+		[Test]
+		public void TextContentClearedAfterElementSelected()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.ShowTextContent("Test");
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
+			Assert.AreEqual(String.Empty, mockXmlTreeView.TextContent);
+		}
+		
+		[Test]
+		public void AttributesClearedAfterTextNodeSelected()
+		{
+			mockXmlTreeView.SelectedTextNode = null;
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
+			Assert.IsTrue(mockXmlTreeView.AttributesDisplayed.Count > 0);
+			
+			mockXmlTreeView.SelectedElement = null;
+			mockXmlTreeView.SelectedTextNode = textNode;
+			editor.SelectedNodeChanged();
+			Assert.IsFalse(mockXmlTreeView.AttributesDisplayed.Count > 0);
+		}
+		
 		protected override string GetXml()
 		{
-			return "<root>text</root>";
+			return "<root a='b'>text</root>";
 		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/TreeControlViewStateTestFixture.cs

@@ -29,7 +29,7 @@ namespace XmlEditor.Tests.Tree
 			
 			// Save view state.
 			using (XmlTreeViewControl treeView = new XmlTreeViewControl()) {
-				treeView.DocumentElement = doc.DocumentElement;
+				treeView.Document = doc;
 				ExtTreeNode node = (ExtTreeNode)treeView.Nodes[0];
 				node.Expanding();
 				expectedSavedViewState = ExtTreeView.GetViewStateString(treeView);
@@ -38,7 +38,7 @@ namespace XmlEditor.Tests.Tree
 			
 			// Load view state.
 			using (XmlTreeViewControl treeView = new XmlTreeViewControl()) {
-				treeView.DocumentElement = doc.DocumentElement;
+				treeView.Document = doc;
 				ExtTreeNode node = (ExtTreeNode)treeView.Nodes[0];
 				node.Expanding();
 				treeView.RestoreViewState(restoredProperties);				

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/XmlCommentTreeNodeTests.cs

@@ -0,0 +1,62 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Xml;
+using ICSharpCode.XmlEditor;
+using NUnit.Framework;
+
+namespace XmlEditor.Tests.Tree
+{
+	/// <summary>
+	/// Tests the XmlCommentTreeNode class.
+	/// </summary>
+	[TestFixture]
+	public class XmlCommentTreeNodeTests
+	{
+		XmlDocument doc;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			doc = new XmlDocument();
+			doc.LoadXml("<root/>");
+		}
+	
+		[Test]
+		public void WhiteSpaceRemoved()
+		{
+			XmlComment comment = doc.CreateComment("  \t\tTest\t\t   ");
+			XmlCommentTreeNode node = new XmlCommentTreeNode(comment);
+			Assert.AreEqual("Test", node.Text);
+		}
+		
+		[Test]
+		public void ImageKey()
+		{
+			XmlComment comment = doc.CreateComment(String.Empty);
+			XmlCommentTreeNode node = new XmlCommentTreeNode(comment);
+			Assert.AreEqual(XmlCommentTreeNode.XmlCommentTreeNodeImageKey, node.ImageKey);
+		}
+		
+		[Test]
+		public void SelectedImageKey()
+		{
+			XmlComment comment = doc.CreateComment(String.Empty);
+			XmlCommentTreeNode node = new XmlCommentTreeNode(comment);
+			Assert.AreEqual(XmlCommentTreeNode.XmlCommentTreeNodeImageKey, node.SelectedImageKey);
+		}
+		
+		[Test]
+		public void XmlCommentIsSame()
+		{
+			XmlComment comment = doc.CreateComment(String.Empty);
+			XmlCommentTreeNode node = new XmlCommentTreeNode(comment);
+			Assert.AreSame(comment, node.XmlComment);
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/XmlElementSelectedTestFixture.cs

@@ -24,8 +24,8 @@ namespace XmlEditor.Tests.Tree
 		public void SetUpFixture()
 		{
 			base.InitFixture();
-			mockXmlTreeView.SelectedElement = mockXmlTreeView.DocumentElement;
-			editor.SelectedElementChanged();
+			mockXmlTreeView.SelectedElement = mockXmlTreeView.Document.DocumentElement;
+			editor.SelectedNodeChanged();
 		}
 		
 		[Test]
@@ -50,10 +50,21 @@ namespace XmlEditor.Tests.Tree
 		public void NoElementSelected()
 		{
 			mockXmlTreeView.SelectedElement = null;
-			editor.SelectedElementChanged();
+			editor.SelectedNodeChanged();
 			Assert.AreEqual(0, mockXmlTreeView.AttributesDisplayed.Count);
 		}
 		
+		/// <summary>
+		/// When the node has changed the text content should
+		/// not have been updated otherwise the TextBox control
+		/// may be on top instead of the attributes grid.
+		/// </summary>
+		[Test]
+		public void ShowTextContentNotCalled()
+		{
+			Assert.IsFalse(mockXmlTreeView.IsShowTextContentCalled);
+		}
+		
 		protected override string GetXml()
 		{
 			return "<root first='a' second='b'/>";

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/XmlTextSelectedTestFixture.cs

@@ -23,22 +23,22 @@ namespace XmlEditor.Tests.Tree
 		public void SetUpFixture()
 		{
 			base.InitFixture();
-			mockXmlTreeView.SelectedTextNode = (XmlText)mockXmlTreeView.DocumentElement.FirstChild;
-			editor.SelectedTextNodeChanged();
+			mockXmlTreeView.SelectedTextNode = (XmlText)mockXmlTreeView.Document.DocumentElement.FirstChild;
+			editor.SelectedNodeChanged();
 		}
 		
 		[Test]
 		public void IsViewShowingText()
 		{
-			Assert.AreEqual("text here", mockXmlTreeView.TextContentDisplayed);
+			Assert.AreEqual("text here", mockXmlTreeView.TextContent);
 		}
 		
 		[Test]
 		public void TextNodeNotSelected()
 		{
 			mockXmlTreeView.SelectedTextNode = null;
-			editor.SelectedTextNodeChanged();
-			Assert.AreEqual(String.Empty, mockXmlTreeView.TextContentDisplayed);
+			editor.SelectedNodeChanged();
+			Assert.AreEqual(String.Empty, mockXmlTreeView.TextContent);
 		}
 	
 		protected override string GetXml()

src/AddIns/DisplayBindings/XmlEditor/Test/Tree/XmlTreeViewContainerTestFixture.cs

@@ -248,7 +248,6 @@ namespace XmlEditor.Tests.Tree
 			Assert.AreEqual("New value", textTreeNode.Text);
 		}
 		
-		
 		/// <summary>
 		/// Check that the DirtyChanged event is not fired
 		/// </summary>
@@ -326,6 +325,43 @@ namespace XmlEditor.Tests.Tree
 			Assert.AreEqual("id", attributesGrid.SelectedGridItem.Label);
 		}
 		
+		[Test]
+		public void XmlElementTreeNodeImageKey()
+		{
+			Assert.IsTrue(treeView.ImageList.Images.ContainsKey(XmlTextTreeNode.XmlTextTreeNodeImageKey));
+		}
+		
+		[Test]
+		public void XmlTextTreeNodeImageKey()
+		{
+			Assert.IsTrue(treeView.ImageList.Images.ContainsKey(XmlElementTreeNode.XmlElementTreeNodeImageKey));
+		}
+		
+		[Test]
+		public void XmlCommentTreeNodeImageKey()
+		{
+			Assert.IsTrue(treeView.ImageList.Images.ContainsKey(XmlCommentTreeNode.XmlCommentTreeNodeImageKey));
+		}
+		
+		/// <summary>
+		/// Checks that setting the TextContent property updates
+		/// the text in the text box.
+		/// </summary>
+		[Test]
+		public void TextBoxChanged()
+		{
+			treeViewContainer.TextContent = "Test";
+			Assert.AreEqual("Test", textBox.Text);
+		}
+		
+		[Test]
+		public void DocumentMatches()
+		{
+			XmlDocument doc = new XmlDocument();
+			treeView.Document = doc;
+			Assert.AreSame(doc, treeView.Document);
+		}
+		
 		void TreeViewContainerDirtyChanged(object source, EventArgs e)
 		{
 			dirtyChanged = true;

src/AddIns/DisplayBindings/XmlEditor/Test/Utils/MockXmlTreeView.cs

@@ -16,10 +16,11 @@ namespace XmlEditor.Tests.Utils
 	{
 		bool notWellFormedMessageDisplayed;
 		XmlException notWellFormedException;
-		XmlElement documentElement;
+		XmlDocument document;
 		XmlElement selectedElement;
 		List<XmlAttribute> attributesDisplayed = new List<XmlAttribute>();
 		string textContentDisplayed;
+		bool showTextContentCalled;
 		XmlText selectedTextNode;
 		bool dirty;
 		bool selectNewAttributesCalled = false;
@@ -38,6 +39,12 @@ namespace XmlEditor.Tests.Utils
 		List<XmlText> textNodesInsertedAfter = new List<XmlText>();
 		List<XmlText> textNodesRemoved = new List<XmlText>();
 		List<XmlText> textNodesUpdated = new List<XmlText>();
+		XmlComment selectedCommentNode;
+		List<XmlComment> commentNodesUpdated = new List<XmlComment>();
+		List<XmlComment> childCommentNodesAdded = new List<XmlComment>();
+		List<XmlComment> commentNodesRemoved = new List<XmlComment>();
+		List<XmlComment> commentNodesInsertedBefore = new List<XmlComment>();
+		List<XmlComment> commentNodesInsertedAfter = new List<XmlComment>();
 		
 		public MockXmlTreeView()
 		{
@@ -58,12 +65,12 @@ namespace XmlEditor.Tests.Utils
 			}
 		}
 		
-		public XmlElement DocumentElement {
+		public XmlDocument Document {
 			get {
-				return documentElement;
+				return document;
 			}
 			set {
-				documentElement = value;
+				document = value;
 			}
 		}
 		
@@ -84,6 +91,15 @@ namespace XmlEditor.Tests.Utils
 				selectedTextNode = value;
 			}
 		}
+		
+		public XmlComment SelectedComment {
+			get {
+				return selectedCommentNode;
+			}
+			set {
+				selectedCommentNode = value;
+			}
+		}
 
 		public void ShowAttributes(XmlAttributeCollection attributes)
 		{
@@ -100,6 +116,7 @@ namespace XmlEditor.Tests.Utils
 		
 		public void ShowTextContent(string text)
 		{
+			showTextContentCalled = true;
 			textContentDisplayed = text;
 		}
 				
@@ -171,19 +188,32 @@ namespace XmlEditor.Tests.Utils
 			textNodesUpdated.Add(textNode);
 		}
 		
-		public string TextContent {
-			get {
-				return textContentDisplayed;
-			}
+		public void UpdateComment(XmlComment comment)
+		{
+			commentNodesUpdated.Add(comment);
 		}
 		
-		public List<XmlAttribute> AttributesDisplayed {
-			get {
-				return attributesDisplayed;
-			}
+		public void AppendChildComment(XmlComment comment)
+		{
+			childCommentNodesAdded.Add(comment);
+		}
+		
+		public void RemoveComment(XmlComment comment)
+		{
+			commentNodesRemoved.Add(comment);
+		}
+		
+		public void InsertCommentBefore(XmlComment comment)
+		{
+			commentNodesInsertedBefore.Add(comment);
 		}
 		
-		public string TextContentDisplayed {
+		public void InsertCommentAfter(XmlComment comment)
+		{
+			commentNodesInsertedAfter.Add(comment);
+		}
+		
+		public string TextContent {
 			get {
 				return textContentDisplayed;
 			}
@@ -192,6 +222,12 @@ namespace XmlEditor.Tests.Utils
 			}
 		}
 		
+		public List<XmlAttribute> AttributesDisplayed {
+			get {
+				return attributesDisplayed;
+			}
+		}
+	
 		public bool IsXmlNotWellFormedMessageDisplayed {
 			get {
 				return notWellFormedMessageDisplayed;
@@ -357,5 +393,65 @@ namespace XmlEditor.Tests.Utils
 				return textNodesUpdated;
 			}
 		}
+		
+		/// <summary>
+		/// Returns a flag indicating whether the ShowTextContent
+		/// method was called.
+		/// </summary>
+		public bool IsShowTextContentCalled {
+			get {
+				return showTextContentCalled;
+			}
+		}
+		
+		/// <summary>
+		/// Returns the comment nodes that were updated via the
+		/// UpdateCommentNode method.
+		/// </summary>
+		public List<XmlComment> CommentNodesUpdated {
+			get {
+				return commentNodesUpdated;
+			}
+		}
+		
+		/// <summary>
+		/// Returns the comment nodes that were added via the
+		/// AddChildComment method.
+		/// </summary>
+		public List<XmlComment> ChildCommentNodesAdded {
+			get {
+				return childCommentNodesAdded;
+			}
+		}
+		
+		/// <summary>
+		/// Returns the comment nodes that were removed via the
+		/// RemoveComment method.
+		/// </summary>
+		public List<XmlComment> CommentNodesRemoved {
+			get {
+				return commentNodesRemoved;
+			}
+		}
+				
+		/// <summary>
+		/// Returns the comment nodes that were inserted via the
+		/// InsertCommentBefore method.
+		/// </summary>
+		public List<XmlComment> CommentNodesInsertedBefore {
+			get {
+				return commentNodesInsertedBefore;
+			}
+		}
+		
+		/// <summary>
+		/// Returns the comment nodes that were inserted via the
+		/// InsertCommentAfter method.
+		/// </summary>
+		public List<XmlComment> CommentNodesInsertedAfter {
+			get {
+				return commentNodesInsertedAfter;
+			}
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/XmlEditor.Tests.csproj

@@ -71,6 +71,8 @@
     <Compile Include="Schema\NestedChoiceTestFixture.cs" />
     <Compile Include="Schema\ChildElementAttributesTestFixture.cs" />
     <Compile Include="Tree\AddChildTextNodeTestFixture.cs" />
+    <Compile Include="Tree\EditCommentNodesInTreeControlTestFixture.cs" />
+    <Compile Include="Tree\EditCommentNodesTestFixture.cs" />
     <Compile Include="Tree\InsertTextNodeAfterTestFixture.cs" />
     <Compile Include="Tree\InsertTextNodeBeforeTestFixture.cs" />
     <Compile Include="Tree\MenuCommandsTestFixture.cs" />
@@ -80,6 +82,7 @@
     <Compile Include="Tree\RemoveElementTestFixture.cs" />
     <Compile Include="Tree\RemoveTextNodesFromTreeControlTestFixture.cs" />
     <Compile Include="Tree\RemoveTextNodeTestFixture.cs" />
+    <Compile Include="Tree\XmlCommentTreeNodeTests.cs" />
     <Compile Include="Tree\XmlTreeViewContainerTestFixture.cs" />
     <Compile Include="Utils\DerivedXmlTreeView.cs" />
     <Compile Include="Utils\DerivedXmlTreeViewContainerControl.cs" />

src/Main/Base/Project/Src/Gui/Components/ExtTreeView/ExtTreeNode.cs

@@ -77,6 +77,12 @@ namespace ICSharpCode.SharpDevelop.Gui
 			parentNode.Nodes.Insert(index, this);
 		}
 		
+		public void Insert(int index, TreeView view)
+		{
+			internalParent = null;
+			view.Nodes.Insert(index, this);
+		}
+		
 		void AddTo(TreeNodeCollection nodes)
 		{
 			nodes.Add(this);