- Removed OverrideEqualsGetHashCodeMethodsCommand and OverrideEqualsGetHashCodeMethodsCommand from Refactor menu

- fixed ClassCodeGeneratorMenuBuilder
- allow OptionBinding to be used from Code

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

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/InlineUIElementGenerator.cs

@@ -24,7 +24,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 			this.textView = textView;
 			this.element = element;
 			this.anchor = anchor;
-			anchor.Deleted += delegate { Remove(); };
+			this.anchor.Deleted += delegate { Remove(); };
 		}
 		
 		public override int GetFirstInterestedOffset(int startOffset)

src/AddIns/Misc/SharpRefactoring/SharpRefactoring.addin

@@ -26,9 +26,12 @@
 		<MenuItem id = "ExtractMethod"
 		          label = "${res:AddIns.SharpRefactoring.ExtractMethod}"
 		          class = "SharpRefactoring.ExtractMethodCommand"/>
-		
+<!--	<MenuItem id = "CodeGenSeparator" type = "Separator"/>
 		<MenuItem id = "OverrideToStringMethod"
 		          label = "${res:AddIns.SharpRefactoring.OverrideToStringMethod}"
 		          class = "SharpRefactoring.OverrideToStringMethodCommand"/>
+		<MenuItem id = "OverrideEqualsGetHashCodeMethods"
+		          label = "${res:AddIns.SharpRefactoring.OverrideEqualsGetHashCodeMethods}"
+		          class = "SharpRefactoring.OverrideEqualsGetHashCodeMethodsCommand"/> -->
 	</Path>
 </AddIn>

src/AddIns/Misc/SharpRefactoring/SharpRefactoring.csproj

@@ -78,12 +78,19 @@
     <Compile Include="Src\Forms\ExtractMethodForm.Designer.cs">
       <DependentUpon>ExtractMethodForm.cs</DependentUpon>
     </Compile>
-    <Compile Include="Src\Gui\InlineRefactorDialog.cs" />
+    <Compile Include="Src\Gui\AbstractInlineRefactorDialog.cs" />
-    <Compile Include="Src\Gui\OverrideToStringMethodDialog.cs" />
+    <Compile Include="Src\Gui\OverrideEqualsGetHashCodeMethodsDialog.cs" />
+    <Compile Include="Src\Gui\OverrideToStringMethodDialog.xaml.cs">
+      <DependentUpon>OverrideToStringMethodDialog.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Src\Gui\OverrideToStringMethodDialogOld.cs" />
     <Compile Include="Src\Gui\Wrapper.cs" />
     <Compile Include="Src\MethodExtractorBase.cs" />
+    <Compile Include="Src\OverrideEqualsGetHashCodeMethodsCommand.cs" />
     <Compile Include="Src\OverrideToStringMethodCommand.cs" />
     <Compile Include="Src\ParameterCheckRefactoringMenuBuilder.cs" />
+    <Compile Include="Src\Options.cs" />
     <Compile Include="Src\Visitors\FindJumpInstructionsVisitor.cs" />
     <Compile Include="Src\Visitors\FindMemberVisitor.cs" />
     <Compile Include="Src\Visitors\FindReferenceVisitor.cs" />
@@ -128,4 +135,7 @@
   <ItemGroup>
     <Folder Include="Src\Gui" />
   </ItemGroup>
+  <ItemGroup>
+    <Page Include="Src\Gui\OverrideToStringMethodDialog.xaml" />
+  </ItemGroup>
 </Project>

src/AddIns/Misc/SharpRefactoring/Src/ClassCodeGeneratorMenuBuilder.cs

@@ -64,7 +64,7 @@ namespace SharpRefactoring
 					EventHandler eh = delegate {
 						var d = FindReferencesAndRenameHelper.GetDocument(c);
 						if (d != null)
-							ImplementAbstractClass(d, c, abstractClass);
+							ImplementAbstractClass(d, c, rtCopy);
 						ParserService.ParseCurrentViewContent();
 					};
 					subItems.Add(new MenuCommand(ambience.Convert(abstractClass), eh));
@@ -83,14 +83,15 @@ namespace SharpRefactoring
 		}
 		
 		#region Code generation
-		void ImplementAbstractClass(IDocument document, IClass target, IClass abstractClass)
+		void ImplementAbstractClass(IDocument document, IClass target, IReturnType abstractClass)
 		{
 			CodeGenerator generator = target.ProjectContent.Language.CodeGenerator;
 			RefactoringDocumentAdapter doc = new RefactoringDocumentAdapter(document);
 			var pos = doc.OffsetToPosition(doc.PositionToOffset(target.BodyRegion.EndLine, target.BodyRegion.EndColumn) - 1);
 			ClassFinder context = new ClassFinder(target, pos.Line, pos.Column);
 			
-			foreach (IMember member in abstractClass.AllMembers.Where(m => m.IsAbstract && !HasMember(m, target))) {
+			foreach (IMember member in MemberLookupHelper.GetAccessibleMembers(abstractClass, target, LanguageProperties.CSharp, true)
+			         .Where(m => m.IsAbstract && !HasMember(m, target))) {
 				generator.InsertCodeAtEnd(target.BodyRegion, doc, generator.GetOverridingMethod(member, context));
 			}
 		}

src/AddIns/Misc/SharpRefactoring/Src/Gui/AbstractInlineRefactorDialog.cs

@@ -14,6 +14,7 @@ using System.Windows.Controls;
 using System.Windows.Media;
 
 using ICSharpCode.Core;
+using ICSharpCode.Core.Presentation;
 using ICSharpCode.NRefactory.Ast;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
@@ -22,14 +23,14 @@ using ICSharpCode.SharpDevelop.Editor;
 
 namespace SharpRefactoring.Gui
 {
-	public abstract class InlineRefactorDialog : DockPanel
+	public abstract class AbstractInlineRefactorDialog : DockPanel, IOptionBindingContainer
 	{
 		protected ITextAnchor anchor;
 		protected ITextEditor editor;
 		
 		public IInlineUIElement Element { get; set; }
 		
-		public InlineRefactorDialog(ITextEditor editor, ITextAnchor anchor)
+		public AbstractInlineRefactorDialog(ITextEditor editor, ITextAnchor anchor)
 		{
 			this.anchor = anchor;
 			this.editor = editor;
@@ -39,7 +40,7 @@ namespace SharpRefactoring.Gui
 			Initialize();
 		}
 		
-		void Initialize()
+		protected virtual void Initialize()
 		{
 			UIElement content = CreateContentElement();
 			
@@ -90,6 +91,11 @@ namespace SharpRefactoring.Gui
 				editor.Document.Insert(anchor.Offset, GenerateCode(generator, current) ?? "");
 			}
 			
+			if (optionBindings != null) {
+				foreach (OptionBinding binding in optionBindings)
+					binding.Save();
+			}
+			
 			Element.Remove();
 		}
 		
@@ -100,5 +106,15 @@ namespace SharpRefactoring.Gui
 			
 			Element.Remove();
 		}
+		
+		List<OptionBinding> optionBindings;
+		
+		public void AddBinding(OptionBinding binding)
+		{
+			if (optionBindings == null)
+				optionBindings = new List<OptionBinding>();
+			
+			optionBindings.Add(binding);
+		}
 	}
 }

src/AddIns/Misc/SharpRefactoring/Src/Gui/OverrideEqualsGetHashCodeMethodsDialog.cs

@@ -0,0 +1,78 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+
+using ICSharpCode.Core;
+using ICSharpCode.Core.Presentation;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.Refactoring;
+using ICSharpCode.SharpDevelop.Editor;
+
+namespace SharpRefactoring.Gui
+{
+	public class OverrideEqualsGetHashCodeMethodsDialog : AbstractInlineRefactorDialog
+	{
+		CheckBox addIEquatableCheckBox;
+		CheckBox addOperatorOverrides;
+		CheckBox implementAllIEquatables;
+		
+		IClass selectedClass;
+		
+		public OverrideEqualsGetHashCodeMethodsDialog(ITextEditor editor, ITextAnchor anchor, IClass selectedClass)
+			: base(editor, anchor)
+		{
+			if (selectedClass == null)
+				throw new ArgumentNullException("selectedClass");
+			
+			this.selectedClass = selectedClass;
+			
+			addIEquatableCheckBox.Content = string.Format(StringParser.Parse("${res:AddIns.SharpRefactoring.AddInterface}"), "IEquatable<" + selectedClass.Name + ">");
+			addIEquatableCheckBox.IsEnabled = !selectedClass.BaseTypes.Any(type => {
+			                                                               	if (!type.IsGenericReturnType)
+			                                                               		return false;
+			                                                               	var genericType = type.CastToGenericReturnType();
+			                                                               	var boundTo = genericType.TypeParameter.BoundTo;
+			                                                               	if (boundTo == null)
+			                                                               		return false;
+			                                                               	return boundTo.Name == selectedClass.Name;
+			                                                               }
+			                                                              );
+			
+			addIEquatableCheckBox.SetValueToExtension(CheckBox.IsCheckedProperty,
+			                                          new OptionBinding(typeof(Options), "AddInterface")
+			                                         );
+		}
+		
+		protected override UIElement CreateContentElement()
+		{
+			addIEquatableCheckBox = new CheckBox();
+			
+			StackPanel panel = new StackPanel() {
+				Orientation = Orientation.Vertical,
+				Children = {
+					addIEquatableCheckBox
+				}
+			};
+			
+			return panel;
+		}
+		
+		protected override string GenerateCode(CodeGenerator generator, IClass currentClass)
+		{
+			throw new NotImplementedException();
+		}
+	}
+	
+	public interface IInlineRefactoring
+	{
+		void GenerateCode(ITextEditor editor);
+	}
+}

src/AddIns/Misc/SharpRefactoring/Src/Gui/OverrideToStringMethodDialog.xaml

@@ -0,0 +1,7 @@
+<UserControl x:Class="SharpRefactoring.Gui.OverrideToStringMethodDialog"
+	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+	<Grid>
+		
+	</Grid>
+</UserControl>

src/AddIns/Misc/SharpRefactoring/Src/Gui/OverrideToStringMethodDialog.xaml.cs

@@ -0,0 +1,30 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace SharpRefactoring.Gui
+{
+	/// <summary>
+	/// Interaction logic for OverrideToStringMethodDialog.xaml
+	/// </summary>
+	public partial class OverrideToStringMethodDialog : UserControl
+	{
+		public OverrideToStringMethodDialog()
+		{
+			InitializeComponent();
+		}
+	}
+}

src/AddIns/Misc/SharpRefactoring/Src/Gui/OverrideToStringMethodDialogOld.cs

@@ -22,12 +22,12 @@ using ICSharpCode.SharpDevelop.Editor;
 
 namespace SharpRefactoring.Gui
 {
-	public class OverrideToStringMethodDialog : InlineRefactorDialog
+	public class OverrideToStringMethodDialogOld : AbstractInlineRefactorDialog
 	{
 		ListBox listBox;
 		List<Wrapper<IField>> fields;
 		
-		public OverrideToStringMethodDialog(ITextEditor editor, ITextAnchor anchor, IList<IField> fields)
+		public OverrideToStringMethodDialogOld(ITextEditor editor, ITextAnchor anchor, IList<IField> fields)
 			: base(editor, anchor)
 		{
 			this.fields = fields.Select(f => new Wrapper<IField>() { Entity = f }).ToList();

src/AddIns/Misc/SharpRefactoring/Src/Options.cs

@@ -0,0 +1,38 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Diagnostics;
+using ICSharpCode.Core;
+
+namespace SharpRefactoring
+{
+	/// <summary>
+	/// Description of Options.
+	/// </summary>
+	public static class Options
+	{
+		static Properties properties;
+		
+		public static Properties Properties {
+			get { 				
+				Debug.Assert(properties != null);
+				return properties;
+			}
+		}
+		
+		static Options()
+		{
+			properties = PropertyService.Get("SharpRefactoringOptions", new Properties());
+		}
+		
+		public static bool AddInterface {
+			get { return properties.Get("AddInterface", false); }
+			set { properties.Set("AddInterface", value); }
+		}
+	}
+}

src/AddIns/Misc/SharpRefactoring/Src/OverrideEqualsGetHashCodeMethodsCommand.cs

@@ -0,0 +1,53 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Siegfried Pammer" email="siegfriedpammer@gmail.com" />
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.SharpDevelop;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.Refactoring;
+using ICSharpCode.SharpDevelop.Editor;
+using ICSharpCode.SharpDevelop.Refactoring;
+using SharpRefactoring.Gui;
+
+namespace SharpRefactoring
+{
+	public class OverrideEqualsGetHashCodeMethodsCommand : AbstractRefactoringCommand
+	{
+		protected override void Run(ITextEditor textEditor, RefactoringProvider provider)
+		{
+			IEditorUIService uiService = textEditor.GetService(typeof(IEditorUIService)) as IEditorUIService;
+			
+			if (uiService == null)
+				return;
+			
+			ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName);
+			
+			if (parseInfo == null)
+				return;
+			
+			CodeGenerator generator = parseInfo.CompilationUnit.Language.CodeGenerator;
+			IClass current = parseInfo.CompilationUnit.GetInnermostClass(textEditor.Caret.Line, textEditor.Caret.Column);
+			
+			if (current == null)
+				return;
+			
+			ITextAnchor anchor = textEditor.Document.CreateAnchor(textEditor.Caret.Offset);
+			anchor.MovementType = AnchorMovementType.AfterInsertion;
+			
+			var line = textEditor.Document.GetLineForOffset(textEditor.Caret.Offset);
+			
+			string indent = DocumentUtilitites.GetWhitespaceAfter(textEditor.Document, line.Offset);
+			
+//			textEditor.Document.Insert(anchor.Offset, "#region Equals and GetHashCode implementation\n" + indent);
+//			textEditor.Document.Insert(anchor.Offset + 1, indent + "#endregion\n");
+//			
+//			AbstractInlineRefactorDialog dialog = new OverrideEqualsGetHashCodeMethodsDialog(textEditor, anchor, current);
+//			
+//			dialog.Element = uiService.CreateInlineUIElement(anchor, dialog);
+		}
+	}
+}

src/AddIns/Misc/SharpRefactoring/Src/OverrideToStringMethodCommand.cs

@@ -48,9 +48,9 @@ namespace SharpRefactoring
 			textEditor.Document.Insert(anchor.Offset, "public override string ToString()\n" + indent + "{\n" + indent + "\t");
 			textEditor.Document.Insert(anchor.Offset + 1, indent + "}\n");
 			
-			InlineRefactorDialog dialog = new OverrideToStringMethodDialog(textEditor, anchor, current.Fields);
+//			AbstractInlineRefactorDialog dialog = new OverrideToStringMethodDialog(textEditor, anchor, current.Fields);
-			
+//			
-			dialog.Element = uiService.CreateInlineUIElement(anchor, dialog);
+//			dialog.Element = uiService.CreateInlineUIElement(anchor, dialog);
 		}
 	}
 }

src/Main/ICSharpCode.Core.Presentation/OptionBinding.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.Core.Presentation
 	/// </example>
 	public class OptionBinding : MarkupExtension
 	{
-		public string PropertyName { get; set; }
+		public string FullPropertyName { get; set; }
 		
 		static readonly Regex regex = new Regex("^.+\\:.+\\..+$", RegexOptions.Compiled);
 		
@@ -41,6 +41,7 @@ namespace ICSharpCode.Core.Presentation
 		DependencyProperty dp;
 		bool isStatic;
 		Type propertyDeclaringType;
+		string propertyName;
 		
 		MemberInfo propertyInfo;
 		
@@ -49,7 +50,13 @@ namespace ICSharpCode.Core.Presentation
 			if (!regex.IsMatch(propertyName))
 				throw new ArgumentException("parameter must have the following format: namespace:ClassName.FieldOrProperty", "propertyName");
 			
-			this.PropertyName = propertyName;
+			this.FullPropertyName = propertyName;
+		}
+		
+		public OptionBinding(Type container, string propertyName)
+		{
+			this.propertyDeclaringType = container;
+			this.propertyName = propertyName;
 		}
 		
 		public override object ProvideValue(IServiceProvider provider)
@@ -65,21 +72,22 @@ namespace ICSharpCode.Core.Presentation
 			if (target == null || dp == null)
 				return null;
 			
-			string[] name =  PropertyName.Split('.');
+			if (FullPropertyName != null) {
-			IXamlTypeResolver typeResolver = provider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
+				string[] name =  FullPropertyName.Split('.');
-			propertyDeclaringType = typeResolver.Resolve(name[0]);
+				IXamlTypeResolver typeResolver = provider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
-			if (propertyDeclaringType == null)
+				propertyDeclaringType = typeResolver.Resolve(name[0]);
-				throw new ArgumentException("Could not find type " + name[0]);
+				propertyName = name[1];
+			}
 			
-			this.propertyInfo = propertyDeclaringType.GetProperty(name[1]);
+			this.propertyInfo = propertyDeclaringType.GetProperty(propertyName);
 			if (this.propertyInfo != null) {
 				isStatic = (propertyInfo as PropertyInfo).GetGetMethod().IsStatic;
 			} else {
-				this.propertyInfo = propertyDeclaringType.GetField(name[1]);
+				this.propertyInfo = propertyDeclaringType.GetField(propertyName);
 				if (this.propertyInfo != null) {
 					isStatic = (propertyInfo as FieldInfo).IsStatic;
 				} else {
-					throw new ArgumentException("Could not find property " + name[1]);
+					throw new ArgumentException("Could not find property " + propertyName);
 				}
 			}
 			
@@ -103,7 +111,7 @@ namespace ICSharpCode.Core.Presentation
 
 				return ConvertOnDemand(result, dp.PropertyType);
 			} catch (Exception e) {
-				throw new Exception("Failing to convert " + this.PropertyName + " to " +
+				throw new Exception("Failing to convert " + this.FullPropertyName + " to " +
 				                    dp.OwnerType.Name + "." + dp.Name + " (" + dp.PropertyType + ")", e);
 			}
 		}
@@ -140,13 +148,13 @@ namespace ICSharpCode.Core.Presentation
 			return Convert.ChangeType(result, returnType);
 		}
 		
-		IOptionBindingContainer TryFindContainer(FrameworkElement start)
+		IOptionBindingContainer TryFindContainer(DependencyObject start)
 		{
 			if (start == null)
 				return null;
 			
 			while (start != null && !(start is IOptionBindingContainer))
-				start = start.Parent as FrameworkElement;
+				start = LogicalTreeHelper.GetParent(start);
 			
 			return start as IOptionBindingContainer;
 		}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/MemberLookupHelper.cs

@@ -22,7 +22,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	public static class MemberLookupHelper
 	{
 		#region LookupMember / GetAccessibleMembers
-		static List<IMember> GetAllMembers(IReturnType rt)
+		public static List<IMember> GetAllMembers(IReturnType rt)
 		{
 			List<IMember> members = new List<IMember>();
 			if (rt != null) {