Example #1
0
 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;
            }
        }
Example #5
0
        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);
        }
Example #7
0
 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)
 {
 }
Example #11
0
 public TransformTransition(IVisualElement visual,
                            IDependencyProperty <TransformationMatrix> property,
                            TimeSpan duration,
                            TimeSpan delay,
                            TransitionFunctionType timing)
     : base(visual, property, duration, delay, timing)
 {
 }
Example #12
0
 public AppliedValueAssignment(IVisualElement visual,
                               IDependencyProperty dependencyProperty,
                               Object?value)
 {
     Visual   = visual;
     Property = dependencyProperty;
     _value   = value;
 }
Example #13
0
 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>());
 }
Example #15
0
 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)
 {
 }
Example #17
0
 /// <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;
 }
Example #20
0
 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));
        }
Example #22
0
        /// <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));
        }
Example #23
0
        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));
            }
        }
Example #24
0
        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);
 }
Example #28
0
        //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;
			}
		}
Example #32
0
        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;
		}
Example #34
0
        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 ());
		}