/// <devdoc>
//
//// </devdoc>
private void AddProperty(string filter, string name, string value, bool mainDirectiveMode) {
Debug.Assert(!String.IsNullOrEmpty(name));
//Second check is a hack to make the intellisense work with strongly typed controls. Existence of ModelType property
//should force creation of code to make the intellisense to work, so far this is the only property
//that is required to be identified at design time.
//If there's atleast one more property, this hack should be removed and another way should be figured out.
if (IgnoreControlProperty && !name.Equals(ItemTypeProperty, StringComparison.OrdinalIgnoreCase)) {
return;
}
string objectModelName = String.Empty;
MemberInfo memberInfo = null;
// This _controlType can be null if we're using a StringPropertyBuilder that has designer expandos
if (_controlType != null) {
if (String.Equals(name, BaseTemplateCodeDomTreeGenerator.skinIDPropertyName, StringComparison.OrdinalIgnoreCase) &&
flags[controlTypeIsControl]) {
// Make sure there isn't filter for skinID property.
if (!String.IsNullOrEmpty(filter)) {
throw new InvalidOperationException(SR.GetString(SR.Illegal_Device, BaseTemplateCodeDomTreeGenerator.skinIDPropertyName));
}
SkinID = value;
return;
}
memberInfo = PropertyMapper.GetMemberInfo(_controlType, name, out objectModelName);
}
if (memberInfo != null) {
// Found a property on the object, so start building a simple property setter
SimplePropertyEntry entry = new SimplePropertyEntry();
entry.Filter = filter;
entry.Name = objectModelName;
entry.PersistedValue = value;
Type memberType = null;
if (memberInfo is PropertyInfo) {
PropertyInfo propInfo = ((PropertyInfo)memberInfo);
entry.PropertyInfo = propInfo;
// If the property is read-only
if (propInfo.GetSetMethod() == null) {
if (!SupportsAttributes) {
// If it doesn't support attributes, throw an exception
throw new HttpException(SR.GetString(SR.Property_readonly, name));
}
else {
// Otherwise, use the attribute accessor
entry.UseSetAttribute = true;
// Use the original casing of the name from the parsed data
entry.Name = name;
}
}
ValidatePersistable(propInfo, entry.UseSetAttribute, mainDirectiveMode, true, filter);
memberType = propInfo.PropertyType;
}
else {
Debug.Assert(memberInfo is FieldInfo);
memberType = ((FieldInfo)memberInfo).FieldType;
}
entry.Type = memberType;
if (entry.UseSetAttribute) {
entry.Value = value;
}
else {
// Get the actual value for the property and store it in the entry
object objectValue = PropertyConverter.ObjectFromString(memberType, memberInfo, value);
DesignTimePageThemeParser themeParser = Parser as DesignTimePageThemeParser;
if (themeParser != null) {
object[] attrs = memberInfo.GetCustomAttributes(typeof(UrlPropertyAttribute), true);
if (attrs.Length > 0) {
string url = objectValue.ToString();
// Do not combine the url if it's apprelative, let controls resolve the url.
if (UrlPath.IsRelativeUrl(url) && !UrlPath.IsAppRelativePath(url)) {
objectValue = themeParser.ThemePhysicalPath + url;
}
}
}
entry.Value = objectValue;
//
if (memberType.IsEnum) {
if (objectValue == null) {
throw new HttpException(SR.GetString(SR.Invalid_enum_value, value, name, entry.Type.FullName));
}
entry.PersistedValue = Enum.Format(memberType, objectValue, "G");
}
else if (memberType == typeof(Boolean)) {
//
if (objectValue == null) {
entry.Value = true;
}
}
}
AddEntry(SimplePropertyEntriesInternal, entry);
}
else {
bool foundEvent = false;
// Check if the property is actually an event handler
if (StringUtil.StringStartsWithIgnoreCase(name, "on")) {
string eventName = name.Substring(2);
EventDescriptor eventDesc = EventDescriptors.Find(eventName, true);
if (eventDesc != null) {
if (InPageTheme) {
throw new HttpException(SR.GetString(SR.Property_theme_disabled, eventName, ControlType.FullName));
}
if (value != null)
value = value.Trim();
if (String.IsNullOrEmpty(value)) {
throw new HttpException(SR.GetString(SR.Event_handler_cant_be_empty, name));
}
if (filter.Length > 0) {
throw new HttpException(SR.GetString(SR.Events_cant_be_filtered, filter, name));
}
foundEvent = true;
// First, give the PageParserFilter a chance to handle the event hookup
if (!Parser.PageParserFilterProcessedEventHookupAttribute(ID, eventDesc.Name, value)) {
// Make sure event handlers are allowed. In no-compile pages, they aren't. (VSWhidbey 450297)
Parser.OnFoundEventHandler(name);
EventEntry entry = new EventEntry();
entry.Name = eventDesc.Name;
entry.HandlerType = eventDesc.EventType;
entry.HandlerMethodName = value;
EventEntriesInternal.Add(entry);
}
}
}
// If we didn't find an eventhandler, we need to use the IAttributeAccessor
if (!foundEvent) {
// Allow the designer filter expandos for simple attributes
if (!SupportsAttributes && (filter != DesignerFilter)) {
if (_controlType != null) {
throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, name));
}
else {
throw new HttpException(SR.GetString(SR.Property_doesnt_have_property, TagName, name));
}
}
SimplePropertyEntry entry = new SimplePropertyEntry();
entry.Filter = filter;
entry.Name = name;
entry.PersistedValue = value;
entry.UseSetAttribute = true;
entry.Value = value;
AddEntry(SimplePropertyEntriesInternal, entry);
}
}
}
//
public void SetResourceKey(string resourceKey) {
// This should only be used in the designer
Debug.Assert(InDesigner);
SimplePropertyEntry entry = new SimplePropertyEntry();
entry.Filter = "meta";
entry.Name = "resourcekey";
entry.Value = resourceKey;
entry.PersistedValue = resourceKey;
entry.UseSetAttribute = true;
entry.Type = typeof(string);
AddEntry(SimplePropertyEntriesInternal, entry);
}
public void SetResourceKey(string resourceKey)
{
SimplePropertyEntry entry = new SimplePropertyEntry {
Filter = "meta",
Name = "resourcekey",
Value = resourceKey,
PersistedValue = resourceKey,
UseSetAttribute = true,
Type = typeof(string)
};
this.AddEntry(this.SimplePropertyEntriesInternal, entry);
}
internal void SetSimpleProperty(SimplePropertyEntry entry, object obj) {
if (entry.UseSetAttribute) {
((IAttributeAccessor)obj).SetAttribute(entry.Name, entry.Value.ToString());
}
else {
try {
PropertyMapper.SetMappedPropertyValue(obj, entry.Name, entry.Value, InDesigner);
}
catch (Exception e) {
throw new HttpException(SR.GetString(SR.Cannot_set_property, entry.PersistedValue, entry.Name), e);
}
}
}
private void AddProperty(string filter, string name, string value, bool mainDirectiveMode)
{
if (!this.IgnoreControlProperty)
{
string nameForCodeGen = string.Empty;
MemberInfo propertyInfo = null;
if (this._controlType != null)
{
if (string.Equals(name, "SkinID", StringComparison.OrdinalIgnoreCase) && this.flags[0x2000])
{
if (!string.IsNullOrEmpty(filter))
{
throw new InvalidOperationException(System.Web.SR.GetString("Illegal_Device", new object[] { "SkinID" }));
}
this.SkinID = value;
return;
}
propertyInfo = PropertyMapper.GetMemberInfo(this._controlType, name, out nameForCodeGen);
}
if (propertyInfo != null)
{
SimplePropertyEntry entry = new SimplePropertyEntry {
Filter = filter,
Name = nameForCodeGen,
PersistedValue = value
};
Type objType = null;
if (propertyInfo is PropertyInfo)
{
PropertyInfo propInfo = (PropertyInfo) propertyInfo;
entry.PropertyInfo = propInfo;
if (propInfo.GetSetMethod() == null)
{
if (!this.SupportsAttributes)
{
throw new HttpException(System.Web.SR.GetString("Property_readonly", new object[] { name }));
}
entry.UseSetAttribute = true;
entry.Name = name;
}
this.ValidatePersistable(propInfo, entry.UseSetAttribute, mainDirectiveMode, true, filter);
objType = propInfo.PropertyType;
}
else
{
objType = ((FieldInfo) propertyInfo).FieldType;
}
entry.Type = objType;
if (entry.UseSetAttribute)
{
entry.Value = value;
}
else
{
object obj2 = PropertyConverter.ObjectFromString(objType, propertyInfo, value);
DesignTimePageThemeParser parser = this.Parser as DesignTimePageThemeParser;
if ((parser != null) && (propertyInfo.GetCustomAttributes(typeof(UrlPropertyAttribute), true).Length > 0))
{
string virtualPath = obj2.ToString();
if (UrlPath.IsRelativeUrl(virtualPath) && !UrlPath.IsAppRelativePath(virtualPath))
{
obj2 = parser.ThemePhysicalPath + virtualPath;
}
}
entry.Value = obj2;
if (objType.IsEnum)
{
if (obj2 == null)
{
throw new HttpException(System.Web.SR.GetString("Invalid_enum_value", new object[] { value, name, entry.Type.FullName }));
}
entry.PersistedValue = Enum.Format(objType, obj2, "G");
}
else if ((objType == typeof(bool)) && (obj2 == null))
{
entry.Value = true;
}
}
this.AddEntry(this.SimplePropertyEntriesInternal, entry);
}
else
{
bool flag = false;
if (StringUtil.StringStartsWithIgnoreCase(name, "on"))
{
string str3 = name.Substring(2);
EventDescriptor descriptor = this.EventDescriptors.Find(str3, true);
if (descriptor != null)
{
if (this.InPageTheme)
{
throw new HttpException(System.Web.SR.GetString("Property_theme_disabled", new object[] { str3, this.ControlType.FullName }));
}
if (value != null)
{
value = value.Trim();
}
if (string.IsNullOrEmpty(value))
{
throw new HttpException(System.Web.SR.GetString("Event_handler_cant_be_empty", new object[] { name }));
}
if (filter.Length > 0)
{
throw new HttpException(System.Web.SR.GetString("Events_cant_be_filtered", new object[] { filter, name }));
}
flag = true;
if (!this.Parser.PageParserFilterProcessedEventHookupAttribute(this.ID, descriptor.Name, value))
{
this.Parser.OnFoundEventHandler(name);
EventEntry entry2 = new EventEntry {
Name = descriptor.Name,
HandlerType = descriptor.EventType,
HandlerMethodName = value
};
this.EventEntriesInternal.Add(entry2);
}
}
}
if (!flag)
{
if (!this.SupportsAttributes && (filter != DesignerFilter))
{
if (this._controlType != null)
{
throw new HttpException(System.Web.SR.GetString("Type_doesnt_have_property", new object[] { this._controlType.FullName, name }));
}
throw new HttpException(System.Web.SR.GetString("Property_doesnt_have_property", new object[] { this.TagName, name }));
}
SimplePropertyEntry entry3 = new SimplePropertyEntry {
Filter = filter,
Name = name,
PersistedValue = value,
UseSetAttribute = true,
Value = value
};
this.AddEntry(this.SimplePropertyEntriesInternal, entry3);
}
}
}
}