716 lines
31 KiB
C#
716 lines
31 KiB
C#
#pragma warning disable 1634, 1691
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Workflow.ComponentModel.Design;
|
|
using System.Workflow.ComponentModel.Compiler;
|
|
using System.Workflow.ComponentModel.Serialization;
|
|
using System.Reflection;
|
|
using System.ComponentModel.Design.Serialization;
|
|
|
|
namespace System.Workflow.ComponentModel
|
|
{
|
|
|
|
//TBD: DharmaS, Move the collections to the LocalStore class and have DO keep a ref to LS
|
|
[DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
|
|
[DesignerSerializer(typeof(DependencyObjectCodeDomSerializer), typeof(CodeDomSerializer))]
|
|
[Obsolete("The System.Workflow.* types are deprecated. Instead, please use the new types from System.Activities.*")]
|
|
public abstract class DependencyObject : IComponent, IDependencyObjectAccessor, IDisposable
|
|
{
|
|
private static DependencyProperty SiteProperty = DependencyProperty.Register("Site", typeof(ISite), typeof(DependencyObject), new PropertyMetadata(DependencyPropertyOptions.Metadata, new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
|
|
private static DependencyProperty ReadonlyProperty = DependencyProperty.Register("Readonly", typeof(bool), typeof(DependencyObject), new PropertyMetadata(DependencyPropertyOptions.Metadata | DependencyPropertyOptions.ReadOnly, new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
|
|
private static DependencyProperty ParentDependencyObjectProperty = DependencyProperty.Register("ParentDependencyObject", typeof(DependencyObject), typeof(DependencyObject), new PropertyMetadata(null, new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
|
|
private static DependencyProperty UserDataProperty = DependencyProperty.Register("UserData", typeof(IDictionary), typeof(DependencyObject), new PropertyMetadata(DependencyPropertyOptions.Metadata | DependencyPropertyOptions.ReadOnly, new Attribute[] { new BrowsableAttribute(false), new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
|
|
|
|
//design meta data holder
|
|
[NonSerialized]
|
|
private IDictionary<DependencyProperty, object> metaProperties = new Dictionary<DependencyProperty, object>();
|
|
[NonSerialized]
|
|
private bool readonlyPropertyValue;
|
|
|
|
protected DependencyObject()
|
|
{
|
|
//
|
|
SetReadOnlyPropertyValue(ReadonlyProperty, false);
|
|
readonlyPropertyValue = false;
|
|
//
|
|
SetReadOnlyPropertyValue(UserDataProperty, Hashtable.Synchronized(new Hashtable()));
|
|
}
|
|
|
|
~DependencyObject()
|
|
{
|
|
// In designer/build scenarios, some dependencies may be missing, which could cause a
|
|
// JIT failure in user overrides of Dispose. Ignore these failures so they don't
|
|
// crash the process.
|
|
if (this.DesignMode)
|
|
{
|
|
try
|
|
{
|
|
Dispose(false);
|
|
}
|
|
// These are the most common JIT exceptions for this scenario, based on Watson data
|
|
catch (TypeInitializationException)
|
|
{
|
|
}
|
|
catch (System.IO.FileNotFoundException)
|
|
{
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Dispose(false);
|
|
}
|
|
}
|
|
|
|
internal bool Readonly
|
|
{
|
|
get
|
|
{
|
|
return (bool)GetValue(ReadonlyProperty);
|
|
}
|
|
set
|
|
{
|
|
SetReadOnlyPropertyValue(ReadonlyProperty, value);
|
|
readonlyPropertyValue = value;
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public IDictionary UserData
|
|
{
|
|
get
|
|
{
|
|
return (IDictionary)GetValue(UserDataProperty);
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
protected internal bool DesignMode
|
|
{
|
|
get
|
|
{
|
|
return !readonlyPropertyValue;
|
|
}
|
|
}
|
|
protected DependencyObject ParentDependencyObject
|
|
{
|
|
get
|
|
{
|
|
return (DependencyObject)this.GetValue(ParentDependencyObjectProperty);
|
|
}
|
|
}
|
|
|
|
#region Dynamic Property Support
|
|
public void SetBinding(DependencyProperty dependencyProperty, ActivityBind bind)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
if (dependencyProperty.DefaultMetadata != null && dependencyProperty.DefaultMetadata.IsReadOnly)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPReadOnly), "dependencyProperty");
|
|
|
|
if (dependencyProperty.OwnerType == null)
|
|
throw new ArgumentException(SR.GetString(SR.Error_MissingOwnerTypeProperty), "dependencyProperty");
|
|
|
|
if (!dependencyProperty.IsAttached && !dependencyProperty.OwnerType.IsAssignableFrom(this.GetType()))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_InvalidDependencyProperty, this.GetType().FullName, dependencyProperty.Name, dependencyProperty.OwnerType.FullName));
|
|
|
|
if (!this.DesignMode)
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_CanNotChangeAtRuntime));
|
|
|
|
if (dependencyProperty.DefaultMetadata != null && dependencyProperty.DefaultMetadata.IsMetaProperty && !typeof(ActivityBind).IsAssignableFrom(dependencyProperty.PropertyType))
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPMetaPropertyBinding), "dependencyProperty");
|
|
|
|
if (this.metaProperties.ContainsKey(dependencyProperty))
|
|
this.metaProperties[dependencyProperty] = bind;
|
|
else
|
|
this.metaProperties.Add(dependencyProperty, bind);
|
|
|
|
// Remove the instance value
|
|
if (this.DependencyPropertyValues.ContainsKey(dependencyProperty))
|
|
this.DependencyPropertyValues.Remove(dependencyProperty);
|
|
}
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
public ActivityBind GetBinding(DependencyProperty dependencyProperty)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
//Designer needs the bind and not bound value
|
|
return (this.metaProperties.ContainsKey(dependencyProperty) ? this.metaProperties[dependencyProperty] as ActivityBind : null);
|
|
}
|
|
public object GetValue(DependencyProperty dependencyProperty)
|
|
{
|
|
//Return the property values
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
if (dependencyProperty.IsEvent)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPGetValueHandler), "dependencyProperty");
|
|
|
|
// Get type-specific metadata for this property
|
|
PropertyMetadata metadata = dependencyProperty.DefaultMetadata;
|
|
if (metadata.GetValueOverride != null)
|
|
return metadata.GetValueOverride(this);
|
|
|
|
return GetValueCommon(dependencyProperty, metadata);
|
|
}
|
|
|
|
private object GetValueCommon(DependencyProperty dependencyProperty, PropertyMetadata metadata)
|
|
{
|
|
//ok, the default case
|
|
// pick either the instance bag or meta bag, instance bag is given first chance
|
|
object value;
|
|
if (!this.DependencyPropertyValues.TryGetValue(dependencyProperty, out value))
|
|
{
|
|
if (metaProperties == null || !metaProperties.TryGetValue(dependencyProperty, out value))
|
|
return dependencyProperty.DefaultMetadata.DefaultValue;
|
|
}
|
|
|
|
//Designer needs the bind and not bound value
|
|
if (this.metaProperties != null && !this.DesignMode && value is ActivityBind && !typeof(ActivityBind).IsAssignableFrom(dependencyProperty.PropertyType))
|
|
value = this.GetBoundValue((ActivityBind)value, dependencyProperty.PropertyType);
|
|
|
|
if (value == null || value is ActivityBind)
|
|
return dependencyProperty.DefaultMetadata.DefaultValue;
|
|
|
|
if (!dependencyProperty.PropertyType.IsAssignableFrom(value.GetType()))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_DynamicPropertyTypeValueMismatch, new object[] { dependencyProperty.PropertyType.FullName, dependencyProperty.Name, value.GetType().FullName }));
|
|
|
|
return value;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public object GetValueBase(DependencyProperty dependencyProperty)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
return this.GetValueCommon(dependencyProperty, dependencyProperty.DefaultMetadata);
|
|
}
|
|
|
|
protected internal void SetReadOnlyPropertyValue(DependencyProperty dependencyProperty, object value)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
if (!dependencyProperty.DefaultMetadata.IsReadOnly)
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_NotReadOnlyProperty, dependencyProperty.Name, dependencyProperty.OwnerType.FullName));
|
|
|
|
if (!dependencyProperty.IsAttached && !dependencyProperty.OwnerType.IsAssignableFrom(this.GetType()))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_InvalidDependencyProperty, this.GetType().FullName, dependencyProperty.Name, dependencyProperty.OwnerType.FullName));
|
|
|
|
IDictionary<DependencyProperty, object> properties = null;
|
|
if (dependencyProperty.DefaultMetadata.IsMetaProperty)
|
|
properties = this.metaProperties;
|
|
else
|
|
properties = this.DependencyPropertyValues;
|
|
|
|
if (properties.ContainsKey(dependencyProperty))
|
|
properties[dependencyProperty] = value;
|
|
else
|
|
properties.Add(dependencyProperty, value);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void SetValueBase(DependencyProperty dependencyProperty, object value)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
PropertyMetadata metadata = dependencyProperty.DefaultMetadata;
|
|
this.SetValueCommon(dependencyProperty, value, metadata, metadata.ShouldAlwaysCallOverride);
|
|
}
|
|
|
|
|
|
public void SetValue(DependencyProperty dependencyProperty, object value)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
PropertyMetadata metadata = dependencyProperty.DefaultMetadata;
|
|
this.SetValueCommon(dependencyProperty, value, metadata, true);
|
|
}
|
|
|
|
internal void SetValueCommon(DependencyProperty dependencyProperty, object value, PropertyMetadata metadata, bool shouldCallSetValueOverrideIfExists)
|
|
{
|
|
if (dependencyProperty.DefaultMetadata.IsReadOnly)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPReadOnly), "dependencyProperty");
|
|
if (value is ActivityBind)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPSetValueBind), "value");
|
|
if (dependencyProperty.IsEvent)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPSetValueHandler), "dependencyProperty");
|
|
|
|
if (!dependencyProperty.IsAttached && !dependencyProperty.OwnerType.IsAssignableFrom(this.GetType()))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_InvalidDependencyProperty, this.GetType().FullName, dependencyProperty.Name, dependencyProperty.OwnerType.FullName));
|
|
|
|
//ok, the default case
|
|
// Work around Declarative conditions
|
|
if (!this.DesignMode && (dependencyProperty.DefaultMetadata.IsMetaProperty && dependencyProperty != Design.ConditionTypeConverter.DeclarativeConditionDynamicProp))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_CanNotChangeAtRuntime));
|
|
|
|
if (value != null && !dependencyProperty.PropertyType.IsAssignableFrom(value.GetType()))
|
|
throw new ArgumentException(SR.GetString(SR.Error_DynamicPropertyTypeValueMismatch, new object[] { dependencyProperty.PropertyType.FullName, dependencyProperty.Name, value.GetType().FullName }), "value");
|
|
|
|
// Set type-specific metadata for this property if the delegate was specified
|
|
if (shouldCallSetValueOverrideIfExists && metadata.SetValueOverride != null)
|
|
{
|
|
metadata.SetValueOverride(this, value);
|
|
return;
|
|
}
|
|
|
|
//Even if the DependencyProperty is an instance property if its value is of type bind
|
|
//we store it in MetaProperties, We need this to make bind work
|
|
IDictionary<DependencyProperty, object> properties = null;
|
|
if (dependencyProperty.DefaultMetadata.IsMetaProperty)
|
|
properties = this.metaProperties;
|
|
else
|
|
properties = this.DependencyPropertyValues;
|
|
|
|
|
|
object oldMetaValue = null;
|
|
if (this.metaProperties != null && this.metaProperties.ContainsKey(dependencyProperty))
|
|
{
|
|
oldMetaValue = this.metaProperties[dependencyProperty];
|
|
if (this.DesignMode)
|
|
this.metaProperties.Remove(dependencyProperty);
|
|
}
|
|
if (!this.DesignMode && (oldMetaValue is ActivityBind))
|
|
{
|
|
this.SetBoundValue((ActivityBind)oldMetaValue, value);
|
|
}
|
|
else
|
|
{
|
|
if (properties.ContainsKey(dependencyProperty))
|
|
properties[dependencyProperty] = value;
|
|
else
|
|
properties.Add(dependencyProperty, value);
|
|
}
|
|
}
|
|
|
|
public bool RemoveProperty(DependencyProperty dependencyProperty)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
bool removed = false;
|
|
if (dependencyProperty.DefaultMetadata != null && dependencyProperty.DefaultMetadata.IsMetaProperty)
|
|
{
|
|
if (!DesignMode)
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_CanNotChangeAtRuntime));
|
|
removed = this.metaProperties.Remove(dependencyProperty);
|
|
}
|
|
else
|
|
{
|
|
//These statements are required as InstanceProperties which are Bind are stored as MetaProperties
|
|
removed = this.metaProperties.Remove(dependencyProperty);
|
|
removed |= this.DependencyPropertyValues.Remove(dependencyProperty);
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
public void AddHandler(DependencyProperty dependencyEvent, object value)
|
|
{
|
|
if (dependencyEvent == null)
|
|
throw new ArgumentNullException("dependencyEvent");
|
|
|
|
if (value == null)
|
|
throw new ArgumentNullException("value");
|
|
|
|
if (value is ActivityBind)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPSetValueBind), "value");
|
|
|
|
if (dependencyEvent.DefaultMetadata != null && dependencyEvent.DefaultMetadata.IsMetaProperty)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPAddHandlerMetaProperty), "dependencyEvent");
|
|
|
|
if (!dependencyEvent.IsEvent)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPAddHandlerNonEvent), "dependencyEvent");
|
|
|
|
if (dependencyEvent.PropertyType == null)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPPropertyTypeMissing), "dependencyEvent");
|
|
|
|
if (dependencyEvent.OwnerType == null)
|
|
throw new ArgumentException(SR.GetString(SR.Error_MissingOwnerTypeProperty), "dependencyEvent");
|
|
|
|
if (!dependencyEvent.IsAttached && !dependencyEvent.OwnerType.IsAssignableFrom(this.GetType()))
|
|
throw new InvalidOperationException(SR.GetString(SR.Error_InvalidDependencyProperty, this.GetType().FullName, dependencyEvent.Name, dependencyEvent.OwnerType.FullName));
|
|
|
|
if (value != null && !dependencyEvent.PropertyType.IsAssignableFrom(value.GetType()))
|
|
throw new ArgumentException(SR.GetString(SR.Error_DynamicPropertyTypeValueMismatch, new object[] { dependencyEvent.PropertyType.FullName, dependencyEvent.Name, value.GetType().FullName }), "value");
|
|
|
|
// get appropriate meta bag or instance bag
|
|
IDictionary<DependencyProperty, object> properties = this.DependencyPropertyValues;
|
|
|
|
// add it to array list
|
|
ArrayList eventListeners = null;
|
|
if (properties.ContainsKey(dependencyEvent))
|
|
{
|
|
eventListeners = (ArrayList)properties[dependencyEvent];
|
|
}
|
|
else
|
|
{
|
|
eventListeners = new ArrayList();
|
|
properties.Add(dependencyEvent, eventListeners);
|
|
}
|
|
eventListeners.Add(value);
|
|
if (this.DesignMode && this.metaProperties.ContainsKey(dependencyEvent))
|
|
this.metaProperties.Remove(dependencyEvent);
|
|
}
|
|
|
|
public void RemoveHandler(DependencyProperty dependencyEvent, object value)
|
|
{
|
|
if (dependencyEvent == null)
|
|
throw new ArgumentNullException("dependencyEvent");
|
|
if (value == null)
|
|
throw new ArgumentNullException("value");
|
|
if (value is ActivityBind)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPRemoveHandlerBind), "value");
|
|
|
|
if (dependencyEvent.DefaultMetadata != null && dependencyEvent.DefaultMetadata.IsMetaProperty)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPAddHandlerMetaProperty), "dependencyEvent");
|
|
|
|
if (!dependencyEvent.IsEvent)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPAddHandlerNonEvent), "dependencyEvent");
|
|
|
|
// get appropriate meta bag or instance bag
|
|
IDictionary<DependencyProperty, object> properties = this.DependencyPropertyValues;
|
|
if (properties.ContainsKey(dependencyEvent))
|
|
{
|
|
ArrayList eventListeners = (ArrayList)properties[dependencyEvent];
|
|
if (eventListeners.Contains(value))
|
|
eventListeners.Remove(value);
|
|
if (eventListeners.Count == 0)
|
|
properties.Remove(dependencyEvent);
|
|
}
|
|
}
|
|
|
|
internal object GetHandler(DependencyProperty dependencyEvent)
|
|
{
|
|
if (dependencyEvent == null)
|
|
throw new ArgumentNullException("dependencyEvent");
|
|
|
|
if (!dependencyEvent.IsEvent)
|
|
throw new ArgumentException("dependencyEvent");
|
|
|
|
IDictionary<DependencyProperty, object> properties = this.DependencyPropertyValues;
|
|
if (properties.ContainsKey(dependencyEvent))
|
|
{
|
|
ArrayList handlers = properties[dependencyEvent] as ArrayList;
|
|
if (handlers != null && handlers.Count != 0)
|
|
{
|
|
if (handlers.Count == 1)
|
|
return handlers[0];
|
|
else //Combine
|
|
{
|
|
Delegate delegateHandler = handlers[0] as Delegate;
|
|
for (int i = 1; i < handlers.Count; ++i)
|
|
{
|
|
delegateHandler = Delegate.Combine(delegateHandler, handlers[i] as Delegate);
|
|
}
|
|
|
|
return delegateHandler;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public bool IsBindingSet(DependencyProperty dependencyProperty)
|
|
{
|
|
if (dependencyProperty == null)
|
|
throw new ArgumentNullException("dependencyProperty");
|
|
|
|
return (!this.DependencyPropertyValues.ContainsKey(dependencyProperty) &&
|
|
this.metaProperties.ContainsKey(dependencyProperty) &&
|
|
this.metaProperties[dependencyProperty] is ActivityBind);
|
|
}
|
|
|
|
public bool MetaEquals(DependencyObject dependencyObject)
|
|
{
|
|
#pragma warning suppress 56506
|
|
return dependencyObject != null && dependencyObject.metaProperties == this.metaProperties;
|
|
}
|
|
|
|
#region IDependencyObjectAccessor
|
|
|
|
void IDependencyObjectAccessor.InitializeInstanceForRuntime(IWorkflowCoreRuntime workflowCoreRuntime)
|
|
{
|
|
OnInitializeInstanceForRuntime(workflowCoreRuntime);
|
|
}
|
|
internal virtual void OnInitializeInstanceForRuntime(IWorkflowCoreRuntime workflowCoreRuntime)
|
|
{
|
|
}
|
|
|
|
//This is invoked for every activating instance
|
|
void IDependencyObjectAccessor.InitializeActivatingInstanceForRuntime(DependencyObject parentDependencyObject, IWorkflowCoreRuntime workflowCoreRuntime)
|
|
{
|
|
if (parentDependencyObject != null)
|
|
this.DependencyPropertyValues[ParentDependencyObjectProperty] = parentDependencyObject;
|
|
|
|
// InitializeForRuntime call allows people to put more meta properties in the bag.
|
|
foreach (DependencyProperty dependencyProperty in this.MetaDependencyProperties)
|
|
{
|
|
object propValue = this.metaProperties[dependencyProperty];
|
|
if (propValue is DependencyObject)
|
|
{
|
|
((IDependencyObjectAccessor)propValue).InitializeActivatingInstanceForRuntime(this, workflowCoreRuntime);
|
|
this.DependencyPropertyValues[dependencyProperty] = propValue;
|
|
}
|
|
else if (propValue is WorkflowParameterBindingCollection)
|
|
{
|
|
IList collection = propValue as IList;
|
|
for (int index2 = 0; index2 < collection.Count; index2++)
|
|
((IDependencyObjectAccessor)collection[index2]).InitializeActivatingInstanceForRuntime(this, workflowCoreRuntime);
|
|
this.DependencyPropertyValues[dependencyProperty] = propValue;
|
|
}
|
|
}
|
|
OnInitializeActivatingInstanceForRuntime(workflowCoreRuntime);
|
|
|
|
this.Readonly = true;
|
|
}
|
|
internal virtual void OnInitializeActivatingInstanceForRuntime(IWorkflowCoreRuntime workflowCoreRuntime)
|
|
{
|
|
InitializeProperties();
|
|
}
|
|
|
|
void IDependencyObjectAccessor.InitializeDefinitionForRuntime(DependencyObject parentDependencyObject)
|
|
{
|
|
if (parentDependencyObject != null)
|
|
this.DependencyPropertyValues[ParentDependencyObjectProperty] = parentDependencyObject;
|
|
|
|
// InitializeForRuntime call allows people to put more meta properties in the bag.
|
|
foreach (DependencyProperty dependencyProperty in this.MetaDependencyProperties)
|
|
{
|
|
object propValue = this.metaProperties[dependencyProperty];
|
|
if (propValue is DependencyObject)
|
|
{
|
|
((IDependencyObjectAccessor)propValue).InitializeDefinitionForRuntime(this);
|
|
this.DependencyPropertyValues[dependencyProperty] = propValue;
|
|
}
|
|
else if (propValue is WorkflowParameterBindingCollection)
|
|
{
|
|
IList collection = propValue as IList;
|
|
for (int index2 = 0; index2 < collection.Count; index2++)
|
|
((IDependencyObjectAccessor)collection[index2]).InitializeDefinitionForRuntime(this);
|
|
this.DependencyPropertyValues[dependencyProperty] = propValue;
|
|
}
|
|
else if (propValue is ActivityBind)
|
|
{
|
|
Activity activity = ResolveOwnerActivity();
|
|
if (activity != null)
|
|
((ActivityBind)propValue).SetContext(activity);
|
|
}
|
|
}
|
|
OnInitializeDefinitionForRuntime();
|
|
InitializeProperties();
|
|
this.Readonly = true;
|
|
}
|
|
internal virtual void OnInitializeDefinitionForRuntime()
|
|
{
|
|
}
|
|
protected virtual void InitializeProperties()
|
|
{
|
|
}
|
|
internal virtual void FixUpMetaProperties(DependencyObject originalObject)
|
|
{
|
|
if (originalObject == null)
|
|
throw new ArgumentNullException();
|
|
|
|
this.metaProperties = originalObject.metaProperties;
|
|
this.readonlyPropertyValue = true; // alway readonly if fixing up
|
|
foreach (KeyValuePair<DependencyProperty, object> keyValuePair in this.DependencyPropertyValues)
|
|
{
|
|
if (keyValuePair.Key != ParentDependencyObjectProperty && originalObject.DependencyPropertyValues.ContainsKey(keyValuePair.Key))
|
|
{
|
|
object originalPropValue = originalObject.DependencyPropertyValues[keyValuePair.Key];
|
|
if (keyValuePair.Value is DependencyObject)
|
|
{
|
|
((DependencyObject)keyValuePair.Value).FixUpMetaProperties(originalPropValue as DependencyObject);
|
|
}
|
|
else if (keyValuePair.Value is WorkflowParameterBindingCollection)
|
|
{
|
|
IList collection = keyValuePair.Value as IList;
|
|
IList originalCollection = originalPropValue as IList;
|
|
for (int index = 0; index < collection.Count; index++)
|
|
{
|
|
((DependencyObject)collection[index]).FixUpMetaProperties(originalCollection[index] as DependencyObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
T[] IDependencyObjectAccessor.GetInvocationList<T>(DependencyProperty dependencyEvent)
|
|
{
|
|
return this.GetInvocationList<T>(dependencyEvent);
|
|
}
|
|
protected T[] GetInvocationList<T>(DependencyProperty dependencyEvent)
|
|
{
|
|
if (dependencyEvent == null)
|
|
throw new ArgumentNullException("dependencyEvent");
|
|
|
|
if (!dependencyEvent.IsEvent)
|
|
throw new ArgumentException(SR.GetString(SR.Error_DPAddHandlerNonEvent), "dependencyEvent");
|
|
|
|
// pick the appropriate meta bag or instance bag, first priority is to instance bag
|
|
IDictionary<DependencyProperty, object> properties = null;
|
|
if (this.DependencyPropertyValues.ContainsKey(dependencyEvent))
|
|
properties = this.DependencyPropertyValues;
|
|
else
|
|
properties = this.metaProperties;
|
|
|
|
List<T> delegates = new List<T>();
|
|
if (properties.ContainsKey(dependencyEvent))
|
|
{
|
|
if (properties[dependencyEvent] is ActivityBind)
|
|
{
|
|
if (!this.DesignMode)
|
|
{
|
|
T delegateValue = default(T);
|
|
delegateValue = (T)this.GetBoundValue((ActivityBind)properties[dependencyEvent], typeof(T));
|
|
if (delegateValue is T)
|
|
delegates.Add(delegateValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (object value in (ArrayList)properties[dependencyEvent])
|
|
{
|
|
if (value is T)
|
|
{
|
|
delegates.Add((T)value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return delegates.ToArray();
|
|
}
|
|
#endregion
|
|
|
|
internal IList<DependencyProperty> MetaDependencyProperties
|
|
{
|
|
get
|
|
{
|
|
return new List<DependencyProperty>(this.metaProperties.Keys).AsReadOnly();
|
|
}
|
|
}
|
|
|
|
//
|
|
private IDictionary<DependencyProperty, object> dependencyPropertyValues = null;
|
|
internal IDictionary<DependencyProperty, object> DependencyPropertyValues
|
|
{
|
|
get
|
|
{
|
|
if (this.dependencyPropertyValues == null)
|
|
this.dependencyPropertyValues = new Dictionary<DependencyProperty, object>();
|
|
return this.dependencyPropertyValues;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Bind resolution Support
|
|
|
|
[EditorBrowsableAttribute(EditorBrowsableState.Never)]
|
|
protected virtual object GetBoundValue(ActivityBind bind, Type targetType)
|
|
{
|
|
if (bind == null)
|
|
throw new ArgumentNullException("bind");
|
|
if (targetType == null)
|
|
throw new ArgumentNullException("targetType");
|
|
|
|
object returnVal = bind;
|
|
Activity activity = ResolveOwnerActivity();
|
|
if (activity != null)
|
|
returnVal = bind.GetRuntimeValue(activity, targetType);
|
|
|
|
return returnVal;
|
|
}
|
|
[EditorBrowsableAttribute(EditorBrowsableState.Never)]
|
|
protected virtual void SetBoundValue(ActivityBind bind, object value)
|
|
{
|
|
if (bind == null)
|
|
throw new ArgumentNullException("bind");
|
|
|
|
Activity activity = ResolveOwnerActivity();
|
|
if (activity != null)
|
|
bind.SetRuntimeValue(activity, value);
|
|
}
|
|
|
|
//
|
|
private Activity ResolveOwnerActivity()
|
|
{
|
|
DependencyObject activityDependencyObject = this;
|
|
while (activityDependencyObject != null && !(activityDependencyObject is Activity))
|
|
activityDependencyObject = activityDependencyObject.ParentDependencyObject;
|
|
return activityDependencyObject as Activity;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IComponent Members
|
|
|
|
private event EventHandler disposed;
|
|
|
|
event EventHandler IComponent.Disposed
|
|
{
|
|
add
|
|
{
|
|
disposed += value;
|
|
}
|
|
remove
|
|
{
|
|
disposed -= value;
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[EditorBrowsableAttribute(EditorBrowsableState.Never)]
|
|
public ISite Site
|
|
{
|
|
get
|
|
{
|
|
return (ISite)GetValue(SiteProperty);
|
|
}
|
|
set
|
|
{
|
|
SetValue(SiteProperty, value);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable Members
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
if (this.Site != null && this.Site.Container != null)
|
|
this.Site.Container.Remove(this);
|
|
|
|
if (disposed != null)
|
|
disposed(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|