Add code-completion icons to AvalonEdit.

src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/CodeCompletion/CompletionList.xaml

@@ -44,7 +44,7 @@
 							<DataTemplate>
 								<StackPanel Orientation="Horizontal">
 									<Image Source="{Binding Image}" Width="16" Height="16" Margin="0,0,2,0"/>
-									<ContentControl Content="{Binding Content}"/>
+									<ContentPresenter Content="{Binding Content}"/>
 								</StackPanel>
 							</DataTemplate>
 						</ItemsControl.ItemTemplate>

src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/CodeCompletion/Images/CompletionImage.cs

@@ -0,0 +1,296 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Threading;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using ICSharpCode.NRefactory.TypeSystem;
+
+namespace ICSharpCode.AvalonEdit.CodeCompletion
+{
+	/// <summary>
+	/// Provides icons for code-completion.
+	/// </summary>
+	public class CompletionImage
+	{
+		#region non-entity Images
+		static readonly BitmapImage namespaceImage = LoadBitmap("NameSpace");
+		
+		/// <summary>
+		/// Gets the image for namespaces.
+		/// </summary>
+		public static ImageSource NamespaceImage {
+			get { return namespaceImage; }
+		}
+		
+		static BitmapImage LoadBitmap(string name)
+		{
+			BitmapImage image = new BitmapImage(new Uri("pack://application:,,,/ICSharpCode.AvalonEdit;component/CodeCompletion/Images/" + name + ".png"));
+			image.Freeze();
+			return image;
+		}
+		#endregion
+		
+		#region Entity Images
+		static readonly CompletionImage imageClass = new CompletionImage("Class", false);
+		static readonly CompletionImage imageStruct = new CompletionImage("Struct", false);
+		static readonly CompletionImage imageInterface = new CompletionImage("Interface", false);
+		static readonly CompletionImage imageDelegate = new CompletionImage("Delegate", false);
+		static readonly CompletionImage imageEnum = new CompletionImage("Enum", false);
+		static readonly CompletionImage imageStaticClass = new CompletionImage("StaticClass", false);
+		
+		/// <summary>Gets the image used for non-static classes.</summary>
+		public static CompletionImage Class { get { return imageClass; } }
+		
+		/// <summary>Gets the image used for structs.</summary>
+		public static CompletionImage Struct { get { return imageStruct; } }
+		
+		/// <summary>Gets the image used for interfaces.</summary>
+		public static CompletionImage Interface { get { return imageInterface; } }
+		
+		/// <summary>Gets the image used for delegates.</summary>
+		public static CompletionImage Delegate { get { return imageDelegate; } }
+		
+		/// <summary>Gets the image used for enums.</summary>
+		public static CompletionImage Enum { get { return imageEnum; } }
+		
+		/// <summary>Gets the image used for modules/static classes.</summary>
+		public static CompletionImage StaticClass { get { return imageStaticClass; } }
+		
+		static readonly CompletionImage imageField = new CompletionImage("Field", true);
+		static readonly CompletionImage imageFieldReadOnly = new CompletionImage("FieldReadOnly", true);
+		static readonly CompletionImage imageLiteral = new CompletionImage("Literal", false);
+		static readonly CompletionImage imageEnumValue = new CompletionImage("EnumValue", false);
+		
+		/// <summary>Gets the image used for non-static classes.</summary>
+		public static CompletionImage Field { get { return imageField; } }
+		
+		/// <summary>Gets the image used for structs.</summary>
+		public static CompletionImage ReadOnlyField { get { return imageFieldReadOnly; } }
+		
+		/// <summary>Gets the image used for constants.</summary>
+		public static CompletionImage Literal { get { return imageLiteral; } }
+		
+		/// <summary>Gets the image used for enum values.</summary>
+		public static CompletionImage EnumValue { get { return imageEnumValue; } }
+		
+		static readonly CompletionImage imageMethod = new CompletionImage("Method", true);
+		static readonly CompletionImage imageConstructor = new CompletionImage("Constructor", true);
+		static readonly CompletionImage imageVirtualMethod = new CompletionImage("VirtualMethod", true);
+		static readonly CompletionImage imageOperator = new CompletionImage("Operator", false);
+		static readonly CompletionImage imageExtensionMethod = new CompletionImage("ExtensionMethod", true);
+		static readonly CompletionImage imagePInvokeMethod = new CompletionImage("PInvokeMethod", true);
+		static readonly CompletionImage imageProperty = new CompletionImage("Property", true);
+		static readonly CompletionImage imageIndexer = new CompletionImage("Indexer", true);
+		static readonly CompletionImage imageEvent = new CompletionImage("Event", true);
+		
+		/// <summary>Gets the image used for methods.</summary>
+		public static CompletionImage Method { get { return imageMethod; } }
+		
+		/// <summary>Gets the image used for constructos.</summary>
+		public static CompletionImage Constructor { get { return imageConstructor; } }
+		
+		/// <summary>Gets the image used for virtual methods.</summary>
+		public static CompletionImage VirtualMethod { get { return imageVirtualMethod; } }
+		
+		/// <summary>Gets the image used for operators.</summary>
+		public static CompletionImage Operator { get { return imageOperator; } }
+		
+		/// <summary>Gets the image used for extension methods.</summary>
+		public static CompletionImage ExtensionMethod { get { return imageExtensionMethod; } }
+		
+		/// <summary>Gets the image used for P/Invoke methods.</summary>
+		public static CompletionImage PInvokeMethod { get { return imagePInvokeMethod; } }
+		
+		/// <summary>Gets the image used for properties.</summary>
+		public static CompletionImage Property { get { return imageProperty; } }
+		
+		/// <summary>Gets the image used for indexers.</summary>
+		public static CompletionImage Indexer { get { return imageIndexer; } }
+		
+		/// <summary>Gets the image used for events.</summary>
+		public static CompletionImage Event { get { return imageEvent; } }
+		
+		/// <summary>
+		/// Gets the CompletionImage instance for the specified entity.
+		/// Returns null when no image is available for the entity type.
+		/// </summary>
+		public static CompletionImage GetCompletionImage(IEntity entity)
+		{
+			if (entity == null)
+				throw new ArgumentNullException("entity");
+			switch (entity.EntityType) {
+				case EntityType.TypeDefinition:
+					switch (((ITypeDefinition)entity).Kind) {
+						case TypeKind.Interface:
+							return imageInterface;
+						case TypeKind.Struct:
+						case TypeKind.Void:
+							return imageStruct;
+						case TypeKind.Delegate:
+							return imageDelegate;
+						case TypeKind.Enum:
+							return imageEnum;
+						case TypeKind.Class:
+							return entity.IsStatic ? imageStaticClass : imageClass;
+						case TypeKind.Module:
+							return imageStaticClass;
+						default:
+							return null;
+					}
+				case EntityType.Field:
+					IField field = (IField)entity;
+					if (field.IsConst) {
+						if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
+							return imageEnumValue;
+						else
+							return imageLiteral;
+					}
+					return field.IsReadOnly ? imageFieldReadOnly : imageField;
+				case EntityType.Property:
+					return imageProperty;
+				case EntityType.Indexer:
+					return imageIndexer;
+				case EntityType.Event:
+					return imageEvent;
+				case EntityType.Method:
+					IMethod method = (IMethod)entity;
+					return method.IsOverridable ? imageVirtualMethod : imageMethod;
+				case EntityType.Operator:
+				case EntityType.Destructor:
+					return imageOperator;
+				case EntityType.Constructor:
+					return imageConstructor;
+				default:
+					return null;
+			}
+		}
+		
+		/// <summary>
+		/// Gets the image for the specified entity.
+		/// Returns null when no image is available for the entity type.
+		/// </summary>
+		public static ImageSource GetImage(IEntity entity)
+		{
+			CompletionImage image = GetCompletionImage(entity);
+			if (image != null)
+				return image.GetImage(entity.Accessibility, entity.IsStatic);
+			else
+				return null;
+		}
+		#endregion
+		
+		#region Overlays
+		static readonly BitmapImage overlayStatic = LoadBitmap("OverlayStatic");
+		
+		/// <summary>
+		/// Gets the overlay image for the static modifier.
+		/// </summary>
+		public ImageSource StaticOverlay { get { return overlayStatic; } }
+		
+		static readonly BitmapImage[] accessibilityOverlays = {
+			null,
+			LoadBitmap("OverlayPrivate"),
+			LoadBitmap("OverlayProtected"),
+			LoadBitmap("OverlayInternal"),
+			LoadBitmap("OverlayProtectedInternal")
+		};
+		
+		/// <summary>
+		/// Gets an overlay image for the specified accessibility.
+		/// Returns null if no overlay exists (for example, public members don't use overlays).
+		/// </summary>
+		public static ImageSource GetAccessibilityOverlay(Accessibility accessibility)
+		{
+			return accessibilityOverlays[GetAccessibilityOverlayIndex(accessibility)];
+		}
+		
+		static int GetAccessibilityOverlayIndex(Accessibility accessibility)
+		{
+			switch (accessibility) {
+				case Accessibility.Private:
+					return 1;
+				case Accessibility.Protected:
+					return 2;
+				case Accessibility.Internal:
+					return 3;
+				case Accessibility.ProtectedOrInternal:
+				case Accessibility.ProtectedAndInternal:
+					return 4;
+				default:
+					return 0;
+			}
+		}
+		#endregion
+		
+		#region Instance Members (add overlay to entity image)
+		readonly string imageName;
+		readonly bool showStaticOverlay;
+		
+		private CompletionImage(string imageName, bool showStaticOverlay)
+		{
+			this.imageName = imageName;
+			this.showStaticOverlay = showStaticOverlay;
+		}
+		
+		ImageSource[] images = new ImageSource[2 * accessibilityOverlays.Length];
+		// 0..N-1  = base image + accessibility overlay
+		// N..2N-1 = base image + static overlay + accessibility overlay
+		
+		/// <summary>
+		/// Gets the image without any overlays.
+		/// </summary>
+		public ImageSource BaseImage {
+			get {
+				ImageSource image = images[0];
+				if (image == null) {
+					image = LoadBitmap(imageName);
+					Thread.MemoryBarrier();
+					images[0] = image;
+				}
+				return image;
+			}
+		}
+		
+		/// <summary>
+		/// Gets this image combined with the specified accessibility overlay.
+		/// </summary>
+		public ImageSource GetImage(Accessibility accessibility, bool isStatic = false)
+		{
+			int accessibilityIndex = GetAccessibilityOverlayIndex(accessibility);
+			int index;
+			if (isStatic && showStaticOverlay)
+				index = accessibilityOverlays.Length + accessibilityIndex;
+			else
+				index = accessibilityIndex;
+			
+			if (index == 0)
+				return this.BaseImage;
+			
+			ImageSource image = images[index];
+			if (image == null) {
+				DrawingGroup g = new DrawingGroup();
+				Rect iconRect = new Rect(0, 0, 16, 16);
+				g.Children.Add(new ImageDrawing(this.BaseImage, iconRect));
+				
+				if (accessibilityOverlays[accessibilityIndex] != null)
+					g.Children.Add(new ImageDrawing(accessibilityOverlays[accessibilityIndex], iconRect));
+				
+				image = new DrawingImage(g);
+				image.Freeze();
+				Thread.MemoryBarrier();
+				images[index] = image;
+			}
+			return image;
+		}
+		
+		/// <inheritdoc/>
+		public override string ToString()
+		{
+			return "[CompletionImage " + imageName + "]";
+		}
+		#endregion
+	}
+}

src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/CodeCompletion/InsightWindow.xaml

@@ -65,8 +65,8 @@
 											<ControlTemplate TargetType="{x:Type Button}">
 												<Border Name="bd"
 												        Background="{TemplateBinding Background}" CornerRadius="2">
-													<ContentControl Margin="{TemplateBinding Padding}"
-													                Content="{TemplateBinding Content}"/>
+													<ContentPresenter Margin="{TemplateBinding Padding}"
+													                  Content="{TemplateBinding Content}"/>
 												</Border>
 												<ControlTemplate.Triggers>
 													<Trigger Property="IsMouseOver" Value="true">

src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/ICSharpCode.AvalonEdit.csproj

@@ -93,6 +93,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="CodeCompletion\ICompletionData.cs" />
+    <Compile Include="CodeCompletion\Images\CompletionImage.cs" />
     <Compile Include="CodeCompletion\InsightWindow.cs" />
     <Compile Include="CodeCompletion\IOverloadProvider.cs" />
     <Compile Include="CodeCompletion\OverloadInsightWindow.cs" />
@@ -434,4 +435,34 @@
     <Resource Include="Search\next.png" />
     <Resource Include="Search\prev.png" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="CodeCompletion\Images" />
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="CodeCompletion\Images\Class.png" />
+    <Resource Include="CodeCompletion\Images\Constructor.png" />
+    <Resource Include="CodeCompletion\Images\Delegate.png" />
+    <Resource Include="CodeCompletion\Images\Enum.png" />
+    <Resource Include="CodeCompletion\Images\EnumValue.png" />
+    <Resource Include="CodeCompletion\Images\Event.png" />
+    <Resource Include="CodeCompletion\Images\ExtensionMethod.png" />
+    <Resource Include="CodeCompletion\Images\Field.png" />
+    <Resource Include="CodeCompletion\Images\FieldReadOnly.png" />
+    <Resource Include="CodeCompletion\Images\Indexer.png" />
+    <Resource Include="CodeCompletion\Images\Interface.png" />
+    <Resource Include="CodeCompletion\Images\Literal.png" />
+    <Resource Include="CodeCompletion\Images\Method.png" />
+    <Resource Include="CodeCompletion\Images\NameSpace.png" />
+    <Resource Include="CodeCompletion\Images\Operator.png" />
+    <Resource Include="CodeCompletion\Images\OverlayInternal.png" />
+    <Resource Include="CodeCompletion\Images\OverlayPrivate.png" />
+    <Resource Include="CodeCompletion\Images\OverlayProtected.png" />
+    <Resource Include="CodeCompletion\Images\OverlayProtectedInternal.png" />
+    <Resource Include="CodeCompletion\Images\OverlayStatic.png" />
+    <Resource Include="CodeCompletion\Images\PInvokeMethod.png" />
+    <Resource Include="CodeCompletion\Images\Property.png" />
+    <Resource Include="CodeCompletion\Images\StaticClass.png" />
+    <Resource Include="CodeCompletion\Images\Struct.png" />
+    <Resource Include="CodeCompletion\Images\VirtualMethod.png" />
+  </ItemGroup>
 </Project>

src/Main/Base/Project/Src/Services/ClassBrowserIcons/ClassBrowserIconService.cs

@@ -38,6 +38,7 @@ namespace ICSharpCode.SharpDevelop
 		}
 	}
 	
+	[Obsolete]
 	public static class ClassBrowserIconService
 	{
 		#region WinForms ImageList

src/Main/Base/Project/Src/Services/RefactoringService/FindReferenceService.cs

@@ -195,122 +195,6 @@ namespace ICSharpCode.SharpDevelop.Refactoring
 			return dict;
 		}
 		#endregion
-		
-		#region GetBaseMember
-		/// <summary>
-		/// Gets the base member that has the same signature.
-		/// </summary>
-		public static IMember GetBaseMember(IMember member)
-		{
-			return GetBaseMembers(member, false).FirstOrDefault();
-		}
-		
-		/// <summary>
-		/// Gets all base members that have the same signature.
-		/// </summary>
-		/// <returns>
-		/// List of base members with the same signature. The member from the derived-most base class is returned first.
-		/// </returns>
-		public static IEnumerable<IMember> GetBaseMembers(IMember member, bool includeImplementedInterfaces)
-		{
-			if (member == null)
-				throw new ArgumentNullException("member");
-			member = member.MemberDefinition;
-			IMethod method = member as IMethod;
-			IProperty property = member as IProperty;
-			IEvent ev = member as IEvent;
-			IField field = member as IField;
-			using (var ctx = ParserService.GetTypeResolveContext(member.ProjectContent).Synchronize()) {
-				IEnumerable<IType> allBaseTypes;
-				if (includeImplementedInterfaces) {
-					allBaseTypes = member.DeclaringTypeDefinition.GetAllBaseTypes(ctx);
-				} else {
-					allBaseTypes = member.DeclaringTypeDefinition.GetNonInterfaceBaseTypes(ctx);
-				}
-				foreach (IType baseType in allBaseTypes.Reverse()) {
-					if (baseType == member.DeclaringTypeDefinition)
-						continue;
-					
-					if (method != null) {
-						foreach (IMethod baseMethod in baseType.GetMethods(
-							ctx, m => m.Name == method.Name && m.Parameters.Count == method.Parameters.Count && m.TypeParameters.Count == method.TypeParameters.Count,
-							GetMemberOptions.IgnoreInheritedMembers))
-						{
-							if (ParameterListComparer.Compare(ctx, method, baseMethod))
-								yield return baseMethod;
-						}
-					}
-					if (property != null) {
-						foreach (IProperty baseProperty in baseType.GetProperties(
-							ctx, p => p.Name == property.Name && p.Parameters.Count == property.Parameters.Count,
-							GetMemberOptions.IgnoreInheritedMembers))
-						{
-							if (ParameterListComparer.Compare(ctx, property, baseProperty))
-								yield return baseProperty;
-						}
-					}
-					if (ev != null) {
-						IEvent baseEvent = baseType.GetEvents(ctx, e => e.Name == ev.Name, GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
-						if (baseEvent != null)
-							yield return baseEvent;
-					}
-					// Fields can't be overridden, but we handle them anyways, just for consistence
-					if (field != null) {
-						IField baseField = baseType.GetFields(ctx, f => f.Name == field.Name, GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
-						if (baseField != null)
-							yield return baseField;
-					}
-				}
-			}
-		}
-		#endregion
-		
-		#region GetDerivedMember
-		/// <summary>
-		/// Finds the member declared in 'derivedType' that has the same signature (could override) 'baseMember'.
-		/// </summary>
-		public static IMember GetDerivedMember(IMember baseMember, ITypeDefinition derivedType)
-		{
-			if (baseMember == null)
-				throw new ArgumentNullException("baseMember");
-			baseMember = baseMember.MemberDefinition;
-			IMethod method = baseMember as IMethod;
-			if (method != null) {
-				foreach (IMethod derivedMethod in derivedType.Methods) {
-					if (derivedMethod.Name == method.Name && derivedMethod.Parameters.Count == method.Parameters.Count) {
-						if (derivedMethod.TypeParameters.Count == method.TypeParameters.Count) {
-							// The method could override the base method:
-							if (FindReferenceService.GetBaseMembers(derivedMethod, true).Any(m => m.MemberDefinition == baseMember))
-								return derivedMethod;
-						}
-					}
-				}
-			}
-			IProperty property = baseMember as IProperty;
-			if (property != null) {
-				foreach (IProperty derivedProperty in derivedType.Properties) {
-					if (derivedProperty.Name == property.Name && derivedProperty.Parameters.Count == property.Parameters.Count) {
-						// The property could override the base property:
-						if (FindReferenceService.GetBaseMembers(derivedProperty, true).Any(m => m.MemberDefinition == baseMember))
-							return derivedProperty;
-					}
-				}
-			}
-			if (baseMember is IEvent) {
-				foreach (IEvent derivedEvent in derivedType.Events) {
-					if (derivedEvent.Name == baseMember.Name)
-						return derivedEvent;
-				}
-			}
-			if (baseMember is IField) {
-				foreach (IField derivedField in derivedType.Fields) {
-					if (derivedField.Name == baseMember.Name)
-						return derivedField;
-				}
-			}
-			return null;
-		}
-		#endregion
 	}
 	
 	public class SymbolSearchArgs