// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2004-2008 Novell, Inc.
//
// Authors:
//	Jonathan Chambers (jonathan.chambers@ansys.com)
//      Ivan N. Zlatev	  (contact@i-nz.net)
//

// NOT COMPLETE

using System;
using System.Collections;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Globalization;

namespace System.Windows.Forms.PropertyGridInternal
{
	internal class GridEntry : GridItem, ITypeDescriptorContext
	{
		#region Local Variables
		private PropertyGrid property_grid;
		private bool expanded;
		private GridItemCollection grid_items;
		private GridItem parent;
		private PropertyDescriptor[] property_descriptors;
		private int top;
		private Rectangle plus_minus_bounds;
		private GridItemCollection child_griditems_cache;
		#endregion	// Local Variables

		#region  Contructors
		protected GridEntry (PropertyGrid propertyGrid, GridEntry parent)
		{
			if (propertyGrid == null)
				throw new ArgumentNullException ("propertyGrid");
			property_grid = propertyGrid;
			plus_minus_bounds = new Rectangle (0,0,0,0);
			top = -1;
			grid_items = new GridItemCollection ();
			expanded = false;
			this.parent = parent;
			child_griditems_cache = null;
		}

		// Cannot use one PropertyDescriptor for all owners, because the
		// propertydescriptors might have different Invokees. Check
		// ReflectionPropertyDescriptor.GetInvokee and how it's used.
		//
		public GridEntry (PropertyGrid propertyGrid, PropertyDescriptor[] properties, 
				  GridEntry parent) : this (propertyGrid, parent) 
		{
			if (properties == null || properties.Length == 0)
				throw new ArgumentNullException ("prop_desc");
			property_descriptors = properties;
		}
		#endregion	// Constructors


		public override bool Expandable {
			get {
				TypeConverter converter = GetConverter ();
				if (converter == null || !converter.GetPropertiesSupported ((ITypeDescriptorContext)this))
					return false;

				if (GetChildGridItemsCached ().Count > 0)
					return true;

				return false;
			}
		}

		public override bool Expanded {
			get { return expanded; }
			set {
				if (expanded != value) {
					expanded = value;
					PopulateChildGridItems ();
					if (value)
						property_grid.OnExpandItem (this);
					else
						property_grid.OnCollapseItem (this);
				}
			}
		}

		public override GridItemCollection GridItems {
			get {
				PopulateChildGridItems ();
				return grid_items; 
			}
		}

		public override GridItemType GridItemType {
			get { return GridItemType.Property; }
		}

		public override string Label {
			get { 
				PropertyDescriptor property = this.PropertyDescriptor;
				if (property != null) {
					string label = property.DisplayName;
					ParenthesizePropertyNameAttribute parensAttr = 
						property.Attributes[typeof (ParenthesizePropertyNameAttribute)] as ParenthesizePropertyNameAttribute;
					if (parensAttr != null && parensAttr.NeedParenthesis)
						label = "(" + label + ")";
					return label;
				}
				return String.Empty;
			}
		}

		public override GridItem Parent {
			get { return parent; }
		}

		public GridEntry ParentEntry {
			get { 
				if (parent != null && parent.GridItemType == GridItemType.Category)
					return parent.Parent as GridEntry;
				return parent as GridEntry; 
			}
		}

		public override PropertyDescriptor PropertyDescriptor {
			get { return property_descriptors != null ? property_descriptors[0] : null; }
		}

		public PropertyDescriptor[] PropertyDescriptors {
			get { return property_descriptors; }
		}

		public object PropertyOwner {
			get { 
				object[] owners = PropertyOwners;
				if (owners != null)
					return owners[0];
				return null;
			}
		}

		public object[] PropertyOwners {
			get { 
				if (ParentEntry == null)
					return null;

				object[] owners = ParentEntry.Values;
				PropertyDescriptor[] properties = PropertyDescriptors;
				object newOwner = null;
				for (int i=0; i < owners.Length; i++) {
					if (owners[i] is ICustomTypeDescriptor) {
						newOwner = ((ICustomTypeDescriptor)owners[i]).GetPropertyOwner (properties[i]);
						if (newOwner != null)
							owners[i] = newOwner;
					}
				}
				return owners;
			}
		}

		// true if the value is the same among all properties
		public bool HasMergedValue {
			get {
				if (!IsMerged)
					return false;

				object[] values = this.Values;
				for (int i=0; i+1 < values.Length; i++) {
					if (!Object.Equals (values[i], values[i+1]))
						return false;
				}
				return true;
			}
		}

		public virtual bool IsMerged {
			get { return (PropertyDescriptors != null && PropertyDescriptors.Length > 1); }
		}

		// If IsMerged this will return all values for all properties in all owners
		public virtual object[] Values {
			get {
				if (PropertyDescriptor == null || this.PropertyOwners == null)
					return null;
				if (IsMerged) {
					object[] owners = this.PropertyOwners;
					PropertyDescriptor[] properties = PropertyDescriptors;
					object[] values = new object[owners.Length];
					for (int i=0; i < owners.Length; i++)
						values[i] = properties[i].GetValue (owners[i]);
					return values;
				} else {
					return new object[] { this.Value };
				}
			}
		}

		// Returns the first value for the first propertyowner and propertydescriptor
		//
		public override object Value {
			get {
				if (PropertyDescriptor == null || PropertyOwner == null)
					return null;

				return PropertyDescriptor.GetValue (PropertyOwner);
			}
		}

		public string ValueText {
			get { 
				string text = null;
				try {
					text = ConvertToString (this.Value);
					if (text == null)
						text = String.Empty;
				} catch {
					text = String.Empty;
				}
				return text;
			}
		}

		public override bool Select ()
		{
			property_grid.SelectedGridItem = this;
			return true;
		}

		#region ITypeDescriptorContext
		void ITypeDescriptorContext.OnComponentChanged () 
		{
		}

		bool ITypeDescriptorContext.OnComponentChanging () 
		{
			return false;
		}

		IContainer ITypeDescriptorContext.Container {
			get {
				if (PropertyOwner == null)
					return null;

				IComponent component = property_grid.SelectedObject as IComponent;
				if (component != null && component.Site != null)
					return component.Site.Container;
				return null;
			}
		}

		object ITypeDescriptorContext.Instance {
			get {
				if (ParentEntry != null && ParentEntry.PropertyOwner != null)
					return ParentEntry.PropertyOwner;
				return PropertyOwner;
			}
		}

		PropertyDescriptor ITypeDescriptorContext.PropertyDescriptor {
			get {
				if (ParentEntry != null && ParentEntry.PropertyDescriptor != null)
					return ParentEntry.PropertyDescriptor; 
				return PropertyDescriptor;
			}
		}
		#endregion

		#region IServiceProvider Members

		object IServiceProvider.GetService (Type serviceType) {
			IComponent selectedComponent = property_grid.SelectedObject as IComponent;
			if (selectedComponent != null && selectedComponent.Site != null)
				return selectedComponent.Site.GetService (serviceType);
			return null;
		}

		#endregion

		internal int Top {
			get { return top; }
			set {
				if (top != value)
					top = value;
			}
		}

		internal Rectangle PlusMinusBounds {
			get { return plus_minus_bounds; }
			set { plus_minus_bounds = value; }
		}

		public void SetParent (GridItem parent)
		{
			this.parent = parent;
		}

		public ICollection AcceptedValues {
			get {
				TypeConverter converter = GetConverter ();
				if (PropertyDescriptor != null && converter != null &&
				    converter.GetStandardValuesSupported ((ITypeDescriptorContext)this)) {
					ArrayList values = new ArrayList ();
					string stringVal = null;
					ICollection standardValues = converter.GetStandardValues ((ITypeDescriptorContext)this);
					if (standardValues != null) {
						foreach (object value in standardValues) {
							stringVal = ConvertToString (value);
							if (stringVal != null)
								values.Add (stringVal);
						}
					}
					return values.Count > 0 ? values : null;
				}
				return null;
			}
		}

		private string ConvertToString (object value)
		{
			if (value is string)
				return (string)value;

			if (PropertyDescriptor != null && PropertyDescriptor.Converter != null &&
			    PropertyDescriptor.Converter.CanConvertTo ((ITypeDescriptorContext)this, typeof (string))) {
				try {
					return PropertyDescriptor.Converter.ConvertToString ((ITypeDescriptorContext)this, value);
				} catch {
					// XXX: Happens too often...
					// property_grid.ShowError ("Property value of '" + property_descriptor.Name + "' is not convertible to string.");
					return null;
				}
			}

			return null;
		}

		public bool HasCustomEditor {
			get { return EditorStyle != UITypeEditorEditStyle.None; }
		}

		public UITypeEditorEditStyle EditorStyle {
			get {
				UITypeEditor editor = GetEditor ();
				if (editor != null) {
					try {
						return editor.GetEditStyle ((ITypeDescriptorContext)this);
					} catch {
						// Some of our Editors throw NotImplementedException
					}
				}
				return UITypeEditorEditStyle.None;
			}
		}

		public bool EditorResizeable {
			get {
				if (this.EditorStyle == UITypeEditorEditStyle.DropDown) {
					UITypeEditor editor = GetEditor ();
					if (editor != null && editor.IsDropDownResizable)
						return true;
				}
				return false;
			}
		}

		public bool EditValue (IWindowsFormsEditorService service)
		{
			if (service == null)
				throw new ArgumentNullException ("service");

			IServiceContainer parent = ((ITypeDescriptorContext)this).GetService (typeof (IServiceContainer)) as IServiceContainer;
			ServiceContainer container = null;

			if (parent != null)
				container = new ServiceContainer (parent);
			else
				container = new ServiceContainer ();

			container.AddService (typeof (IWindowsFormsEditorService), service);

			UITypeEditor editor = GetEditor ();
			if (editor != null) {
				try {
					object value = editor.EditValue ((ITypeDescriptorContext)this,
									 container,
									 this.Value);
					string error = null;
					return SetValue (value, out error);
				} catch { //(Exception e) {
					// property_grid.ShowError (e.Message + Environment.NewLine + e.StackTrace);
				}
			}
			return false;
		}

		private UITypeEditor GetEditor ()
		{
			if (PropertyDescriptor != null) {
				try { // can happen, because we are missing some editors
					if (PropertyDescriptor != null)
						return (UITypeEditor) PropertyDescriptor.GetEditor (typeof (UITypeEditor));
				} catch {
					// property_grid.ShowError ("Unable to load UITypeEditor for property '" + PropertyDescriptor.Name + "'.");
				}
			}
			return null;
		}

		private TypeConverter GetConverter ()
		{
			if (PropertyDescriptor != null)
				return PropertyDescriptor.Converter;
			return null;
		}

		public bool ToggleValue ()
		{
			if (IsReadOnly || (IsMerged && !HasMergedValue))
				return false;

			bool success = false;
			string error = null;
			object value = this.Value;
			if (PropertyDescriptor.PropertyType == typeof(bool))
				success = SetValue (!(bool)value, out error);
			else {
				TypeConverter converter = GetConverter ();
				if (converter != null && 
				    converter.GetStandardValuesSupported ((ITypeDescriptorContext)this)) {
					TypeConverter.StandardValuesCollection values = 
						(TypeConverter.StandardValuesCollection) converter.GetStandardValues ((ITypeDescriptorContext)this);
					if (values != null) {
						for (int i = 0; i < values.Count; i++) {
							if (value != null && value.Equals (values[i])){
								if (i < values.Count-1)
									success = SetValue (values[i+1], out error);
								else
									success = SetValue (values[0], out error);
								break;
							}
						}
					}
				}
			}
			if (!success && error != null)
				property_grid.ShowError (error);
			return success;
		}

		public bool SetValue (object value, out string error)
		{
			error = null;
			if (this.IsReadOnly)
				return false;

			if (SetValueCore (value, out error)) {
				InvalidateChildGridItemsCache ();
				property_grid.OnPropertyValueChangedInternal (this, this.Value);
				return true;
			}
			return false;
		}

		protected virtual bool SetValueCore (object value, out string error)
		{
			error = null;

			TypeConverter converter = GetConverter ();
			Type valueType = value != null ? value.GetType () : null;
			// if the new value is not of the same type try to convert it
			if (valueType != null && this.PropertyDescriptor.PropertyType != null &&
			    !this.PropertyDescriptor.PropertyType.IsAssignableFrom (valueType)) {
				bool conversionError = false;
				try {
					if (converter != null &&
					    converter.CanConvertFrom ((ITypeDescriptorContext)this, valueType))
						value = converter.ConvertFrom ((ITypeDescriptorContext)this, 
									       CultureInfo.CurrentCulture, value);
					else
						conversionError = true;
				} catch (Exception e) {
					error = e.Message;
					conversionError = true;
				}
				if (conversionError) {
					string valueText = ConvertToString (value);
					string errorShortDescription = null;
					if (valueText != null) {
						errorShortDescription = "Property value '" + valueText + "' of '" +
							PropertyDescriptor.Name + "' is not convertible to type '" +
							this.PropertyDescriptor.PropertyType.Name + "'";

					} else {
						errorShortDescription = "Property value of '" +
							PropertyDescriptor.Name + "' is not convertible to type '" +
							this.PropertyDescriptor.PropertyType.Name + "'";
					}
					error = errorShortDescription + Environment.NewLine + Environment.NewLine + error;
					return false;
				}
			}

			bool changed = false;
			bool current_changed = false;
			object[] propertyOwners = this.PropertyOwners;
			PropertyDescriptor[] properties = PropertyDescriptors;
			for (int i=0; i < propertyOwners.Length; i++) {
				object currentVal = properties[i].GetValue (propertyOwners[i]);
				current_changed = false;
				if (!Object.Equals (currentVal, value)) {
					if (this.ShouldCreateParentInstance) {
						Hashtable updatedParentProperties = new Hashtable ();
						PropertyDescriptorCollection parentProperties = TypeDescriptor.GetProperties (propertyOwners[i]);
						foreach (PropertyDescriptor property in parentProperties) {
							if (property.Name == properties[i].Name)
								updatedParentProperties[property.Name] = value;
							else
								updatedParentProperties[property.Name] = property.GetValue (propertyOwners[i]);
						}
						object updatedParentValue = this.ParentEntry.PropertyDescriptor.Converter.CreateInstance (
							(ITypeDescriptorContext)this, updatedParentProperties);
						if (updatedParentValue != null)
							current_changed = this.ParentEntry.SetValueCore (updatedParentValue, out error);
					} else {
						try {
							properties[i].SetValue (propertyOwners[i], value);
						} catch {
							// MS seems to swallow this
							//
							// string valueText = ConvertToString (value);
							// if (valueText != null)
							// 	error = "Property value '" + valueText + "' of '" + properties[i].Name + "' is invalid.";
							// else
							// 	error = "Property value of '" + properties[i].Name + "' is invalid.";
							return false;
						}

						if (IsValueType (this.ParentEntry)) 
							current_changed = ParentEntry.SetValueCore (propertyOwners[i], out error);
						else
							current_changed = Object.Equals (properties[i].GetValue (propertyOwners[i]), value);
					}
				}
				if (current_changed)
					changed = true;
			}
			return changed;
		}

		private bool IsValueType (GridEntry item)
		{
			if (item != null && item.PropertyDescriptor != null && 
			    (item.PropertyDescriptor.PropertyType.IsValueType ||
			     item.PropertyDescriptor.PropertyType.IsPrimitive))
				return true;
			return false;
		}

		public bool ResetValue ()
		{
			if (IsResetable) {
				object[] owners = this.PropertyOwners;
				PropertyDescriptor[] properties = PropertyDescriptors;
				for (int i=0; i < owners.Length; i++) {
					properties[i].ResetValue (owners[i]);
					if (IsValueType (this.ParentEntry)) {
						string error = null;
						if (!ParentEntry.SetValueCore (owners[i], out error) && error != null)
							property_grid.ShowError (error);
					}
				}
				property_grid.OnPropertyValueChangedInternal (this, this.Value);
				return true;
			}
			return false;
		}

		public bool HasDefaultValue {
			get {
				if (PropertyDescriptor != null)
				    return !PropertyDescriptor.ShouldSerializeValue (PropertyOwner);
				return false;
			}
		}

		// Determines if the current value can be reset
		//
		public virtual bool IsResetable {
			get { return (!IsReadOnly && PropertyDescriptor.CanResetValue (PropertyOwner)); }

		}

		// If false the entry can be modified only by the means of a predefined values
		// and not such inputed by the user.
		//
		public virtual bool IsEditable {
			get {
				TypeConverter converter = GetConverter ();
				if (PropertyDescriptor == null)
					return false;
				else if (PropertyDescriptor.PropertyType.IsArray)
					return false;
				else if (PropertyDescriptor.IsReadOnly && !this.ShouldCreateParentInstance)
					return false;
				else if (converter == null || 
					 !converter.CanConvertFrom ((ITypeDescriptorContext)this, typeof (string)))
					return false;
				else if (converter.GetStandardValuesSupported ((ITypeDescriptorContext)this) &&
					 converter.GetStandardValuesExclusive ((ITypeDescriptorContext)this))
					return false;
				else
					return true;
			}
		}

		// If true the the entry cannot be modified at all
		//
		public virtual bool IsReadOnly {
			get {
       				TypeConverter converter = GetConverter ();
				if (PropertyDescriptor == null || PropertyOwner == null)
					return true;
				else if (PropertyDescriptor.IsReadOnly && 
					 (EditorStyle != UITypeEditorEditStyle.Modal || PropertyDescriptor.PropertyType.IsValueType) && 
					 !this.ShouldCreateParentInstance)
					return true;
				else if (PropertyDescriptor.IsReadOnly && 
					 TypeDescriptor.GetAttributes (PropertyDescriptor.PropertyType)
					  [typeof(ImmutableObjectAttribute)].Equals (ImmutableObjectAttribute.Yes))
					return true;
				else if (ShouldCreateParentInstance && ParentEntry.IsReadOnly)
					return true;
				else if (!HasCustomEditor && converter == null)
					return true;
				else if (converter != null &&
					 !converter.GetStandardValuesSupported ((ITypeDescriptorContext)this) &&
					 !converter.CanConvertFrom ((ITypeDescriptorContext)this,
								    typeof (string)) &&
					 !HasCustomEditor) {
					return true;
				} else if (PropertyDescriptor.PropertyType.IsArray && !HasCustomEditor)
					return true;
				else
					return false;
			}
		}

		public bool IsPassword {
			get {
				if (PropertyDescriptor != null)
					return PropertyDescriptor.Attributes.Contains (PasswordPropertyTextAttribute.Yes);
				return false;
			}
		}
		// This is a way to set readonly properties (e.g properties without a setter).
		// The way it works is that if CreateInstance is supported by the parent's converter  
		// it gets passed a list of properties and their values which it uses to create an 
		// instance (e.g by passing them to the ctor of that object type).
		// 
		// This is used for e.g Font
		//
		public virtual bool ShouldCreateParentInstance {
			get {
				if (this.ParentEntry != null && ParentEntry.PropertyDescriptor != null) {
					TypeConverter parentConverter = ParentEntry.GetConverter ();
					if (parentConverter != null && parentConverter.GetCreateInstanceSupported ((ITypeDescriptorContext)this))
						return true;
				}
				return false;
			}
		}

		public virtual bool PaintValueSupported {
			get {
				UITypeEditor editor = GetEditor ();
				if (editor != null) {
					try {
						return editor.GetPaintValueSupported ();
					} catch {
						// Some of our Editors throw NotImplementedException
					}
				}
				return false;
			}
		}

		public virtual void PaintValue (Graphics gfx, Rectangle rect)
		{
			UITypeEditor editor = GetEditor ();
			if (editor != null) {
				try {
					editor.PaintValue (this.Value, gfx, rect);
				} catch {
					// Some of our Editors throw NotImplementedException
				}
			}
		}

#region Population
		protected void PopulateChildGridItems ()
		{
			grid_items = GetChildGridItemsCached ();
		}

		private void InvalidateChildGridItemsCache ()
		{
			if (child_griditems_cache != null) {
				child_griditems_cache = null;
				PopulateChildGridItems ();
			}
		}

		private GridItemCollection GetChildGridItemsCached ()
		{
			if (child_griditems_cache == null) {
				child_griditems_cache = GetChildGridItems ();
				// foreach (GridEntry item in child_griditems_cache)
				// 	PrintDebugInfo (item);
			}

			return child_griditems_cache;
		}

		// private static void PrintDebugInfo (GridEntry item)
		// {
       		// 	if (item.PropertyDescriptor != null) {
       		// 		Console.WriteLine ("=== [" + item.PropertyDescriptor.Name + "] ===");
		// 		try {
		// 			TypeConverter converter = item.GetConverter ();
		// 			Console.WriteLine ("IsReadOnly: " + item.IsReadOnly);
		// 			Console.WriteLine ("IsEditable: " + item.IsEditable);
		// 			Console.WriteLine ("PropertyDescriptor.IsReadOnly: " + item.PropertyDescriptor.IsReadOnly);
		// 			if (item.ParentEntry != null)
		// 				Console.WriteLine ("ParentEntry.IsReadOnly: " + item.ParentEntry.IsReadOnly);
		// 			Console.WriteLine ("ImmutableObjectAttribute.Yes: " + TypeDescriptor.GetAttributes (item.PropertyDescriptor.PropertyType)
		// 					   [typeof(ImmutableObjectAttribute)].Equals (ImmutableObjectAttribute.Yes));
		// 			UITypeEditor editor = item.GetEditor ();
		// 			Console.WriteLine ("Editor: " + (editor == null ? "none" : editor.GetType ().Name));
		// 			if (editor != null)
		// 				Console.WriteLine ("Editor.EditorStyle: " + editor.GetEditStyle ((ITypeDescriptorContext)item));
		// 			Console.WriteLine ("Converter: " + (converter == null ? "none" : converter.GetType ().Name));
		// 			if (converter != null) {
		// 				Console.WriteLine ("Converter.GetStandardValuesSupported: " + converter.GetStandardValuesSupported ((ITypeDescriptorContext)item).ToString ());
		// 				Console.WriteLine ("Converter.GetStandardValuesExclusive: " + converter.GetStandardValuesExclusive ((ITypeDescriptorContext)item).ToString ());
		// 				Console.WriteLine ("ShouldCreateParentInstance: " + item.ShouldCreateParentInstance);
		// 				Console.WriteLine ("CanConvertFrom (string): " + converter.CanConvertFrom ((ITypeDescriptorContext)item, typeof (string)));
		// 			}
		// 			Console.WriteLine ("IsArray: " + item.PropertyDescriptor.PropertyType.IsArray.ToString ());
		// 		} catch { /* Some converters and editor throw NotImplementedExceptions */ }
		// 	}
		// }

		private GridItemCollection GetChildGridItems ()
		{
			object[] propertyOwners = this.Values;
			string[] propertyNames = GetMergedPropertyNames (propertyOwners);
			GridItemCollection items = new GridItemCollection ();

			foreach (string propertyName in propertyNames) {
				PropertyDescriptor[] properties = new PropertyDescriptor[propertyOwners.Length];
				for (int i=0; i < propertyOwners.Length; i++)
					properties[i] = GetPropertyDescriptor (propertyOwners[i], propertyName);
				items.Add (new GridEntry (property_grid, properties, this));
			}

			return items;
		}

		private bool IsPropertyMergeable (PropertyDescriptor property)
		{
			if (property == null)
				return false;
				
			MergablePropertyAttribute attrib = property.Attributes [typeof (MergablePropertyAttribute)] as MergablePropertyAttribute;
			if (attrib != null && !attrib.AllowMerge)
				return false;

			return true;
		}

		private string[] GetMergedPropertyNames (object [] objects)
		{
			if (objects == null || objects.Length == 0)
				return new string[0];

			ArrayList intersection = new ArrayList ();
			for (int i = 0; i < objects.Length; i ++) {
				if (objects [i] == null)
					continue;

				PropertyDescriptorCollection properties = GetProperties (objects[i], property_grid.BrowsableAttributes);
				ArrayList new_intersection = new ArrayList ();

				foreach (PropertyDescriptor currentProperty in (i == 0 ? (ICollection)properties : (ICollection)intersection)) {
					PropertyDescriptor matchingProperty = (i == 0 ? currentProperty : properties [currentProperty.Name]);
					if (objects.Length > 1 && !IsPropertyMergeable (matchingProperty))
						continue;
					if (matchingProperty.PropertyType == currentProperty.PropertyType)
						new_intersection.Add (matchingProperty);
				}

				intersection = new_intersection;
			}

			string[] propertyNames = new string [intersection.Count];
			for (int i=0; i < intersection.Count; i++)
				propertyNames[i] = ((PropertyDescriptor)intersection[i]).Name;
				
			return propertyNames;
		}

		private PropertyDescriptor GetPropertyDescriptor (object propertyOwner, string propertyName)
		{
			if (propertyOwner == null || propertyName == null)
				return null;

			PropertyDescriptorCollection properties = GetProperties (propertyOwner, property_grid.BrowsableAttributes);
			if (properties != null)
				return properties[propertyName];
			return null;
		}

		private PropertyDescriptorCollection GetProperties (object propertyOwner, AttributeCollection attributes)
		{
			if (propertyOwner == null || property_grid.SelectedTab == null)
				return new PropertyDescriptorCollection (null);

			Attribute[] atts = new Attribute[attributes.Count];
			attributes.CopyTo (atts, 0);
			return property_grid.SelectedTab.GetProperties ((ITypeDescriptorContext)this, propertyOwner, atts);
		}
#endregion
	}
}