Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / Design / LogicalExpressionTypeConverter.cs / 1305376 / LogicalExpressionTypeConverter.cs
// ----------------------------------------------------------------------------
// Copyright (C) 2006 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------
using System.CodeDom;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Globalization;
using System.Security.Permissions;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Activities.Common;
namespace System.Workflow.Activities.Rules.Design
{
internal abstract class RuleDefinitionDynamicPropertyDescriptor : DynamicPropertyDescriptor
{
public RuleDefinitionDynamicPropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
protected RuleDefinitions GetRuleDefinitions(object component)
{
IReferenceService referenceService = ((IReferenceService)this.ServiceProvider.GetService(typeof(IReferenceService)));
if (referenceService == null)
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(IReferenceService).FullName));
Activity activity = referenceService.GetComponent(component) as Activity;
if (activity == null)
return null;
Activity root = Helpers.GetRootActivity(activity);
if (root == null)
return null;
Activity declaring = Helpers.GetDeclaringActivity(activity);
if (declaring == root || declaring == null)
return ConditionHelper.Load_Rules_DT(this.ServiceProvider, root);
else
return ConditionHelper.GetRuleDefinitionsFromManifest(declaring.GetType());
}
}
#region Class RuleConditionReferenceTypeConverter
internal class RuleConditionReferenceTypeConverter : TypeConverter
{
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
PropertyDescriptorCollection newProps = new PropertyDescriptorCollection(null);
newProps.Add(new RuleConditionReferenceNamePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "ConditionName", typeof(string), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
newProps.Add(new RuleConditionReferencePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "Expression", typeof(CodeExpression), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
return newProps.Sort(new string[] { "ConditionName", "Expression" });
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
}
#endregion
#region Class CodeDomRuleExpressionTypeConverter
internal class RuleConditionReferenceExpressionTypeConverter : TypeConverter
{
internal RuleConditionReferenceExpressionTypeConverter()
{
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context == null)
throw new ArgumentNullException("context");
if (destinationType != typeof(string))
return base.ConvertTo(context, culture, value, destinationType);
CodeExpression expression = value as CodeExpression;
if (expression == null)
return Messages.ConditionExpression;
return new RuleExpressionCondition(expression).ToString();
}
}
#endregion
#region Class RuleSetReferenceTypeConverter
internal class RuleSetReferenceTypeConverter : TypeConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
if (sourceType == typeof(string))
return true;
else
return base.CanConvertFrom(context, sourceType);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object valueToConvert)
{
if (context == null)
throw new ArgumentNullException("context");
string ruleSetName = valueToConvert as string;
if ((ruleSetName == null) || (ruleSetName.TrimEnd().Length == 0))
ruleSetName = string.Empty;
ISite site = PropertyDescriptorUtils.GetSite(context, context.Instance);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleSetCollection ruleSetCollection = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetName.Length != 0 && !ruleSetCollection.Contains(ruleSetName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleSet newRuleSet = new RuleSet();
newRuleSet.Name = ruleSetName;
ruleSetCollection.Add(newRuleSet);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
RuleSetReference ruleSetReference = new RuleSetReference();
ruleSetReference.RuleSetName = ruleSetName;
return ruleSetReference;
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
throw new ArgumentNullException("destinationType");
if (destinationType != typeof(string))
return base.ConvertTo(context, culture, value, destinationType);
RuleSetReference convertedValue = value as RuleSetReference;
if (convertedValue != null)
return convertedValue.RuleSetName;
return null;
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
ISite site = null;
IComponent component = PropertyDescriptorUtils.GetComponent(context);
if (component != null)
site = component.Site;
PropertyDescriptorCollection newProps = new PropertyDescriptorCollection(null);
newProps.Add(new RuleSetPropertyDescriptor(site, TypeDescriptor.CreateProperty(typeof(RuleSet), "RuleSet Definition", typeof(RuleSet), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
return newProps;
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
}
#endregion
#region Class RuleSetDefinitionTypeConverter
internal class RuleSetDefinitionTypeConverter : TypeConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context == null)
throw new ArgumentNullException("context");
RuleSet rs = value as RuleSet;
if (destinationType == typeof(string) && rs != null)
return DesignerHelpers.GetRuleSetPreview(rs);
else
return base.ConvertTo(context, culture, value, destinationType);
}
}
#endregion
#region Class CodeDomRuleNamePropertyDescriptor
internal class RuleConditionReferenceNamePropertyDescriptor : DynamicPropertyDescriptor
{
public RuleConditionReferenceNamePropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new ConditionNameEditor();
}
public override string Description
{
get
{
return Messages.NamePropertyDescription;
}
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
if (conditionDecl.ConditionName != null)
return conditionDecl.ConditionName;
return null;
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
string conditionName = value as string;
if ((conditionName == null) || (conditionName.TrimEnd().Length == 0))
conditionName = string.Empty;
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleConditionCollection conditionDefinitions = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
conditionDefinitions = rules.Conditions;
if (conditionDefinitions != null && conditionName.Length != 0 && !conditionDefinitions.Contains(conditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition newCondition = new RuleExpressionCondition();
newCondition.Name = conditionName;
conditionDefinitions.Add(newCondition);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
// Cause component change events to be fired.
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(component)["ConditionName"];
if (propertyDescriptor != null)
PropertyDescriptorUtils.SetPropertyValue(site, propertyDescriptor, component, conditionName);
}
}
#endregion
#region Class CodeDomRuleExpressionPropertyDescriptor
internal class RuleConditionReferencePropertyDescriptor : RuleDefinitionDynamicPropertyDescriptor
{
public RuleConditionReferencePropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override TypeConverter Converter
{
get
{
return new RuleConditionReferenceExpressionTypeConverter();
}
}
public override string Description
{
get
{
return Messages.ExpressionPropertyDescription;
}
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new LogicalExpressionEditor();
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
if (conditionDecl.ConditionName != null)
{
RuleDefinitions rules = GetRuleDefinitions(component);
if (rules != null)
{
RuleConditionCollection conditionDefs = rules.Conditions;
if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition conditionDefinition = (RuleExpressionCondition)conditionDefs[conditionDecl.ConditionName];
return conditionDefinition.Expression;
}
}
}
return null;
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentNullException("component");
CodeExpression expression = value as CodeExpression;
if (conditionDecl.ConditionName != null)
{
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleConditionCollection conditionDefs = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
conditionDefs = rules.Conditions;
if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition conditionDefinition = (RuleExpressionCondition) conditionDefs[conditionDecl.ConditionName];
conditionDefinition.Expression = expression;
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
}
}
}
#endregion
#region Class RuleSetPropertyDescriptor
internal class RuleSetPropertyDescriptor : RuleDefinitionDynamicPropertyDescriptor
{
public RuleSetPropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override TypeConverter Converter
{
get
{
return new RuleSetDefinitionTypeConverter();
}
}
public override string Description
{
get
{
return SR.GetString(SR.RuleSetDefinitionDescription);
}
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new RuleSetDefinitionEditor();
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleSetReference ruleSetReference = component as RuleSetReference;
if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
RuleDefinitions rules = GetRuleDefinitions(component);
if (rules != null)
{
RuleSetCollection ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetCollection.Contains(ruleSetReference.RuleSetName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleSet ruleSet = ruleSetCollection[ruleSetReference.RuleSetName];
return ruleSet;
}
}
}
return null;
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleSetReference ruleSetReference = component as RuleSetReference;
if (ruleSetReference == null)
throw new ArgumentNullException("component");
RuleSet ruleSet = value as RuleSet;
if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleSetCollection ruleSetCollection = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetCollection.Contains(ruleSetReference.RuleSetName))
{
ruleSetCollection.Remove(ruleSetReference.RuleSetName);
ruleSetCollection.Add(ruleSet);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
}
}
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
// ----------------------------------------------------------------------------
// Copyright (C) 2006 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------
using System.CodeDom;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Globalization;
using System.Security.Permissions;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Activities.Common;
namespace System.Workflow.Activities.Rules.Design
{
internal abstract class RuleDefinitionDynamicPropertyDescriptor : DynamicPropertyDescriptor
{
public RuleDefinitionDynamicPropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
protected RuleDefinitions GetRuleDefinitions(object component)
{
IReferenceService referenceService = ((IReferenceService)this.ServiceProvider.GetService(typeof(IReferenceService)));
if (referenceService == null)
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(IReferenceService).FullName));
Activity activity = referenceService.GetComponent(component) as Activity;
if (activity == null)
return null;
Activity root = Helpers.GetRootActivity(activity);
if (root == null)
return null;
Activity declaring = Helpers.GetDeclaringActivity(activity);
if (declaring == root || declaring == null)
return ConditionHelper.Load_Rules_DT(this.ServiceProvider, root);
else
return ConditionHelper.GetRuleDefinitionsFromManifest(declaring.GetType());
}
}
#region Class RuleConditionReferenceTypeConverter
internal class RuleConditionReferenceTypeConverter : TypeConverter
{
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
PropertyDescriptorCollection newProps = new PropertyDescriptorCollection(null);
newProps.Add(new RuleConditionReferenceNamePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "ConditionName", typeof(string), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
newProps.Add(new RuleConditionReferencePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "Expression", typeof(CodeExpression), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
return newProps.Sort(new string[] { "ConditionName", "Expression" });
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
}
#endregion
#region Class CodeDomRuleExpressionTypeConverter
internal class RuleConditionReferenceExpressionTypeConverter : TypeConverter
{
internal RuleConditionReferenceExpressionTypeConverter()
{
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context == null)
throw new ArgumentNullException("context");
if (destinationType != typeof(string))
return base.ConvertTo(context, culture, value, destinationType);
CodeExpression expression = value as CodeExpression;
if (expression == null)
return Messages.ConditionExpression;
return new RuleExpressionCondition(expression).ToString();
}
}
#endregion
#region Class RuleSetReferenceTypeConverter
internal class RuleSetReferenceTypeConverter : TypeConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
if (sourceType == typeof(string))
return true;
else
return base.CanConvertFrom(context, sourceType);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object valueToConvert)
{
if (context == null)
throw new ArgumentNullException("context");
string ruleSetName = valueToConvert as string;
if ((ruleSetName == null) || (ruleSetName.TrimEnd().Length == 0))
ruleSetName = string.Empty;
ISite site = PropertyDescriptorUtils.GetSite(context, context.Instance);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleSetCollection ruleSetCollection = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetName.Length != 0 && !ruleSetCollection.Contains(ruleSetName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleSet newRuleSet = new RuleSet();
newRuleSet.Name = ruleSetName;
ruleSetCollection.Add(newRuleSet);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
RuleSetReference ruleSetReference = new RuleSetReference();
ruleSetReference.RuleSetName = ruleSetName;
return ruleSetReference;
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
throw new ArgumentNullException("destinationType");
if (destinationType != typeof(string))
return base.ConvertTo(context, culture, value, destinationType);
RuleSetReference convertedValue = value as RuleSetReference;
if (convertedValue != null)
return convertedValue.RuleSetName;
return null;
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
ISite site = null;
IComponent component = PropertyDescriptorUtils.GetComponent(context);
if (component != null)
site = component.Site;
PropertyDescriptorCollection newProps = new PropertyDescriptorCollection(null);
newProps.Add(new RuleSetPropertyDescriptor(site, TypeDescriptor.CreateProperty(typeof(RuleSet), "RuleSet Definition", typeof(RuleSet), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes)));
return newProps;
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
}
#endregion
#region Class RuleSetDefinitionTypeConverter
internal class RuleSetDefinitionTypeConverter : TypeConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (context == null)
throw new ArgumentNullException("context");
RuleSet rs = value as RuleSet;
if (destinationType == typeof(string) && rs != null)
return DesignerHelpers.GetRuleSetPreview(rs);
else
return base.ConvertTo(context, culture, value, destinationType);
}
}
#endregion
#region Class CodeDomRuleNamePropertyDescriptor
internal class RuleConditionReferenceNamePropertyDescriptor : DynamicPropertyDescriptor
{
public RuleConditionReferenceNamePropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new ConditionNameEditor();
}
public override string Description
{
get
{
return Messages.NamePropertyDescription;
}
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
if (conditionDecl.ConditionName != null)
return conditionDecl.ConditionName;
return null;
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
string conditionName = value as string;
if ((conditionName == null) || (conditionName.TrimEnd().Length == 0))
conditionName = string.Empty;
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleConditionCollection conditionDefinitions = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
conditionDefinitions = rules.Conditions;
if (conditionDefinitions != null && conditionName.Length != 0 && !conditionDefinitions.Contains(conditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition newCondition = new RuleExpressionCondition();
newCondition.Name = conditionName;
conditionDefinitions.Add(newCondition);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
// Cause component change events to be fired.
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(component)["ConditionName"];
if (propertyDescriptor != null)
PropertyDescriptorUtils.SetPropertyValue(site, propertyDescriptor, component, conditionName);
}
}
#endregion
#region Class CodeDomRuleExpressionPropertyDescriptor
internal class RuleConditionReferencePropertyDescriptor : RuleDefinitionDynamicPropertyDescriptor
{
public RuleConditionReferencePropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override TypeConverter Converter
{
get
{
return new RuleConditionReferenceExpressionTypeConverter();
}
}
public override string Description
{
get
{
return Messages.ExpressionPropertyDescription;
}
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new LogicalExpressionEditor();
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component");
if (conditionDecl.ConditionName != null)
{
RuleDefinitions rules = GetRuleDefinitions(component);
if (rules != null)
{
RuleConditionCollection conditionDefs = rules.Conditions;
if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition conditionDefinition = (RuleExpressionCondition)conditionDefs[conditionDecl.ConditionName];
return conditionDefinition.Expression;
}
}
}
return null;
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleConditionReference conditionDecl = component as RuleConditionReference;
if (conditionDecl == null)
throw new ArgumentNullException("component");
CodeExpression expression = value as CodeExpression;
if (conditionDecl.ConditionName != null)
{
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleConditionCollection conditionDefs = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
conditionDefs = rules.Conditions;
if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleExpressionCondition conditionDefinition = (RuleExpressionCondition) conditionDefs[conditionDecl.ConditionName];
conditionDefinition.Expression = expression;
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
}
}
}
#endregion
#region Class RuleSetPropertyDescriptor
internal class RuleSetPropertyDescriptor : RuleDefinitionDynamicPropertyDescriptor
{
public RuleSetPropertyDescriptor(IServiceProvider serviceProvider, PropertyDescriptor descriptor)
: base(serviceProvider, descriptor)
{
}
public override TypeConverter Converter
{
get
{
return new RuleSetDefinitionTypeConverter();
}
}
public override string Description
{
get
{
return SR.GetString(SR.RuleSetDefinitionDescription);
}
}
public override object GetEditor(Type editorBaseType)
{
SecurityPermission MyPermission = new SecurityPermission(PermissionState.Unrestricted);
MyPermission.Demand();
return new RuleSetDefinitionEditor();
}
public override object GetValue(object component)
{
if (component == null)
throw new ArgumentNullException("component");
RuleSetReference ruleSetReference = component as RuleSetReference;
if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
RuleDefinitions rules = GetRuleDefinitions(component);
if (rules != null)
{
RuleSetCollection ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetCollection.Contains(ruleSetReference.RuleSetName))
{
//in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection
RuleSet ruleSet = ruleSetCollection[ruleSetReference.RuleSetName];
return ruleSet;
}
}
}
return null;
}
public override bool IsReadOnly
{
get
{
return false;
}
}
public override void SetValue(object component, object value)
{
if (component == null)
throw new ArgumentNullException("component");
RuleSetReference ruleSetReference = component as RuleSetReference;
if (ruleSetReference == null)
throw new ArgumentNullException("component");
RuleSet ruleSet = value as RuleSet;
if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component);
if (site == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName);
throw new InvalidOperationException(message);
}
RuleSetCollection ruleSetCollection = null;
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
if (rules != null)
ruleSetCollection = rules.RuleSets;
if (ruleSetCollection != null && ruleSetCollection.Contains(ruleSetReference.RuleSetName))
{
ruleSetCollection.Remove(ruleSetReference.RuleSetName);
ruleSetCollection.Add(ruleSet);
ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity));
}
}
}
}
#endregion
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AmbientValueAttribute.cs
- DataContractSerializer.cs
- DataSvcMapFileSerializer.cs
- SqlRemoveConstantOrderBy.cs
- Quaternion.cs
- XmlUtilWriter.cs
- CheckBoxRenderer.cs
- GridViewCommandEventArgs.cs
- ChangeBlockUndoRecord.cs
- HashSetEqualityComparer.cs
- DaylightTime.cs
- RewritingPass.cs
- ResetableIterator.cs
- StringUtil.cs
- ProcessModule.cs
- TargetParameterCountException.cs
- SerializationBinder.cs
- ItemDragEvent.cs
- HttpListenerContext.cs
- TransformPattern.cs
- StorageEntityContainerMapping.cs
- Composition.cs
- ApplicationManager.cs
- RowParagraph.cs
- SafeThemeHandle.cs
- DbConnectionStringBuilder.cs
- ApplicationSecurityInfo.cs
- ToolStripPanelCell.cs
- TextUtf8RawTextWriter.cs
- ObjectDataSource.cs
- ContentPlaceHolder.cs
- WindowsListBox.cs
- WebAdminConfigurationHelper.cs
- WindowsStatusBar.cs
- FileDetails.cs
- ComAdminWrapper.cs
- ReferencedAssemblyResolver.cs
- RelatedImageListAttribute.cs
- COM2DataTypeToManagedDataTypeConverter.cs
- RadioButtonPopupAdapter.cs
- Binding.cs
- ErrorProvider.cs
- SubMenuStyleCollectionEditor.cs
- Composition.cs
- IisTraceWebEventProvider.cs
- NavigatorInput.cs
- Int16.cs
- NativeActivityTransactionContext.cs
- OptimizerPatterns.cs
- AdCreatedEventArgs.cs
- wgx_commands.cs
- BitmapEffectDrawing.cs
- ReverseComparer.cs
- Translator.cs
- ByteAnimation.cs
- FilteredAttributeCollection.cs
- EventTrigger.cs
- sqlinternaltransaction.cs
- EntitySqlException.cs
- NativeMethods.cs
- PipeConnection.cs
- Size.cs
- UITypeEditor.cs
- XmlLinkedNode.cs
- XmlEncoding.cs
- IDQuery.cs
- PackageDigitalSignatureManager.cs
- RoutedCommand.cs
- NameValuePair.cs
- PropertyCondition.cs
- SqlServer2KCompatibilityCheck.cs
- SqlProvider.cs
- SamlAssertionKeyIdentifierClause.cs
- ReverseInheritProperty.cs
- DynamicPropertyReader.cs
- DataGridViewBand.cs
- WebPartConnectionsCancelEventArgs.cs
- Renderer.cs
- Rectangle.cs
- TraceListeners.cs
- BufferModeSettings.cs
- NamespaceDisplayAutomationPeer.cs
- ThicknessAnimation.cs
- CodeMethodReturnStatement.cs
- DbParameterHelper.cs
- NameTable.cs
- Deflater.cs
- PlainXmlSerializer.cs
- ToolStripGripRenderEventArgs.cs
- GridViewRowEventArgs.cs
- SafeLocalAllocation.cs
- AliasedExpr.cs
- DefaultClaimSet.cs
- Rotation3DAnimationBase.cs
- TemplateEditingFrame.cs
- KeyNameIdentifierClause.cs
- DurableInstance.cs
- TogglePatternIdentifiers.cs
- ObjectNotFoundException.cs
- XPathNode.cs