Files
mono/mcs/class/System/System.ComponentModel/MemberDescriptor.cs
T
Miguel de Icaza e3990cf9e1 2006-11-29 Ivan N. Zlatev <[email protected]>
* MemberDescriptor.cs, ReflectionPropertyDescriptor.cs: 1) The
	ReflectionPropretyDescriptor must be able to operate with non
	public properties.

	2) The current implementation ignores the fact that the component
	can be in design mode. In design mode some of the properties (the
	design-time ones) are supposed to be redirected to the
	designer. The component which should be used to access the
	property is retrieved by using MemberDescriptor.GetInvokee
	(implemented in the patch). Updated the
	ReflectorPropertyDescriptor to use GetInvokee to decide which
	component should it use.

	Reviewed by: Miguel de Icaza


svn path=/trunk/mcs/; revision=68728
2006-11-30 03:52:42 +00:00

254 lines
6.9 KiB
C#

//
// System.ComponentModel.MemberDescriptor.cs
//
// Author:
// Miguel de Icaza ([email protected])
// Andreas Nahr ([email protected])
// Ivan N. Zlatev <[email protected]>
//
// (C) Ximian, Inc. http://www.ximian.com
// (C) 2003 Andreas Nahr
//
//
// 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.
//
using System;
using System.Collections;
using System.Reflection;
using System.Runtime.InteropServices;
using System.ComponentModel.Design;
namespace System.ComponentModel
{
[ComVisible (true)]
public abstract class MemberDescriptor
{
private string name;
private Attribute [] attrs;
private AttributeCollection attrCollection;
protected MemberDescriptor (string name, Attribute [] attrs)
{
this.name = name;
this.attrs = attrs;
}
protected MemberDescriptor (MemberDescriptor reference, Attribute [] attrs)
{
name = reference.name;
this.attrs = attrs;
}
protected MemberDescriptor (string name)
{
this.name = name;
}
protected MemberDescriptor (MemberDescriptor reference)
{
name = reference.name;
attrs = reference.AttributeArray;
}
protected virtual Attribute [] AttributeArray
{
get
{
if (attrs == null)
{
ArrayList list = new ArrayList ();
FillAttributes (list);
ArrayList filtered = new ArrayList ();
foreach (Attribute at in list) {
bool found = false;
for (int n=0; n<filtered.Count && !found; n++)
found = (filtered[n].GetType() == at.GetType ());
if (!found)
filtered.Add (at);
}
attrs = (Attribute[]) filtered.ToArray (typeof(Attribute));
}
return attrs;
}
set
{
attrs = value;
}
}
protected virtual void FillAttributes(System.Collections.IList attributeList)
{
// to be overriden
}
public virtual AttributeCollection Attributes
{
get
{
if (attrCollection == null)
attrCollection = CreateAttributeCollection ();
return attrCollection;
}
}
protected virtual AttributeCollection CreateAttributeCollection()
{
return new AttributeCollection (AttributeArray);
}
public virtual string Category
{
get
{
return ((CategoryAttribute) Attributes [typeof (CategoryAttribute)]).Category;
}
}
public virtual string Description
{
get
{
foreach (Attribute attr in AttributeArray)
{
if (attr is DescriptionAttribute)
return ((DescriptionAttribute) attr).Description;
}
return "";
}
}
public virtual bool DesignTimeOnly
{
get
{
foreach (Attribute attr in AttributeArray)
{
if (attr is DesignOnlyAttribute)
return ((DesignOnlyAttribute) attr).IsDesignOnly;
}
return false;
}
}
public virtual string DisplayName
{
get
{
return name;
}
}
public virtual string Name
{
get
{
return name;
}
}
public virtual bool IsBrowsable
{
get
{
foreach (Attribute attr in AttributeArray)
{
if (attr is BrowsableAttribute)
return ((BrowsableAttribute) attr).Browsable;
}
return true;
}
}
protected virtual int NameHashCode
{
get
{
return name.GetHashCode ();
}
}
public override int GetHashCode()
{
return base.GetHashCode ();
}
public override bool Equals(object obj)
{
MemberDescriptor other = obj as MemberDescriptor;
if (other == null) return false;
return other.name == name;
}
protected static ISite GetSite(object component)
{
if (component is Component)
return ((Component) component).Site;
else
return null;
}
protected static object GetInvokee(Type componentClass, object component)
{
if (component is IComponent) {
ISite site = ((IComponent) component).Site;
if (site != null && site.DesignMode) {
IDesignerHost host = site.GetService (typeof (IDesignerHost)) as IDesignerHost;
if (host != null) {
IDesigner designer = host.GetDesigner ((IComponent) component);
if (designer != null && componentClass.IsInstanceOfType (designer)) {
component = designer;
}
}
}
}
return component;
}
protected static MethodInfo FindMethod(Type componentClass, string name,
Type[ ] args, Type returnType)
{
return FindMethod (componentClass, name, args, returnType, true);
}
protected static MethodInfo FindMethod(Type componentClass, string name,
Type[ ] args, Type returnType, bool publicOnly)
{
BindingFlags bf;
if (publicOnly == true)
bf = BindingFlags.Public;
else
bf = BindingFlags.NonPublic | BindingFlags.Public;
// FIXME returnType is not taken into account. AFAIK methods are not allowed to only
// differ by return type anyway
return componentClass.GetMethod (name, bf, null, CallingConventions.Any, args, null);
}
}
}