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; } }