improvements in XAML binding

added Tests for XAML binding

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

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/Test1.xaml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<Window x:Class="XamlTest.Window1"
+        xmlns="http://schemas.microsoft.com/netfx/2007/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="XamlTest" Height="300" Width="300"
+>
+	<Grid>
+		<CheckBox />
+	</Grid>
+</Window>

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/Test2.xaml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<Window x:Class="XamlTest.Window1"
+        xmlns="http://schemas.microsoft.com/netfx/2007/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="XamlTest" Height="300" Width="300"
+>
+	<Grid>
+		<CheckBox xmlns:y="clr-namespace:ICSharpCode.Profiler.Controls;assembly=ICSharpCode.Profiler.Controls" />
+	</Grid>
+</Window>

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/Test3.xaml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<Window x:Class="XamlTest.Window1"
+        xmlns="http://schemas.microsoft.com/netfx/2007/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="XamlTest" Height="300" Width="300"
+>
+	<Grid>
+		<CheckBox xmlns:x="clr-namespace:ICSharpCode.Profiler.Controls;assembly=ICSharpCode.Profiler.Controls" />
+	</Grid>
+</Window>

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/UtilsTests.cs

@@ -0,0 +1,78 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="sie_pam@gmx.at"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+using NUnit.Framework;
+
+namespace ICSharpCode.XamlBinding.Tests
+{
+	[TestFixture]
+	public class UtilsTests
+	{
+		[Test]
+		public void XmlNamespacesForOffsetSimple()
+		{
+			string xaml = File.ReadAllText("Test1.xaml");
+			int offset = xaml.IndexOf("CheckBox") + "CheckBox ".Length;
+			
+			var expectedResult = new Dictionary<string, string> {
+				{"xmlns", "http://schemas.microsoft.com/netfx/2007/xaml/presentation"},
+				{"xmlns:x", "http://schemas.microsoft.com/winfx/2006/xaml"}
+			};
+			
+			var result = Utils.GetXmlNamespacesForOffset(xaml, offset);
+			
+			foreach (var p in result)
+				Debug.Print(p.Key + " " + p.Value);
+			
+			Assert.AreEqual(expectedResult, result, "Is not equal");
+		}
+		
+		[Test]
+		public void XmlNamespacesForOffsetSimple2()
+		{
+			string xaml = File.ReadAllText("Test2.xaml");
+			int offset = xaml.IndexOf("CheckBox") + "CheckBox ".Length;
+			
+			var expectedResult = new Dictionary<string, string> {
+				{"xmlns", "http://schemas.microsoft.com/netfx/2007/xaml/presentation"},
+				{"xmlns:x", "http://schemas.microsoft.com/winfx/2006/xaml"},
+				{"xmlns:y", "clr-namespace:ICSharpCode.Profiler.Controls;assembly=ICSharpCode.Profiler.Controls"}
+			};
+			
+			var result = Utils.GetXmlNamespacesForOffset(xaml, offset);
+			
+			foreach (var p in result)
+				Debug.Print(p.Key + " " + p.Value);
+			
+			Assert.AreEqual(expectedResult, result, "Is not equal");
+		}
+		
+		[Test]
+		public void XmlNamespacesForOffsetComplex()
+		{
+			string xaml = File.ReadAllText("Test3.xaml");
+			int offset = xaml.IndexOf("CheckBox") + "CheckBox ".Length;
+			
+			var expectedResult = new Dictionary<string, string> {
+				{"xmlns", "http://schemas.microsoft.com/netfx/2007/xaml/presentation"},
+				{"xmlns:x", "clr-namespace:ICSharpCode.Profiler.Controls;assembly=ICSharpCode.Profiler.Controls"}
+			};
+			
+			var result = Utils.GetXmlNamespacesForOffset(xaml, offset);
+			
+			foreach (var p in result)
+				Debug.Print(p.Key + " " + p.Value);
+			
+			Assert.AreEqual(expectedResult, result, "Is not equal");
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/XamlBinding.Tests/XamlBinding.Tests.csproj

@@ -33,7 +33,7 @@
     <RegisterForComInterop>False</RegisterForComInterop>
     <GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies>
     <BaseAddress>4194304</BaseAddress>
-    <PlatformTarget>AnyCPU</PlatformTarget>
+    <PlatformTarget>x86</PlatformTarget>
     <FileAlignment>4096</FileAlignment>
   </PropertyGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
@@ -56,6 +56,7 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UtilsTests.cs" />
     <Compile Include="XamlExpressionFinderTests.cs" />
     <Compile Include="XmlTests.cs" />
   </ItemGroup>
@@ -72,5 +73,14 @@
       <Project>{7C96B65D-28A5-4F28-A35B-8D83CE831EE8}</Project>
       <Name>XamlBinding</Name>
     </ProjectReference>
+    <None Include="Test1.xaml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Include="Test2.xaml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Include="Test3.xaml">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 </Project>

src/AddIns/BackendBindings/XamlBinding/XamlBinding/CompletionDataHelper.cs

@@ -0,0 +1,329 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="sie_pam@gmx.at"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml;
+
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.XmlEditor;
+
+namespace ICSharpCode.XamlBinding
+{
+	public static class CompletionDataHelper
+	{
+		static List<ICompletionItem> CreateListForAttributeName(ParseInformation parseInfo, string fileContent, XamlExpressionContext context, string[] existingItems)
+		{
+			if (context.ElementPath.Elements.Count == 0)
+				return null;
+			QualifiedName lastElement = context.ElementPath.Elements[context.ElementPath.Elements.Count - 1];
+			XamlCompilationUnit cu = parseInfo.BestCompilationUnit as XamlCompilationUnit;
+			if (cu == null)
+				return null;
+			IReturnType rt = cu.CreateType(lastElement.Namespace, lastElement.Name);
+			if (rt == null)
+				return null;
+			var list = new List<ICompletionItem>();
+			foreach (IProperty p in rt.GetProperties()) {
+				if (p.IsPublic && p.CanSet && !existingItems.Contains(p.Name)) {
+					list.Add(new XamlCompletionItem(p));
+				}
+			}
+			foreach (IEvent e in rt.GetEvents()) {
+				if (e.IsPublic && !existingItems.Contains(e.Name)) {
+					list.Add(new XamlCompletionItem(e));
+				}
+			}
+			return list;
+		}
+		
+		static bool IsReaderAtTarget(XmlTextReader r, int caretLine, int caretColumn)
+		{
+			if (r.LineNumber > caretLine)
+				return true;
+			else if (r.LineNumber == caretLine)
+				return r.LinePosition >= caretColumn;
+			else
+				return false;
+		}
+		
+		static List<ICompletionItem> CreateListForElement(ParseInformation parseInfo, string fileContent, int caretLine, int caretColumn)
+		{
+			using (XmlTextReader r = new XmlTextReader(new StringReader(fileContent))) {
+				try {
+					r.WhitespaceHandling = WhitespaceHandling.Significant;
+					// move reader to correct position
+					while (r.Read() && !IsReaderAtTarget(r, caretLine, caretColumn)) { }
+				}
+				catch (XmlException) {
+				}
+				var result = new List<ICompletionItem>();
+				IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
+				
+				TypeResolveResult rr = new XamlResolver().Resolve(new ExpressionResult(r.Name), parseInfo, fileContent) as TypeResolveResult;
+				if (rr != null) {
+					AddPropertiesForType(result, r, rr);
+					AddEventsForType(result, r, rr);
+				}
+				
+				foreach (var ns in r.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml)) {
+					var list = XamlCompilationUnit.GetNamespaceMembers(pc, ns.Value);
+					if (list != null) {
+						foreach (IClass c in list.OfType<IClass>()) {
+							if (c.ClassType != ClassType.Class)
+								continue;
+							if (c.IsAbstract && c.IsStatic)
+								continue;
+							if (c.ClassInheritanceTree.Any(b => b.FullyQualifiedName == "System.Attribute"))
+								continue;
+							if (!c.Methods.Any(m => m.IsConstructor && m.IsPublic))
+								continue;
+							
+							if (!string.IsNullOrEmpty(ns.Key))
+								result.Add(new XamlCompletionItem(c, ns.Key));
+							else
+								result.Add(new XamlCompletionItem(c));
+						}
+					}
+				}
+				
+				return result;
+			}
+		}
+		
+		static void AddEventsForType(List<ICompletionItem> result, XmlTextReader r, TypeResolveResult rr)
+		{
+			if (rr.ResolvedType != null) {
+				foreach (IEvent e in rr.ResolvedType.GetEvents()) {
+					if (!e.IsPublic)
+						continue;
+					
+					string propPrefix = e.DeclaringType.Name;
+					if (!string.IsNullOrEmpty(r.Prefix))
+						propPrefix = r.Prefix + ":" + propPrefix;
+					result.Add(new XamlCompletionItem(e, propPrefix));
+				}
+			}
+		}
+		
+		static void AddPropertiesForType(List<ICompletionItem> result, XmlTextReader r, TypeResolveResult rr)
+		{
+			if (rr.ResolvedType != null) {
+				foreach (IProperty p in rr.ResolvedType.GetProperties()) {
+					if (!p.IsPublic)
+						continue;
+					if (!p.CanSet && !IsCollectionType(p.ReturnType))
+						continue;
+					string propPrefix = p.DeclaringType.Name;
+					if (!string.IsNullOrEmpty(r.Prefix))
+						propPrefix = r.Prefix + ":" + propPrefix;
+					result.Add(new XamlCompletionItem(p, propPrefix));
+				}
+			}
+		}
+		
+		static bool IsCollectionType(IReturnType rt)
+		{
+			if (rt == null)
+				return false;
+			return rt.GetMethods().Any(m => m.Name == "Add" && m.IsPublic);
+		}
+		
+		class XamlCompletionProperty : DefaultProperty, IEntity
+		{
+			string newName;
+
+			public XamlCompletionProperty(IProperty baseProperty, string prefix)
+				: base(baseProperty.DeclaringType, baseProperty.Name)
+			{
+				this.Modifiers = baseProperty.Modifiers;
+				this.CopyDocumentationFrom(baseProperty);
+				newName = prefix + "." + baseProperty.Name;
+			}
+
+			string IEntity.Name
+			{
+				get { return newName; }
+			}
+		}
+		
+		class XamlCompletionEvent : DefaultEvent, IEntity
+		{
+			string newName;
+
+			public XamlCompletionEvent(IEvent baseEvent, string prefix)
+				: base(baseEvent.DeclaringType, baseEvent.Name)
+			{
+				this.Modifiers = baseEvent.Modifiers;
+				this.CopyDocumentationFrom(baseEvent);
+				newName = prefix + "." + baseEvent.Name;
+			}
+
+			string IEntity.Name
+			{
+				get { return newName; }
+			}
+		}
+		
+		static readonly List<ICompletionItem> standardElements = new List<ICompletionItem> {
+			new DefaultCompletionItem("!--"),
+			new DefaultCompletionItem("![CDATA["),
+			new DefaultCompletionItem("?")
+		};
+		
+		static readonly List<ICompletionItem> standardAttributes = new List<ICompletionItem> {
+			new DefaultCompletionItem("xmlns:")
+		};
+		
+		public const string XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+		
+		static List<ICompletionItem> CreateListOfMarkupExtensions(ParseInformation parseInfo, string fileContent, int caretLine, int caretColumn)
+		{
+			var list = CreateListForElement(parseInfo, fileContent, caretLine, caretColumn);
+			
+			var neededItems = list
+				.Where(i => ((i as XamlCompletionItem).Entity as IClass).ClassInheritanceTree
+				       .Any(item => item.FullyQualifiedName == "System.Windows.Markup.MarkupExtension"))
+				.Select(
+					selItem => {
+						var it = selItem as XamlCompletionItem;
+						string text = it.Text;
+						if (it.Text.EndsWith("Extension"))
+							text = text.Remove(it.Text.Length - "Extension".Length);
+						return new XamlCompletionItem(text, it.Entity) as ICompletionItem;
+					}
+				);
+			
+			return neededItems.ToList();
+		}
+
+		public static ICompletionItemList CreateListForContext(ITextEditor editor, XamlContext context, XmlElementPath path, IEntity entity)
+		{
+			XamlCompletionItemList list = new XamlCompletionItemList();
+			ParseInformation info = ParserService.GetParseInformation(editor.FileName);
+			
+			switch (context) {
+				case XamlContext.AtTag:
+					list.Items.AddRange(standardElements);
+					list.Items.AddRange(CreateListForElement(info, editor.Document.Text, editor.Caret.Line, editor.Caret.Column));
+					break;
+				case XamlContext.InTag:
+					list.Items.AddRange(CreateListForAttributeName(info, editor.Document.Text, new XamlExpressionContext(path, null, false), Utils.GetListOfExistingAttributeNames(editor.Document.Text, editor.Caret.Offset)));
+					list.Items.AddRange(standardAttributes);
+					break;
+				case XamlContext.InAttributeValue:
+					if (entity is IProperty) {
+						IProperty prop = entity as IProperty;
+						IReturnType type = prop.ReturnType;
+						if (type != null) {
+							TypeCompletion(type.GetUnderlyingClass(), list);
+						}
+					} else if (entity is IEvent) {
+						IEvent e = entity as IEvent;
+						IMethod invoker = GetInvokeMethod(e.ReturnType);
+						if (invoker == null)
+							break;
+						var item = path.Elements[path.Elements.Count - 1];
+						string name = Utils.GetAttributeValue(editor.Document.Text, editor.Caret.Offset, "name");
+						list.Items.Add(new NewEventCompletionItem(e, (string.IsNullOrEmpty(name)) ? item.Name : name));
+						AddMatchingEventHandlers(editor, invoker, list.Items);
+					}
+					break;
+				case XamlContext.InMarkupExtension:
+					list.Items.AddRange(CreateListOfMarkupExtensions(info, editor.Document.Text, editor.Caret.Line, editor.Caret.Column));
+					break;
+			}
+			
+			list.SortItems();
+			
+			if (list.Items.Count >= 1)
+				list.SuggestedItem = list.Items[0];
+			
+			return list;
+		}
+		
+		static void AddMatchingEventHandlers(ITextEditor editor, IMethod delegateInvoker, List<ICompletionItem> list)
+		{
+			ParseInformation p = ParserService.GetParseInformation(editor.FileName);
+			var unit = p.MostRecentCompilationUnit;
+			var loc = editor.Document.OffsetToPosition(editor.Caret.Offset);
+			IClass c = unit.GetInnermostClass(loc.Line, loc.Column);
+			if (c == null)
+				return;
+			CompoundClass compound = c.GetCompoundClass() as CompoundClass;
+			if (compound != null) {
+				foreach (IClass part in compound.Parts) {
+					foreach (IMethod m in part.Methods) {
+						if (m.Parameters.Count != delegateInvoker.Parameters.Count)
+							continue;
+						
+						if ((m.ReturnType != null && delegateInvoker.ReturnType != null) && m.ReturnType.DotNetName != delegateInvoker.ReturnType.DotNetName)
+							continue;
+						
+						bool equal = true;
+						for (int i = 0; i < m.Parameters.Count; i++) {
+							equal &= CompareParameter(m.Parameters[i], delegateInvoker.Parameters[i]);
+							if (!equal)
+								break;
+						}
+						if (equal) {
+							list.Add(new XamlCompletionItem(m));
+						}
+					}
+				}
+			}
+		}
+		
+		static bool CompareParameter(IParameter p1, IParameter p2)
+		{
+			bool result = p1.ReturnType.DotNetName == p2.ReturnType.DotNetName;
+			
+			result &= (p1.IsOut == p2.IsOut);
+			result &= (p1.IsParams == p2.IsParams);
+			result &= (p1.IsRef == p2.IsRef);
+			
+			return result;
+		}
+		
+		static IMethod GetInvokeMethod(IReturnType type)
+		{
+			if (type == null)
+				return null;
+			
+			foreach (IMethod method in type.GetMethods()) {
+				if (method.Name == "Invoke")
+					return method;
+			}
+			
+			return null;
+		}
+		
+		static bool TypeCompletion(IClass type, XamlCompletionItemList list)
+		{
+			switch (type.ClassType) {
+				case ClassType.Enum:
+					foreach (IField f in type.Fields) {
+						list.Items.Add(new XamlCompletionItem(f));
+					}
+					return true;
+				case ClassType.Struct:
+					if (type.FullyQualifiedName == "System.Boolean") {
+						list.Items.Add(new DefaultCompletionItem("True"));
+						list.Items.Add(new DefaultCompletionItem("False"));
+						return true;
+					}
+					break;
+			}
+			
+			return false;
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/Utils.cs

@@ -5,11 +5,17 @@
 //     <version>$Revision$</version>
 // </file>
 
-using ICSharpCode.XmlEditor;
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Text.RegularExpressions;
 using System.Xml;
 
+using ICSharpCode.Core;
+using ICSharpCode.XmlEditor;
+using System.Linq;
+
 namespace ICSharpCode.XamlBinding
 {
 	/// <summary>
@@ -48,28 +54,160 @@ namespace ICSharpCode.XamlBinding
 			return false;
 		}
 		
-		public static string GetNameAttributeValue(string text, int offset)
+		public static string GetAttributeValue(string text, int offset, string name)
 		{
-			int index = XmlParser.GetActiveElementStartIndex(text, offset);
-			if (index == -1)
+			text = SimplifyToSingleElement(text, offset, "Test");
+			
+			if (text == null)
 				return null;
-			index = text.IndexOf(' ', index);
 			
+			XmlReader reader = XmlTextReader.Create(new StringReader(text));
+			
+			try {
+				reader.ReadToFollowing("Test");
+				
+				if (!reader.MoveToFirstAttribute())
+					return null;
+				
+				do {
+					LoggingService.Debug("name: " + reader.Name + " value: " + reader.Value);
+					int start = reader.Name.IndexOf(':') + 1;
+					string plainName = reader.Name.Substring(start, reader.Name.Length - start).ToLowerInvariant();
+					
+					if (plainName == name.ToLowerInvariant())
+						return reader.Value;
+				} while (reader.MoveToNextAttribute());
+			} catch (XmlException) { }
+			
+			return null;
+		}
+		
+		public static Dictionary<string, string> GetXmlNamespacesForOffset(string fileContent, int offset)
+		{
+			if (fileContent == null)
+				throw new ArgumentNullException("fileContent");
+			if (offset < 0 || offset > fileContent.Length)
+				throw new ArgumentOutOfRangeException("offset", offset, "Value must be between 0 and " + fileContent.Length);
+			
+			var map = new Dictionary<string, string>();
+			
+			int endIndex = fileContent.IndexOfAny(new char[] {'<', '>'}, offset);
+			if (endIndex > -1)
+				fileContent = fileContent.Substring(0, endIndex + 1);
+			
+			int lastWhiteSpacePos = fileContent.LastIndexOfAny(new char[] {' ', '\t', '\n', '\r'});
+			
+			bool inDouble = false, inSingle = false;
+			
+			for (int i = 0; i < fileContent.Length; i++) {
+				if (fileContent[i] == '"' && !inSingle)
+					inDouble = !inDouble;
+				if (fileContent[i] == '\'' && !inDouble)
+					inSingle = !inSingle;
+				if (fileContent[i] == '>') {
+					int lastDelimiterPos = fileContent.Substring(0, i + 1).LastIndexOfAny(new char[] {'>', '/'});
+					if (inDouble) {
+						fileContent.Insert(lastDelimiterPos, "\"");
+						i++;
+						inDouble = false;
+					}
+					if (inSingle) {
+						fileContent.Insert(lastDelimiterPos, "'");
+						inSingle = false;
+						i++;
+					}
+				}
+			}
+
+			fileContent = fileContent.Replace("<?", " ").Replace("?>", " ").Replace("<", " ").Replace("/>", " ").Replace(">", " ").Replace("\n", " ").Replace("\r", " ").Replace("\t", " ");
+			while (fileContent.Contains("  "))
+				fileContent = fileContent.Replace("  ", " ");
+
+			fileContent = fileContent.Replace("= \"", "=\"");
+			fileContent = fileContent.Replace(" =\"", "=\"");
+			
+			Debug.Print(fileContent);
+			
+			string[] data = fileContent.Split(' ');
+			
+			var filter1 = data.Where(s => s.StartsWith("xmlns"));
+			
+			foreach (string item in filter1) {
+				string[] parts = item.Split(new char[] {'='}, 2);
+				if (parts.Length == 2) {
+					if (map.ContainsKey(parts[0])) // replace namespace with new one
+						map.Remove(parts[0]);
+					map.Add(parts[0], parts[1].Trim('"', '\''));
+				}
+			}
+			
+			return map;
+		}
+		
+		public static string[] GetListOfExistingAttributeNames(string text, int offset)
+		{
+			List<string> list = new List<string>();
+			
+			text = SimplifyToSingleElement(text, offset, "Test");
+			
+			if (text == null)
+				return list.ToArray();
+			
+			XmlReader reader = XmlTextReader.Create(new StringReader(text));
+			
+			try {
+				reader.ReadToFollowing("Test");
+				
+				if (!reader.MoveToFirstAttribute())
+					return list.ToArray();
+				
+				do {
+					LoggingService.Debug("name: " + reader.Name + " value: " + reader.Value);
+					list.Add(reader.Name);
+				} while (reader.MoveToNextAttribute());
+			} catch (XmlException) { }
+			
+			return list.ToArray();
+		}
+		
+		public static int GetPreviousLTCharPos(string text, int startIndex)
+		{
+			if (text == null)
+				throw new ArgumentNullException("text");
+			
+			if (startIndex < 0)
+				return -1;
+			if (startIndex >= text.Length)
+				startIndex = text.Length - 1;
+			
+			while (startIndex > -1 && text[startIndex] != '<')
+				startIndex--;
+			
+			return startIndex;
+		}
+
+		static string SimplifyToSingleElement(string text, int offset, string name)
+		{
+			int index = XmlParser.GetActiveElementStartIndex(text, offset);
+			if (index == -1) return null;
+			index = text.IndexOf(' ', index);
 			text = text.Substring(index);
 			int endIndex = text.IndexOfAny(new char[] { '<', '>' });
-			text = text.Substring(0, endIndex).Trim(' ', '\t', '\n', '\r');
+			text = text.Substring(0, endIndex).Trim(' ', '\t', '\n', '\r', '/');
+			LoggingService.Debug("text: '" + text + "'");
+			text = "<" + name + " " + text + " />";
 			
-			string[] attributes = text.Split(new string[] {"=\"", "\""}, StringSplitOptions.None);
+			return text;
+		}
 		
-			for (int i = 0; i < attributes.Length; i += 2) {
-				if (i + 1 < attributes.Length) {
-					if (attributes[i].Trim(' ', '\t', '\n', '\r').ToLowerInvariant() == "name")
-						return attributes[i + 1];
-				} else
-					break;
-			}
+		public static string GetXamlNamespacePrefix(string xaml, int offset)
+		{
+			var list = Utils.GetXmlNamespacesForOffset(xaml, offset);
+			var item = list.FirstOrDefault(i => i.Value == CompletionDataHelper.XamlNamespace);
 			
-			return null;
+			if (item.Key.StartsWith("xmlns:"))
+				return item.Key.Substring("xmlns:".Length);
+			return string.Empty;
 		}
 	}
 }

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlBinding.csproj

@@ -60,15 +60,20 @@
     <Compile Include="..\..\..\..\Main\GlobalAssemblyInfo.cs">
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
+    <Compile Include="CompletionDataHelper.cs" />
     <Compile Include="Utils.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="XamlClassReturnType.cs" />
     <Compile Include="XamlCodeCompletionBinding.cs" />
+    <Compile Include="XamlColorizerServer.cs" />
     <Compile Include="XamlCompilationUnit.cs" />
     <Compile Include="XamlCompletionItem.cs" />
     <Compile Include="XamlCompletionItemList.cs" />
     <Compile Include="XamlExpressionContext.cs" />
-    <Compile Include="XamlExpressionFinder.cs" />
+    <Compile Include="XamlExpressionFinder.cs">
+      <DependentUpon>XamlExpressionContext.cs</DependentUpon>
+    </Compile>
+    <Compile Include="XamlColorizer.cs" />
     <Compile Include="XamlParser.cs" />
     <Compile Include="XamlResolver.cs" />
     <ProjectReference Include="..\..\..\..\Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj">

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCodeCompletionBinding.cs

@@ -30,7 +30,11 @@ namespace ICSharpCode.XamlBinding
 		/// <summary>
 		/// Inside '="Value"'
 		/// </summary>
-		InAttributeValue
+		InAttributeValue,
+		/// <summary>
+		/// Inside '="{}"'
+		/// </summary>
+		InMarkupExtension
 	}
 	
 	public class XamlCodeCompletionBinding : ICodeCompletionBinding
@@ -38,14 +42,17 @@ namespace ICSharpCode.XamlBinding
 		public CodeCompletionKeyPressResult HandleKeyPress(ITextEditor editor, char ch)
 		{
 			XamlResolver resolver = new XamlResolver();
+			ParseInformation info = ParserService.GetParseInformation(editor.FileName);
+			
 			XmlElementPath path;
 			int offset;
+			
 			switch (ch) {
 				case '<':
-					int prevLTCharPos = GetPreviousLTCharPos(editor.Document.Text, editor.Caret.Offset) + 1;
+					int prevLTCharPos = Utils.GetPreviousLTCharPos(editor.Document.Text, editor.Caret.Offset) + 1;
 					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, prevLTCharPos);
 					if (path != null && path.Elements.Count > 0) {
-						ICompletionItemList list = CreateListForContext(editor, XamlContext.AtTag, path, null);
+						ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.AtTag, path, null);
 						editor.ShowCompletionWindow(list);
 						return CodeCompletionKeyPressResult.Completed;
 					}
@@ -77,24 +84,38 @@ namespace ICSharpCode.XamlBinding
 					break;
 				case '"':
 					offset = editor.Caret.Offset;
-					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, offset);
-					if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
-						editor.Document.Insert(offset, "\"");
-						editor.Caret.Offset = offset;
+					
+					if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, offset)) {
+						int search = offset + 1;
+						while (char.IsWhiteSpace(editor.Document.GetCharAt(search)))
+							search++;
+						
+						if (editor.Document.GetCharAt(search) != '"') {
+							editor.Document.Insert(offset, "\"");
+							editor.Caret.Offset = offset;
+							return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
+						}
 					}
 					break;
 				case '{': // starting point for Markup Extension Completion
 					offset = editor.Caret.Offset;
 					if (offset > 0) {
 						int searchOffset = offset - 1;
-						char c = editor.Document.GetCharAt(searchOffset);
-						while (char.IsWhiteSpace(c)) {
+						while (char.IsWhiteSpace(editor.Document.GetCharAt(searchOffset)))
 							searchOffset--;
-							c = editor.Document.GetCharAt(searchOffset);
-						}
+						
+						char c = editor.Document.GetCharAt(searchOffset);
+						
 						if (XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset) && c == '"') {
 							editor.Document.Insert(offset, "}");
 							editor.Caret.Offset = offset;
+							
+							path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, editor.Caret.Offset);
+							if (path != null && path.Elements.Count > 0) {
+								ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InMarkupExtension, path, null);
+								editor.ShowCompletionWindow(list);
+								return CodeCompletionKeyPressResult.Completed;
+							}
 						}
 					}
 					break;
@@ -102,21 +123,72 @@ namespace ICSharpCode.XamlBinding
 					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, editor.Caret.Offset);
 					if (path != null && path.Elements.Count > 0) {
 						if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
-							ICompletionItemList list = CreateListForContext(editor, XamlContext.InTag, path, null);
+							ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InTag, path, null);
+							editor.ShowCompletionWindow(list);
+							return CodeCompletionKeyPressResult.Completed;
+						}
+					}
+					break;
+				case '.':
+					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, editor.Caret.Offset);
+					if (path != null && path.Elements.Count > 0) {
+						if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
+							ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InTag, path, null);
 							editor.ShowCompletionWindow(list);
 							return CodeCompletionKeyPressResult.Completed;
 						}
 					}
 					break;
+				case ':':
+					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, editor.Caret.Offset);
+					if (path != null && path.Elements.Count > 0) {
+						if (XmlParser.GetQualifiedAttributeNameAtIndex(editor.Document.Text, editor.Caret.Offset) == null) {
+							ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.AtTag, path, null);
+							editor.ShowCompletionWindow(list);
+							return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
+						}
+					}
+					break;
+				case '=':
+					offset = editor.Caret.Offset;
+					path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, offset);
+					if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
+						int searchOffset = offset + 1;
+						while (char.IsWhiteSpace(editor.Document.GetCharAt(searchOffset)))
+							searchOffset++;
+						
+						if (editor.Document.GetCharAt(searchOffset) != '"') {
+//							if (path != null && path.Elements.Count > 0) {
+//								string attr = editor.GetWordBeforeCaret();
+//								ResolveResult rr = resolver.Resolve(new ExpressionResult(attr, new XamlExpressionContext(path, attr, false)), info, editor.Document.Text);
+//
+//								if (rr == null) {
+//									editor.Document.Insert(offset, "=\"\"");
+//									editor.Caret.Offset = offset + 2;
+//
+//									return CodeCompletionKeyPressResult.EatKey;
+//								}
+//
+//								ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InAttributeValue, path, rr.ResolvedType));
+//								editor.ShowCompletionWindow(list);
+//							}
+							
+							editor.Document.Insert(offset, "=\"\"");
+							editor.Caret.Offset = offset + 2;
+							
+							return CodeCompletionKeyPressResult.EatKey;
+						}
+					}
+					break;
 				default:
 					if (char.IsLetter(ch)) {
 						offset = editor.Caret.Offset;
 						if (offset > 0) {
 							char c = editor.Document.GetCharAt(offset - 1);
+							path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, offset);
 							if (c == ' ' || c == '\t') {
-								path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, offset);
 								if (path != null && path.Elements.Count > 0) {
-									ICompletionItemList list = CreateListForContext(editor, XamlContext.InTag, path, null);
+									ICompletionItemList list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InTag, path, null);
 									editor.ShowCompletionWindow(list);
 									return CodeCompletionKeyPressResult.CompletedIncludeKeyInCompletion;
 								}
@@ -129,223 +201,25 @@ namespace ICSharpCode.XamlBinding
 			return CodeCompletionKeyPressResult.None;
 		}
 
-		int GetPreviousLTCharPos(string text, int startIndex)
-		{
-			if (text == null)
-				throw new ArgumentNullException("text");
-			
-			if (startIndex < 0)
-				return -1;
-			if (startIndex >= text.Length)
-				startIndex = text.Length - 1;
-			
-			while (startIndex > -1 && text[startIndex] != '<')
-				startIndex--;
-			
-			return startIndex;
-		}
-		
-		static readonly List<ICompletionItem> standardItems = new List<ICompletionItem> {
-			new DefaultCompletionItem("!--"),
-			new DefaultCompletionItem("![CDATA["),
-			new DefaultCompletionItem("?")
-		};
-		
-		public static ICompletionItemList CreateListForContext(ITextEditor editor, XamlContext context, XmlElementPath path, IEntity entity)
-		{
-			XamlCompletionItemList list = new XamlCompletionItemList();
-			ParseInformation info = ParserService.GetParseInformation(editor.FileName);
-			
-			switch (context) {
-				case XamlContext.AtTag:
-					list.Items.AddRange(standardItems);
-					list.Items.AddRange(CreateListForElement(info, editor.Document.Text, editor.Caret.Line, editor.Caret.Column));
-					break;
-				case XamlContext.InTag:
-					list.Items.AddRange(CreateListForAttributeName(info, editor.Document.Text, new XamlExpressionContext(path, null, false)));
-					break;
-				case XamlContext.InAttributeValue:
-					if (entity is IProperty) {
-						IProperty prop = entity as IProperty;
-						IReturnType type = prop.ReturnType;
-						if (type != null) {
-							TypeCompletion(type.GetUnderlyingClass(), list);
-						}
-					} else if (entity is IEvent) {
-						IEvent e = entity as IEvent;
-						IMethod invoker = GetInvokeMethod(e.ReturnType);
-						if (invoker == null)
-							break;
-						var item = path.Elements[path.Elements.Count - 1];
-						string name = Utils.GetNameAttributeValue(editor.Document.Text, editor.Caret.Offset);
-						list.Items.Add(new NewEventCompletionItem(e, (string.IsNullOrEmpty(name)) ? item.Name : name));
-						AddMatchingEventHandlers(editor, invoker, list.Items);
-					}
-					break;
-			}
-			
-			list.SortItems();
-			
-			return list;
-		}
-		
-		static void AddMatchingEventHandlers(ITextEditor editor, IMethod delegateInvoker, List<ICompletionItem> list)
-		{
-			ParseInformation p = ParserService.GetParseInformation(editor.FileName);
-			var unit = p.MostRecentCompilationUnit;
-			var loc = editor.Document.OffsetToPosition(editor.Caret.Offset);
-			IClass c = unit.GetInnermostClass(loc.Line, loc.Column);
-			CompoundClass compound = c.GetCompoundClass() as CompoundClass;
-			if (compound != null) {
-				foreach (IClass part in compound.Parts) {
-					foreach (IMethod m in part.Methods) {
-						if (m.Parameters.Count != delegateInvoker.Parameters.Count)
-							continue;
-						
-						if ((m.ReturnType != null && delegateInvoker.ReturnType != null) && m.ReturnType.DotNetName != delegateInvoker.ReturnType.DotNetName)
-							continue;
-						
-						bool equal = true;
-						for (int i = 0; i < m.Parameters.Count; i++) {
-							equal &= CompareParameter(m.Parameters[i], delegateInvoker.Parameters[i]);
-							if (!equal)
-								break;
-						}
-						if (equal) {
-							list.Add(new XamlCompletionItem(m));
-						}
-					}
-				}
-			}
-		}
-		
-		static bool CompareParameter(IParameter p1, IParameter p2)
-		{
-			bool result = p1.ReturnType.DotNetName == p2.ReturnType.DotNetName;
-			
-			result &= (p1.IsOut == p2.IsOut);
-			result &= (p1.IsParams == p2.IsParams);
-			result &= (p1.IsRef == p2.IsRef);
-			
-			return result;
-		}
-		
-		static IMethod GetInvokeMethod(IReturnType type)
-		{
-			if (type == null)
-				return null;
-			
-			foreach (IMethod method in type.GetMethods()) {
-				if (method.Name == "Invoke")
-					return method;
-			}
-			
-			return null;
-		}
-		
-		static bool TypeCompletion(IClass type, XamlCompletionItemList list)
-		{
-			switch (type.ClassType) {
-				case ClassType.Enum:
-					foreach (IField f in type.Fields) {
-						list.Items.Add(new XamlCompletionItem(f));
-					}
-					return true;
-				case ClassType.Struct:
-					if (type.FullyQualifiedName == "System.Boolean") {
-						list.Items.Add(new DefaultCompletionItem("True"));
-						list.Items.Add(new DefaultCompletionItem("False"));
-						return true;
-					}
-					break;
-			}
-			
-			return false;
-		}
-
 		public bool CtrlSpace(ICSharpCode.SharpDevelop.ITextEditor editor)
 		{
-//			XamlCompletionItemProvider provider = new XamlCompletionItemProvider(XamlExpressionContext.Empty);
-//			provider.ShowCompletion(editor);
-			return true;
-		}
-
-		static List<ICompletionItem> CreateListForAttributeName(ParseInformation parseInfo, string fileContent, XamlExpressionContext context)
-		{
-			if (context.ElementPath.Elements.Count == 0)
-				return null;
-			QualifiedName lastElement = context.ElementPath.Elements[context.ElementPath.Elements.Count - 1];
-			XamlCompilationUnit cu = parseInfo.BestCompilationUnit as XamlCompilationUnit;
-			if (cu == null)
-				return null;
-			IReturnType rt = cu.CreateType(lastElement.Namespace, lastElement.Name);
-			if (rt == null)
-				return null;
-			var list = new List<ICompletionItem>();
-			foreach (IProperty p in rt.GetProperties()) {
-				if (p.IsPublic && p.CanSet) {
-					list.Add(new XamlCompletionItem(p));
-				}
-			}
-			foreach (IEvent e in rt.GetEvents()) {
-				if (e.IsPublic) {
-					list.Add(new XamlCompletionItem(e));
-				}
-			}
-			return list;
-		}
-
-		static bool IsReaderAtTarget(XmlTextReader r, int caretLine, int caretColumn)
-		{
-			if (r.LineNumber > caretLine)
-				return true;
-			else if (r.LineNumber == caretLine)
-				return r.LinePosition >= caretColumn;
-			else
-				return false;
-		}
-
-		static List<ICompletionItem> CreateListForElement(ParseInformation parseInfo, string fileContent, int caretLine, int caretColumn)
-		{
-			using (XmlTextReader r = new XmlTextReader(new StringReader(fileContent))) {
-				try {
-					r.WhitespaceHandling = WhitespaceHandling.Significant;
-					// move reader to correct position
-					while (r.Read() && !IsReaderAtTarget(r, caretLine, caretColumn)) { }
-				}
-				catch (XmlException) {
-				}
-				var result = new List<ICompletionItem>();
-				IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
-
-				TypeResolveResult rr = new XamlResolver().Resolve(new ExpressionResult(r.Name), parseInfo, fileContent) as TypeResolveResult;
-//				if (rr != null) {
-//					AddPropertiesForType(result, r, rr);
-//					AddEventsForType(result, r, rr);
-//				}
-
-				foreach (var ns in r.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml)) {
-					var list = XamlCompilationUnit.GetNamespaceMembers(pc, ns.Value);
-					if (list != null) {
-						foreach (IClass c in list.OfType<IClass>()) {
-							if (c.ClassType != ClassType.Class)
-								continue;
-							if (c.IsAbstract && c.IsStatic)
-								continue;
-							if (c.ClassInheritanceTree.Any(b => b.FullyQualifiedName == "System.Attribute"))
-								continue;
-							if (!c.Methods.Any(m => m.IsConstructor && m.IsPublic))
-								continue;
-							if (string.IsNullOrEmpty(ns.Key))
-								result.Add(new XamlCompletionItem(c));
-							else
-								result.Add(new XamlCompletionItem(c, ns.Key));
+			var path = XmlParser.GetActiveElementStartPathAtIndex(editor.Document.Text, editor.Caret.Offset);
+			if (path != null && path.Elements.Count > 0) {
+				if (!XmlParser.IsInsideAttributeValue(editor.Document.Text, editor.Caret.Offset)) {
+					var list = CompletionDataHelper.CreateListForContext(editor, XamlContext.InTag, path, null) as XamlCompletionItemList;
+					string starter = editor.GetWordBeforeCaret().Trim(' ', '\t', '\n', '\r');
+					if (!string.IsNullOrEmpty(starter)) {
+						var item = list.Items.FirstOrDefault(i => i.Text.StartsWith(starter, StringComparison.OrdinalIgnoreCase));
+						if (item != null) {
+							list.SuggestedItem = item;
+							list.PreselectionLength = starter.Length;
 						}
 					}
+					editor.ShowCompletionWindow(list);
+					return true;
 				}
-
-				return result;
 			}
+			return false;
 		}
 	}
 }

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlColorizer.cs

@@ -0,0 +1,74 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="sie_pam@gmx.at"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.TextFormatting;
+
+using ICSharpCode.AvalonEdit.AddIn;
+using ICSharpCode.AvalonEdit.Document;
+using ICSharpCode.AvalonEdit.Gui;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.XamlBinding
+{
+	public class XamlColorizer : ColorizingTransformer
+	{
+		static readonly XamlColorizerSettings defaultSettings = new XamlColorizerSettings();
+		XamlColorizerSettings settings = defaultSettings;
+		static readonly char[] punctuationItems = {'"' }; // , '<', '>', '.', '=', '{', '}'
+		
+		public AvalonEditViewContent Content { get; set; }
+		
+		public XamlColorizer(AvalonEditViewContent content)
+		{
+			this.Content = content;
+		}
+		
+		protected override void Colorize(ITextRunConstructionContext context)
+		{
+			DocumentLine line = context.VisualLine.FirstDocumentLine;
+			
+			while (line != null) {
+				if (!line.IsDeleted) {
+					int index = 0;
+					do {
+						index = line.Text.IndexOfAny(punctuationItems, index);
+						if (index > -1) {
+							int col = context.VisualLine.GetVisualColumn(index);
+							ChangeVisualElements(index, index + 1, ColorizePunctuation);
+							index++;
+						}
+					} while (index > -1);
+				}
+				
+				line = line.NextLine;
+			}
+		}
+		
+		void ColorizePunctuation(VisualLineElement element)
+		{
+			element.TextRunProperties.SetForegroundBrush(settings.PunctuationForegroundBrush);
+			element.TextRunProperties.SetBackgroundBrush(settings.PunctuationBackgroundBrush);
+		}
+	}
+	
+	public class XamlColorizerSettings
+	{
+		public Brush PunctuationForegroundBrush { get; set; }
+		public Brush PunctuationBackgroundBrush { get; set; }
+		
+		public XamlColorizerSettings()
+		{
+			this.PunctuationBackgroundBrush = Brushes.Transparent;
+			this.PunctuationForegroundBrush = Brushes.Red;
+		}
+	}
+}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlColorizerServer.cs

@@ -0,0 +1,75 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="sie_pam@gmx.at"/>
+//     <version>$Revision$</version>
+// </file>
+
+using ICSharpCode.AvalonEdit.Gui;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using ICSharpCode.AvalonEdit.AddIn;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.XamlBinding
+{
+	/// <summary>
+	/// Description of XamlColorizerServer.
+	/// </summary>
+	public static class XamlColorizerServer
+	{
+		public static void InitializeServer()
+		{
+			WorkbenchSingleton.Workbench.ViewOpened += new ViewContentEventHandler(WorkbenchSingleton_Workbench_ViewOpened);
+		}
+
+		static void WorkbenchSingleton_Workbench_ViewOpened(object sender, ViewContentEventArgs e)
+		{
+			if (e.Content is AvalonEditViewContent) {
+				AvalonEditViewContent content = e.Content as AvalonEditViewContent;
+				if (!Path.GetExtension(content.CodeEditor.FileName).Equals(".xaml", StringComparison.OrdinalIgnoreCase))
+					return;
+				content.CodeEditor.TextArea.TextView.LineTransformers.Insert(1, new XamlColorizer(content));
+			}
+		}
+	}
+	
+	public class ColorizerDoozer : IDoozer
+	{
+		public bool HandleConditions {
+			get {
+				return false;
+			}
+		}
+		
+		public object BuildItem(object caller, Codon codon, System.Collections.ArrayList subItems)
+		{
+			return new ColorizerDescriptor(codon);
+		}
+	}
+	
+	public class ColorizerDescriptor
+	{
+		Codon codon;
+		ColorizingTransformer colorizer;
+		
+		public ColorizingTransformer Colorizer {
+			get {
+				if (colorizer == null)
+					this.colorizer = (ColorizingTransformer)codon.AddIn.CreateObject(codon.Properties["class"]);
+				
+				return colorizer;
+			}
+		}
+		
+		public ColorizerDescriptor(Codon codon)
+		{
+			this.codon = codon;
+		}
+		
+		
+	}
+}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCompletionItem.cs

@@ -37,6 +37,12 @@ namespace ICSharpCode.XamlBinding
 		{
 			this.entity = entity;
 		}
+		
+		public XamlCompletionItem(string text, IEntity entity)
+			: base(text)
+		{
+			this.entity = entity;
+		}
 	}
 	
 	class NewEventCompletionItem : DefaultCompletionItem

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCompletionItemList.cs

@@ -5,20 +5,13 @@
 //     <version>$Revision: 3731 $</version>
 // </file>
 
-using ICSharpCode.AvalonEdit.AddIn;
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
+using ICSharpCode.AvalonEdit.AddIn;
 using ICSharpCode.NRefactory.Ast;
 using ICSharpCode.SharpDevelop;
-using ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Dom.Refactoring;
-using ICSharpCode.SharpDevelop.Gui;
-using ICSharpCode.SharpDevelop.Project;
-using ICSharpCode.TextEditor.Gui.CompletionWindow;
 using ICSharpCode.XmlEditor;
 
 namespace ICSharpCode.XamlBinding
@@ -31,6 +24,9 @@ namespace ICSharpCode.XamlBinding
 		
 		public override CompletionItemListKeyResult ProcessInput(char key)
 		{
+			if (key == ':')
+				return CompletionItemListKeyResult.NormalKey;
+			
 			return base.ProcessInput(key);
 		}
 		
@@ -39,23 +35,42 @@ namespace ICSharpCode.XamlBinding
 			if (item is XamlCompletionItem) {
 				XamlCompletionItem cItem = item as XamlCompletionItem;
 				
-				if (cItem.Entity is IProperty) {
-					context.Editor.Document.Insert(context.EndOffset, "=\"\"");
-					context.Editor.Caret.Offset--;
-					XmlElementPath path = XmlParser.GetActiveElementStartPathAtIndex(context.Editor.Document.Text, context.Editor.Caret.Offset);
-					if (path != null && path.Elements.Count > 0) {
-						ICompletionItemList list = XamlCodeCompletionBinding.CreateListForContext(context.Editor, XamlContext.InAttributeValue, path, cItem.Entity);
-						context.Editor.ShowCompletionWindow(list);
+				if (cItem.Entity is IProperty || cItem.Entity is IEvent) {
+					if (context.Editor.Document.GetCharAt(context.StartOffset - 1) != '.') {
+						context.Editor.Document.Insert(context.EndOffset, "=\"\"");
+						context.Editor.Caret.Offset--;
+						XmlElementPath path = XmlParser.GetActiveElementStartPathAtIndex(context.Editor.Document.Text, context.Editor.Caret.Offset);
+						if (path != null && path.Elements.Count > 0) {
+							ICompletionItemList list = CompletionDataHelper.CreateListForContext(context.Editor, XamlContext.InAttributeValue, path, cItem.Entity);
+							context.Editor.ShowCompletionWindow(list);
+						}
 					}
 				}
 				
-				if (cItem.Entity is IEvent) {
-					context.Editor.Document.Insert(context.EndOffset, "=\"\"");
-					context.Editor.Caret.Offset--;
-					XmlElementPath path = XmlParser.GetActiveElementStartPathAtIndex(context.Editor.Document.Text, context.Editor.Caret.Offset);
-					if (path != null && path.Elements.Count > 0) {
-						ICompletionItemList list = XamlCodeCompletionBinding.CreateListForContext(context.Editor, XamlContext.InAttributeValue, path, cItem.Entity);
-						context.Editor.ShowCompletionWindow(list);
+				if (cItem.Entity is IClass) {
+					IClass c = cItem.Entity as IClass;
+					// TODO : maybe allow accessing ch from HandleKeyPress through context?
+					if (c.FullyQualifiedName == "System.Windows.Style") {
+						string insertionString = "";
+						if (!char.IsWhiteSpace(context.Editor.Document.GetCharAt(context.StartOffset - 1))) {
+							insertionString = " ";
+						}
+						
+						string prefix = Utils.GetXamlNamespacePrefix(context.Editor.Document.Text, context.StartOffset);
+						if (!string.IsNullOrEmpty(prefix))
+							prefix += ":";
+						
+						insertionString += "TargetType=\"{" + prefix + "Type }\"";
+						context.Editor.Document.Insert(context.EndOffset, insertionString);
+						context.Editor.Caret.Offset = context.EndOffset + insertionString.Length - 2;
+					} else if (c.FullyQualifiedName == "System.Windows.Setter") {
+						string insertionString = "";
+						if (!char.IsWhiteSpace(context.Editor.Document.GetCharAt(context.StartOffset - 1))) {
+							insertionString = " ";
+						}
+						insertionString += "Property=\"\"";
+						context.Editor.Document.Insert(context.EndOffset, insertionString);
+						context.Editor.Caret.Offset = context.EndOffset + insertionString.Length - 1;
 					}
 				}
 			} else {
@@ -74,6 +89,8 @@ namespace ICSharpCode.XamlBinding
 			var unit = p.MostRecentCompilationUnit;
 			var loc = context.Editor.Document.OffsetToPosition(context.StartOffset);
 			IClass c = unit.GetInnermostClass(loc.Line, loc.Column);
+			if (c == null)
+				return;
 			IMethod initializeComponent = c.Methods[0];
 			CompoundClass compound = c.GetCompoundClass() as CompoundClass;
 			if (compound != null) {
@@ -110,7 +127,6 @@ namespace ICSharpCode.XamlBinding
 							unit.ProjectContent.Language.CodeGenerator.InsertCodeAfter(lastMember, wrapper.Document, node);
 						else
 							unit.ProjectContent.Language.CodeGenerator.InsertCodeAtEnd(part.Region, wrapper.Document, node);
-						return;
 					}
 					return;
 				}

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlParser.cs

@@ -32,6 +32,12 @@ namespace ICSharpCode.XamlBinding
 			get { return LanguageProperties.CSharp; }
 		}
 		
+		public XamlParser()
+		{
+			// HACK to make colorizing working!
+			XamlColorizerServer.InitializeServer();
+		}
+
 		public bool CanParse(string fileName)
 		{
 			return Path.GetExtension(fileName).Equals(".xaml", StringComparison.OrdinalIgnoreCase);
@@ -42,8 +48,6 @@ namespace ICSharpCode.XamlBinding
 			return false;
 		}
 
-		const string XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
-
 		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, string fileContent)
 		{
 			XamlCompilationUnit cu = new XamlCompilationUnit(projectContent);
@@ -54,7 +58,7 @@ namespace ICSharpCode.XamlBinding
 					r.Read();
 					r.MoveToContent();
 					DomRegion classStart = new DomRegion(r.LineNumber, r.LinePosition - 1);
-					string className = r.GetAttribute("Class", XamlNamespace);
+					string className = r.GetAttribute("Class", CompletionDataHelper.XamlNamespace);
 					if (string.IsNullOrEmpty(className)) {
 						LoggingService.Debug("XamlParser: returning empty cu because root element has no Class attribute");
 					}
@@ -95,7 +99,7 @@ namespace ICSharpCode.XamlBinding
 		void ParseXamlElement(XamlCompilationUnit cu, DefaultClass c, XmlTextReader r)
 		{
 			Debug.Assert(r.NodeType == XmlNodeType.Element);
-			string name = r.GetAttribute("Name", XamlNamespace) ?? r.GetAttribute("Name");
+			string name = r.GetAttribute("Name", CompletionDataHelper.XamlNamespace) ?? r.GetAttribute("Name");
 			bool isEmptyElement = r.IsEmptyElement;
 
 			if (!string.IsNullOrEmpty(name)) {

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlResolver.cs

@@ -181,82 +181,6 @@ namespace ICSharpCode.XamlBinding
 			return null;
 		}
 		
-		void AddEventsForType(ArrayList result, XmlTextReader r, TypeResolveResult rr)
-		{
-			if (rr.ResolvedType != null) {
-				foreach (IEvent e in rr.ResolvedType.GetEvents()) {
-					if (!e.IsPublic)
-						continue;
-					
-					string propPrefix = e.DeclaringType.Name;
-					if (!string.IsNullOrEmpty(r.Prefix))
-						propPrefix = r.Prefix + ":" + propPrefix;
-					result.Add(new XamlCompletionEvent(e, propPrefix));
-				}
-			}
-		}
-		
-		void AddPropertiesForType(ArrayList result, XmlTextReader r, TypeResolveResult rr)
-		{
-			if (rr.ResolvedType != null) {
-				foreach (IProperty p in rr.ResolvedType.GetProperties()) {
-					if (!p.IsPublic)
-						continue;
-					if (!p.CanSet && !IsCollectionType(p.ReturnType))
-						continue;
-					string propPrefix = p.DeclaringType.Name;
-					if (!string.IsNullOrEmpty(r.Prefix))
-						propPrefix = r.Prefix + ":" + propPrefix;
-					result.Add(new XamlCompletionProperty(p, propPrefix));
-				}
-			}
-		}
-
-		bool IsCollectionType(IReturnType rt)
-		{
-			if (rt == null)
-				return false;
-			return rt.GetMethods().Any(m => m.Name == "Add" && m.IsPublic);
-		}
-
-
-
-		class XamlCompletionProperty : DefaultProperty, IEntity
-		{
-			string newName;
-
-			public XamlCompletionProperty(IProperty baseProperty, string prefix)
-				: base(baseProperty.DeclaringType, baseProperty.Name)
-			{
-				this.Modifiers = baseProperty.Modifiers;
-				this.CopyDocumentationFrom(baseProperty);
-				newName = prefix + "." + baseProperty.Name;
-			}
-
-			string IEntity.Name
-			{
-				get { return newName; }
-			}
-		}
-		
-		class XamlCompletionEvent : DefaultEvent, IEntity
-		{
-			string newName;
-
-			public XamlCompletionEvent(IEvent baseEvent, string prefix)
-				: base(baseEvent.DeclaringType, baseEvent.Name)
-			{
-				this.Modifiers = baseEvent.Modifiers;
-				this.CopyDocumentationFrom(baseEvent);
-				newName = prefix + "." + baseEvent.Name;
-			}
-
-			string IEntity.Name
-			{
-				get { return newName; }
-			}
-		}
-		
 		public ArrayList CtrlSpace(int caretLine, int caretColumn, ParseInformation parseInfo, string fileContent, ExpressionContext context)
 		{
 			return new ArrayList();

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

@@ -203,6 +203,8 @@ namespace ICSharpCode.XmlEditor
 		{
 			string name = GetAttributeNameAtIndex(xml, index);
 			QualifiedName qualifiedName = GetQualifiedName(name);
+			if (qualifiedName == null)
+				return null;
 			if (String.IsNullOrEmpty(qualifiedName.Namespace) && includeNamespace) {
 				QualifiedNameCollection namespaces = new QualifiedNameCollection();
 				XmlElementPath path = GetActiveElementStartPathAtIndex(xml, index, namespaces);

src/SharpDevelop.Tests.sln

@@ -1,128 +1,128 @@
 
 Microsoft Visual Studio Solution File, Format Version 10.00
 # Visual Studio 2008
-# SharpDevelop 3.1.0.3916
+# SharpDevelop 3.1.0.3955
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AddIns", "AddIns", "{14A277EE-7DF1-4529-B639-7D1EF334C1C5}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBNetBinding.Tests", "AddIns\BackendBindings\VBNetBinding\Test\VBNetBinding.Tests.csproj", "{50A89267-A28B-4DF3-8E62-912E005143B8}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Python", "Python", "{F94FA21D-78E6-410B-895D-E16D3E7240DB}"
-	ProjectSection(SolutionItems) = postProject
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding.Tests", "AddIns\BackendBindings\Python\PythonBinding\Test\PythonBinding.Tests.csproj", "{23B517C9-1ECC-4419-A13F-0B7136D085CB}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Python.Build.Tasks.Tests", "AddIns\BackendBindings\Python\Python.Build.Tasks\Test\Python.Build.Tasks.Tests.csproj", "{833904AB-3CD4-4071-9B48-5770E44685AA}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XamlBinding.Tests", "AddIns\BackendBindings\XamlBinding\XamlBinding.Tests\XamlBinding.Tests.csproj", "{F390DA70-1FE1-4715-81A0-389AB010C130}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding", "AddIns\BackendBindings\Python\PythonBinding\Project\PythonBinding.csproj", "{8D732610-8FC6-43BA-94C9-7126FD7FE361}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XamlBinding", "AddIns\BackendBindings\XamlBinding\XamlBinding\XamlBinding.csproj", "{7C96B65D-28A5-4F28-A35B-8D83CE831EE8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Python.Build.Tasks", "AddIns\BackendBindings\Python\Python.Build.Tasks\Project\Python.Build.Tasks.csproj", "{D332F2D1-2CF1-43B7-903C-844BD5211A7E}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ResourceToolkit.Tests", "AddIns\Misc\ResourceToolkit\Test\ResourceToolkit.Tests.csproj", "{DD9AE6A5-2B9D-443A-BC71-38BE578C36BD}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CSharpBinding", "AddIns\BackendBindings\CSharpBinding\Project\CSharpBinding.csproj", "{1F1AC7CD-D154-45BB-8EAF-804CA8055F5A}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ResourceToolkit", "AddIns\Misc\ResourceToolkit\Project\ResourceToolkit.csproj", "{461606BD-E824-4D0A-8CBA-01810B1F5E02}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Debugger", "Debugger", "{6604365C-C702-4C10-9BA8-637F1E3D4D0D}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Boo", "Boo", "{5DA95927-5F2D-46D8-9265-D092734B6F0E}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.Core", "AddIns\Misc\Debugger\Debugger.Core\Project\Debugger.Core.csproj", "{1D18D788-F7EE-4585-A23B-34DC8EC63CB8}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter.Tests", "AddIns\BackendBindings\Boo\NRefactoryToBooConverter\Test\NRefactoryToBooConverter.Tests.csproj", "{C9DE556D-325C-4544-B29F-16A9EB7C9830}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.AddIn", "AddIns\Misc\Debugger\Debugger.AddIn\Project\Debugger.AddIn.csproj", "{EC06F96A-AEEC-49D6-B03D-AB87C6EB674C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter", "AddIns\BackendBindings\Boo\NRefactoryToBooConverter\Project\NRefactoryToBooConverter.csproj", "{DBCF20A1-BA13-4582-BFA9-74DE4D987B73}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.Tests", "AddIns\Misc\Debugger\Debugger.Tests\Project\Debugger.Tests.csproj", "{A4C858C8-51B6-4265-A695-A20FCEBA1D19}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BooBinding.Tests", "AddIns\BackendBindings\Boo\BooBinding\Test\BooBinding.Tests.csproj", "{6FA16499-896F-4C02-BB43-1AF5C6C7C713}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor", "AddIns\DisplayBindings\XmlEditor\Project\XmlEditor.csproj", "{6B717BD1-CD5E-498C-A42E-9E6A4584DC48}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BooBinding", "AddIns\BackendBindings\Boo\BooBinding\Project\BooBinding.csproj", "{4AC2D5F1-F671-480C-A075-6BF62B3721B2}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor.Tests", "AddIns\DisplayBindings\XmlEditor\Test\XmlEditor.Tests.csproj", "{FC0FE702-A87D-4D70-A9B6-1ECCD611125F}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchAndReplace.Tests", "AddIns\Misc\SearchAndReplace\Test\SearchAndReplace.Tests.csproj", "{A569DCC1-C608-45FD-B770-4F79335EF154}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBNetBinding", "AddIns\BackendBindings\VBNetBinding\Project\VBNetBinding.csproj", "{BF38FB72-B380-4196-AF8C-95749D726C61}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchAndReplace", "AddIns\Misc\SearchAndReplace\Project\SearchAndReplace.csproj", "{9196DD8A-B4D4-4780-8742-C5762E547FC2}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCoverage.Tests", "AddIns\Misc\CodeCoverage\Test\CodeCoverage.Tests.csproj", "{A5C0E8F8-9D04-46ED-91D6-1DEF1575313B}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTesting.Tests", "AddIns\Misc\UnitTesting\Test\UnitTesting.Tests.csproj", "{44A8DE09-CAB9-49D8-9CFC-5EB0A552F181}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCoverage", "AddIns\Misc\CodeCoverage\Project\CodeCoverage.csproj", "{08ce9972-283b-44f4-82fa-966f7dfa6b7a}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WixBinding.Tests", "AddIns\BackendBindings\WixBinding\Test\WixBinding.Tests.csproj", "{388E7B64-0393-4EB4-A3E3-5C474F141853}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTesting", "AddIns\Misc\UnitTesting\UnitTesting.csproj", "{1F261725-6318-4434-A1B1-6C70CE4CD324}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WixBinding", "AddIns\BackendBindings\WixBinding\Project\WixBinding.csproj", "{e1b288a2-08ee-4318-8bbb-8ab72c69e33e}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeAnalysis", "AddIns\Misc\CodeAnalysis\CodeAnalysis.csproj", "{3EAA45A9-735C-4AC7-A799-947B93EA449D}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FormsDesigner", "AddIns\DisplayBindings\FormsDesigner\Project\FormsDesigner.csproj", "{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeAnalysis", "AddIns\Misc\CodeAnalysis\CodeAnalysis.csproj", "{3EAA45A9-735C-4AC7-A799-947B93EA449D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTesting", "AddIns\Misc\UnitTesting\UnitTesting.csproj", "{1F261725-6318-4434-A1B1-6C70CE4CD324}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WixBinding", "AddIns\BackendBindings\WixBinding\Project\WixBinding.csproj", "{e1b288a2-08ee-4318-8bbb-8ab72c69e33e}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCoverage", "AddIns\Misc\CodeCoverage\Project\CodeCoverage.csproj", "{08ce9972-283b-44f4-82fa-966f7dfa6b7a}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WixBinding.Tests", "AddIns\BackendBindings\WixBinding\Test\WixBinding.Tests.csproj", "{388E7B64-0393-4EB4-A3E3-5C474F141853}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCoverage.Tests", "AddIns\Misc\CodeCoverage\Test\CodeCoverage.Tests.csproj", "{A5C0E8F8-9D04-46ED-91D6-1DEF1575313B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTesting.Tests", "AddIns\Misc\UnitTesting\Test\UnitTesting.Tests.csproj", "{44A8DE09-CAB9-49D8-9CFC-5EB0A552F181}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBNetBinding", "AddIns\BackendBindings\VBNetBinding\Project\VBNetBinding.csproj", "{BF38FB72-B380-4196-AF8C-95749D726C61}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchAndReplace", "AddIns\Misc\SearchAndReplace\Project\SearchAndReplace.csproj", "{9196DD8A-B4D4-4780-8742-C5762E547FC2}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor.Tests", "AddIns\DisplayBindings\XmlEditor\Test\XmlEditor.Tests.csproj", "{FC0FE702-A87D-4D70-A9B6-1ECCD611125F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SearchAndReplace.Tests", "AddIns\Misc\SearchAndReplace\Test\SearchAndReplace.Tests.csproj", "{A569DCC1-C608-45FD-B770-4F79335EF154}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XmlEditor", "AddIns\DisplayBindings\XmlEditor\Project\XmlEditor.csproj", "{6B717BD1-CD5E-498C-A42E-9E6A4584DC48}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Boo", "Boo", "{5DA95927-5F2D-46D8-9265-D092734B6F0E}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Debugger", "Debugger", "{6604365C-C702-4C10-9BA8-637F1E3D4D0D}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BooBinding", "AddIns\BackendBindings\Boo\BooBinding\Project\BooBinding.csproj", "{4AC2D5F1-F671-480C-A075-6BF62B3721B2}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.Tests", "AddIns\Misc\Debugger\Debugger.Tests\Project\Debugger.Tests.csproj", "{A4C858C8-51B6-4265-A695-A20FCEBA1D19}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BooBinding.Tests", "AddIns\BackendBindings\Boo\BooBinding\Test\BooBinding.Tests.csproj", "{6FA16499-896F-4C02-BB43-1AF5C6C7C713}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.AddIn", "AddIns\Misc\Debugger\Debugger.AddIn\Project\Debugger.AddIn.csproj", "{EC06F96A-AEEC-49D6-B03D-AB87C6EB674C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter", "AddIns\BackendBindings\Boo\NRefactoryToBooConverter\Project\NRefactoryToBooConverter.csproj", "{DBCF20A1-BA13-4582-BFA9-74DE4D987B73}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debugger.Core", "AddIns\Misc\Debugger\Debugger.Core\Project\Debugger.Core.csproj", "{1D18D788-F7EE-4585-A23B-34DC8EC63CB8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryToBooConverter.Tests", "AddIns\BackendBindings\Boo\NRefactoryToBooConverter\Test\NRefactoryToBooConverter.Tests.csproj", "{C9DE556D-325C-4544-B29F-16A9EB7C9830}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CSharpBinding", "AddIns\BackendBindings\CSharpBinding\Project\CSharpBinding.csproj", "{1F1AC7CD-D154-45BB-8EAF-804CA8055F5A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ResourceToolkit", "AddIns\Misc\ResourceToolkit\Project\ResourceToolkit.csproj", "{461606BD-E824-4D0A-8CBA-01810B1F5E02}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Python", "Python", "{F94FA21D-78E6-410B-895D-E16D3E7240DB}"
+	ProjectSection(SolutionItems) = postProject
+	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ResourceToolkit.Tests", "AddIns\Misc\ResourceToolkit\Test\ResourceToolkit.Tests.csproj", "{DD9AE6A5-2B9D-443A-BC71-38BE578C36BD}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Python.Build.Tasks", "AddIns\BackendBindings\Python\Python.Build.Tasks\Project\Python.Build.Tasks.csproj", "{D332F2D1-2CF1-43B7-903C-844BD5211A7E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XamlBinding", "AddIns\BackendBindings\XamlBinding\XamlBinding\XamlBinding.csproj", "{7C96B65D-28A5-4F28-A35B-8D83CE831EE8}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding", "AddIns\BackendBindings\Python\PythonBinding\Project\PythonBinding.csproj", "{8D732610-8FC6-43BA-94C9-7126FD7FE361}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XamlBinding.Tests", "AddIns\BackendBindings\XamlBinding\XamlBinding.Tests\XamlBinding.Tests.csproj", "{F390DA70-1FE1-4715-81A0-389AB010C130}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Python.Build.Tasks.Tests", "AddIns\BackendBindings\Python\Python.Build.Tasks\Test\Python.Build.Tasks.Tests.csproj", "{833904AB-3CD4-4071-9B48-5770E44685AA}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding.Tests", "AddIns\BackendBindings\Python\PythonBinding\Test\PythonBinding.Tests.csproj", "{23B517C9-1ECC-4419-A13F-0B7136D085CB}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBNetBinding.Tests", "AddIns\BackendBindings\VBNetBinding\Test\VBNetBinding.Tests.csproj", "{50A89267-A28B-4DF3-8E62-912E005143B8}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Libraries", "Libraries", "{9421EDF4-9769-4BE9-B5A6-C87DE221D73C}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Libraries\NRefactory\Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.AvalonEdit.Tests", "Libraries\AvalonEdit\ICSharpCode.AvalonEdit.Tests\ICSharpCode.AvalonEdit.Tests.csproj", "{6222A3A1-83CE-47A3-A4E4-A018F82D44D8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Libraries\NRefactory\Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.AvalonEdit", "Libraries\AvalonEdit\ICSharpCode.AvalonEdit\ICSharpCode.AvalonEdit.csproj", "{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TextEditor", "Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj", "{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Aga.Controls", "Libraries\TreeViewAdv\Aga.Controls\Aga.Controls.csproj", "{E73BB233-D88B-44A7-A98F-D71EE158381D}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TextEditor.Tests", "Libraries\ICSharpCode.TextEditor\Test\ICSharpCode.TextEditor.Tests.csproj", "{6259D767-BA7C-484D-9472-68F350A20086}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Aga.Controls", "Libraries\TreeViewAdv\Aga.Controls\Aga.Controls.csproj", "{E73BB233-D88B-44A7-A98F-D71EE158381D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TextEditor", "Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj", "{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.AvalonEdit", "Libraries\AvalonEdit\ICSharpCode.AvalonEdit\ICSharpCode.AvalonEdit.csproj", "{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Libraries\NRefactory\Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.AvalonEdit.Tests", "Libraries\AvalonEdit\ICSharpCode.AvalonEdit.Tests\ICSharpCode.AvalonEdit.Tests.csproj", "{6222A3A1-83CE-47A3-A4E4-A018F82D44D8}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Libraries\NRefactory\Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Main", "Main", "{5A3EBEBA-0560-41C1-966B-23F7D03A5486}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StartUp", "Main\StartUp\Project\StartUp.csproj", "{1152B71B-3C05-4598-B20D-823B5D40559E}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core", "Main\Core\Project\ICSharpCode.Core.csproj", "{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Presentation", "Main\ICSharpCode.Core.Presentation\ICSharpCode.Core.Presentation.csproj", "{7E4A7172-7FF5-48D0-B719-7CD959DD1AC9}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop", "Main\Base\Project\ICSharpCode.SharpDevelop.csproj", "{2748AD25-9C63-4E12-877B-4DCE96FBED54}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.WinForms", "Main\ICSharpCode.Core.WinForms\ICSharpCode.Core.WinForms.csproj", "{857CA1A3-FC88-4BE0-AB6A-D1EE772AB288}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Tests", "Main\Base\Test\ICSharpCode.SharpDevelop.Tests.csproj", "{4980B743-B32F-4aba-AABD-45E2CAD3568D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Dom.Tests", "Main\ICSharpCode.SharpDevelop.Dom\Tests\ICSharpCode.SharpDevelop.Dom.Tests\ICSharpCode.SharpDevelop.Dom.Tests.csproj", "{7DB80259-24D4-46C3-A024-53FF1987733D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Tests", "Main\Core\Test\ICSharpCode.Core.Tests.csproj", "{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.BuildWorker", "Main\ICSharpCode.SharpDevelop.BuildWorker\ICSharpCode.SharpDevelop.BuildWorker.csproj", "{C3CBC8E3-81D8-4C5B-9941-DCCD12D50B1F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Sda", "Main\ICSharpCode.SharpDevelop.Sda\ICSharpCode.SharpDevelop.Sda.csproj", "{80318B5F-A25D-45AB-8A95-EF31D2370A4C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Widgets", "Main\ICSharpCode.SharpDevelop.Widgets\Project\ICSharpCode.SharpDevelop.Widgets.csproj", "{8035765F-D51F-4A0C-A746-2FD100E19419}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Dom", "Main\ICSharpCode.SharpDevelop.Dom\Project\ICSharpCode.SharpDevelop.Dom.csproj", "{924EE450-603D-49C1-A8E5-4AFAA31CE6F3}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Widgets", "Main\ICSharpCode.SharpDevelop.Widgets\Project\ICSharpCode.SharpDevelop.Widgets.csproj", "{8035765F-D51F-4A0C-A746-2FD100E19419}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Sda", "Main\ICSharpCode.SharpDevelop.Sda\ICSharpCode.SharpDevelop.Sda.csproj", "{80318B5F-A25D-45AB-8A95-EF31D2370A4C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.BuildWorker", "Main\ICSharpCode.SharpDevelop.BuildWorker\ICSharpCode.SharpDevelop.BuildWorker.csproj", "{C3CBC8E3-81D8-4C5B-9941-DCCD12D50B1F}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Tests", "Main\Core\Test\ICSharpCode.Core.Tests.csproj", "{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Dom.Tests", "Main\ICSharpCode.SharpDevelop.Dom\Tests\ICSharpCode.SharpDevelop.Dom.Tests\ICSharpCode.SharpDevelop.Dom.Tests.csproj", "{7DB80259-24D4-46C3-A024-53FF1987733D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Tests", "Main\Base\Test\ICSharpCode.SharpDevelop.Tests.csproj", "{4980B743-B32F-4aba-AABD-45E2CAD3568D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.WinForms", "Main\ICSharpCode.Core.WinForms\ICSharpCode.Core.WinForms.csproj", "{857CA1A3-FC88-4BE0-AB6A-D1EE772AB288}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop", "Main\Base\Project\ICSharpCode.SharpDevelop.csproj", "{2748AD25-9C63-4E12-877B-4DCE96FBED54}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Presentation", "Main\ICSharpCode.Core.Presentation\ICSharpCode.Core.Presentation.csproj", "{7E4A7172-7FF5-48D0-B719-7CD959DD1AC9}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core", "Main\Core\Project\ICSharpCode.Core.csproj", "{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StartUp", "Main\StartUp\Project\StartUp.csproj", "{1152B71B-3C05-4598-B20D-823B5D40559E}"
 EndProject
 Project("{00000000-0000-0000-0000-000000000000}") = "Tools", "Tools\Tools.build", "{970116b0-f96b-4257-8579-986b9cf086f5}"
 EndProject
@@ -337,57 +337,57 @@ Global
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{F390DA70-1FE1-4715-81A0-389AB010C130} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{7C96B65D-28A5-4F28-A35B-8D83CE831EE8} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{DD9AE6A5-2B9D-443A-BC71-38BE578C36BD} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{461606BD-E824-4D0A-8CBA-01810B1F5E02} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{5DA95927-5F2D-46D8-9265-D092734B6F0E} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{A569DCC1-C608-45FD-B770-4F79335EF154} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{9196DD8A-B4D4-4780-8742-C5762E547FC2} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{44A8DE09-CAB9-49D8-9CFC-5EB0A552F181} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{388E7B64-0393-4EB4-A3E3-5C474F141853} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{e1b288a2-08ee-4318-8bbb-8ab72c69e33e} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{3EAA45A9-735C-4AC7-A799-947B93EA449D} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{1F261725-6318-4434-A1B1-6C70CE4CD324} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{08ce9972-283b-44f4-82fa-966f7dfa6b7a} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{A5C0E8F8-9D04-46ED-91D6-1DEF1575313B} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{BF38FB72-B380-4196-AF8C-95749D726C61} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{FC0FE702-A87D-4D70-A9B6-1ECCD611125F} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{6B717BD1-CD5E-498C-A42E-9E6A4584DC48} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{6604365C-C702-4C10-9BA8-637F1E3D4D0D} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{1F1AC7CD-D154-45BB-8EAF-804CA8055F5A} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{F94FA21D-78E6-410B-895D-E16D3E7240DB} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
 		{50A89267-A28B-4DF3-8E62-912E005143B8} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
-		{D332F2D1-2CF1-43B7-903C-844BD5211A7E} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
-		{8D732610-8FC6-43BA-94C9-7126FD7FE361} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
-		{833904AB-3CD4-4071-9B48-5770E44685AA} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
-		{23B517C9-1ECC-4419-A13F-0B7136D085CB} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
-		{A4C858C8-51B6-4265-A695-A20FCEBA1D19} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
-		{EC06F96A-AEEC-49D6-B03D-AB87C6EB674C} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
-		{1D18D788-F7EE-4585-A23B-34DC8EC63CB8} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
-		{C9DE556D-325C-4544-B29F-16A9EB7C9830} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
-		{DBCF20A1-BA13-4582-BFA9-74DE4D987B73} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
-		{6FA16499-896F-4C02-BB43-1AF5C6C7C713} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
+		{F94FA21D-78E6-410B-895D-E16D3E7240DB} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{1F1AC7CD-D154-45BB-8EAF-804CA8055F5A} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{6604365C-C702-4C10-9BA8-637F1E3D4D0D} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{6B717BD1-CD5E-498C-A42E-9E6A4584DC48} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{FC0FE702-A87D-4D70-A9B6-1ECCD611125F} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{BF38FB72-B380-4196-AF8C-95749D726C61} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{A5C0E8F8-9D04-46ED-91D6-1DEF1575313B} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{08ce9972-283b-44f4-82fa-966f7dfa6b7a} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{1F261725-6318-4434-A1B1-6C70CE4CD324} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{7D7E92DF-ACEB-4B69-92C8-8AC7A703CD57} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{3EAA45A9-735C-4AC7-A799-947B93EA449D} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{e1b288a2-08ee-4318-8bbb-8ab72c69e33e} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{388E7B64-0393-4EB4-A3E3-5C474F141853} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{44A8DE09-CAB9-49D8-9CFC-5EB0A552F181} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{9196DD8A-B4D4-4780-8742-C5762E547FC2} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{A569DCC1-C608-45FD-B770-4F79335EF154} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{5DA95927-5F2D-46D8-9265-D092734B6F0E} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{461606BD-E824-4D0A-8CBA-01810B1F5E02} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{DD9AE6A5-2B9D-443A-BC71-38BE578C36BD} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{7C96B65D-28A5-4F28-A35B-8D83CE831EE8} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
+		{F390DA70-1FE1-4715-81A0-389AB010C130} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
 		{4AC2D5F1-F671-480C-A075-6BF62B3721B2} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
-		{6222A3A1-83CE-47A3-A4E4-A018F82D44D8} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{E73BB233-D88B-44A7-A98F-D71EE158381D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{6259D767-BA7C-484D-9472-68F350A20086} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{870115DD-960A-4406-A6B9-600BCDC36A03} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{6FA16499-896F-4C02-BB43-1AF5C6C7C713} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
+		{DBCF20A1-BA13-4582-BFA9-74DE4D987B73} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
+		{C9DE556D-325C-4544-B29F-16A9EB7C9830} = {5DA95927-5F2D-46D8-9265-D092734B6F0E}
+		{1D18D788-F7EE-4585-A23B-34DC8EC63CB8} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
+		{EC06F96A-AEEC-49D6-B03D-AB87C6EB674C} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
+		{A4C858C8-51B6-4265-A695-A20FCEBA1D19} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
+		{23B517C9-1ECC-4419-A13F-0B7136D085CB} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
+		{833904AB-3CD4-4071-9B48-5770E44685AA} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
+		{8D732610-8FC6-43BA-94C9-7126FD7FE361} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
+		{D332F2D1-2CF1-43B7-903C-844BD5211A7E} = {F94FA21D-78E6-410B-895D-E16D3E7240DB}
 		{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{7E4A7172-7FF5-48D0-B719-7CD959DD1AC9} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{857CA1A3-FC88-4BE0-AB6A-D1EE772AB288} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{7DB80259-24D4-46C3-A024-53FF1987733D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{C3CBC8E3-81D8-4C5B-9941-DCCD12D50B1F} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{8035765F-D51F-4A0C-A746-2FD100E19419} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{924EE450-603D-49C1-A8E5-4AFAA31CE6F3} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{80318B5F-A25D-45AB-8A95-EF31D2370A4C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{4980B743-B32F-4aba-AABD-45E2CAD3568D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{2748AD25-9C63-4E12-877B-4DCE96FBED54} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{870115DD-960A-4406-A6B9-600BCDC36A03} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{6259D767-BA7C-484D-9472-68F350A20086} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{E73BB233-D88B-44A7-A98F-D71EE158381D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{6C55B776-26D4-4DB3-A6AB-87E783B2F3D1} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{6222A3A1-83CE-47A3-A4E4-A018F82D44D8} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
 		{1152B71B-3C05-4598-B20D-823B5D40559E} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{2748AD25-9C63-4E12-877B-4DCE96FBED54} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{4980B743-B32F-4aba-AABD-45E2CAD3568D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{80318B5F-A25D-45AB-8A95-EF31D2370A4C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{924EE450-603D-49C1-A8E5-4AFAA31CE6F3} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{8035765F-D51F-4A0C-A746-2FD100E19419} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{C3CBC8E3-81D8-4C5B-9941-DCCD12D50B1F} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{7DB80259-24D4-46C3-A024-53FF1987733D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{857CA1A3-FC88-4BE0-AB6A-D1EE772AB288} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{7E4A7172-7FF5-48D0-B719-7CD959DD1AC9} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
 	EndGlobalSection
 EndGlobal

src/SharpDevelop.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 10.00
 # Visual Studio 2008
-# SharpDevelop 3.1.0.3903
+# SharpDevelop 3.1.0.3946
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AddIns", "AddIns", "{14A277EE-7DF1-4529-B639-7D1EF334C1C5}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection