Fixed problems with the XML Editor's XmlParser class preventing the XamlExpressionFinder from correctly identifying an attribute or element in a different namespace. The GetActiveElementStartPath, GetParentElementPath and GetQualifiedAttributeName all now correctly determine the namespace of the element or attribute if the xml has mixed namespaces.

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

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

@@ -87,36 +87,41 @@ namespace ICSharpCode.XmlEditor
 		/// Gets the namespace of the qualified name.
 		/// </summary>
 		public string Namespace {
-			get {
-				return xmlQualifiedName.Namespace;
-			}
-			set {
-				xmlQualifiedName = new XmlQualifiedName(xmlQualifiedName.Name, value);
-			}
+			get { return xmlQualifiedName.Namespace; }
+			set { xmlQualifiedName = new XmlQualifiedName(xmlQualifiedName.Name, value); }
 		}
 		
 		/// <summary>
 		/// Gets the name of the element.
 		/// </summary>
 		public string Name {
-			get {
-				return xmlQualifiedName.Name;
-			}
-			set {
-				xmlQualifiedName = new XmlQualifiedName(value, xmlQualifiedName.Namespace);
-			}
+			get { return xmlQualifiedName.Name; }
+			set { xmlQualifiedName = new XmlQualifiedName(value, xmlQualifiedName.Namespace); }
 		}
 		
 		/// <summary>
 		/// Gets the namespace prefix used.
 		/// </summary>
 		public string Prefix {
-			get {
-				return prefix;
-			}
-			set {
-				prefix = value;
+			get { return prefix; }
+			set { prefix = value; }
+		}
+		
+		/// <summary>
+		/// Returns a string that represents the QualifiedName.
+		/// </summary>
+		public override string ToString()
+		{			
+			if (xmlQualifiedName.Namespace.Length > 0) {
+				string prefixToString = String.Empty;
+				if (!String.IsNullOrEmpty(prefix)) {
+					prefixToString = prefix + ":";
+				}
+				return String.Concat(prefixToString, xmlQualifiedName.Name, " [", xmlQualifiedName.Namespace, "]");
+			} else if (!String.IsNullOrEmpty(prefix)) {
+				return prefix + ":" + xmlQualifiedName.Name;
 			}
+			return xmlQualifiedName.Name;
 		}
 	}
 }

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

@@ -207,14 +207,11 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		public string LastPrefix {
 			get {
-				string prefix = String.Empty;
-				
 				if (Count > 0) {
 					QualifiedName name = this[Count - 1];
-					prefix = name.Prefix;
+					return name.Prefix;
 				}
-				
-				return prefix;
+				return String.Empty;
 			}
 		}
 		

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

@@ -6,6 +6,7 @@
 // </file>
 
 using System;
+using System.Text;
 
 namespace ICSharpCode.XmlEditor
 {
@@ -26,9 +27,7 @@ namespace ICSharpCode.XmlEditor
 		/// </summary>
 		/// <remarks>The order of the elements determines the path.</remarks>
 		public QualifiedNameCollection Elements {
-			get {
-				return elements;
-			}
+			get { return elements; }
 		}
 		
 		/// <summary>
@@ -55,8 +54,8 @@ namespace ICSharpCode.XmlEditor
 		/// An xml element path is considered to be equal if 
 		/// each path item has the same name and namespace.
 		/// </summary>
-		public override bool Equals(object obj) {
-			
+		public override bool Equals(object obj) 
+		{	
 			if (!(obj is XmlElementPath)) return false;
 			if (this == obj) return true;
 			
@@ -74,10 +73,34 @@ namespace ICSharpCode.XmlEditor
 			return false;
 		}
 		
-		public override int GetHashCode() {
+		public override int GetHashCode() 
+		{
 			return elements.GetHashCode();
 		}
 		
+		
+		/// <summary>
+		/// Gets a string that represents the XmlElementPath.
+		/// </summary>
+		public override string ToString()
+		{
+			if (elements.Count > 0) {
+				StringBuilder toString = new StringBuilder();
+				int lastIndex = elements.Count - 1;
+				for (int i = 0; i < elements.Count; ++i) {
+					string elementToString = GetElementToString(elements[i]);
+					if (i == lastIndex) {
+						toString.Append(elementToString);
+					} else {
+						toString.Append(elementToString);
+						toString.Append(" > ");
+					}
+				}
+				return toString.ToString();
+			}
+			return String.Empty;
+		}
+		
 		/// <summary>
 		/// Removes elements up to and including the specified index.
 		/// </summary>
@@ -109,5 +132,18 @@ namespace ICSharpCode.XmlEditor
 			}
 			return index;
 		}
+		
+		/// <summary>
+		/// Returns the qualified name as a string. If the name has a 
+		/// prefix then it returns "prefix:element" otherwise it returns
+		/// just the element name.
+		/// </summary>
+		static string GetElementToString(QualifiedName name)
+		{
+			if (name.Prefix.Length > 0) {
+				return name.Prefix + ":" + name.Name;
+			}
+			return name.Name;
+		}
 	}
 }

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

@@ -6,6 +6,7 @@
 // </file>
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Text;
@@ -45,18 +46,12 @@ namespace ICSharpCode.XmlEditor
 			}
 			
 			public string Namespace {
-				get {
-					return namespaceURI;
-				}
-				set {
-					namespaceURI = value;
-				}
+				get { return namespaceURI; }
+				set { namespaceURI = value; }
 			}
 			
 			public string Prefix {
-				get {
-					return prefix;
-				}
+				get { return prefix; }
 				set {
 					prefix = value;
 					if (prefix == null) {
@@ -64,12 +59,20 @@ namespace ICSharpCode.XmlEditor
 					}
 				}
 			}
+			
+			public override string ToString()
+			{
+				if (!String.IsNullOrEmpty(prefix)) {
+					return prefix + ":" + namespaceURI;
+				}
+				return namespaceURI;
+			}
 		}
 		
 		XmlParser()
 		{
 		}
-		
+
 		/// <summary>
 		/// Gets path of the xml element start tag that the specified 
 		/// <paramref name="index"/> is currently inside.
@@ -78,30 +81,10 @@ namespace ICSharpCode.XmlEditor
 		/// is returned.</remarks>
 		public static XmlElementPath GetActiveElementStartPath(string xml, int index)
 		{
-			XmlElementPath path = new XmlElementPath();
-			
-			string elementText = GetActiveElementStartText(xml, index);
-			
-			if (elementText != null) {
-				QualifiedName elementName = GetElementName(elementText);
-				NamespaceURI elementNamespace = GetElementNamespace(elementText);
-							
-				path = GetParentElementPath(xml.Substring(0, index));
-				if (elementNamespace.Namespace.Length == 0) {
-					if (path.Elements.Count > 0) {
-						QualifiedName parentName = path.Elements[path.Elements.Count - 1];
-						elementNamespace.Namespace = parentName.Namespace;
-						elementNamespace.Prefix = parentName.Prefix;
-					}
-				}
-				
-				path.Elements.Add(new QualifiedName(elementName.Name, elementNamespace.Namespace, elementNamespace.Prefix));		
-				path.Compact();
-			}
-			
-			return path;
+			QualifiedNameCollection namespaces = new QualifiedNameCollection();
+			return GetActiveElementStartPath(xml, index, namespaces);
 		}
-		
+				
 		/// <summary>
 		/// Gets path of the xml element start tag that the specified 
 		/// <paramref name="index"/> is currently located. This is different to the
@@ -112,56 +95,21 @@ namespace ICSharpCode.XmlEditor
 		/// is returned.</remarks>
 		public static XmlElementPath GetActiveElementStartPathAtIndex(string xml, int index)
 		{
-			// Find first non xml element name character to the right of the index.
-			index = GetCorrectedIndex(xml.Length, index);
-			int currentIndex = index;
-			for (; currentIndex < xml.Length; ++currentIndex) {
-				char ch = xml[currentIndex];
-				if (!IsXmlNameChar(ch)) {
-					break;
-				}
-			}
-		
-			string elementText = GetElementNameAtIndex(xml, currentIndex);
-			if (elementText != null) {
-				return GetActiveElementStartPath(xml, currentIndex, elementText);
-			}
-			return new XmlElementPath();
+			QualifiedNameCollection namespaces = new QualifiedNameCollection();
+			return GetActiveElementStartPathAtIndex(xml, index, namespaces);
 		}
-		
+
 		/// <summary>
 		/// Gets the parent element path based on the index position.
 		/// </summary>
 		public static XmlElementPath GetParentElementPath(string xml)
 		{
-			XmlElementPath path = new XmlElementPath();
-			
-			try {
-				StringReader reader = new StringReader(xml);
-				XmlTextReader xmlReader = new XmlTextReader(reader);
-				xmlReader.XmlResolver = null; // prevent XmlTextReader from loading external DTDs
-				while (xmlReader.Read()) {
-					switch (xmlReader.NodeType) {
-						case XmlNodeType.Element:
-							if (!xmlReader.IsEmptyElement) {
-								QualifiedName elementName = new QualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Prefix);
-								path.Elements.Add(elementName);
-							}
-							break;
-						case XmlNodeType.EndElement:
-							path.Elements.RemoveLast();
-							break;
-					}
-				}
-			} catch (XmlException) { 
-				// Do nothing.
-			}
-			
+			QualifiedNameCollection namespaces = new QualifiedNameCollection();
+			XmlElementPath path = GetFullParentElementPath(xml, namespaces);
 			path.Compact();
-			
 			return path;
-		}			
-		
+		}
+				
 		/// <summary>
 		/// Checks whether the attribute at the end of the string is a 
 		/// namespace declaration.
@@ -242,15 +190,32 @@ namespace ICSharpCode.XmlEditor
 			index = GetCorrectedIndex(xml.Length, index);
 			return GetAttributeName(xml, index, true, true, true);
 		}
+
+		/// <summary>
+		/// Gets the name of the attribute and its prefix at the specified index. The index
+		/// can be anywhere inside the attribute name or in the attribute value. 
+		/// The namespace for the element containing the attribute will also be determined
+		/// if the includeNamespace flag is set to true.
+		/// </summary>
+		public static QualifiedName GetQualifiedAttributeNameAtIndex(string xml, int index, bool includeNamespace)
+		{
+			string name = GetAttributeNameAtIndex(xml, index);
+			QualifiedName qualifiedName = GetQualifiedName(name);
+			if (String.IsNullOrEmpty(qualifiedName.Namespace) && includeNamespace) {
+				QualifiedNameCollection namespaces = new QualifiedNameCollection();
+				XmlElementPath path = GetActiveElementStartPathAtIndex(xml, index, namespaces);
+				qualifiedName.Namespace = GetNamespaceForPrefix(namespaces, path.Elements.LastPrefix);
+			}
+			return qualifiedName;
+		}
 		
 		/// <summary>
 		/// Gets the name of the attribute and its prefix at the specified index. The index
-		/// can be anywhere inside the attribute name or in the attribute value.
+		/// can be anywhere inside the attribute name or in the attribute value. 
 		/// </summary>
 		public static QualifiedName GetQualifiedAttributeNameAtIndex(string xml, int index)
 		{
-			string name = GetAttributeNameAtIndex(xml, index);
-			return GetQualifiedName(name);
+			return GetQualifiedAttributeNameAtIndex(xml, index, false);
 		}
 		
 		/// <summary>
@@ -601,12 +566,20 @@ namespace ICSharpCode.XmlEditor
 		/// <summary>
 		/// Gets the active element path given the element text.
 		/// </summary>
-		static XmlElementPath GetActiveElementStartPath(string xml, int index, string elementText)
+		static XmlElementPath GetActiveElementStartPath(string xml, int index, string elementText, QualifiedNameCollection namespaces)
 		{
 			QualifiedName elementName = GetElementName(elementText);
 			NamespaceURI elementNamespace = GetElementNamespace(elementText);
 						
-			XmlElementPath path = GetParentElementPath(xml.Substring(0, index));
+			XmlElementPath path = GetFullParentElementPath(xml.Substring(0, index), namespaces);
+			
+			// Try to get a namespace for the active element's prefix.
+			if (elementName.Prefix.Length > 0 && elementNamespace.Namespace.Length == 0) {
+				elementName.Namespace = GetNamespaceForPrefix(namespaces, elementName.Prefix);
+				elementNamespace.Namespace = elementName.Namespace;
+				elementNamespace.Prefix = elementName.Prefix;
+			}
+			
 			if (elementNamespace.Namespace.Length == 0) {
 				if (path.Elements.Count > 0) {
 					QualifiedName parentName = path.Elements[path.Elements.Count - 1];
@@ -712,6 +685,106 @@ namespace ICSharpCode.XmlEditor
 			}
 			return qualifiedName;
 		}
+	
+		/// <summary>
+		/// Gets the parent element path based on the index position. This
+		/// method does not compact the path so it will include all elements
+		/// including those in another namespace in the path.
+		/// </summary>
+		static XmlElementPath GetFullParentElementPath(string xml, QualifiedNameCollection namespaces)
+		{
+			XmlElementPath path = new XmlElementPath();
+			IDictionary<string,string> namespacesInScope = null;
+			using (StringReader reader = new StringReader(xml)) {
+				using (XmlTextReader xmlReader = new XmlTextReader(reader)) {
+					try {
+						xmlReader.XmlResolver = null; // prevent XmlTextReader from loading external DTDs
+						while (xmlReader.Read()) {
+							switch (xmlReader.NodeType) {
+								case XmlNodeType.Element:
+									if (!xmlReader.IsEmptyElement) {
+										QualifiedName elementName = new QualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Prefix);
+										path.Elements.Add(elementName);
+									}
+									break;
+								case XmlNodeType.EndElement:
+									path.Elements.RemoveLast();
+									break;
+							}
+						}
+					} catch (XmlException) { 
+						namespacesInScope = xmlReader.GetNamespacesInScope(XmlNamespaceScope.All);
+					}
+				}
+			}
+			
+			// Add namespaces in scope for the last element read.
+			if (namespacesInScope != null) {
+				foreach (KeyValuePair<string, string> ns in namespacesInScope) {
+					namespaces.Add(new QualifiedName(String.Empty, ns.Value, ns.Key));
+				}
+			}
+			
+			return path;
+		}
+			
+		/// <summary>
+		/// Finds the namespace for the specified prefix.
+		/// </summary>
+		static string GetNamespaceForPrefix(QualifiedNameCollection namespaces, string prefix)
+		{
+			foreach (QualifiedName name in namespaces) {
+				if (name.Prefix == prefix) {
+					return name.Namespace;
+				}
+			}
+			return String.Empty;
+		}
+		
+		/// <summary>
+		/// Gets path of the xml element start tag that the specified 
+		/// <paramref name="index"/> is currently inside.
+		/// </summary>
+		/// <remarks>If the index outside the start tag then an empty path
+		/// is returned.</remarks>
+		/// <param name="namespaces">Returns the namespaces that are
+		/// exist in the xml.</param>
+		static XmlElementPath GetActiveElementStartPath(string xml, int index, QualifiedNameCollection namespaces)
+		{
+			XmlElementPath path = new XmlElementPath();
+			string elementText = GetActiveElementStartText(xml, index);
+			if (elementText != null) {
+				path = GetActiveElementStartPath(xml, index, elementText, namespaces);
+			}
+			return path;
+		}		
+		
+		/// <summary>
+		/// Gets path of the xml element start tag that the specified 
+		/// <paramref name="index"/> is currently located. This is different to the
+		/// GetActiveElementStartPath method since the index can be inside the element 
+		/// name.
+		/// </summary>
+		/// <remarks>If the index outside the start tag then an empty path
+		/// is returned.</remarks>
+		static XmlElementPath GetActiveElementStartPathAtIndex(string xml, int index, QualifiedNameCollection namespaces)
+		{
+			// Find first non xml element name character to the right of the index.
+			index = GetCorrectedIndex(xml.Length, index);
+			int currentIndex = index;
+			for (; currentIndex < xml.Length; ++currentIndex) {
+				char ch = xml[currentIndex];
+				if (!IsXmlNameChar(ch)) {
+					break;
+				}
+			}
+		
+			string elementText = GetElementNameAtIndex(xml, currentIndex);
+			if (elementText != null) {
+				return GetActiveElementStartPath(xml, currentIndex, elementText, namespaces);
+			}
+			return new XmlElementPath();
+		}		
 	}
 }
 

src/AddIns/DisplayBindings/XmlEditor/Test/Parser/XamlMixedNamespaceTestFixture.cs

@@ -0,0 +1,87 @@
+// <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.XmlEditor;
+using NUnit.Framework;
+
+namespace XmlEditor.Tests.Parser
+{
+	/// <summary>
+	/// The XmlParser does not find the correct path when the first
+	/// element of a namespace is under the current cursor position. It 
+	/// incorrectly uses the namespace of the parent element even though
+	/// the element itself has its own prefix.
+	/// </summary>
+	[TestFixture]
+	public class XamlMixedNamespaceTestFixture
+	{
+		string xaml = "<Window\r\n" +
+						"	x:Class=\"DefaultNamespace.Window2\" xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\" xmlns:designer=\"clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer\"\r\n" +
+						"	Title=\"DefaultNamespace\"\r\n" +
+						"	Height=\"300\"\r\n" +
+						"	Width=\"300\">\r\n" +
+						"	<Grid>\r\n" +
+						"		<TabControl\r\n" +
+						"			TabStripPlacement=\"Bottom\"\r\n" +
+						"			Name=\"tabControl\"\r\n" +
+						"			SelectionChanged=\"tabControlSelectionChanged\"\r\n" +
+						"			Grid.Column=\"0\">\r\n" +
+						"			<TabItem\r\n" +
+						"				Header=\"Design\"\r\n" +
+						"				Name=\"designTab\">\r\n" +
+						"				<designer:DesignSurface\r\n" +
+						"					Name=\"designSurface\"/>\r\n" +
+						"			</TabItem>\r\n" +
+						"		</TabControl>\r\n" +
+						"	</Grid>\r\n" +
+						"</Window>";
+
+		XmlElementPath designSurfacePath;
+		XmlElementPath designSurfacePath2;
+		QualifiedName designSurfaceNameAttribute;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			// Get the path for the DesignSurface element.
+			int index = xaml.IndexOf("designer:DesignSurface");
+			designSurfacePath = XmlParser.GetActiveElementStartPathAtIndex(xaml, index);
+			designSurfacePath2 = XmlParser.GetActiveElementStartPath(xaml, index);
+			
+			// Get the path for the DesignSurface/@Name attribute.
+			index = xaml.IndexOf("Name=\"designSurface\"");
+			designSurfaceNameAttribute = XmlParser.GetQualifiedAttributeNameAtIndex(xaml, index, true);
+		}
+		
+		[Test]
+		public void DesignSurfacePath()
+		{
+			XmlElementPath expectedPath = new XmlElementPath();
+			expectedPath.Elements.Add(new QualifiedName("DesignSurface", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", "designer"));
+			
+			Assert.AreEqual(expectedPath, designSurfacePath);
+		}
+
+		[Test]
+		public void DesignSurfacePath2()
+		{
+			XmlElementPath expectedPath = new XmlElementPath();
+			expectedPath.Elements.Add(new QualifiedName("DesignSurface", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", "designer"));
+			
+			Assert.AreEqual(expectedPath, designSurfacePath2);
+		}
+		
+		[Test]
+		public void DesignSurfaceNameAttribute()
+		{
+			QualifiedName expectedName = new QualifiedName("Name", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", String.Empty);
+			
+			Assert.AreEqual(expectedName, designSurfaceNameAttribute);
+		}
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NoElementPathTestFixture.cs

@@ -71,5 +71,12 @@ namespace XmlEditor.Tests.Paths
 		{
 			Assert.AreEqual(path.Elements.GetHashCode(), path.GetHashCode());
 		}
+		
+		[Test]
+		public void PathToString()
+		{
+			string expectedToString = String.Empty;
+			Assert.AreEqual(expectedToString, path.ToString());
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/Paths/QualifiedNameToStringTests.cs

@@ -0,0 +1,70 @@
+// <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.XmlEditor;
+using NUnit.Framework;
+
+namespace XmlEditor.Tests.Paths
+{
+	/// <summary>
+	/// Tests the QualifiedName.ToString method.
+	/// </summary>
+	[TestFixture]
+	public class QualifiedNameToStringTests
+	{
+		[Test]
+		public void EmptyQualifiedName()
+		{
+			QualifiedName name = new QualifiedName();
+			Assert.AreEqual(String.Empty, name.ToString());
+		}
+		
+		[Test]
+		public void NameOnly()
+		{
+			QualifiedName name = new QualifiedName("root", String.Empty);
+			Assert.AreEqual("root", name.ToString());
+		}
+		
+		[Test]
+		public void NameAndNamespace()
+		{
+			QualifiedName name = new QualifiedName("root", "urn:my-uri");
+			Assert.AreEqual("root [urn:my-uri]", name.ToString());
+		}
+
+		[Test]
+		public void NameNamespaceAndPrefix()
+		{
+			QualifiedName name = new QualifiedName("root", "urn:my-uri", "a");
+			Assert.AreEqual("a:root [urn:my-uri]", name.ToString());
+		}
+		
+		[Test]
+		public void NameAndPrefixOnly()
+		{
+			QualifiedName name = new QualifiedName("root", String.Empty, "b");
+			Assert.AreEqual("b:root", name.ToString());
+		}
+		
+		[Test]
+		public void NullPrefix()
+		{
+			QualifiedName name = new QualifiedName("root", String.Empty, null);
+			Assert.AreEqual("root", name.ToString());
+		}
+		
+		[Test]
+		public void NullPrefixAndNonEmptyNamespace()
+		{
+			QualifiedName name = new QualifiedName("root", "urn:my-uri", null);
+			Assert.AreEqual("root [urn:my-uri]", name.ToString());
+		}
+		
+	}
+}

src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathTestFixture.cs

@@ -63,5 +63,20 @@ namespace XmlEditor.Tests.Paths
 			path.Compact();
 			Equality();
 		}
+		
+		[Test]
+		public void PathToString()
+		{
+			string expectedToString = "foo";
+			Assert.AreEqual(expectedToString, path.ToString());
+		}
+		
+		[Test]
+		public void TwoElementsPathToString()
+		{
+			QualifiedName qualifiedName = new QualifiedName("bar", "http://foo");
+			path.Elements.Add(qualifiedName);
+			Assert.AreEqual("foo > bar", path.ToString());
+		}
 	}
 }

src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathTestFixture.cs

@@ -93,5 +93,12 @@ namespace XmlEditor.Tests.Paths
 			path.Compact();
 			Assert.IsTrue(newPath.Equals(path), "Should be equal.");
 		}
+
+		[Test]
+		public void PathToString()
+		{
+			string expectedToString = "f:foo > b:bar";
+			Assert.AreEqual(expectedToString, path.ToString());
+		}
 	}
 }

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

@@ -45,6 +45,8 @@
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="Completion\FirstCompletionListItemSelectedTestFixture.cs" />
+    <Compile Include="Parser\XamlMixedNamespaceTestFixture.cs" />
+    <Compile Include="Paths\QualifiedNameToStringTests.cs" />
     <Compile Include="Schema\SingleElementSchemaTestFixture.cs" />
     <Compile Include="Schema\ElementWithAttributeSchemaTestFixture.cs" />
     <Compile Include="Schema\NestedElementSchemaTestFixture.cs" />

src/AddIns/DisplayBindings/XmlEditor/XmlEditor.sln

@@ -1,7 +1,7 @@
 
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual Studio 2005
-# SharpDevelop 2.1.0.2169
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+# SharpDevelop 3.0.0.2745
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor", "Project\XmlEditor.csproj", "{6B717BD1-CD5E-498C-A42E-9E6A4584DC48}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor.Tests", "Test\XmlEditor.Tests.csproj", "{FC0FE702-A87D-4D70-A9B6-1ECCD611125F}"