public static void EnsureNotReadOnly(this IDependencyProperty dp) { if (dp.IsReadOnly) { throw new InvalidOperationException($"{dp.Name} is a read only property and should be changed using a key"); } }
private void HandlePropertyChanged (object sender, DPropertyValueChangedEventArgs e) { if (Source != null) { Source.DependencyPropertyValueChanged -= HandlePropertyValueChanged; var container = Source.Value as IAttachedPropertiesContainer; if (container != null) { container.AddedItem -= HandleAddedItem; container.RemovedItem -= HandleRemovedItem; } } Source = e.NewValue as IDependencyProperty; if (Source != null) { var container = Source.Value as IAttachedPropertiesContainer; if (container != null) { Property = container.GetProperty (Item, PropertyName); container.AddedItem += HandleAddedItem; container.RemovedItem += HandleRemovedItem; } Source.DependencyPropertyValueChanged += HandlePropertyValueChanged; } else { Property = null; } }
public ValueChangedEventArgs(IDependencyComponent component, IDependencyProperty property, IMaybe <object> oldValue, IMaybe <object> newValue) { Component = component; Property = property; OldValue = oldValue; NewValue = newValue; }
private void HandlePropertyChanged(object sender, DPropertyValueChangedEventArgs e) { if (Source != null) { Source.DependencyPropertyValueChanged -= HandlePropertyValueChanged; var container = Source.Value as IAttachedPropertiesContainer; if (container != null) { container.AddedItem -= HandleAddedItem; container.RemovedItem -= HandleRemovedItem; } } Source = e.NewValue as IDependencyProperty; if (Source != null) { var container = Source.Value as IAttachedPropertiesContainer; if (container != null) { Property = container.GetProperty(Item, PropertyName); container.AddedItem += HandleAddedItem; container.RemovedItem += HandleRemovedItem; } Source.DependencyPropertyValueChanged += HandlePropertyValueChanged; } else { Property = null; } }
public override void Write(SerializationContext serializationContext, ModelElement element, XmlWriter writer, RootElementSettings rootElementSettings) { #region Check Parameters Debug.Assert(element != null); if (element == null) { throw new ArgumentNullException("element"); } #endregion // On ne serialise que si ce n'est pas la valeur par défaut DependencyProperty instanceOfDependencyProperty = element as DependencyProperty; IDependencyProperty dp = DependencyPropertyRegistry.Instance.FindDependencyProperty(instanceOfDependencyProperty.StrategyId, instanceOfDependencyProperty.Name); object defaultValue = dp != null?dp.GetDefaultValue() : null; string defaultValueAsString = defaultValue != null?defaultValue.ToString() : String.Empty; if (instanceOfDependencyProperty.Value != null && dp != null && !Utils.StringCompareEquals(instanceOfDependencyProperty.Value.ToString(), defaultValueAsString)) { base.Write(serializationContext, element, writer, rootElementSettings); } }
private void RaisePropertyChanged(IDependencyProperty dp, IPropertyMetadata metadata, object oldValue, object newValue) { var args = new DependencyPropertyChangedEventArgs(dp, oldValue, newValue); metadata.PropertyChangedCallback?.Invoke(this.owner, args); PropertyChanged?.Invoke(this.owner, args); }
public static void VerifyReadOnlyKey(this IDependencyProperty dp, IDependencyPropertyKey key) { if (ReferenceEquals(dp, key.DependencyProperty)) { throw new InvalidOperationException($"The provided key doesn't match property {dp.Name}"); } }
public AppliedValueAssignment(TVisual visual, IDependencyProperty <TVisual, TValue> dependencyProperty, TValue value) { Visual = visual; Property = dependencyProperty; _value = value; }
private IMaybe <object> ResolveEffectiveStoresValue(IDependencyProperty dp) { if (effectiveSources.TryGetValue(dp, out var source)) { return(source.GetValue(dp)); } return(Maybe.None <object>()); }
public ThicknessTransition(IVisualElement visual, IDependencyProperty <QuantifiedThickness> property, TimeSpan duration, TimeSpan delay, TransitionFunctionType timing) : base(visual, property, duration, delay, timing) { }
public TransformTransition(IVisualElement visual, IDependencyProperty <TransformationMatrix> property, TimeSpan duration, TimeSpan delay, TransitionFunctionType timing) : base(visual, property, duration, delay, timing) { }
public AppliedValueAssignment(IVisualElement visual, IDependencyProperty dependencyProperty, Object?value) { Visual = visual; Property = dependencyProperty; _value = value; }
public AppliedStyleCondition(IVisualElement visual, IDependencyProperty dependencyProperty, Boolean value) { Visual = visual; DependencyProperty = dependencyProperty; Value = value; }
public IMaybe <object> GetValue(IDependencyProperty dp) { if (HasValue(dp)) { return(Maybe.FromValue(parent.GetValue(dp))); } return(Maybe.None <object>()); }
public ComputedValueAssignment(IVisualElement visual, IDependencyProperty dependencyProperty, Func <IVisualElement, Object?> valueBuilder) { Visual = visual; Property = dependencyProperty; _valueBuilder = valueBuilder; }
public DoublePropertyTransition(IVisualElement visual, IDependencyProperty <Double> property, TimeSpan duration, TimeSpan delay, TransitionFunctionType timing) : base(visual, property, duration, delay, timing) { }
/// <summary> /// Gets the value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="property">The property.</param> /// <returns></returns> internal T GetValue <T>(IDependencyProperty property) { if (this.property == null) { internalValue = GetValue <T>(property, valueAsString); } this.property = property; return((T)internalValue); }
public BrushTransition(IVisualElement visual, IDependencyProperty <IBrush> property, TimeSpan duration, TimeSpan delay, TransitionFunctionType timing) : base(visual, property, duration, delay, timing) { _startValue = SolidColorBrush.Tranparent; _endValue = SolidColorBrush.Tranparent; }
public QuantifiedDoubleTransition(IVisualElement visual, IDependencyProperty <QuantifiedDouble?> property, TimeSpan duration, TimeSpan delay, TransitionFunctionType timing) : base(visual, property, duration, delay, timing) { _currentDifference = QuantifiedDouble.Zero; }
public StyleValueDeclaration(IDependencyProperty property, StyleSetterType setterType, T value, Transition?transition) { _value = value; Property = property; SetterType = setterType; Transition = transition; }
public void MonitorPropertyChange(IDependencyProperty property, IVisualElement visual) { if (!_monitoredProperties.TryAdd(visual, property, 1)) { return; } property.AddOnChangedHandler(visual, _ => Execute(true)); }
/// <summary> /// Tries the get value. /// </summary> /// <param name="element">The element.</param> /// <param name="strategyId">The strategy id.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="value">The value.</param> /// <returns></returns> public static bool TryGetValue(ICustomizableElement element, string strategyId, string propertyName, out T value) { IDependencyProperty p = DependencyPropertyRegistry.Instance.FindDependencyProperty(strategyId, propertyName); if (p != null) { return(TryGetValue(p, element, strategyId, propertyName, out value)); } throw new Exception(String.Concat("Invalid property name ", propertyName, " for strategy ", strategyId)); }
public virtual void SetValue(IDependencyProperty dp, object value) { var oldValue = GetValue(dp); var newValue = Maybe.FromValue(value); if (Helpers.AreDifferent(oldValue, newValue)) { store[dp] = value; ValueChanged?.Invoke(this, new ValueChangedEventArgs(Component, dp, oldValue, newValue)); } }
public virtual void ClearValue(IDependencyProperty dp) { if (store.ContainsKey(dp)) { var oldValue = Maybe.FromValue(store[dp]); var newValue = Maybe.None <object>(); store.Remove(dp); ValueChanged?.Invoke(this, new ValueChangedEventArgs(Component, dp, oldValue, newValue)); } }
private void HandleTargetPropertyChanged (object sender, DPropertyValueChangedEventArgs e) { if (TargetProperty != null) TargetProperty.DependencyPropertyValueChanged -= HandleTargetValueChanged; TargetProperty = e.NewValue as IDependencyProperty; if (TargetProperty != null) TargetProperty.DependencyPropertyValueChanged += HandleTargetValueChanged; UpdateTargetValue (); }
public static void SetBinding (DependencyObject source, string path, IDependencyProperty target, IValueConverter converter = null) { var paths = path.Split ('.'); BindingExpression expression = new PropertyExpression (source.GetProperty (paths [0])); foreach (var p in paths.Skip(1)) { expression = new PathExpression (expression, p); } new Binding (expression, new PropertyExpression (target), converter ?? new EmptyConverter ()); }
public bool HasValue(IDependencyProperty dp) { if (parent != null) { var metadata = Component.GetMetadata(dp); if (metadata.IsInherited) { return(true); } } return(false); }
//private static void OnTextChanged(Label sender, // String oldValue, String newValue) //{ // sender.InvalidateMeasure(); //} public override Boolean TryGetDependencyProperty(DeclarationProperty declarationProperty, out IDependencyProperty property) { switch (declarationProperty) { case DeclarationProperty.Color: property = TextBrushProperty; return(true); default: return(base.TryGetDependencyProperty(declarationProperty, out property)); } }
private IValueSource GetHighestPrecedenceSetValueSource(IDependencyProperty dp, int startIndex = 0) { for (int i = startIndex; i < valueSources.Count; i++) { var store = valueSources[i]; if (store.HasValue(dp)) { return(store); } } return(null); }
public object GetValue(IDependencyProperty dp) { var maybe = ResolveEffectiveStoresValue(dp); if (maybe.HasValue) { return(maybe.Value); } var metadata = dp.GetMetadata(ownerType); return(metadata.DefaultValue); }
private void HandlePropertyChanged (object sender, DPropertyValueChangedEventArgs e) { if (Source != null) Source.DependencyPropertyValueChanged -= HandlePropertyValueChanged; Source = e.NewValue as IDependencyProperty; if (Source != null) { if (Source.Value != null) Property = (Source.Value as DependencyObject).GetProperty (PropertyName); Source.DependencyPropertyValueChanged += HandlePropertyValueChanged; } }
public static void SetBinding(DependencyObject source, string path, IDependencyProperty target, IValueConverter converter = null) { var paths = path.Split('.'); BindingExpression expression = new PropertyExpression(source.GetProperty(paths [0])); foreach (var p in paths.Skip(1)) { expression = new PathExpression(expression, p); } new Binding(expression, new PropertyExpression(target), converter ?? new EmptyConverter()); }
public PathExpression (BindingExpression expression, string propertyName) { PropertyName = propertyName; Source = expression.Property; if (Source != null) { if (Source.Value != null) Property = (Source.Value as DependencyObject).GetProperty (propertyName); Source.DependencyPropertyValueChanged += HandlePropertyValueChanged; } expression.GetProperty ("Property").DependencyPropertyValueChanged += HandlePropertyChanged; }
private static Object?BuildPropertyValue(IDependencyProperty property, IMarkupNode parentNode) { if (typeof(IVisualTemplate).IsAssignableFrom(property.PropertyType)) { if (parentNode.ChildrenCount != 1) { throw new NotImplementedException(); } return(new DeferredVisualTemplate(parentNode[0])); } throw new NotImplementedException(); }
private static IStyleValueAssignment ApplyDeclarationToDependencyProperty(IVisualElement visual, IDependencyProperty property, IStyleDeclaration declaration) { var declarationValue = GetDeclarationValue(declaration); switch (declarationValue) { case Func <IVisualElement, Object?> computed: return(new ComputedValueAssignment(visual, property, computed)); default: return(new AppliedValueAssignment(visual, property, declarationValue)); } }
public AttachedPropertyExpression (BindingExpression expression, object item, string propertyName) { PropertyName = propertyName; Item = item; Source = expression.Property; if (Source != null) { var container = Source.Value as IAttachedPropertiesContainer; if (container != null) { Property = container.GetProperty (item, propertyName); container.AddedItem += HandleAddedItem; container.RemovedItem += HandleRemovedItem; } Source.DependencyPropertyValueChanged += HandlePropertyValueChanged; } expression.GetProperty ("Property").DependencyPropertyValueChanged += HandlePropertyChanged; }
public Binding (PathExpression source, PathExpression target, IValueConverter converter) { Source = source; Target = target; Converter = converter; SourceProperty = Source.Property; TargetProperty = Target.Property; Source.GetProperty ("Property").DependencyPropertyValueChanged += HandleSourcePropertyChanged; Target.GetProperty ("Property").DependencyPropertyValueChanged += HandleTargetPropertyChanged; UpdateTargetValue (); if (SourceProperty != null) SourceProperty.DependencyPropertyValueChanged += HandleSourceValueChanged; if (TargetProperty != null) TargetProperty.DependencyPropertyValueChanged += HandleTargetValueChanged; }
public static void SetBinding (DependencyObject source, string path, IDependencyProperty target, IValueConverter converter = null) { new Binding (PathExpressionParser.Parse (source, path), new PropertyExpression (target), converter ?? new EmptyConverter ()); }
public PropertyExpression (IDependencyProperty property) { Property = property; }
public static void SetBinding (IDependencyProperty source, IAttachedPropertiesContainer container, object item, string propertyName, IValueConverter converter = null) { var self = new SelfExpression (container); new Binding (new PropertyExpression (source), new AttachedPropertyExpression (self, item, propertyName), converter ?? new EmptyConverter ()); }
public static void SetBinding (IDependencyProperty source, IDependencyProperty target, IValueConverter converter = null) { new Binding (new PropertyExpression (source), new PropertyExpression (target), converter ?? new EmptyConverter ()); }