Add DataGridView to SettingsEditor.

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

src/AddIns/DisplayBindings/SettingsEditor/Project/ProxyPropertyDescriptor.cs

@@ -0,0 +1,69 @@
+/*
+ * Created by SharpDevelop.
+ * User: Daniel Grunwald
+ * Date: 10/29/2006
+ * Time: 8:30 AM
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+
+using System;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace ICSharpCode.SettingsEditor
+{
+	public class ProxyPropertyDescriptor : PropertyDescriptor
+	{
+		PropertyDescriptor baseDescriptor;
+		
+		public ProxyPropertyDescriptor(PropertyDescriptor baseDescriptor)
+			: base(baseDescriptor)
+		{
+			this.baseDescriptor = baseDescriptor;
+		}
+		
+		public override Type ComponentType {
+			get {
+				return baseDescriptor.ComponentType;
+			}
+		}
+		
+		public override bool IsReadOnly {
+			get {
+				return baseDescriptor.IsReadOnly;
+			}
+		}
+		
+		public override bool CanResetValue(object component)
+		{
+			return baseDescriptor.CanResetValue(component);
+		}
+		
+		public override object GetValue(object component)
+		{
+			return baseDescriptor.GetValue(component);
+		}
+		
+		public override void ResetValue(object component)
+		{
+			baseDescriptor.ResetValue(component);
+		}
+		
+		public override void SetValue(object component, object value)
+		{
+			baseDescriptor.SetValue(component, value);
+		}
+		
+		public override bool ShouldSerializeValue(object component)
+		{
+			return baseDescriptor.ShouldSerializeValue(component);
+		}
+		
+		public override Type PropertyType {
+			get {
+				return baseDescriptor.PropertyType;
+			}
+		}
+	}
+}

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsEditor.csproj

@@ -39,6 +39,7 @@
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
+    <Reference Include="System.Configuration" />
   </ItemGroup>
   <ItemGroup>
     <None Include="SettingsEditor.addin">
@@ -54,6 +55,11 @@
       <DependentUpon>SettingsView.cs</DependentUpon>
     </Compile>
     <Compile Include="SettingsView.cs" />
+    <Compile Include="SettingsEntry.cs" />
+    <EmbeddedResource Include="SettingsView.resx">
+      <DependentUpon>SettingsView.cs</DependentUpon>
+    </EmbeddedResource>
+    <Compile Include="ProxyPropertyDescriptor.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\Main\Base\Project\ICSharpCode.SharpDevelop.csproj">

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsEntry.cs

@@ -0,0 +1,197 @@
+/*
+ * Created by SharpDevelop.
+ * User: Daniel Grunwald
+ * Date: 10/28/2006
+ * Time: 11:16 PM
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+
+using System;
+using System.ComponentModel;
+using System.Xml;
+using System.Configuration;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.SettingsEditor
+{
+	public enum SettingScope
+	{
+		Application, User
+	}
+	
+	public class SettingsEntry : LocalizedObject
+	{
+		string description;
+		bool   generateDefaultValueInCode = true;
+		string name;
+		string provider = "";
+		bool roaming;
+		SettingScope scope = SettingScope.User;
+		Type type;
+		object value;
+		
+		public SettingsEntry()
+		{
+		}
+		
+		public SettingsEntry(XmlElement element)
+		{
+			description = element.GetAttribute("Description");
+			if (!bool.TryParse(element.GetAttribute("GenerateDefaultValueInCode"), out generateDefaultValueInCode))
+				generateDefaultValueInCode = true;
+			name = element.GetAttribute("Name");
+			provider = element.GetAttribute("Provider");
+			bool.TryParse(element.GetAttribute("Roaming"), out roaming);
+			if ("Application".Equals(element.GetAttribute("Scope"), StringComparison.OrdinalIgnoreCase)) {
+				scope = SettingScope.Application;
+			} else {
+				scope = SettingScope.User;
+			}
+			type = GetType(element.GetAttribute("Type"));
+			if (type != null && type != typeof(string)) {
+				TypeConverter c = TypeDescriptor.GetConverter(type);
+				SettingsSerializeAs ssa;
+				if (c.CanConvertFrom(typeof(string)) && c.CanConvertTo(typeof(string))) {
+					ssa = SettingsSerializeAs.String;
+				} else {
+					ssa = SettingsSerializeAs.Xml;
+				}
+				SettingsProperty p = new SettingsProperty(name);
+				p.PropertyType = type;
+				p.SerializeAs = ssa;
+				SettingsPropertyValue v = new SettingsPropertyValue(p);
+				v.SerializedValue = element["Value"].InnerText;
+				this.value = v.PropertyValue;
+			} else {
+				this.value = element["Value"].InnerText;
+			}
+		}
+		
+		Type GetType(string typeName)
+		{
+			return typeof(object).Assembly.GetType(typeName, false)
+				?? typeof(Uri).Assembly.GetType(typeName, false)
+				?? typeof(System.Data.DataRow).Assembly.GetType(typeName, false);
+		}
+		
+		[LocalizedProperty("Description",
+		                   Description="Description of the setting.")]
+		public string Description {
+			get { return description; }
+			set { description = value; }
+		}
+		
+		[LocalizedProperty("Generate default value in code",
+		                   Description="Specifies whether the value should be saved as attribute in the generated code.")]
+		[DefaultValue(true)]
+		public bool GenerateDefaultValueInCode {
+			get { return generateDefaultValueInCode; }
+			set { generateDefaultValueInCode = value; }
+		}
+		
+		[LocalizedProperty("Name",
+		                   Description="Name of the setting.")]
+		public string Name {
+			get { return name; }
+			set { name = value; }
+		}
+		
+		[LocalizedProperty("Provider",
+		                   Description="The provider used to manage the setting.")]
+		public string Provider {
+			get { return provider; }
+			set { provider = value; }
+		}
+		
+		[LocalizedProperty("Roaming",
+		                   Description="Specifies whether changes to the setting are stored in 'Application Data' (Roaming=true) or 'Local Application Data' (Roaming=false)")]
+		public bool Roaming {
+			get { return roaming; }
+			set { roaming = value; }
+		}
+		
+		[LocalizedProperty("Scope",
+		                   Description="Specifies whether the setting is per-application (read-only) or per-user (read/write).")]
+		public SettingScope Scope {
+			get { return scope; }
+			set { scope = value; }
+		}
+		
+		[LocalizedProperty("SerializedSettingType",
+		                   Description="The type used for the setting in the strongly-typed settings class.")]
+		public string SerializedSettingType {
+			get {
+				if (type != null)
+					return type.FullName;
+				else
+					return "(null)";
+			}
+		}
+		
+		[LocalizedProperty("Value",
+		                   Description="The default value of the setting.")]
+		public object Value {
+			get { return value; }
+			set {
+				if (type == null || type.IsInstanceOfType(value)) {
+					this.value = value;
+				} else {
+					throw new ArgumentException("Invalid type for property value.");
+				}
+			}
+		}
+		
+		#region Custom property descriptors
+		protected override void FilterProperties(PropertyDescriptorCollection col)
+		{
+			base.FilterProperties(col);
+			PropertyDescriptor oldValue = col["Value"];
+			col.Remove(oldValue);
+			col.Add(new CustomValuePropertyDescriptor(oldValue, type));
+			PropertyDescriptor oldRoaming = col["Roaming"];
+			col.Remove(oldRoaming);
+			col.Add(new RoamingPropertyDescriptor(oldRoaming, this));
+		}
+		
+		class RoamingPropertyDescriptor : ProxyPropertyDescriptor
+		{
+			SettingsEntry entry;
+			
+			public RoamingPropertyDescriptor(PropertyDescriptor baseDescriptor, SettingsEntry entry)
+				: base(baseDescriptor)
+			{
+				this.entry = entry;
+			}
+			
+			public override bool IsReadOnly {
+				get {
+					return entry.Scope == SettingScope.Application; 
+				}
+			}
+		}
+		
+		class CustomValuePropertyDescriptor : ProxyPropertyDescriptor
+		{
+			Type newPropertyType;
+			
+			public CustomValuePropertyDescriptor(PropertyDescriptor baseDescriptor, Type newPropertyType)
+				: base(baseDescriptor)
+			{
+				this.newPropertyType = newPropertyType;
+			}
+			
+			public override Type PropertyType {
+				get {
+					return newPropertyType;
+				}
+			}
+			
+			public override object GetEditor(Type editorBaseType)
+			{
+				return TypeDescriptor.GetEditor(newPropertyType, editorBaseType);
+			}
+		}
+		#endregion
+	}
+}

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsView.Designer.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * Created by SharpDevelop.
  * User: Daniel Grunwald
  * Date: 10/28/2006
@@ -36,11 +36,46 @@ namespace ICSharpCode.SettingsEditor
 		/// </summary>
 		private void InitializeComponent()
 		{
+			this.grid = new System.Windows.Forms.DataGridView();
+			this.label1 = new System.Windows.Forms.Label();
+			((System.ComponentModel.ISupportInitialize)(this.grid)).BeginInit();
+			this.SuspendLayout();
+			// 
+			// grid
+			// 
+			this.grid.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+									| System.Windows.Forms.AnchorStyles.Left) 
+									| System.Windows.Forms.AnchorStyles.Right)));
+			this.grid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+			this.grid.Location = new System.Drawing.Point(3, 38);
+			this.grid.Name = "grid";
+			this.grid.Size = new System.Drawing.Size(480, 321);
+			this.grid.TabIndex = 0;
+			this.grid.SelectionChanged += new System.EventHandler(this.GridSelectionChanged);
+			this.grid.CellContentClick += new System.Windows.Forms.DataGridViewCellEventHandler(this.GridCellContentClick);
+			// 
+			// label1
+			// 
+			this.label1.AutoSize = true;
+			this.label1.Location = new System.Drawing.Point(4, 9);
+			this.label1.Name = "label1";
+			this.label1.Size = new System.Drawing.Size(292, 13);
+			this.label1.TabIndex = 1;
+			this.label1.Text = "SettingsView prototype. Code generation not implemented!";
 			// 
 			// SettingsView
 			// 
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
 			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.Controls.Add(this.label1);
+			this.Controls.Add(this.grid);
 			this.Name = "SettingsView";
+			this.Size = new System.Drawing.Size(486, 362);
+			((System.ComponentModel.ISupportInitialize)(this.grid)).EndInit();
+			this.ResumeLayout(false);
+			this.PerformLayout();
 		}
+		private System.Windows.Forms.Label label1;
+		private System.Windows.Forms.DataGridView grid;
 	}
 }

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsView.cs

@@ -11,6 +11,7 @@ using System;
 using System.ComponentModel;
 using System.Drawing;
 using System.Windows.Forms;
+using System.Collections.Generic;
 
 namespace ICSharpCode.SettingsEditor
 {
@@ -30,5 +31,58 @@ namespace ICSharpCode.SettingsEditor
 			// TODO: Add constructor code after the InitializeComponent() call.
 			//
 		}
+		
+		void GridCellContentClick(object sender, System.Windows.Forms.DataGridViewCellEventArgs e)
+		{
+			
+		}
+		
+		public void ShowEntries(List<SettingsEntry> list)
+		{
+			grid.AutoGenerateColumns = false;
+			grid.DataSource = list;
+			if (grid.Columns.Count == 0) {
+				grid.Columns.Add("Name", "Name");
+				grid.Columns[0].DataPropertyName = "Name";
+				grid.Columns.Add("Value", "Value");
+				grid.Columns[1].DataPropertyName = "Value";
+				grid.Columns[1].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
+				grid.Columns[1].MinimumWidth = 75;
+			}
+			grid.AllowUserToAddRows = true;
+			/*foreach (SettingsEntry e in list) {
+				grid.Rows.Add(e.Name,
+				              e.SerializedSettingType,
+				              e.Scope,
+				              e.Value);
+			}*/
+		}
+		
+		void GridSelectionChanged(object sender, EventArgs e)
+		{
+			if (SelectionChanged != null)
+				SelectionChanged(this, e);
+		}
+		
+		public List<SettingsEntry> GetSelectedEntries()
+		{
+			List<SettingsEntry> l = new List<SettingsEntry>();
+			if (grid.SelectedRows.Count > 0) {
+				foreach (DataGridViewRow row in grid.SelectedRows) {
+					l.Add((SettingsEntry)row.DataBoundItem);
+				}
+			} else {
+				bool[] rowAdded = new bool[grid.Rows.Count];
+				foreach (DataGridViewCell cell in grid.SelectedCells) {
+					if (rowAdded[cell.RowIndex] == false) {
+						rowAdded[cell.RowIndex] = true;
+						l.Add((SettingsEntry)cell.OwningRow.DataBoundItem);
+					}
+				}
+			}
+			return l;
+		}
+		
+		public event EventHandler SelectionChanged;
 	}
 }

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsView.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

src/AddIns/DisplayBindings/SettingsEditor/Project/SettingsViewContent.cs

@@ -1,13 +1,16 @@
 /*
  * Created by SharpDevelop.
- * User: tfssetup
+ * User: Daniel Grunwald
  * Date: 10/28/2006
  * Time: 5:54 PM
  * 
  * To change this template use Tools | Options | Coding | Edit Standard Headers.
  */
 
+using System.Xml;
 using System;
+using System.IO;
+using System.Collections.Generic;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Gui;
@@ -15,9 +18,17 @@ using System.Windows.Forms;
 
 namespace ICSharpCode.SettingsEditor
 {
-	public class SettingsViewContent : AbstractViewContent
+	public class SettingsViewContent : AbstractViewContent, IHasPropertyContainer
 	{
 		SettingsView view = new SettingsView();
+		PropertyContainer propertyContainer = new PropertyContainer();
+		
+		public SettingsViewContent()
+		{
+			view.SelectionChanged += delegate {
+				propertyContainer.SelectedObjects = view.GetSelectedEntries().ToArray();
+			};
+		}
 		
 		public override Control Control {
 			get {
@@ -25,12 +36,36 @@ namespace ICSharpCode.SettingsEditor
 			}
 		}
 		
-		public override void Load(string fileName)
+		public override void Load(string filename)
 		{
+			TitleName = Path.GetFileName(filename);
+			FileName = filename;
+			IsDirty = false;
+			
+			try {
+				XmlDocument doc = new XmlDocument();
+				doc.Load(filename);
+				XmlElement settings = doc.DocumentElement["Settings"];
+				List<SettingsEntry> entries = new List<SettingsEntry>();
+				foreach (XmlNode node in settings.ChildNodes) {
+					if (node is XmlElement) {
+						entries.Add(new SettingsEntry(node as XmlElement));
+					}
+				}
+				view.ShowEntries(entries);
+			} catch (XmlException ex) {
+				MessageService.ShowMessage(ex.Message);
+			}
 		}
 		
 		public override void Save()
 		{
 		}
+		
+		public PropertyContainer PropertyContainer {
+			get {
+				return propertyContainer;
+			}
+		}
 	}
 }

src/Main/Base/Project/Src/Gui/Components/LocalizedPropertyGrid/LocalizedObject.cs

@@ -22,57 +22,61 @@ namespace ICSharpCode.SharpDevelop.Gui
 	{
 		PropertyDescriptorCollection globalizedProps;
 		
-		public string GetClassName()
+		string ICustomTypeDescriptor.GetClassName()
 		{
 			return TypeDescriptor.GetClassName(this,true);
 		}
 
-		public AttributeCollection GetAttributes()
+		AttributeCollection ICustomTypeDescriptor.GetAttributes()
 		{
 			return TypeDescriptor.GetAttributes(this,true);
 		}
 
-		public string GetComponentName()
+		string ICustomTypeDescriptor.GetComponentName()
 		{
 			return TypeDescriptor.GetComponentName(this, true);
 		}
 
-		public TypeConverter GetConverter()
+		TypeConverter ICustomTypeDescriptor.GetConverter()
 		{
 			return TypeDescriptor.GetConverter(this, true);
 		}
 
-		public EventDescriptor GetDefaultEvent() 
+		EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() 
 		{
 			return TypeDescriptor.GetDefaultEvent(this, true);
 		}
 
-		public PropertyDescriptor GetDefaultProperty() 
+		PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() 
 		{
 			return TypeDescriptor.GetDefaultProperty(this, true);
 		}
 
-		public object GetEditor(Type editorBaseType) 
+		object ICustomTypeDescriptor.GetEditor(Type editorBaseType) 
 		{
 			return TypeDescriptor.GetEditor(this, editorBaseType, true);
 		}
 
-		public EventDescriptorCollection GetEvents(Attribute[] attributes) 
+		EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) 
 		{
 			return TypeDescriptor.GetEvents(this, attributes, true);
 		}
 
-		public EventDescriptorCollection GetEvents()
+		EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
 		{
 			return TypeDescriptor.GetEvents(this, true);
 		}
 
+		protected virtual void FilterProperties(PropertyDescriptorCollection globalizedProps)
+		{
+		}
+		
 		/// <summary>
 		/// Called to get the properties of a type.
 		/// </summary>
 		/// <param name="attributes"></param>
 		/// <returns></returns>
-		public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
+		PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
 		{
 			if ( globalizedProps == null) {
 				// Get the collection of properties
@@ -84,11 +88,12 @@ namespace ICSharpCode.SharpDevelop.Gui
 				foreach (PropertyDescriptor oProp in baseProps) {
 					globalizedProps.Add(new LocalizedPropertyDescriptor(oProp));
 				}
+				FilterProperties(globalizedProps);
 			}
 			return globalizedProps;
 		}
 
-		public PropertyDescriptorCollection GetProperties()
+		PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
 		{
 			// Only do once
 			if (globalizedProps == null) {
@@ -100,11 +105,12 @@ namespace ICSharpCode.SharpDevelop.Gui
 				foreach (PropertyDescriptor oProp in baseProps) {
 					globalizedProps.Add(new LocalizedPropertyDescriptor(oProp));
 				}
+				FilterProperties(globalizedProps);
 			}
 			return globalizedProps;
 		}
 
-		public object GetPropertyOwner(PropertyDescriptor pd) 
+		object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) 
 		{
 			return this;
 		}

src/Main/Base/Project/Src/Gui/Components/LocalizedPropertyGrid/LocalizedPropertyDescriptor.cs

@@ -136,6 +136,5 @@ namespace ICSharpCode.SharpDevelop.Gui
 				((LocalizedObject)component).InformSetValue(this, component, value);
 			}
 		}
-		
 	}
 }