/// <summary>
/// Tests for object equality
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (object.ReferenceEquals(obj, this))
{
return(true);
}
ScriptControlPropertyAttribute other = obj as ScriptControlPropertyAttribute;
if (other != null)
{
return(other._isScriptProperty == _isScriptProperty);
}
return(false);
}
protected override void PreFilterProperties(System.Collections.IDictionary properties)
{
base.PreFilterProperties(properties);
string[] propertyNames = new string[properties.Keys.Count];
properties.Keys.CopyTo(propertyNames, 0);
foreach (string propertyName in propertyNames)
{
PropertyDescriptor pd = (PropertyDescriptor)properties[propertyName];
if (propertyName == "TargetControlID")
{
// get the control type.
//
TargetControlTypeAttribute targetControlType = (TargetControlTypeAttribute)TypeDescriptor.GetAttributes(ExtenderControl)[typeof(TargetControlTypeAttribute)];
if (targetControlType != null && !targetControlType.IsDefaultAttribute())
{
Type genericType = typeof(TypedControlIDConverter <>).MakeGenericType(targetControlType.TargetControlType);
properties[propertyName] = TypeDescriptor.CreateProperty(pd.ComponentType, pd, new TypeConverterAttribute(genericType));
}
}
ScriptControlPropertyAttribute extenderPropAttr = (ScriptControlPropertyAttribute)pd.Attributes[typeof(ScriptControlPropertyAttribute)];
if (extenderPropAttr == null || !extenderPropAttr.IsScriptProperty)
{
continue;
}
BrowsableAttribute browsableAttr = (BrowsableAttribute)pd.Attributes[typeof(BrowsableAttribute)];
if (browsableAttr.Browsable == BrowsableAttribute.Yes.Browsable)
{
properties[propertyName] = TypeDescriptor.CreateProperty(pd.ComponentType, pd, BrowsableAttribute.No, ExtenderVisiblePropertyAttribute.Yes);
}
}
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
// we'll walk the extenders properties looking for the ones marked as ExtenderControl properties.
// for those, we'll make them visible, then add them to the list.
//
PropertyDescriptorCollection propCollection = TypeDescriptor.GetProperties(this.Target);
if (_propsToHide != null && _propsToHide.Length > 0)
{
List <PropertyDescriptor> props = new List <PropertyDescriptor>();
for (int i = 0; i < propCollection.Count; i++)
{
PropertyDescriptor prop = propCollection[i];
ScriptControlPropertyAttribute extenderPropAttr = (ScriptControlPropertyAttribute)prop.Attributes[typeof(ScriptControlPropertyAttribute)];
if (extenderPropAttr == null)
{
continue;
}
ExtenderVisiblePropertyAttribute evpa = (ExtenderVisiblePropertyAttribute)prop.Attributes[typeof(ExtenderVisiblePropertyAttribute)];
if (evpa == null || !evpa.Value)
{
// if there isn't an ExtenderVisiblePropertyAttribute on here (the designer adds this),
// then we shouldn't process it. Usually this means the developer marked it as Browsable.False.
//
continue;
}
// if the name is in the list, remove browsable from the name.
//
int index = Array.FindIndex <string>(_propsToHide,
delegate(string s) {
return(s == prop.Name);
}
);
if (index != -1)
{
continue;
}
// add the drop down if it is selectable.
//
IDReferencePropertyAttribute controlRefAttr = (IDReferencePropertyAttribute)prop.Attributes[typeof(IDReferencePropertyAttribute)];
Attribute tca = prop.Attributes[typeof(TypeConverterAttribute)];
if (controlRefAttr != null && !controlRefAttr.IsDefaultAttribute())
{
Type t = typeof(TypedControlIDConverter <Control>).GetGenericTypeDefinition();
t = t.MakeGenericType(controlRefAttr.ReferencedControlType);
tca = new TypeConverterAttribute(t);
}
prop = TypeDescriptor.CreateProperty(prop.ComponentType, prop, BrowsableAttribute.Yes, tca);
// add it to the list.
//
props.Add(prop);
}
propCollection = new PropertyDescriptorCollection(props.ToArray());
}
return(propCollection);
}
public static void DescribeComponent(object instance, ScriptComponentDescriptor descriptor, IUrlResolutionService urlResolver, IControlResolver controlResolver)
{
// validate preconditions
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
if (urlResolver == null)
{
urlResolver = instance as IUrlResolutionService;
}
if (controlResolver == null)
{
controlResolver = instance as IControlResolver;
}
// describe properties
// PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(instance);
PropertyInfo[] properties = instance.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (PropertyInfo prop in properties)
{
ScriptControlPropertyAttribute propAttr = null;
ScriptControlEventAttribute eventAttr = null;
string propertyName = prop.Name;
System.ComponentModel.AttributeCollection attribs = new System.ComponentModel.AttributeCollection(Attribute.GetCustomAttributes(prop, false));
// Try getting a property attribute
propAttr = (ScriptControlPropertyAttribute)attribs[typeof(ScriptControlPropertyAttribute)];
if (propAttr == null || !propAttr.IsScriptProperty)
{
// Try getting an event attribute
eventAttr = (ScriptControlEventAttribute)attribs[typeof(ScriptControlEventAttribute)];
if (eventAttr == null || !eventAttr.IsScriptEvent)
{
continue;
}
}
// attempt to rename the property/event
ClientPropertyNameAttribute nameAttr = (ClientPropertyNameAttribute)attribs[typeof(ClientPropertyNameAttribute)];
if (nameAttr != null && !string.IsNullOrEmpty(nameAttr.PropertyName))
{
propertyName = nameAttr.PropertyName;
}
// determine whether to serialize the value of a property. readOnly properties should always be serialized
//bool serialize = true;// prop.ShouldSerializeValue(instance) || prop.IsReadOnly;
//if (serialize)
//{
// get the value of the property, skip if it is null
Control c = null;
object value = prop.GetValue(instance, new object[0] {
});
if (value == null)
{
continue;
}
// convert and resolve the value
if (eventAttr != null && prop.PropertyType != typeof(String))
{
throw new InvalidOperationException("ScriptControlEventAttribute can only be applied to a property with a PropertyType of System.String.");
}
else
{
if (!prop.PropertyType.IsPrimitive && !prop.PropertyType.IsEnum)
{
if (prop.PropertyType == typeof(Color))
{
value = ColorTranslator.ToHtml((Color)value);
}
else
{
// TODO: Determine if we should let ASP.NET AJAX handle this type of conversion, as it supports JSON serialization
//TypeConverter conv = prop.Converter;
//value = conv.ConvertToString(null, CultureInfo.InvariantCulture, value);
//if (prop.PropertyType == typeof(CssStyleCollection))
// value = (new CssStyleCollectionJSCoverter()).Serialize(value, new JavaScriptSerializer());
//if (prop.PropertyType == typeof(Style))
// value = (new CssStyleCollectionJSCoverter()).Serialize(((Style)value).GetStyleAttributes(null), new JavaScriptSerializer());
Type valueType = value.GetType();
JavaScriptConverterAttribute attr = (JavaScriptConverterAttribute)attribs[typeof(JavaScriptConverterAttribute)];
JavaScriptConverter converter = attr != null ?
(JavaScriptConverter)TypeCreator.CreateInstance(attr.ConverterType) :
JSONSerializerFactory.GetJavaScriptConverter(valueType);
if (converter != null)
{
value = converter.Serialize(value, JSONSerializerFactory.GetJavaScriptSerializer());
}
else
{
value = JSONSerializerExecute.PreSerializeObject(value);
}
//Dictionary<string, object> dict = value as Dictionary<string, object>;
//if (dict != null && !dict.ContainsKey("__type"))
// dict["__type"] = valueType.AssemblyQualifiedName;
}
}
if (attribs[typeof(IDReferencePropertyAttribute)] != null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (attribs[typeof(UrlPropertyAttribute)] != null && urlResolver != null)
{
value = urlResolver.ResolveClientUrl((string)value);
}
}
// add the value as an appropriate description
if (eventAttr != null)
{
if (!string.IsNullOrEmpty((string)value))
{
descriptor.AddEvent(propertyName, (string)value);
}
}
else if (attribs[typeof(ElementReferenceAttribute)] != null)
{
if (c == null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (c != null)
{
value = c.ClientID;
}
descriptor.AddElementProperty(propertyName, (string)value);
}
else if (attribs[typeof(ComponentReferenceAttribute)] != null)
{
if (c == null && controlResolver != null)
{
c = controlResolver.ResolveControl((string)value);
}
if (c != null)
{
//ExtenderControlBase ex = c as ExtenderControlBase;
//if (ex != null && ex.BehaviorID.Length > 0)
// value = ex.BehaviorID;
//else
value = c.ClientID;
}
descriptor.AddComponentProperty(propertyName, (string)value);
}
else
{
if (c != null)
{
value = c.ClientID;
}
descriptor.AddProperty(propertyName, value);
}
}
//}
// determine if we should describe methods
foreach (MethodInfo method in instance.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public))
{
ScriptControlMethodAttribute methAttr = (ScriptControlMethodAttribute)Attribute.GetCustomAttribute(method, typeof(ScriptControlMethodAttribute));
if (methAttr == null || !methAttr.IsScriptMethod)
{
continue;
}
// We only need to support emitting the callback target and registering the WebForms.js script if there is at least one valid method
Control control = instance as Control;
if (control != null)
{
// Force WebForms.js
control.Page.ClientScript.GetCallbackEventReference(control, null, null, null);
// Add the callback target
descriptor.AddProperty("_callbackTarget", control.UniqueID);
}
break;
}
}