/// <summary>
 /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
 /// </summary>
 /// <param name="value">
 /// The value used for the <see cref="BindingMode.OneTime"/> binding.
 /// </param>
 /// <param name="priority">The binding priority.</param>
 public InstancedBinding(object value,
     BindingPriority priority = BindingPriority.LocalValue)
 {
     Mode = BindingMode.OneTime;
     Priority = priority;
     Value = value;
 }
        public bool SetTargetValue(object value, BindingPriority priority)
        {
            if (_accessor != null)
            {
                try { return _accessor.SetValue(value, priority); } catch { }
            }

            return false;
        }
            public override bool SetValue(object value, BindingPriority priority)
            {
                if (!_property.IsReadOnly)
                {
                    Instance.SetValue(_property, value, priority);
                    return true;
                }

                return false;
            }
 /// <summary>
 /// Initializes a new instance of the <see cref="PerspexPropertyValue"/> class.
 /// </summary>
 /// <param name="property">The property.</param>
 /// <param name="value">The current property value.</param>
 /// <param name="priority">The priority of the current value.</param>
 /// <param name="diagnostic">A diagnostic string.</param>
 public PerspexPropertyValue(
     PerspexProperty property,
     object value,
     BindingPriority priority,
     string diagnostic)
 {
     this.Property = property;
     this.Value = value;
     this.Priority = priority;
     this.Diagnostic = diagnostic;
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
        /// </summary>
        /// <param name="subject">The subject for a two-way binding.</param>
        /// <param name="mode">The binding mode.</param>
        /// <param name="priority">The binding priority.</param>
        public InstancedBinding(
            ISubject<object> subject,
            BindingMode mode = BindingMode.OneWay,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires<ArgumentNullException>(subject != null);

            Mode = mode;
            Priority = priority;
            Subject = subject;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="AvaloniaPropertyValue"/> class.
 /// </summary>
 /// <param name="property">The property.</param>
 /// <param name="value">The current property value.</param>
 /// <param name="priority">The priority of the current value.</param>
 /// <param name="diagnostic">A diagnostic string.</param>
 public AvaloniaPropertyValue(
     AvaloniaProperty property,
     object value,
     BindingPriority priority,
     string diagnostic)
 {
     Property = property;
     Value = value;
     Priority = priority;
     Diagnostic = diagnostic;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="AvaloniaPropertyChangedEventArgs"/> class.
 /// </summary>
 /// <param name="sender">The object that the property changed on.</param>
 /// <param name="property">The property that changed.</param>
 /// <param name="oldValue">The old value of the property.</param>
 /// <param name="newValue">The new value of the property.</param>
 /// <param name="priority">The priority of the binding that produced the value.</param>
 public AvaloniaPropertyChangedEventArgs(
     AvaloniaObject sender,
     AvaloniaProperty property,
     object oldValue,
     object newValue,
     BindingPriority priority)
 {
     Sender = sender;
     Property = property;
     OldValue = oldValue;
     NewValue = newValue;
     Priority = priority;
 }
Exemple #8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PerspexPropertyChangedEventArgs"/> class.
 /// </summary>
 /// <param name="sender">The object that the property changed on.</param>
 /// <param name="property">The property that changed.</param>
 /// <param name="oldValue">The old value of the property.</param>
 /// <param name="newValue">The new value of the property.</param>
 /// <param name="priority">The priority of the binding that produced the value.</param>
 public PerspexPropertyChangedEventArgs(
     PerspexObject sender,
     PerspexProperty property,
     object oldValue,
     object newValue,
     BindingPriority priority)
 {
     Sender   = sender;
     Property = property;
     OldValue = oldValue;
     NewValue = newValue;
     Priority = priority;
 }
        protected override bool SetTargetValueCore(object value, BindingPriority priority)
        {
            if (_accessor != null)
            {
                try
                {
                    return(_accessor.SetValue(value, priority));
                }
                catch { }
            }

            return(false);
        }
        public override bool SetValue(object value, BindingPriority priority)
        {
            if (_property.CanSet && _reference.TryGetTarget(out var o))
            {
                _property.Set(o, value);

                SendCurrentValue();

                return(true);
            }

            return(false);
        }
Exemple #11
0
        void IValueSink.ValueChanged <TValue>(
            StyledPropertyBase <TValue> property,
            BindingPriority priority,
            Optional <TValue> oldValue,
            BindingValue <TValue> newValue)
        {
            if (priority == BindingPriority.LocalValue)
            {
                _localValue = default;
            }

            UpdateEffectiveValue();
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="AvaloniaPropertyChangedEventArgs"/> class.
 /// </summary>
 /// <param name="sender">The object that the property changed on.</param>
 /// <param name="property">The property that changed.</param>
 /// <param name="oldValue">The old value of the property.</param>
 /// <param name="newValue">The new value of the property.</param>
 /// <param name="priority">The priority of the binding that produced the value.</param>
 public AvaloniaPropertyChangedEventArgs(
     AvaloniaObject sender,
     AvaloniaProperty property,
     object oldValue,
     object newValue,
     BindingPriority priority)
 {
     Sender   = sender;
     Property = property;
     OldValue = oldValue;
     NewValue = newValue;
     Priority = priority;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="PerspexPropertyChangedEventArgs"/> class.
 /// </summary>
 /// <param name="sender">The object that the property changed on.</param>
 /// <param name="property">The property that changed.</param>
 /// <param name="oldValue">The old value of the property.</param>
 /// <param name="newValue">The new value of the property.</param>
 /// <param name="priority">The priority of the binding that produced the value.</param>
 public PerspexPropertyChangedEventArgs(
     PerspexObject sender,
     PerspexProperty property,
     object oldValue,
     object newValue,
     BindingPriority priority)
 {
     this.Sender = sender;
     this.Property = property;
     this.OldValue = oldValue;
     this.NewValue = newValue;
     this.Priority = priority;
 }
 public BindingEntry(
     IAvaloniaObject owner,
     StyledPropertyBase <T> property,
     IObservable <BindingValue <T> > source,
     BindingPriority priority,
     IValueSink sink)
 {
     _owner   = owner;
     Property = property;
     Source   = source;
     Priority = priority;
     _sink    = sink;
 }
Exemple #15
0
        protected override void OnPropertyChanged <T>(
            AvaloniaProperty <T> property,
            Optional <T> oldValue,
            BindingValue <T> newValue,
            BindingPriority priority)
        {
            base.OnPropertyChanged(property, oldValue, newValue, priority);

            if (property == PositionProperty)
            {
                UpdatePseudoClasses(newValue.GetValueOrDefault <NotificationPosition>());
            }
        }
Exemple #16
0
        protected override void OnPropertyChanged <T>(
            AvaloniaProperty <T> property,
            Optional <T> oldValue,
            BindingValue <T> newValue,
            BindingPriority priority)
        {
            base.OnPropertyChanged(property, oldValue, newValue, priority);

            if (property == SelectedDateProperty)
            {
                DataValidationErrors.SetError(this, newValue.Error);
            }
        }
Exemple #17
0
        /// <summary>
        /// Binds a <see cref="AvaloniaProperty"/> to an observable.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="source">The observable.</param>
        /// <param name="priority">The priority of the binding.</param>
        /// <returns>
        /// A disposable which can be used to terminate the binding.
        /// </returns>
        public IDisposable Bind(
            AvaloniaProperty property,
            IObservable <object> source,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires <ArgumentNullException>(property != null);
            Contract.Requires <ArgumentNullException>(source != null);

            VerifyAccess();

            var description = GetDescription(source);

            if (property.IsDirect)
            {
                if (property.IsReadOnly)
                {
                    throw new ArgumentException($"The property {property.Name} is readonly.");
                }

                Logger.Verbose(
                    LogArea.Property,
                    this,
                    "Bound {Property} to {Binding} with priority LocalValue",
                    property,
                    description);

                if (_directBindings == null)
                {
                    _directBindings = new List <DirectBindingSubscription>();
                }

                return(new DirectBindingSubscription(this, property, source));
            }
            else
            {
                Logger.Verbose(
                    LogArea.Property,
                    this,
                    "Bound {Property} to {Binding} with priority {Priority}",
                    property,
                    description,
                    priority);

                if (_values == null)
                {
                    _values = new ValueStore(this);
                }

                return(_values.AddBinding(property, source, priority));
            }
        }
Exemple #18
0
        /// <summary>
        /// Sets the value of a styled property.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="value">The value.</param>
        /// <param name="priority">The priority of the value.</param>
        private void SetStyledValue(AvaloniaProperty property, object value, BindingPriority priority)
        {
            var notification = value as BindingNotification;

            // We currently accept BindingNotifications for non-direct properties but we just
            // strip them to their underlying value.
            if (notification != null)
            {
                if (!notification.HasValue)
                {
                    return;
                }
                else
                {
                    value = notification.Value;
                }
            }

            var originalValue = value;

            if (!AvaloniaPropertyRegistry.Instance.IsRegistered(this, property))
            {
                ThrowNotRegistered(property);
            }

            if (!TypeUtilities.TryConvertImplicit(property.PropertyType, value, out value))
            {
                throw new ArgumentException(string.Format(
                                                "Invalid value for Property '{0}': '{1}' ({2})",
                                                property.Name,
                                                originalValue,
                                                originalValue?.GetType().FullName ?? "(null)"));
            }

            PriorityValue v;

            if (!_values.TryGetValue(property, out v))
            {
                if (value == AvaloniaProperty.UnsetValue)
                {
                    return;
                }

                v = CreatePriorityValue(property);
                _values.Add(property, v);
            }

            LogPropertySet(property, value, priority);
            v.SetValue(value, (int)priority);
        }
Exemple #19
0
        public void SetValue(T value, BindingPriority priority)
        {
            if (priority == BindingPriority.LocalValue)
            {
                _localValue = value;
            }
            else
            {
                var insert = FindInsertPoint(priority);
                _entries.Insert(insert, new ConstantValueEntry <T>(Property, value, priority));
            }

            UpdateEffectiveValue();
        }
        protected override bool SetTargetValueCore(object?value, BindingPriority priority)
        {
            try
            {
                Target.TryGetTarget(out var target);

                _setDelegate.DynamicInvoke(target, value);
                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Exemple #21
0
        /// <summary>
        /// Binds a <see cref="PerspexProperty"/> to an observable.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="source">The observable.</param>
        /// <param name="priority">The priority of the binding.</param>
        /// <returns>
        /// A disposable which can be used to terminate the binding.
        /// </returns>
        public IDisposable Bind(
            PerspexProperty property,
            IObservable <object> source,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires <ArgumentNullException>(property != null);
            VerifyAccess();

            if (property.IsDirect)
            {
                property = GetRegistered(property);

                if (property.Setter == null)
                {
                    throw new ArgumentException($"The property {property.Name} is readonly.");
                }

                _propertyLog.Verbose(
                    "Bound {Property} to {Binding} with priority LocalValue",
                    property,
                    GetDescription(source));

                return(source
                       .Select(x => TypeUtilities.CastOrDefault(x, property.PropertyType))
                       .Subscribe(x => SetValue(property, x)));
            }
            else
            {
                PriorityValue v;

                if (!PerspexPropertyRegistry.Instance.IsRegistered(this, property))
                {
                    ThrowNotRegistered(property);
                }

                if (!_values.TryGetValue(property, out v))
                {
                    v = CreatePriorityValue(property);
                    _values.Add(property, v);
                }

                _propertyLog.Verbose(
                    "Bound {Property} to {Binding} with priority {Priority}",
                    property,
                    GetDescription(source),
                    priority);

                return(v.Add(source, (int)priority));
            }
        }
Exemple #22
0
        private void UpdateEffectiveValue()
        {
            var reachedLocalValues = false;
            var value = default(Optional <T>);

            if (_entries.Count > 0)
            {
                for (var i = _entries.Count - 1; i >= 0; --i)
                {
                    var entry = _entries[i];

                    if (!reachedLocalValues && entry.Priority >= BindingPriority.LocalValue)
                    {
                        reachedLocalValues = true;

                        if (_localValue.HasValue)
                        {
                            value         = _localValue;
                            ValuePriority = BindingPriority.LocalValue;
                            break;
                        }
                    }

                    if (entry.Value.HasValue)
                    {
                        value         = entry.Value;
                        ValuePriority = entry.Priority;
                        break;
                    }
                }
            }
            else if (_localValue.HasValue)
            {
                value         = _localValue;
                ValuePriority = BindingPriority.LocalValue;
            }

            if (value.HasValue && _coerceValue != null)
            {
                value = _coerceValue(_owner, value.Value);
            }

            if (value != Value)
            {
                var old = Value;
                Value = value;
                _sink.ValueChanged(Property, ValuePriority, old, value);
            }
        }
Exemple #23
0
        private int FindInsertPoint(BindingPriority priority)
        {
            var result = _entries.Count;

            for (var i = 0; i < _entries.Count; ++i)
            {
                if (_entries[i].Priority < priority)
                {
                    result = i;
                    break;
                }
            }

            return(result);
        }
Exemple #24
0
 /// <summary>
 /// Gets a subject for a <see cref="AvaloniaProperty"/>.
 /// </summary>
 /// <typeparam name="T">The property type.</typeparam>
 /// <param name="o">The object.</param>
 /// <param name="property">The property.</param>
 /// <param name="priority">
 /// The priority with which binding values are written to the object.
 /// </param>
 /// <returns>
 /// An <see cref="ISubject{T}"/> which can be used for two-way binding to/from the
 /// property.
 /// </returns>
 public static ISubject <BindingValue <T> > GetBindingSubject <T>(
     this IAvaloniaObject o,
     AvaloniaProperty <T> property,
     BindingPriority priority = BindingPriority.LocalValue)
 {
     return(Subject.Create <BindingValue <T> >(
                Observer.Create <BindingValue <T> >(x =>
     {
         if (x.HasValue)
         {
             o.SetValue(property, x.Value, priority);
         }
     }),
                o.GetBindingObservable(property)));
 }
Exemple #25
0
        /// <summary>
        /// Sets a <see cref="PerspexProperty"/> value.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="value">The value.</param>
        /// <param name="priority">The priority of the value.</param>
        public void SetValue(
            PerspexProperty property,
            object value,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires <ArgumentNullException>(property != null);
            VerifyAccess();

            if (property.IsDirect)
            {
                var accessor = (IDirectPropertyAccessor)GetRegistered(property);
                LogPropertySet(property, value, priority);
                accessor.SetValue(this, DirectUnsetToDefault(value, property));
            }
            else
            {
                PriorityValue v;
                var           originalValue = value;

                if (!PerspexPropertyRegistry.Instance.IsRegistered(this, property))
                {
                    ThrowNotRegistered(property);
                }

                if (!TypeUtilities.TryCast(property.PropertyType, value, out value))
                {
                    throw new ArgumentException(string.Format(
                                                    "Invalid value for Property '{0}': '{1}' ({2})",
                                                    property.Name,
                                                    originalValue,
                                                    originalValue?.GetType().FullName ?? "(null)"));
                }

                if (!_values.TryGetValue(property, out v))
                {
                    if (value == PerspexProperty.UnsetValue)
                    {
                        return;
                    }

                    v = CreatePriorityValue(property);
                    _values.Add(property, v);
                }

                LogPropertySet(property, value, priority);
                v.SetValue(value, (int)priority);
            }
        }
Exemple #26
0
        /// <summary>
        /// Initiates a two-way binding between a <see cref="PerspexProperty"/> and an
        /// <see cref="ISubject{Object}"/>.
        /// </summary>
        /// <param name="property">The property on this object.</param>
        /// <param name="source">The subject to bind to.</param>
        /// <param name="priority">The priority of the binding.</param>
        /// <returns>
        /// A disposable which can be used to terminate the binding.
        /// </returns>
        /// <remarks>
        /// The binding is first carried out from <paramref name="source"/> to this.
        /// </remarks>
        public IDisposable BindTwoWay(
            PerspexProperty property,
            ISubject <object> source,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            VerifyAccess();
            _propertyLog.Verbose(
                "Bound two way {Property} to {Binding} with priority {Priority}",
                property,
                GetDescription(source),
                priority);

            return(new CompositeDisposable(
                       Bind(property, source),
                       GetObservable(property).Subscribe(source)));
        }
 protected override bool SetTargetValueCore(object?value, BindingPriority priority)
 {
     try
     {
         if (Target.TryGetTarget(out var target) && target is IAvaloniaObject obj)
         {
             obj.SetValue(_property, value, priority);
             return(true);
         }
         return(false);
     }
     catch
     {
         return(false);
     }
 }
Exemple #28
0
 /// <summary>
 /// Attempts to set the value of a property expression.
 /// </summary>
 /// <param name="value">The value to set.</param>
 /// <param name="priority">The binding priority to use.</param>
 /// <returns>
 /// True if the value could be set; false if the expression does not evaluate to a
 /// property. Note that the <see cref="ExpressionObserver"/> must be subscribed to
 /// before setting the target value can work, as setting the value requires the
 /// expression to be evaluated.
 /// </returns>
 public bool SetValue(object?value, BindingPriority priority = BindingPriority.LocalValue)
 {
     if (Leaf is SettableNode settable)
     {
         foreach (var transform in TransformNodes)
         {
             value = transform.Transform(value);
             if (value is BindingNotification)
             {
                 return(false);
             }
         }
         return(settable.SetTargetValue(value, priority));
     }
     return(false);
 }
Exemple #29
0
        /// <summary>
        /// Binds a <see cref="AvaloniaProperty"/> to an observable.
        /// </summary>
        /// <typeparam name="T">The type of the property.</typeparam>
        /// <param name="target">The object.</param>
        /// <param name="property">The property.</param>
        /// <param name="source">The observable.</param>
        /// <param name="priority">The priority of the binding.</param>
        /// <returns>
        /// A disposable which can be used to terminate the binding.
        /// </returns>
        public static IDisposable Bind <T>(
            this IAvaloniaObject target,
            AvaloniaProperty <T> property,
            IObservable <BindingValue <T> > source,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            target   = target ?? throw new ArgumentNullException(nameof(target));
            property = property ?? throw new ArgumentNullException(nameof(property));
            source   = source ?? throw new ArgumentNullException(nameof(source));

            return(property switch
            {
                StyledPropertyBase <T> styled => target.Bind(styled, source, priority),
                DirectPropertyBase <T> direct => target.Bind(direct, source),
                _ => throw new NotSupportedException("Unsupported AvaloniaProperty type."),
            });
        public override bool SetValue(object value, BindingPriority priority)
        {
            if (Next != null)
            {
                return Next.SetValue(value, priority);
            }
            else
            {
                if (_accessor != null)
                {
                    return _accessor.SetValue(value, priority);
                }

                return false;
            }
        }
Exemple #31
0
        public override bool SetValue(object value, BindingPriority priority)
        {
            if (Next != null)
            {
                return(Next.SetValue(value, priority));
            }
            else
            {
                if (_accessor != null)
                {
                    return(_accessor.SetValue(value, priority));
                }

                return(false);
            }
        }
Exemple #32
0
        /// <summary>
        /// Initiates a two-way binding between <see cref="PerspexProperty"/>s.
        /// </summary>
        /// <param name="property">The property on this object.</param>
        /// <param name="source">The source object.</param>
        /// <param name="sourceProperty">The property on the source object.</param>
        /// <param name="priority">The priority of the binding.</param>
        /// <returns>
        /// A disposable which can be used to terminate the binding.
        /// </returns>
        /// <remarks>
        /// The binding is first carried out from <paramref name="source"/> to this.
        /// </remarks>
        public IDisposable BindTwoWay(
            PerspexProperty property,
            PerspexObject source,
            PerspexProperty sourceProperty,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            VerifyAccess();
            _propertyLog.Verbose(
                "Bound two way {Property} to {Binding} with priority {Priority}",
                property,
                source,
                priority);

            return(new CompositeDisposable(
                       Bind(property, source.GetObservable(sourceProperty)),
                       source.Bind(sourceProperty, GetObservable(property))));
        }
Exemple #33
0
        public bool TryGetValue <T>(
            StyledPropertyBase <T> property,
            BindingPriority maxPriority,
            out T value)
        {
            if (_values.TryGetValue(property, out var slot))
            {
                var v = ((IValue <T>)slot).GetValue(maxPriority);

                if (v.HasValue)
                {
                    value = v.Value;
                    return(true);
                }
            }

            value = default !;
            public override bool SetValue(object value, BindingPriority priority)
            {
                try
                {
                    return base.SetValue(value, priority);
                }
                catch (TargetInvocationException ex)
                {
                    Observer.OnNext(new BindingNotification(ex.InnerException, BindingErrorType.DataValidationError));
                }
                catch (Exception ex)
                {
                    Observer.OnNext(new BindingNotification(ex, BindingErrorType.DataValidationError));
                }

                return false;
            }
Exemple #35
0
            public override bool SetValue(object value, BindingPriority priority)
            {
                if (_property.CanWrite)
                {
                    _eventRaised = false;
                    _property.SetValue(_reference.Target, value);

                    if (!_eventRaised)
                    {
                        SendCurrentValue();
                    }

                    return(true);
                }

                return(false);
            }
Exemple #36
0
        /// <summary>
        /// Sets a <see cref="AvaloniaProperty"/> value.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="value">The value.</param>
        /// <param name="priority">The priority of the value.</param>
        public void SetValue(
            AvaloniaProperty property,
            object value,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires <ArgumentNullException>(property != null);
            VerifyAccess();

            if (property.IsDirect)
            {
                SetDirectValue(property, value);
            }
            else
            {
                SetStyledValue(property, value, priority);
            }
        }
Exemple #37
0
            public override bool SetValue(object?value, BindingPriority priority)
            {
                try
                {
                    return(base.SetValue(value, priority));
                }
                catch (TargetInvocationException ex) when(ex.InnerException is not null)
                {
                    PublishValue(new BindingNotification(ex.InnerException, BindingErrorType.DataValidationError));
                }
                catch (Exception ex)
                {
                    PublishValue(new BindingNotification(ex, BindingErrorType.DataValidationError));
                }

                return(false);
            }
            public override bool SetValue(object value, BindingPriority priority)
            {
                try
                {
                    return(base.SetValue(value, priority));
                }
                catch (TargetInvocationException ex)
                {
                    Observer.OnNext(new BindingNotification(ex.InnerException, BindingErrorType.DataValidationError));
                }
                catch (Exception ex)
                {
                    Observer.OnNext(new BindingNotification(ex, BindingErrorType.DataValidationError));
                }

                return(false);
            }
Exemple #39
0
        /// <summary>
        /// Raises the <see cref="PropertyChanged"/> event.
        /// </summary>
        /// <param name="property">The property that has changed.</param>
        /// <param name="oldValue">The old property value.</param>
        /// <param name="newValue">The new property value.</param>
        /// <param name="priority">The priority of the binding that produced the value.</param>
        protected void RaisePropertyChanged(
            PerspexProperty property,
            object oldValue,
            object newValue,
            BindingPriority priority)
        {
            Contract.Requires <ArgumentNullException>(property != null);
            VerifyAccess();

            PerspexPropertyChangedEventArgs e = new PerspexPropertyChangedEventArgs(
                this,
                property,
                oldValue,
                newValue,
                priority);

            if (property.Notifying != null)
            {
                property.Notifying(this, true);
            }

            try
            {
                OnPropertyChanged(e);
                property.NotifyChanged(e);

                if (PropertyChanged != null)
                {
                    PropertyChanged(this, e);
                }

                if (_inpcChanged != null)
                {
                    PropertyChangedEventArgs e2 = new PropertyChangedEventArgs(property.Name);
                    _inpcChanged(this, e2);
                }
            }
            finally
            {
                if (property.Notifying != null)
                {
                    property.Notifying(this, false);
                }
            }
        }
        /// <summary>
        /// Gets a subject for a <see cref="AvaloniaProperty"/>.
        /// </summary>
        /// <typeparam name="T">The property type.</typeparam>
        /// <param name="o">The object.</param>
        /// <param name="property">The property.</param>
        /// <param name="priority">
        /// The priority with which binding values are written to the object.
        /// </param>
        /// <returns>
        /// An <see cref="ISubject{T}"/> which can be used for two-way binding to/from the
        /// property.
        /// </returns>
        public static ISubject <T> GetSubject <T>(
            this IAvaloniaObject o,
            AvaloniaProperty <T> property,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            // TODO: Subject.Create<T> is not yet in stable Rx : once it is, remove the
            // AnonymousSubject classes from this file and use Subject.Create<T>.
            var output = new Subject <T>();
            var result = new AnonymousSubject <T>(
                Observer.Create <T>(
                    x => output.OnNext(x),
                    e => output.OnError(e),
                    () => output.OnCompleted()),
                o.GetObservable(property));

            o.Bind(property, output, priority);
            return(result);
        }
 public override bool SetValue(object value, BindingPriority priority)
 {
     try
     {
         var success = base.SetValue(value, priority);
         SendValidationCallback(new ExceptionValidationStatus(null));
         return success;
     }
     catch (TargetInvocationException ex)
     {
         SendValidationCallback(new ExceptionValidationStatus(ex.InnerException));
     }
     catch (Exception ex)
     {
         SendValidationCallback(new ExceptionValidationStatus(ex));
     }
     return false;
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="InstancedBinding"/> class.
        /// </summary>
        /// <param name="observable">The observable for a one-way binding.</param>
        /// <param name="mode">The binding mode.</param>
        /// <param name="priority">The binding priority.</param>
        public InstancedBinding(
            IObservable<object> observable, 
            BindingMode mode = BindingMode.OneWay,
            BindingPriority priority = BindingPriority.LocalValue)
        {
            Contract.Requires<ArgumentNullException>(observable != null);

            if (mode == BindingMode.OneWayToSource || mode == BindingMode.TwoWay)
            {
                throw new ArgumentException(
                    "Invalid BindingResult mode: OneWayToSource and TwoWay bindings" +
                    "require a Subject.");
            }

            Mode = mode;
            Priority = priority;
            Observable = observable;
        }
Exemple #43
0
 /// <inheritdoc/>
 public bool SetValue(object value, BindingPriority priority)
 {
     return false;
 }
 public override bool SetValue(object value, BindingPriority priority)
 {
     return base.SetValue(value, priority);
 }
 public void SetValue(PerspexProperty property, object value, BindingPriority priority)
 {
     throw new NotImplementedException();
 }
 public IDisposable Bind(PerspexProperty property, IObservable<object> source, BindingPriority priority)
 {
     throw new NotImplementedException();
 }
 /// <inheritdoc/>
 public virtual bool SetValue(object value, BindingPriority priority) => _accessor.SetValue(value, priority);
 /// <inheritdoc/>
 public abstract bool SetValue(object value, BindingPriority priority);