XamlBinding:

fixed smaller bugs
improved Trigger and Style CC

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

src/AddIns/BackendBindings/XamlBinding/XamlBinding/Comparers.cs

@@ -0,0 +1,53 @@
+// <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 ICSharpCode.SharpDevelop.Dom;
+using System.Collections.Generic;
+
+namespace ICSharpCode.XamlBinding
+{
+	sealed class ParameterComparer : IEqualityComparer<IParameter> {
+		public bool Equals(IParameter x, IParameter y)
+		{
+			return x.Compare(y);
+		}
+		
+		public int GetHashCode(IParameter obj)
+		{
+			return obj.GetHashCode();
+		}
+	}
+	
+	sealed class XmlnsEqualityComparer : IEqualityComparer<XmlnsCompletionItem> {
+		public bool Equals(XmlnsCompletionItem x, XmlnsCompletionItem y)
+		{
+			return x.Namespace == y.Namespace && x.Assembly == y.Assembly;
+		}
+		
+		public int GetHashCode(XmlnsCompletionItem obj)
+		{
+			return string.IsNullOrEmpty(obj.Assembly) ? obj.Namespace.GetHashCode() : obj.Namespace.GetHashCode() ^ obj.Assembly.GetHashCode();
+		}
+	}
+	
+	sealed class XmlnsComparer : IComparer<XmlnsCompletionItem> {
+		public int Compare(XmlnsCompletionItem x, XmlnsCompletionItem y)
+		{
+			if (x.IsUrl && y.IsUrl)
+				return string.CompareOrdinal(x.Namespace, y.Namespace);
+			if (x.IsUrl)
+				return -1;
+			if (y.IsUrl)
+				return 1;
+			if (x.Assembly == y.Assembly)
+				return string.CompareOrdinal(x.Namespace, y.Namespace);
+			else
+				return string.CompareOrdinal(x.Assembly, y.Assembly);
+		}
+	}
+}

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

@@ -231,34 +231,6 @@ namespace ICSharpCode.XamlBinding
 				.Cast<ICompletionItem>();
 		}
 		
-		sealed class XmlnsEqualityComparer : IEqualityComparer<XmlnsCompletionItem> {
-			public bool Equals(XmlnsCompletionItem x, XmlnsCompletionItem y)
-			{
-				return x.Namespace == y.Namespace && x.Assembly == y.Assembly;
-			}
-			
-			public int GetHashCode(XmlnsCompletionItem obj)
-			{
-				return string.IsNullOrEmpty(obj.Assembly) ? obj.Namespace.GetHashCode() : obj.Namespace.GetHashCode() ^ obj.Assembly.GetHashCode();
-			}
-		}
-		
-		sealed class XmlnsComparer : IComparer<XmlnsCompletionItem> {
-			public int Compare(XmlnsCompletionItem x, XmlnsCompletionItem y)
-			{
-				if (x.IsUrl && y.IsUrl)
-					return string.CompareOrdinal(x.Namespace, y.Namespace);
-				if (x.IsUrl)
-					return -1;
-				if (y.IsUrl)
-					return 1;
-				if (x.Assembly == y.Assembly)
-					return string.CompareOrdinal(x.Namespace, y.Namespace);
-				else
-					return string.CompareOrdinal(x.Assembly, y.Assembly);
-			}
-		}
-		
 		static string GetContentPropertyName(IReturnType type)
 		{
 			if (type == null)
@@ -681,9 +653,11 @@ namespace ICSharpCode.XamlBinding
 					yield break;
 			}
 			
-			bool isExplicit;
+			bool isExplicit, showFull = false;
 			IReturnType typeName;
 			
+			string valueBeforeCaret = (context.ValueStartOffset > 0) ? context.RawAttributeValue.Substring(0, context.ValueStartOffset + 1) : "";
+			
 			switch (c.ClassType) {
 				case ClassType.Class:
 					switch (c.FullyQualifiedName) {
@@ -701,16 +675,26 @@ namespace ICSharpCode.XamlBinding
 							
 							bool isReadOnly = context.ActiveElement.Name.EndsWith("Trigger");
 							
+							Core.LoggingService.Debug("value: " + valueBeforeCaret);
+
+							if (!isExplicit && valueBeforeCaret.Contains("."))
+								showFull = true;
+							
 							if (typeName != null) {
-								foreach (var item in typeName.GetDependencyProperties(true, !isExplicit, !isReadOnly))
+								foreach (var item in typeName.GetDependencyProperties(true, !isExplicit, !isReadOnly, showFull))
 									yield return item;
 							}
 							break;
 						case "System.Windows.RoutedEvent":
 							typeName = GetType(context, out isExplicit);
 							
+							Core.LoggingService.Debug("value: " + valueBeforeCaret);
+							
+							if (!isExplicit && valueBeforeCaret.Contains("."))
+								showFull = true;
+							
 							if (typeName != null) {
-								foreach (var item in typeName.GetRoutedEvents(true, !isExplicit))
+								foreach (var item in typeName.GetRoutedEvents(true, !isExplicit, showFull))
 									yield return item;
 							}
 							break;
@@ -896,12 +880,7 @@ namespace ICSharpCode.XamlBinding
 						if ((m.ReturnType != null && delegateInvoker.ReturnType != null) && m.ReturnType.DotNetName != delegateInvoker.ReturnType.DotNetName)
 							continue;
 						
-						bool equal = true;
+						bool equal = m.Parameters.SequenceEqual(delegateInvoker.Parameters, new ParameterComparer());
-						for (int i = 0; i < m.Parameters.Count; i++) {
-							equal &= CompareParameter(m.Parameters[i], delegateInvoker.Parameters[i]);
-							if (!equal)
-								break;
-						}
 						if (equal) {
 							yield return new XamlCodeCompletionItem(m);
 						}
@@ -910,7 +889,7 @@ namespace ICSharpCode.XamlBinding
 			}
 		}
 
-		static bool CompareParameter(IParameter p1, IParameter p2)
+		public static bool Compare(this IParameter p1, IParameter p2)
 		{
 			return (p1.ReturnType.DotNetName == p2.ReturnType.DotNetName) &&
 				(p1.IsOut == p2.IsOut) && (p1.IsParams == p2.IsParams) && (p1.IsRef == p2.IsRef);
@@ -939,7 +918,7 @@ namespace ICSharpCode.XamlBinding
 				 (thisValue.SetterModifiers & ModifierEnum.Public) == ModifierEnum.Public);
 		}
 		
-		public static IEnumerable<ICompletionItem> GetDependencyProperties(this IReturnType type, bool excludeSuffix, bool addType, bool requiresSetable)
+		public static IEnumerable<ICompletionItem> GetDependencyProperties(this IReturnType type, bool excludeSuffix, bool addType, bool requiresSetable, bool showFull)
 		{
 			foreach (var field in type.GetFields()) {
 				if (field.ReturnType.FullyQualifiedName != "System.Windows.DependencyProperty")
@@ -950,20 +929,23 @@ namespace ICSharpCode.XamlBinding
 				IProperty property = type.GetProperties().FirstOrDefault(p => p.Name == fieldName);
 				if (property == null)
 					continue;
-				if (requiresSetable && property.IsPubliclySetable())
+				if (requiresSetable && !property.IsPubliclySetable())
-					
+					continue;
 				
 				if (!excludeSuffix)
-					fieldName += "Property";
+					fieldName = field.Name;
+				
+				if (showFull) {
+					addType = false;
 					
-				if (addType)
+					fieldName = field.DeclaringType.Name + "." + fieldName;
-					fieldName = type.Name + "." + fieldName;
+				}
 				
-				yield return new XamlCodeCompletionItem(fieldName, field);
+				yield return new XamlLazyValueCompletionItem(field, fieldName, addType);
 			}
 		}
 		
-		public static IEnumerable<ICompletionItem> GetRoutedEvents(this IReturnType type, bool excludeSuffix, bool addType)
+		public static IEnumerable<ICompletionItem> GetRoutedEvents(this IReturnType type, bool excludeSuffix, bool addType, bool showFull)
 		{
 			foreach (var field in type.GetFields()) {
 				if (field.ReturnType.FullyQualifiedName != "System.Windows.RoutedEvent")
@@ -975,12 +957,15 @@ namespace ICSharpCode.XamlBinding
 					continue;
 				
 				if (!excludeSuffix)
-					fieldName += "Event";
+					fieldName = field.Name;
+				
+				if (showFull) {
+					addType = false;
 					
-				if (addType)
+					fieldName = field.DeclaringType.Name + "." + fieldName;
-					fieldName = type.Name + "." + fieldName;
+				}
 				
-				yield return new XamlCodeCompletionItem(fieldName, field);
+				yield return new XamlLazyValueCompletionItem(field, fieldName, addType);
 			}
 		}
 

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlBinding.addin

@@ -44,12 +44,12 @@
 		<CodeCompletionBinding id = "XAML" extensions = ".xaml" class = "ICSharpCode.XamlBinding.XamlCodeCompletionBinding"/>
 	</Path>
 	
-<Path name="/SharpDevelop/Workbench/LanguageBindings">
+	<Path name="/SharpDevelop/Workbench/LanguageBindings">
 		<LanguageBinding
 			id="XAML"
 		    class="ICSharpCode.XamlBinding.XamlLanguageBinding"
 		    extensions=".xaml" />
-</Path>
+	</Path>
 
 	<!-- Options panel -->
 	<Path name="/SharpDevelop/Dialogs/OptionsDialog/TextEditorOptions">
@@ -69,9 +69,9 @@
 				<MenuItem id="RemoveMargin"
 						   class="ICSharpCode.XamlBinding.PowerToys.Commands.RemoveMarginCommand"
 						   label="${res:AddIns.XamlBinding.Menu.RemoveMargin}" />
-				<MenuItem id="RemoveUnnecessaryAttributes"
+<!--				<MenuItem id="RemoveUnnecessaryAttributes"
 						   class="ICSharpCode.XamlBinding.PowerToys.Commands.RemoveUnnecessaryAttributesCommand"
-						   label="${res:AddIns.XamlBinding.Menu.RemoveUnnecessaryAttributes}" />
+						   label="${res:AddIns.XamlBinding.Menu.RemoveUnnecessaryAttributes}" />-->
 				<MenuItem type="Separator" />
 				<MenuItem id="ExtractPropertiesAsStyle"
 						   class="ICSharpCode.XamlBinding.PowerToys.Commands.ExtractPropertiesAsStyleCommand"
@@ -89,9 +89,9 @@
 				<MenuItem id="EditGridColumnsAndRows"
 						   class="ICSharpCode.XamlBinding.PowerToys.Commands.EditGridColumnsAndRowsCommand"
 						   label="${res:AddIns.XamlBinding.Menu.EditGridColumnsAndRows}" />
-				<MenuItem id="CreateBusinessForm"
+<!--				<MenuItem id="CreateBusinessForm"
 						   class="ICSharpCode.XamlBinding.PowerToys.Commands.CreateBusinessFormFromClassCommand"
-						   label="${res:AddIns.XamlBinding.Menu.CreateBusinessFormFromClass}" />
+						   label="${res:AddIns.XamlBinding.Menu.CreateBusinessFormFromClass}" />-->
 			</MenuItem>
 		</ComplexCondition>
 	</Path>

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

@@ -66,6 +66,7 @@
     <Compile Include="..\..\..\..\Main\GlobalAssemblyInfo.cs">
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
+    <Compile Include="Comparers.cs" />
     <Compile Include="LookupInfo.cs" />
     <Compile Include="MarkupExtensionInfo.cs" />
     <Compile Include="MarkupExtensionParser.cs" />

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

@@ -340,12 +340,8 @@ namespace ICSharpCode.XamlBinding
 						if (invoker == null)
 							break;
 						
-						var list = new List<ICompletionItem>() {
-							new NewEventCompletionItem(evtMember.ResolvedMember as IEvent, typeName.Name)
-						};
-						
 						completionList.Items.AddRange(
-							CompletionDataHelper.AddMatchingEventHandlers(context, invoker).Concat(list)
+							CompletionDataHelper.AddMatchingEventHandlers(context, invoker).Add(new NewEventCompletionItem(evtMember.ResolvedMember as IEvent, typeName.Name))
 						);
 						break;
 				}

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

@@ -56,6 +56,28 @@ namespace ICSharpCode.XamlBinding
 		}
 	}
 	
+	class XamlLazyValueCompletionItem : XamlCodeCompletionItem
+	{
+		bool addType;
+		
+		public XamlLazyValueCompletionItem(IEntity entity, string text, bool addType)
+			: base(entity)
+		{
+			this.addType = addType;
+			this.Text = text;
+		}
+		
+		public override void Complete(CompletionContext context)
+		{
+			if (addType) {
+				string newText = Entity.DeclaringType.Name + "." + Text;
+				context.Editor.Document.Replace(context.StartOffset, context.Length, newText);
+				context.EndOffset = context.StartOffset + newText.Length;
+			} else
+				base.Complete(context);
+		}
+	}
+	
 	class XamlCompletionItem : DefaultCompletionItem
 	{
 		string prefix, @namespace, name;

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

@@ -5,14 +5,16 @@
 //     <version>$Revision: 3731 $</version>
 // </file>
 
-using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
 using System;
+using System.Collections.Generic;
 using System.Linq;
+
 using ICSharpCode.NRefactory.Ast;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Dom.Refactoring;
 using ICSharpCode.SharpDevelop.Editor;
+using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
 using ICSharpCode.SharpDevelop.Gui;
 using ICSharpCode.XmlEditor;
 
@@ -92,7 +94,11 @@ namespace ICSharpCode.XamlBinding
 				
 				if (item is NewEventCompletionItem) {
 					NewEventCompletionItem eventItem = item as NewEventCompletionItem;
-					CreateEventHandlerCode(context, eventItem);
+					int discriminator;
+					if (CreateEventHandlerCode(context, eventItem, out discriminator)) {
+						if (discriminator > 0)
+							context.Editor.Document.Insert(context.EndOffset, discriminator.ToString());
+					}
 				}
 				
 				if (item is XmlnsCompletionItem) {
@@ -126,16 +132,27 @@ namespace ICSharpCode.XamlBinding
 			}
 		}
 		
-		static void CreateEventHandlerCode(CompletionContext context, NewEventCompletionItem completionItem)
+		static bool CreateEventHandlerCode(CompletionContext context, NewEventCompletionItem completionItem, out int discriminator)
 		{
 			ParseInformation p = ParserService.GetParseInformation(context.Editor.FileName);
 			var unit = p.MostRecentCompilationUnit;
 			var loc = context.Editor.Document.OffsetToPosition(context.StartOffset);
 			IClass c = unit.GetInnermostClass(loc.Line, loc.Column);
+			
+			discriminator = 1;
+			
 			if (c == null)
-				return;
+				return false;
 			IMethod initializeComponent = c.Methods[0];
 			CompoundClass compound = c.GetCompoundClass() as CompoundClass;
+			
+			IMethod invokeMethod = completionItem.EventType.ReturnType.GetMethods().FirstOrDefault(m => m.Name == "Invoke");
+			
+			string handlerName = completionItem.HandlerName;
+			
+			if (invokeMethod == null)
+				throw new ArgumentException("delegateType is not a valid delegate!");
+
 			if (compound != null) {
 				foreach (IClass part in compound.Parts) {
 					IMember lastMember = part.Methods.LastOrDefault();
@@ -144,31 +161,38 @@ namespace ICSharpCode.XamlBinding
 						continue;
 					
 					if (completionItem.EventType.ReturnType == null)
-						return;
+						return false;
 					
-					IMethod method = completionItem.EventType.ReturnType.GetMethods().FirstOrDefault(m => m.Name == "Invoke");
+					while (part.Methods.Any(m => m.Name == handlerName &&
+					                        m.Parameters.Count == invokeMethod.Parameters.Count &&
+					                        m.Parameters.SequenceEqual(invokeMethod.Parameters, new ParameterComparer())
+					                       )) {
+						handlerName = completionItem.HandlerName + discriminator;
+						discriminator++;
+					}
 					
-					if (method == null)
+					discriminator--;
-						throw new ArgumentException("delegateType is not a valid delegate!");
 					
-					ParametrizedNode node = CodeGenerator.ConvertMember(method, new ClassFinder(part, context.Editor.Caret.Line, context.Editor.Caret.Column));
+					ParametrizedNode node = CodeGenerator.ConvertMember(invokeMethod, new ClassFinder(part, context.Editor.Caret.Line, context.Editor.Caret.Column));
 					
-					node.Name = completionItem.HandlerName;
+					node.Name = handlerName;
 					
 					node.Modifier = Modifiers.None;
 
 					IViewContent viewContent = FileService.OpenFile(part.CompilationUnit.FileName, XamlBindingOptions.SwitchToCodeViewAfterInsertion);
 					IFileDocumentProvider document = viewContent as IFileDocumentProvider;
 					
-					if (viewContent != null || document != null) {
+					if (viewContent != null && document != null) {
 						if (lastMember != null)
 							unit.ProjectContent.Language.CodeGenerator.InsertCodeAfter(lastMember, new RefactoringDocumentAdapter(document.GetDocumentForFile(viewContent.PrimaryFile)), node);
 						else
 							unit.ProjectContent.Language.CodeGenerator.InsertCodeAtEnd(part.Region, new RefactoringDocumentAdapter(document.GetDocumentForFile(viewContent.PrimaryFile)), node);
 					}
-					return;
+					return true;
 				}
 			}
+			
+			return false;
 		}
 	}
 }