281 lines
11 KiB
C#
281 lines
11 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="DebugExtendedPropertyDescriptor.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
#if DEBUG
|
|
|
|
/*
|
|
|
|
This class exists in debug only. It is a complete copy of the
|
|
V1.0 TypeDescriptor object and is used to validate that the
|
|
behavior of the V2.0 TypeDescriptor matches 1.0 behavior.
|
|
|
|
*/
|
|
namespace System.ComponentModel {
|
|
|
|
|
|
using System.Diagnostics;
|
|
|
|
using System;
|
|
using System.ComponentModel.Design;
|
|
using System.Collections;
|
|
using Microsoft.Win32;
|
|
using System.Security.Permissions;
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// This class wraps an PropertyDescriptor with something that looks like a property. It
|
|
/// allows you to treat extended properties the same as regular properties.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[HostProtection(SharedState = true)]
|
|
internal sealed class DebugExtendedPropertyDescriptor : PropertyDescriptor {
|
|
|
|
private readonly DebugReflectPropertyDescriptor extenderInfo; // the extender property
|
|
private readonly IExtenderProvider provider; // the guy providing it
|
|
private TypeConverter converter;
|
|
private object[] editors;
|
|
private Type[] editorTypes;
|
|
private int editorCount;
|
|
|
|
/// <devdoc>
|
|
/// Creates a new extended property info. Callers can then treat this as
|
|
/// a standard property.
|
|
/// </devdoc>
|
|
public DebugExtendedPropertyDescriptor(DebugReflectPropertyDescriptor extenderInfo, Type receiverType, IExtenderProvider provider) : this(extenderInfo, receiverType, provider, null) {
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Creates a new extended property info. Callers can then treat this as
|
|
/// a standard property.
|
|
/// </devdoc>
|
|
public DebugExtendedPropertyDescriptor(DebugReflectPropertyDescriptor extenderInfo, Type receiverType, IExtenderProvider provider, Attribute[] attributes)
|
|
: base(extenderInfo, attributes) {
|
|
|
|
Debug.Assert(extenderInfo != null, "DebugExtendedPropertyDescriptor must have extenderInfo");
|
|
Debug.Assert(provider != null, "DebugExtendedPropertyDescriptor must have provider");
|
|
|
|
ArrayList attrList = new ArrayList(AttributeArray);
|
|
attrList.Add(ExtenderProvidedPropertyAttribute.Create(extenderInfo, receiverType, provider));
|
|
if (extenderInfo.IsReadOnly) {
|
|
attrList.Add(ReadOnlyAttribute.Yes);
|
|
}
|
|
|
|
Attribute[] temp = new Attribute[attrList.Count];
|
|
attrList.CopyTo(temp, 0);
|
|
AttributeArray = temp;
|
|
|
|
this.extenderInfo = extenderInfo;
|
|
this.provider = provider;
|
|
}
|
|
|
|
public DebugExtendedPropertyDescriptor(PropertyDescriptor extender, Attribute[] attributes) : base(extender, attributes) {
|
|
Debug.Assert(extender != null, "The original PropertyDescriptor must be non-null");
|
|
|
|
ExtenderProvidedPropertyAttribute attr = extender.Attributes[typeof(ExtenderProvidedPropertyAttribute)] as ExtenderProvidedPropertyAttribute;
|
|
|
|
Debug.Assert(attr != null, "The original PropertyDescriptor does not have an ExtenderProvidedPropertyAttribute");
|
|
|
|
|
|
DebugReflectPropertyDescriptor reflectDesc = attr.ExtenderProperty as DebugReflectPropertyDescriptor;
|
|
|
|
Debug.Assert(reflectDesc != null, "The original PropertyDescriptor has an invalid ExtenderProperty");
|
|
|
|
this.extenderInfo = reflectDesc;
|
|
this.provider = attr.Provider;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Determines if the the component will allow its value to be reset.
|
|
/// </devdoc>
|
|
public override bool CanResetValue(object comp) {
|
|
return extenderInfo.ExtenderCanResetValue(provider, comp);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Retrieves the type of the component this PropertyDescriptor is bound to.
|
|
/// </devdoc>
|
|
public override Type ComponentType {
|
|
get {
|
|
return extenderInfo.ComponentType;
|
|
}
|
|
}
|
|
|
|
public override TypeConverter Converter {
|
|
get {
|
|
if (converter == null) {
|
|
TypeConverterAttribute attr = (TypeConverterAttribute)Attributes[typeof(TypeConverterAttribute)];
|
|
if (attr.ConverterTypeName != null && attr.ConverterTypeName.Length > 0) {
|
|
Type converterType = GetTypeFromName(attr.ConverterTypeName);
|
|
if (converterType != null && typeof(TypeConverter).IsAssignableFrom(converterType)) {
|
|
converter = (TypeConverter)CreateInstance(converterType);
|
|
}
|
|
}
|
|
|
|
if (converter == null) {
|
|
converter = DebugTypeDescriptor.GetConverter(PropertyType);
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Determines if the property can be written to.
|
|
/// </devdoc>
|
|
public override bool IsReadOnly {
|
|
get {
|
|
return Attributes[typeof(ReadOnlyAttribute)].Equals(ReadOnlyAttribute.Yes);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Retrieves the data type of the property.
|
|
/// </devdoc>
|
|
public override Type PropertyType {
|
|
get {
|
|
return extenderInfo.ExtenderGetType(provider);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Retrieves the display name of the property. This is the name that will
|
|
/// be displayed in a properties window. This will be the same as the property
|
|
/// name for most properties.
|
|
/// </devdoc>
|
|
public override string DisplayName {
|
|
get {
|
|
string name = Name;
|
|
ISite site = GetSite(provider);
|
|
if (site != null) {
|
|
string providerName = site.Name;
|
|
if (providerName != null && providerName.Length > 0) {
|
|
name = SR.GetString(SR.MetaExtenderName, name, providerName);
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Retrieves the properties
|
|
/// </devdoc>
|
|
public override PropertyDescriptorCollection GetChildProperties(object instance, Attribute[] filter) {
|
|
if (instance == null) {
|
|
return DebugTypeDescriptor.GetProperties(PropertyType, filter);
|
|
}
|
|
else {
|
|
return DebugTypeDescriptor.GetProperties(instance, filter);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets an editor of the specified type.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public override object GetEditor(Type editorBaseType) {
|
|
object editor = null;
|
|
|
|
// Check the editors we've already created for this type.
|
|
//
|
|
if (editorTypes != null) {
|
|
for (int i = 0; i < editorCount; i++) {
|
|
if (editorTypes[i] == editorBaseType) {
|
|
return editors[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// If one wasn't found, then we must go through the attributes.
|
|
//
|
|
if (editor == null) {
|
|
for (int i = 0; i < Attributes.Count; i++) {
|
|
|
|
if (!(Attributes[i] is EditorAttribute)) {
|
|
continue;
|
|
}
|
|
|
|
EditorAttribute attr = (EditorAttribute)Attributes[i];
|
|
Type editorType = GetTypeFromName(attr.EditorBaseTypeName);
|
|
|
|
if (editorBaseType == editorType) {
|
|
Type type = GetTypeFromName(attr.EditorTypeName);
|
|
if (type != null) {
|
|
editor = CreateInstance(type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now, if we failed to find it in our own attributes, go to the
|
|
// component descriptor.
|
|
//
|
|
if (editor == null) {
|
|
editor = DebugTypeDescriptor.GetEditor(PropertyType, editorBaseType);
|
|
}
|
|
|
|
// Now, another slot in our editor cache for next time
|
|
//
|
|
if (editorTypes == null) {
|
|
editorTypes = new Type[5];
|
|
editors = new object[5];
|
|
}
|
|
|
|
if (editorCount >= editorTypes.Length) {
|
|
Type[] newTypes = new Type[editorTypes.Length * 2];
|
|
object[] newEditors = new object[editors.Length * 2];
|
|
Array.Copy(editorTypes, newTypes, editorTypes.Length);
|
|
Array.Copy(editors, newEditors, editors.Length);
|
|
editorTypes = newTypes;
|
|
editors = newEditors;
|
|
}
|
|
|
|
editorTypes[editorCount] = editorBaseType;
|
|
editors[editorCount++] = editor;
|
|
}
|
|
|
|
return editor;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Retrieves the value of the property for the given component. This will
|
|
/// throw an exception if the component does not have this property.
|
|
/// </devdoc>
|
|
public override object GetValue(object comp) {
|
|
return extenderInfo.ExtenderGetValue(provider, comp);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Resets the value of this property on comp to the default value.
|
|
/// </devdoc>
|
|
public override void ResetValue(object comp) {
|
|
extenderInfo.ExtenderResetValue(provider, comp, this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Sets the value of this property on the given component.
|
|
/// </devdoc>
|
|
public override void SetValue(object component, object value) {
|
|
extenderInfo.ExtenderSetValue(provider, component, value, this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Determines if this property should be persisted. A property is
|
|
/// to be persisted if it is marked as persistable through a
|
|
/// PersistableAttribute, and if the property contains something other
|
|
/// than the default value. Note, however, that this method will
|
|
/// return true for design time properties as well, so callers
|
|
/// should also check to see if a property is design time only before
|
|
/// persisting to runtime storage.
|
|
/// </devdoc>
|
|
public override bool ShouldSerializeValue(object comp) {
|
|
return extenderInfo.ExtenderShouldSerializeValue(provider, comp);
|
|
}
|
|
}
|
|
}
|
|
#endif
|