public DependencyPropertyObserver(DependencyProperty dependencyProperty)
{
this.dependencyProperty = dependencyProperty;
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
}
public BindingExpression(DependencyObject target, DependencyProperty targetProperty, PropertyPath path,
object source = null, RelativeSource relativeSource = null, string elementName = null,
BindingMode mode = BindingMode.Default, UpdateSourceTrigger updateSourceTrigger = UpdateSourceTrigger.Default,
IValueConverter converter = null, object converterParameter = null, object fallbackValue = null, object targetNullValue = null)
{
this.Target = target;
this.TargetProperty = targetProperty;
this.Path = path;
this.Source = source;
this.RelativeSource = relativeSource;
this.ElementName = elementName;
this.Mode = mode;
this.UpdateSourceTrigger = updateSourceTrigger;
this.Converter = converter;
this.ConverterParameter = converterParameter;
this.FallbackValue = fallbackValue;
this.TargetNullValue = targetNullValue;
Status = BindingStatus.Inactive;
disableSourceUpdate = new ReentrancyLock();
disableTargetUpdate = new ReentrancyLock();
targetValue = new ObservableValue(Target.GetValue(TargetProperty));
targetValue.ValueChanged += OnTargetValueChanged;
BindingMode resolvedBindingMode = Mode == BindingMode.Default ? GetDefaultBindingMode(Target, TargetProperty) : Mode;
isSourceUpdateMode = resolvedBindingMode == BindingMode.TwoWay || resolvedBindingMode == BindingMode.OneWayToSource;
isTargetUpdateMode = resolvedBindingMode == BindingMode.TwoWay || resolvedBindingMode == BindingMode.OneWay;
sourceObserver = CreateSourceObserver(Target, Source, RelativeSource, ElementName);
sourceExpression = new ObservableExpression(sourceObserver, Path ?? PropertyPath.Empty);
// try to update the target (or the source on OneWayToSource)
if (isTargetUpdateMode)
{
sourceExpression.ValueChanged += (sender, oldValue, newValue) => UpdateTargetOnSourceChanged();
UpdateTargetOnSourceChanged();
}
else if (isSourceUpdateMode)
{
sourceExpression.ValueChanged += (sender, oldValue, newValue) =>
{
if (Status == BindingStatus.UpdateSourceError && sourceExpression.Value != ObservableValue.UnsetValue && !disableTargetUpdate)
{
// source was connected
UpdateSourceOnTargetChanged();
}
};
UpdateSourceOnTargetChanged();
}
if (UpdateSourceTrigger == UpdateSourceTrigger.LostFocus && isSourceUpdateMode && Target is UIElement)
{
((UIElement)Target).LostFocus += OnLostFocus;
}
}
private object GetValue()
{
if (ObservableValue.IsNullOrUnset(baseValue) || propertyGetMethod == null)
{
return(ObservableValue.UnsetValue);
}
return(propertyGetMethod.Invoke(baseValue, index.ToArray()));
}
public ClrPropertyObserver(PropertyInfo propertyInfo, IEnumerable <object> index)
{
this.propertyInfo = propertyInfo;
this.propertyGetMethod = propertyInfo.GetGetMethod();
this.propertySetMethod = propertyInfo.GetSetMethod();
this.index = index;
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
}
public CoercedDependencyPropertyValueEntry(IDependencyPropertyValueEntry source, DependencyObject dependencyObject, CoerceValueCallback coerceValueCallback)
{
this.source = source;
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
observableValue.Value = source.Value;
source.ValueChanged += (sender, e) => observableValue.Value = coerceValueCallback(dependencyObject, source.Value);
}
public bool TrySetValue(object value)
{
if (ObservableValue.IsNullOrUnset(baseValue) || propertySetMethod == null)
{
return(false);
}
propertySetMethod.Invoke(baseValue, index.Concat(new object[] { value }).ToArray());
observableValue.Value = GetValue();
return(true);
}
public ResourceReferenceExpression(IResourceContainer resourceContainer, object resourceKey)
{
this.resourceContainer = resourceContainer;
this.resourceKey = resourceKey;
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
observableValue.Value = GetResourceValue();
resourceContainer.ResourcesChanged += OnResourcesChanged;
}
public ContextSourceObserver(DependencyObject target, object baseValue)
{
this.target = target;
observableValue = new ObservableValue(baseValue);
observableValue.ValueChanged += (sender, oldValue, newValue) => ValueChanged.Raise(this, oldValue, newValue);
if (target is IContextElement)
{
((IContextElement)target).ContextParentChanged += OnTargetContextParentChanged;
}
}
public AnimationExpression(DependencyObject dependencyObject, DependencyProperty dependencyProperty)
{
this.dependencyObject = dependencyObject;
this.dependencyProperty = dependencyProperty;
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
layers = new AnimationLayerCollection();
layers.LayerInvalidated += OnLayerInvalidated;
SetAnimationValue();
}
public DataContextSourceObserver(DependencyObject target)
{
this.target = target;
frameworkElementValue = new ObservableValue(GetFrameworkElementAncestor(target));
frameworkElementValue.ValueChanged += (sender, oldValue, newValue) => dataContextValue.SetBaseValue(newValue);
dataContextValue = new DependencyPropertyObserver(FrameworkElement.DataContextProperty);
dataContextValue.SetBaseValue(frameworkElementValue.Value);
dataContextValue.ValueChanged += (sender, oldValue, newValue) => ValueChanged.Raise(this, oldValue, newValue);
if (target is IContextElement)
{
((IContextElement)target).ContextParentChanged += OnTargetContextParentChanged;
}
}
public PatternViewModel(PatternData data)
{
Data = data;
Pattern = new ObservableValue<string>(data.Regex.ToString());
Enabled = new ObservableValue<bool>(data.Enabled);
IsEmpty = Pattern.GetObservable(string.IsNullOrEmpty);
Enabled.PropertyChanged += (sender, e) => {
data.Enabled = ((ObservableValue<bool>)sender).Value;
};
Pattern.PropertyChanged += (sender, e) => {
var pattern = ((ObservableValue<string>) sender).Value;
if (string.IsNullOrEmpty(pattern))
return;
data.Regex = new Regex(pattern);
};
}
public void ReadOnlyObservableValueChangedTest()
{
int valueChangedCount = 0;
ObservableValue observableValue = new ObservableValue();
ReadOnlyObservableValue readOnlyObservableValue = new ReadOnlyObservableValue(observableValue);
readOnlyObservableValue.ValueChanged += (sender, e) => valueChangedCount++;
Assert.AreEqual(ObservableValue.UnsetValue, readOnlyObservableValue.Value);
observableValue.Value = "value1";
Assert.AreEqual(1, valueChangedCount);
observableValue.Value = "value1";
Assert.AreEqual(1, valueChangedCount);
observableValue.Value = "value2";
Assert.AreEqual(2, valueChangedCount);
}
public ObservableExpression(object baseValue, PropertyPath propertyPath)
{
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
if (propertyPath.IsEmpty)
{
observableValue.Value = baseValue;
ValueType = baseValue != null?baseValue.GetType() : null;
}
else
{
propertyPathElement = propertyPath.Elements.Last();
baseObserver = new ObservableExpression(baseValue, propertyPath.GetBasePropertyPath());
baseObserver.ValueChanged += (sender, e) => SetDelegateObserverBaseValue();
SetDelegateObserverBaseValue();
}
}
public ObservableExpression(object baseValue, PropertyPath propertyPath)
{
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
if (propertyPath.IsEmpty)
{
observableValue.Value = baseValue;
ValueType = baseValue != null ? baseValue.GetType() : null;
}
else
{
propertyPathElement = propertyPath.Elements.Last();
baseObserver = new ObservableExpression(baseValue, propertyPath.GetBasePropertyPath());
baseObserver.ValueChanged += (sender, e) => SetDelegateObserverBaseValue();
SetDelegateObserverBaseValue();
}
}
private void SetDelegateObserverBaseValue()
{
object baseValue = baseObserver.Value;
if (ObservableValue.IsNullOrUnset(baseValue) || baseObserverValueType == baseValue.GetType())
{
if (delegateObserver != null)
{
delegateObserver.SetBaseValue(baseValue);
}
return;
}
baseObserverValueType = baseValue.GetType();
if (delegateObserver is IDisposable)
{
((IDisposable)delegateObserver).Dispose();
}
delegateObserver = propertyPathElement.CreatePropertyObserver(baseObserverValueType);
if (delegateObserver != null)
{
ValueType = delegateObserver.ValueType;
delegateObserver.SetBaseValue(baseValue);
delegateObserver.ValueChanged += (sender, e) => observableValue.Value = delegateObserver.Value;
observableValue.Value = delegateObserver.Value;
}
else
{
ValueType = null;
observableValue.Value = ObservableValue.UnsetValue;
}
}
public DependencyPropertyValueEntry(DependencyObject dependencyObject, DependencyProperty dependencyProperty)
{
this.dependencyProperty = dependencyProperty;
this.defaultValue = dependencyProperty.GetMetadata(dependencyObject.GetType()).DefaultValue;
currentValue = new ObservableValue();
currentValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
baseValues = new object[BaseValuePriorities];
for (int i = 0; i < baseValues.Length; i++)
{
baseValues[i] = ObservableValue.UnsetValue;
}
animationValue = ObservableValue.UnsetValue;
}
public void SetBaseValueTest()
{
int valueChangedCount = 0;
IDependencyPropertyValueEntry dependencyPropertyValue = new DependencyPropertyValueEntry(new DependencyObject(), TestObject.ValueProperty);
dependencyPropertyValue.ValueChanged += (sender, e) => valueChangedCount++;
ObservableValue observableValue = new ObservableValue("value3");
dependencyPropertyValue.SetBaseValue(0, "value0");
Assert.AreEqual("value0", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(1, valueChangedCount);
dependencyPropertyValue.SetBaseValue(0, "value0a");
Assert.AreEqual("value0a", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(2, valueChangedCount);
dependencyPropertyValue.SetBaseValue(2, "value2");
Assert.AreEqual("value2", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(3, valueChangedCount);
dependencyPropertyValue.SetBaseValue(1, "value1");
Assert.AreEqual("value2", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(3, valueChangedCount);
dependencyPropertyValue.SetBaseValue(3, observableValue);
Assert.AreEqual(observableValue, dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(4, valueChangedCount);
observableValue.Value = "value3a";
Assert.AreEqual(observableValue, dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(5, valueChangedCount);
dependencyPropertyValue.SetBaseValue(4, "value4");
Assert.AreEqual("value4", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(6, valueChangedCount);
observableValue.Value = "value3b";
Assert.AreEqual("value4", dependencyPropertyValue.GetBaseValue(false));
Assert.AreEqual(6, valueChangedCount);
}
public TestExpression(object value, bool isReadOnly = false)
{
observableValue = new ObservableValue(value);
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
this.isReadOnly = isReadOnly;
}
public ValueOverlapExpression()
{
values = new List<Tuple<object, object>>();
observableValue = new ObservableValue();
observableValue.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
}
public BindingExpression(DependencyObject target, DependencyProperty targetProperty, PropertyPath path,
object source = null, RelativeSource relativeSource = null, string elementName = null,
BindingMode mode = BindingMode.Default, UpdateSourceTrigger updateSourceTrigger = UpdateSourceTrigger.Default,
IValueConverter converter = null, object converterParameter = null, object fallbackValue = null, object targetNullValue = null)
{
this.Target = target;
this.TargetProperty = targetProperty;
this.Path = path;
this.Source = source;
this.RelativeSource = relativeSource;
this.ElementName = elementName;
this.Mode = mode;
this.UpdateSourceTrigger = updateSourceTrigger;
this.Converter = converter;
this.ConverterParameter = converterParameter;
this.FallbackValue = fallbackValue;
this.TargetNullValue = targetNullValue;
Status = BindingStatus.Inactive;
disableSourceUpdate = new ReentrancyLock();
disableTargetUpdate = new ReentrancyLock();
targetValue = new ObservableValue(Target.GetValue(TargetProperty));
targetValue.ValueChanged += OnTargetValueChanged;
BindingMode resolvedBindingMode = Mode == BindingMode.Default ? GetDefaultBindingMode(Target, TargetProperty) : Mode;
isSourceUpdateMode = resolvedBindingMode == BindingMode.TwoWay || resolvedBindingMode == BindingMode.OneWayToSource;
isTargetUpdateMode = resolvedBindingMode == BindingMode.TwoWay || resolvedBindingMode == BindingMode.OneWay;
object resolvedSource = Source ?? GetRelativeSource(Target, RelativeSource, ElementName);
sourceExpression = new ObservableExpression(resolvedSource, Path);
// try to update the target (or the source on OneWayToSource)
if (isTargetUpdateMode)
{
sourceExpression.ValueChanged += (sender, e) => UpdateTargetOnSourceChanged();
UpdateTargetOnSourceChanged();
}
else if (isSourceUpdateMode)
{
sourceExpression.ValueChanged += (sender, e) =>
{
if (Status == BindingStatus.UpdateSourceError && sourceExpression.Value != ObservableValue.UnsetValue && !disableTargetUpdate)
{
// source was connected
UpdateSourceOnTargetChanged();
}
};
UpdateSourceOnTargetChanged();
}
if (((RelativeSource != null && RelativeSource.Mode != RelativeSourceMode.Self) || !ElementName.IsNullOrEmpty()) && Target is Visual)
{
((Visual)Target).VisualAncestorChanged += OnTargetVisualAncestorChanged;
}
if (UpdateSourceTrigger == UpdateSourceTrigger.LostFocus && isSourceUpdateMode && Target is UIElement)
{
((UIElement)Target).LostFocus += OnLostFocus;
}
}
