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
- ThreadAttributes.cs
- CompensatableTransactionScopeActivityDesigner.cs
- SafeSecurityHandles.cs
- AssemblyAttributesGoHere.cs
- CachingHintValidation.cs
- UriWriter.cs
- odbcmetadatacolumnnames.cs
- Section.cs
- PageWrapper.cs
- CodeMethodInvokeExpression.cs
- MetadataItem.cs
- ImpersonationContext.cs
- NamedPipeAppDomainProtocolHandler.cs
- DateTimeOffsetConverter.cs
- StringOutput.cs
- CqlErrorHelper.cs
- DataGridCommandEventArgs.cs
- CultureMapper.cs
- UdpChannelListener.cs
- FontFamilyValueSerializer.cs
- ClientSettingsStore.cs
- PersonalizationAdministration.cs
- ViewLoader.cs
- SQLResource.cs
- TransactionalPackage.cs
- SyntaxCheck.cs
- GeneralTransform3DGroup.cs
- ControlCachePolicy.cs
- RootProfilePropertySettingsCollection.cs
- SimpleHandlerBuildProvider.cs
- InnerItemCollectionView.cs
- PackagePart.cs
- SafeCryptContextHandle.cs
- FormViewInsertEventArgs.cs
- PointF.cs
- ButtonBaseAdapter.cs
- ZipIOEndOfCentralDirectoryBlock.cs
- AdvancedBindingPropertyDescriptor.cs
- CalendarDay.cs
- WebUtil.cs
- Environment.cs
- RawStylusInput.cs
- SafeNativeMethodsMilCoreApi.cs
- ConvertersCollection.cs
- DesignerHost.cs
- XmlStringTable.cs
- ArraySegment.cs
- DynamicResourceExtension.cs
- SQLDecimal.cs
- BindingList.cs
- TextWriterTraceListener.cs
- Validator.cs
- Menu.cs
- GenericRootAutomationPeer.cs
- SortQueryOperator.cs
- WinInetCache.cs
- SqlDataSourceQueryEditor.cs
- CompilerScopeManager.cs
- TemplateControlBuildProvider.cs
- MatrixStack.cs
- X509CertificateClaimSet.cs
- TempFiles.cs
- BulletChrome.cs
- TransformDescriptor.cs
- ResourceProviderFactory.cs
- CellTreeNodeVisitors.cs
- SharedDp.cs
- OdbcStatementHandle.cs
- SymmetricKey.cs
- TabPanel.cs
- RangeValidator.cs
- OutKeywords.cs
- UserControlParser.cs
- HttpCookiesSection.cs
- NativeMethods.cs
- FileVersion.cs
- ExpressionConverter.cs
- SocketStream.cs
- Effect.cs
- XmlIlVisitor.cs
- UdpDuplexChannel.cs
- XhtmlBasicLabelAdapter.cs
- ObjectTag.cs
- SqlBinder.cs
- ImageField.cs
- ExpressionList.cs
- BackgroundFormatInfo.cs
- XmlElement.cs
- DoubleConverter.cs
- VSDExceptions.cs
- ConfigurationElementProperty.cs
- UniqueEventHelper.cs
- Style.cs
- HorizontalAlignConverter.cs
- Point3DConverter.cs
- TrackingValidationObjectDictionary.cs
- HandleRef.cs
- NonVisualControlAttribute.cs
- ToggleProviderWrapper.cs
- CollectionCodeDomSerializer.cs