public ExpressionObserver CreateExpressionObserver(
IObservablePropertyBag instance,
PerspexProperty property)
{
IObservable<object> dataContext = null;
if (property != Control.DataContextProperty)
{
dataContext = instance.GetObservable(Control.DataContextProperty);
}
else
{
var parent = instance.InheritanceParent as IObservablePropertyBag;
if (parent != null)
{
dataContext = parent.GetObservable(Control.DataContextProperty);
}
}
if (dataContext != null)
{
var result = new ExpressionObserver(null, SourcePropertyPath);
dataContext.Subscribe(x => result.Root = x);
return result;
}
return null;
}
public XamlBindingDefinition(Control target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, BindingMode bindingMode)
{
this.target = target;
this.targetProperty = targetProperty;
this.sourcePropertyPath = sourcePropertyPath;
this.bindingMode = bindingMode;
}
public XamlBindingDefinition(Control target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, BindingMode bindingMode)
{
_target = target;
_targetProperty = targetProperty;
_sourcePropertyPath = sourcePropertyPath;
_bindingMode = bindingMode;
}
internal void Bind(IObservablePropertyBag target, PerspexProperty property, ISubject<object> subject)
{
var mode = BindingMode == BindingMode.Default ?
property.DefaultBindingMode : BindingMode;
switch (mode)
{
case BindingMode.Default:
case BindingMode.OneWay:
target.Bind(property, subject);
break;
case BindingMode.TwoWay:
target.BindTwoWay(property, subject);
break;
case BindingMode.OneTime:
target.GetObservable(Control.DataContextProperty).Subscribe(dataContext =>
{
subject.Take(1).Subscribe(x => target.SetValue(property, x));
});
break;
case BindingMode.OneWayToSource:
target.GetObservable(property).Subscribe(subject);
break;
}
}
public void Bind(IObservablePropertyBag instance, PerspexProperty property)
{
var subject = CreateSubject(instance, property);
if (subject != null)
{
Bind(instance, property, subject);
}
}
public void Bind(IObservablePropertyBag instance, PerspexProperty property)
{
var subject = new ExpressionSubject(CreateExpressionObserver(instance, property));
if (subject != null)
{
Bind(instance, property, subject);
}
}
/// <summary>
/// Merges the metadata with the base metadata.
/// </summary>
/// <param name="baseMetadata">The base metadata to merge.</param>
/// <param name="property">The property to which the metadata is being applied.</param>
public virtual void Merge(
PropertyMetadata baseMetadata,
PerspexProperty property)
{
if (_defaultBindingMode == BindingMode.Default)
{
_defaultBindingMode = baseMetadata.DefaultBindingMode;
}
}
/// <summary>
/// Applies the binding to a property on an instance.
/// </summary>
/// <param name="instance">The target instance.</param>
/// <param name="property">The target property.</param>
public void Bind(IPerspexObject instance, PerspexProperty property)
{
var subject = CreateSubject(instance, property);
if (subject != null)
{
Bind(instance, property, subject);
}
}
public Accessor(PerspexObject instance, PerspexProperty property, Action<object> changed)
{
Contract.Requires<ArgumentNullException>(instance != null);
Contract.Requires<ArgumentNullException>(property != null);
_instance = instance;
_property = property;
_subscription = instance.GetObservable(property).Skip(1).Subscribe(changed);
}
/// <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>
/// Applies the binding to a property on an instance.
/// </summary>
/// <param name="instance">The target instance.</param>
/// <param name="property">The target property.</param>
public void Bind(IObservablePropertyBag instance, PerspexProperty property)
{
var subject = CreateSubject(
instance,
property.PropertyType,
property == Control.DataContextProperty);
if (subject != null)
{
Bind(instance, property, subject);
}
}
private static void SetBinding(
object instance,
MutableMember member,
PerspexProperty property,
IBinding binding)
{
if (!(AssignBinding(instance, member, binding) || ApplyBinding(instance, property, binding)))
{
throw new InvalidOperationException(
$"Cannot assign to '{member.Name}' on '{instance.GetType()}");
}
}
public void GetDefaultValue_Returns_Registered_Value_For_Not_Overridden_Class()
{
PerspexProperty<string> target = new PerspexProperty<string>(
"test",
typeof(Class1),
"Foo",
false,
BindingMode.OneWay,
null);
Assert.Equal("Foo", target.GetDefaultValue<Class2>());
}
public DataContextChangeSynchronizer(PerspexObject target, PerspexProperty targetProperty,
PropertyPath sourcePropertyPath, object source, ITypeConverterProvider typeConverterProvider)
{
Guard.ThrowIfNull(target, nameof(target));
Guard.ThrowIfNull(targetProperty, nameof(targetProperty));
Guard.ThrowIfNull(sourcePropertyPath, nameof(sourcePropertyPath));
Guard.ThrowIfNull(source, nameof(source));
Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider));
this.bindingEndpoint = new TargetBindingEndpoint(target, targetProperty);
this.sourceEndpoint = new ObservablePropertyBranch(source, sourcePropertyPath);
this.targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(targetProperty.PropertyType);
}
/// <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;
}
/// <inheritdoc/>
public InstancedBinding Initiate(
IPerspexObject target,
PerspexProperty targetProperty,
object anchor = null)
{
Contract.Requires <ArgumentNullException>(target != null);
var pathInfo = ParsePath(Path);
ValidateState(pathInfo);
ExpressionObserver observer;
if (pathInfo.ElementName != null || ElementName != null)
{
observer = CreateElementObserver(
(target as IControl) ?? (anchor as IControl),
pathInfo.ElementName ?? ElementName,
pathInfo.Path);
}
else if (Source != null)
{
observer = CreateSourceObserver(Source, pathInfo.Path);
}
else if (RelativeSource == null || RelativeSource.Mode == RelativeSourceMode.DataContext)
{
observer = CreateDataContexObserver(
target,
pathInfo.Path,
targetProperty == Control.DataContextProperty,
anchor);
}
else if (RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
{
observer = CreateTemplatedParentObserver(target, pathInfo.Path);
}
else
{
throw new NotSupportedException();
}
var subject = new ExpressionSubject(
observer,
targetProperty?.PropertyType ?? typeof(object),
Converter ?? DefaultValueConverter.Instance,
ConverterParameter,
FallbackValue,
Priority);
return(new InstancedBinding(subject, Mode, Priority));
}
/// <summary>
/// Creates a subject that can be used to get and set the value of the binding.
/// </summary>
/// <param name="target">The target instance.</param>
/// <param name="targetProperty">The target property.</param>
/// <returns>An <see cref="ISubject{Object}"/>.</returns>
public ISubject<object> CreateSubject(IPerspexObject target, PerspexProperty targetProperty)
{
if (Converter == null)
{
throw new NotSupportedException("MultiBinding without Converter not currently supported.");
}
var targetType = targetProperty?.PropertyType ?? typeof(object);
var result = new BehaviorSubject<object>(PerspexProperty.UnsetValue);
var children = Bindings.Select(x => x.CreateSubject(target, null));
var input = children.CombineLatest().Select(x => ConvertValue(x, targetType));
input.Subscribe(result);
return result;
}
public void Constructor_Sets_Properties()
{
PerspexProperty <string> target = new PerspexProperty <string>(
"test",
typeof(Class1),
"Foo",
false,
BindingMode.OneWay);
Assert.AreEqual("test", target.Name);
Assert.AreEqual(typeof(string), target.PropertyType);
Assert.AreEqual(typeof(Class1), target.OwnerType);
Assert.AreEqual(false, target.Inherits);
}
protected void AddPseudoClass(PerspexProperty <bool> property, string className)
{
this.GetObservable(property).Subscribe(x =>
{
if (x)
{
this.classes.Add(className);
}
else
{
this.classes.Remove(className);
}
});
}
public void GetDefaultValue_Returns_Overridden_Value()
{
PerspexProperty <string> target = new PerspexProperty <string>(
"test",
typeof(Class1),
"Foo",
false,
BindingMode.OneWay,
null);
target.OverrideDefaultValue(typeof(Class2), "Bar");
Assert.Equal("Bar", target.GetDefaultValue <Class2>());
}
private static void SetBinding(
object instance,
MutableMember member,
PerspexProperty property,
IValueContext context,
IBinding binding)
{
if (!(AssignBinding(instance, member, binding) ||
ApplyBinding(instance, property, context, binding)))
{
throw new InvalidOperationException(
$"Cannot assign to '{member.Name}' on '{instance.GetType()}");
}
}
public void GetDefaultValue_Returns_Overridden_Value()
{
PerspexProperty<string> target = new PerspexProperty<string>(
"test",
typeof(Class1),
"Foo",
false,
BindingMode.OneWay,
null);
target.OverrideDefaultValue(typeof(Class2), "Bar");
Assert.Equal("Bar", target.GetDefaultValue<Class2>());
}
/// <summary>
/// Applies the binding to a property on an instance.
/// </summary>
/// <param name="instance">The target instance.</param>
/// <param name="property">The target property.</param>
public void Bind(IObservablePropertyBag instance, PerspexProperty property)
{
Contract.Requires <ArgumentNullException>(instance != null);
Contract.Requires <ArgumentNullException>(property != null);
var subject = CreateSubject(
instance,
property.PropertyType,
property == Control.DataContextProperty);
if (subject != null)
{
Bind(instance, property, subject);
}
}
/// <summary>
/// Creates a subject that can be used to get and set the value of the binding.
/// </summary>
/// <param name="target">The target instance.</param>
/// <param name="targetProperty">The target property.</param>
/// <returns>An <see cref="ISubject{Object}"/>.</returns>
public ISubject <object> CreateSubject(IPerspexObject target, PerspexProperty targetProperty)
{
if (Converter == null)
{
throw new NotSupportedException("MultiBinding without Converter not currently supported.");
}
var targetType = targetProperty?.PropertyType ?? typeof(object);
var result = new BehaviorSubject <object>(PerspexProperty.UnsetValue);
var children = Bindings.Select(x => x.CreateSubject(target, null));
var input = children.CombineLatest().Select(x => ConvertValue(x, targetType));
input.Subscribe(result);
return(result);
}
public void Constructor_Sets_Properties()
{
PerspexProperty<string> target = new PerspexProperty<string>(
"test",
typeof(Class1),
"Foo",
false,
BindingMode.OneWay,
null);
Assert.Equal("test", target.Name);
Assert.Equal(typeof(string), target.PropertyType);
Assert.Equal(typeof(Class1), target.OwnerType);
Assert.Equal(false, target.Inherits);
}
/// <summary>
/// Applies the binding to a property on an instance.
/// </summary>
/// <param name="instance">The target instance.</param>
/// <param name="property">The target property.</param>
public void Bind(IObservablePropertyBag instance, PerspexProperty property)
{
Contract.Requires<ArgumentNullException>(instance != null);
Contract.Requires<ArgumentNullException>(property != null);
var subject = CreateSubject(
instance,
property.PropertyType,
property == Control.DataContextProperty);
if (subject != null)
{
Bind(instance, property, subject);
}
}
/// <summary>
/// Applies an <see cref="InstancedBinding"/> a property on an <see cref="IPerspexObject"/>.
/// </summary>
/// <param name="target">The target object.</param>
/// <param name="property">The property to bind.</param>
/// <param name="binding">The instanced binding.</param>
/// <param name="anchor">
/// An optional anchor from which to locate required context. When binding to objects that
/// are not in the logical tree, certain types of binding need an anchor into the tree in
/// order to locate named controls or resources. The <paramref name="anchor"/> parameter
/// can be used to provice this context.
/// </param>
/// <returns>An <see cref="IDisposable"/> which can be used to cancel the binding.</returns>
public static IDisposable Apply(
IPerspexObject target,
PerspexProperty property,
InstancedBinding binding,
object anchor)
{
Contract.Requires <ArgumentNullException>(target != null);
Contract.Requires <ArgumentNullException>(property != null);
Contract.Requires <ArgumentNullException>(binding != null);
var mode = binding.Mode;
if (mode == BindingMode.Default)
{
mode = property.GetMetadata(target.GetType()).DefaultBindingMode;
}
switch (mode)
{
case BindingMode.Default:
case BindingMode.OneWay:
return(target.Bind(property, binding.Observable ?? binding.Subject, binding.Priority));
case BindingMode.TwoWay:
return(new CompositeDisposable(
target.Bind(property, binding.Subject, binding.Priority),
target.GetObservable(property).Subscribe(binding.Subject)));
case BindingMode.OneTime:
var source = binding.Subject ?? binding.Observable;
if (source != null)
{
return(source.Take(1).Subscribe(x => target.SetValue(property, x, binding.Priority)));
}
else
{
target.SetValue(property, binding.Value, binding.Priority);
return(Disposable.Empty);
}
case BindingMode.OneWayToSource:
return(target.GetObservable(property).Subscribe(binding.Subject));
default:
throw new ArgumentException("Invalid binding mode.");
}
}
public ISubject<object> CreateSubject(
IObservablePropertyBag instance,
PerspexProperty property)
{
if (Converter == null)
{
throw new NotSupportedException("MultiBinding without Converter not currently supported.");
}
var result = new Subject<object>();
var children = Bindings.Select(x => x.CreateExpressionSubject(instance, property));
var input = Observable.CombineLatest(children).Select(x =>
Converter.Convert(x, property.PropertyType, null, CultureInfo.CurrentUICulture));
input.Subscribe(result);
return result;
}
public ISubject <object> CreateSubject(
IObservablePropertyBag instance,
PerspexProperty property)
{
if (Converter == null)
{
throw new NotSupportedException("MultiBinding without Converter not currently supported.");
}
var result = new Subject <object>();
var children = Bindings.Select(x => x.CreateExpressionSubject(instance, property));
var input = Observable.CombineLatest(children).Select(x =>
Converter.Convert(x, property.PropertyType, null, CultureInfo.CurrentUICulture));
input.Subscribe(result);
return(result);
}
/// <summary>
/// Creates a subject that can be used to get and set the value of the binding.
/// </summary>
/// <param name="target">The target instance.</param>
/// <param name="targetProperty">The target property. May be null.</param>
/// <returns>An <see cref="ISubject{Object}"/>.</returns>
public ISubject<object> CreateSubject(
IPerspexObject target,
PerspexProperty targetProperty)
{
Contract.Requires<ArgumentNullException>(target != null);
var pathInfo = ParsePath(Path);
ValidateState(pathInfo);
ExpressionObserver observer;
if (pathInfo.ElementName != null || ElementName != null)
{
observer = CreateElementObserver(
(IControl)target,
pathInfo.ElementName ?? ElementName,
pathInfo.Path);
}
else if (Source != null)
{
observer = CreateSourceObserver(Source, pathInfo.Path);
}
else if (RelativeSource == null || RelativeSource.Mode == RelativeSourceMode.DataContext)
{
observer = CreateDataContexObserver(
target,
pathInfo.Path,
targetProperty == Control.DataContextProperty);
}
else if (RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
{
observer = CreateTemplatedParentObserver(target, pathInfo.Path);
}
else
{
throw new NotSupportedException();
}
return new ExpressionSubject(
observer,
targetProperty?.PropertyType ?? typeof(object),
Converter ?? DefaultValueConverter.Instance,
ConverterParameter,
FallbackValue);
}
public PropertyDetails(PerspexObject o, PerspexProperty property)
{
Name = property.IsAttached ?
$"[{property.OwnerType.Name}.{property.Name}]" :
property.Name;
IsAttached = property.IsAttached;
// TODO: Unsubscribe when view model is deactivated.
o.GetObservable(property).Subscribe(x =>
{
var diagnostic = o.GetDiagnostic(property);
Value = diagnostic.Value ?? "(null)";
Priority = (diagnostic.Priority != BindingPriority.Unset) ?
diagnostic.Priority.ToString() :
diagnostic.Property.Inherits ? "Inherited" : "Unset";
Diagnostic = diagnostic.Diagnostic;
});
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeItemContainerGenerator{T}"/> class.
/// </summary>
/// <param name="owner">The owner control.</param>
/// <param name="contentProperty">The container's Content property.</param>
/// <param name="itemsProperty">The container's Items property.</param>
/// <param name="isExpandedProperty">The container's IsExpanded property.</param>
/// <param name="rootGenerator">
/// The item container for the root of the tree, or null if this generator is itself the
/// root of the tree.
/// </param>
public TreeItemContainerGenerator(
IControl owner,
PerspexProperty contentProperty,
PerspexProperty itemsProperty,
PerspexProperty isExpandedProperty,
ITreeItemContainerGenerator rootGenerator)
: base(owner, contentProperty)
{
ItemsProperty = itemsProperty;
IsExpandedProperty = isExpandedProperty;
RootGenerator = rootGenerator;
if (rootGenerator == null)
{
_itemToContainer = new Dictionary <object, T>();
_containerToItem = new Dictionary <IControl, object>();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeItemContainerGenerator{T}"/> class.
/// </summary>
/// <param name="owner">The owner control.</param>
/// <param name="contentProperty">The container's Content property.</param>
/// <param name="itemsProperty">The container's Items property.</param>
/// <param name="isExpandedProperty">The container's IsExpanded property.</param>
/// <param name="index">The container index for the tree</param>
public TreeItemContainerGenerator(
IControl owner,
PerspexProperty contentProperty,
PerspexProperty itemsProperty,
PerspexProperty isExpandedProperty,
TreeContainerIndex index)
: base(owner, contentProperty)
{
Contract.Requires <ArgumentNullException>(owner != null);
Contract.Requires <ArgumentNullException>(contentProperty != null);
Contract.Requires <ArgumentNullException>(itemsProperty != null);
Contract.Requires <ArgumentNullException>(isExpandedProperty != null);
Contract.Requires <ArgumentNullException>(index != null);
ItemsProperty = itemsProperty;
IsExpandedProperty = isExpandedProperty;
Index = index;
}
public PropertyDetails(PerspexObject o, PerspexProperty property)
{
Name = property.IsAttached ?
$"[{property.OwnerType.Name}.{property.Name}]" :
property.Name;
IsAttached = property.IsAttached;
// TODO: Unsubscribe when view model is deactivated.
o.GetObservable(property).Subscribe(x =>
{
var diagnostic = o.GetDiagnostic(property);
Value = diagnostic.Value ?? "(null)";
Priority = (diagnostic.Priority != BindingPriority.Unset) ?
diagnostic.Priority.ToString() :
diagnostic.Property.Inherits ? "Inherited" : "Unset";
Diagnostic = diagnostic.Diagnostic;
});
}
private void Bind(
IStyleable control,
PerspexProperty property,
IBinding binding,
ISubject <object> subject)
{
var mode = binding.Mode;
if (mode == BindingMode.Default)
{
mode = property.GetMetadata(control.GetType()).DefaultBindingMode;
}
control.Bind(
property,
subject,
mode,
binding.Priority);
}
private static bool ApplyBinding(
object instance,
PerspexProperty property,
IValueContext context,
IBinding binding)
{
if (property == null)
{
return(false);
}
var control = instance as IControl;
if (control != null)
{
DelayedBinding.Add(control, property, binding);
}
else
{
// The target is not a control, so we need to find an anchor that will let us look
// up named controls and style resources. First look for the closest IControl in
// the TopDownValueContext.
object anchor = context.TopDownValueContext.StoredInstances
.Select(x => x.Instance)
.OfType <IControl>()
.LastOrDefault();
// If a control was not found, then try to find the highest-level style as the XAML
// file could be a XAML file containing only styles.
if (anchor == null)
{
anchor = context.TopDownValueContext.StoredInstances
.Select(x => x.Instance)
.OfType <IStyle>()
.FirstOrDefault();
}
((IPerspexObject)instance).Bind(property, binding, anchor);
}
return(true);
}
public ExpressionObserver CreateTemplatedParentExpressionSubject(
IObservablePropertyBag instance,
PerspexProperty property)
{
var result = new ExpressionObserver(
() => instance.GetValue(Control.TemplatedParentProperty),
GetExpression());
if (instance.GetValue(Control.TemplatedParentProperty) == null)
{
// TemplatedParent should only be set once, so only listen for the first non-null
// value.
instance.GetObservable(Control.TemplatedParentProperty)
.Where(x => x != null)
.Take(1)
.Subscribe(x => result.UpdateRoot());
}
return(result);
}
public ExpressionObserver CreateExpressionObserver(
IObservablePropertyBag instance,
PerspexProperty property)
{
var dataContextHost = property != Control.DataContextProperty ?
instance :
instance.InheritanceParent as IObservablePropertyBag;
if (dataContextHost != null)
{
var result = new ExpressionObserver(
() => dataContextHost.GetValue(Control.DataContextProperty),
SourcePropertyPath);
dataContextHost.GetObservable(Control.DataContextProperty).Subscribe(x =>
result.UpdateRoot());
return(result);
}
return(null);
}
/// <summary>
/// Adds a delayed binding to a control.
/// </summary>
/// <param name="target">The control.</param>
/// <param name="property">The property on the control to bind to.</param>
/// <param name="binding">The binding.</param>
public static void Add(IControl target, PerspexProperty property, IBinding binding)
{
if (target.IsInitialized)
{
target.Bind(property, binding);
}
else
{
List <Entry> bindings;
if (!_entries.TryGetValue(target, out bindings))
{
bindings = new List <Entry>();
_entries.Add(target, bindings);
// TODO: Make this a weak event listener.
target.Initialized += ApplyBindings;
}
bindings.Add(new Entry(binding, property));
}
}
/// <summary>
/// Gets a diagnostic for a <see cref="PerspexProperty"/> on a <see cref="PerspexObject"/>.
/// </summary>
/// <param name="o">The object.</param>
/// <param name="property">The property.</param>
/// <returns>
/// A <see cref="PerspexPropertyValue"/> that can be used to diagnose the state of the
/// property on the object.
/// </returns>
public static PerspexPropertyValue GetDiagnostic(this PerspexObject o, PerspexProperty property)
{
var set = o.GetSetValues();
PriorityValue value;
if (set.TryGetValue(property, out value))
{
return new PerspexPropertyValue(
property,
value.Value,
(BindingPriority)value.ValuePriority,
value.GetDiagnostic());
}
else
{
return new PerspexPropertyValue(
property,
o.GetValue(property),
BindingPriority.Unset,
"Unset");
}
}
/// <summary>
/// Gets a diagnostic for a <see cref="PerspexProperty"/> on a <see cref="PerspexObject"/>.
/// </summary>
/// <param name="o">The object.</param>
/// <param name="property">The property.</param>
/// <returns>
/// A <see cref="PerspexPropertyValue"/> that can be used to diagnose the state of the
/// property on the object.
/// </returns>
public static PerspexPropertyValue GetDiagnostic(this PerspexObject o, PerspexProperty property)
{
var set = o.GetSetValues();
PriorityValue value;
if (set.TryGetValue(property, out value))
{
return(new PerspexPropertyValue(
property,
o.GetValue(property),
(BindingPriority)value.ValuePriority,
value.GetDiagnostic()));
}
else
{
return(new PerspexPropertyValue(
property,
o.GetValue(property),
BindingPriority.Unset,
"Unset"));
}
}
public ISubject <object> CreateExpressionSubject(
IObservablePropertyBag instance,
PerspexProperty property)
{
ExpressionObserver observer;
if (RelativeSource == null || RelativeSource.Mode == RelativeSourceMode.DataContext)
{
observer = CreateDataContextExpressionSubject(instance, property);
}
else if (RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
{
observer = CreateTemplatedParentExpressionSubject(instance, property);
}
else
{
throw new NotSupportedException();
}
return(new ExpressionSubject(
observer,
property.PropertyType,
Converter ?? DefaultValueConverter.Instance));
}
public ISubject<object> CreateExpressionSubject(
IObservablePropertyBag instance,
PerspexProperty property)
{
ExpressionObserver observer;
if (RelativeSource == null || RelativeSource.Mode == RelativeSourceMode.DataContext)
{
observer = CreateDataContextExpressionSubject(instance, property);
}
else if (RelativeSource.Mode == RelativeSourceMode.TemplatedParent)
{
observer = CreateTemplatedParentExpressionSubject(instance, property);
}
else
{
throw new NotSupportedException();
}
return new ExpressionSubject(
observer,
property.PropertyType,
Converter ?? DefaultValueConverter.Instance);
}
internal void Bind(IObservablePropertyBag target, PerspexProperty property, ISubject<object> subject)
{
var mode = Mode == BindingMode.Default ?
property.DefaultBindingMode : Mode;
switch (mode)
{
case BindingMode.Default:
case BindingMode.OneWay:
target.Bind(property, subject, Priority);
break;
case BindingMode.TwoWay:
throw new NotSupportedException("TwoWay MultiBinding not currently supported.");
case BindingMode.OneTime:
target.GetObservable(Control.DataContextProperty).Subscribe(dataContext =>
{
subject.Take(1).Subscribe(x => target.SetValue(property, x, Priority));
});
break;
case BindingMode.OneWayToSource:
target.GetObservable(property).Subscribe(subject);
break;
}
}
public IDisposable Bind <T>(PerspexProperty <T> property, IObservable <T> source, BindingPriority priority = BindingPriority.LocalValue)
{
throw new NotImplementedException();
}
public IDisposable Bind(PerspexProperty property, IObservable <object> source, BindingPriority priority)
{
throw new NotImplementedException();
}
public bool IsSet(PerspexProperty property)
{
throw new NotImplementedException();
}
public void SetValue <T>(PerspexProperty <T> property, T value, BindingPriority priority = BindingPriority.LocalValue)
{
throw new NotImplementedException();
}
public void SetValue(PerspexProperty property, object value, BindingPriority priority)
{
throw new NotImplementedException();
}
public T GetValue <T>(PerspexProperty <T> property)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyTransition"/> class.
/// </summary>
/// <param name="property">The property to be animated/</param>
/// <param name="duration">The duration of the animation.</param>
/// <param name="easing">The easing function to use.</param>
public PropertyTransition(PerspexProperty property, TimeSpan duration, IEasing easing)
{
Property = property;
Duration = duration;
Easing = easing;
}
/// <summary>
/// Initializes a new instance of the <see cref="Setter"/> class.
/// </summary>
/// <param name="property">The property to set.</param>
/// <param name="value">The property value.</param>
public Setter(PerspexProperty property, object value)
{
Property = property;
Value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectableMixin"/> class.
/// </summary>
/// <typeparam name="TControl">The control type.</typeparam>
/// <param name="content">The content property.</param>
/// <param name="logicalChildrenSelector">
/// Given an control of <typeparamref name="TControl"/> should return the control's
/// logical children collection.
/// </param>
/// <param name="presenterName">
/// The name of the content presenter in the control's template.
/// </param>
public static void Attach <TControl>(
PerspexProperty content,
Func <TControl, IPerspexList <ILogical> > logicalChildrenSelector,
string presenterName = "PART_ContentPresenter")
where TControl : TemplatedControl
{
Contract.Requires <ArgumentNullException>(content != null);
Contract.Requires <ArgumentNullException>(logicalChildrenSelector != null);
EventHandler <RoutedEventArgs> templateApplied = (s, ev) =>
{
var sender = s as TControl;
if (sender != null)
{
var e = (TemplateAppliedEventArgs)ev;
var presenter = (IControl)e.NameScope.Find(presenterName);
if (presenter != null)
{
presenter.ApplyTemplate();
var logicalChildren = logicalChildrenSelector(sender);
var subscription = presenter
.GetObservableWithHistory(ContentPresenter.ChildProperty)
.Subscribe(child => UpdateLogicalChild(
sender,
logicalChildren,
child.Item1,
child.Item2));
UpdateLogicalChild(
sender,
logicalChildren,
logicalChildren.FirstOrDefault(),
presenter.GetValue(ContentPresenter.ChildProperty));
subscriptions.Value.Add(sender, subscription);
}
}
};
TemplatedControl.TemplateAppliedEvent.AddClassHandler(
typeof(TControl),
templateApplied,
RoutingStrategies.Direct);
content.Changed.Subscribe(e =>
{
var sender = e.Sender as TControl;
if (sender != null)
{
var logicalChildren = logicalChildrenSelector(sender);
UpdateLogicalChild(sender, logicalChildren, e.OldValue, e.NewValue);
}
});
Control.TemplatedParentProperty.Changed.Subscribe(e =>
{
var sender = e.Sender as TControl;
if (sender != null)
{
var logicalChild = logicalChildrenSelector(sender).FirstOrDefault() as IControl;
logicalChild?.SetValue(Control.TemplatedParentProperty, sender.TemplatedParent);
}
});
TemplatedControl.TemplateProperty.Changed.Subscribe(e =>
{
var sender = e.Sender as TControl;
if (sender != null)
{
IDisposable subscription;
if (subscriptions.Value.TryGetValue(sender, out subscription))
{
subscription.Dispose();
subscriptions.Value.Remove(sender);
}
}
});
}
private static bool ApplyBinding(object instance, PerspexProperty property, IBinding binding)
{
if (property != null)
{
((IPerspexObject)instance).Bind(property, binding);
return true;
}
return false;
}
public XamlBinding GetBinding(PerspexObject po, PerspexProperty pp)
{
return this.bindings.First(xamlBinding => xamlBinding.Target == po && xamlBinding.TargetProperty == pp);
}
public void ClearValue(PerspexProperty property)
{
throw new NotImplementedException();
}
public BindingTarget(PerspexObject @object, PerspexProperty property)
{
_obj = @object;
_property = property;
}
public object GetValue(PerspexProperty property)
{
throw new NotImplementedException();
}
public IObservable <T> GetObservable <T>(PerspexProperty <T> property)
{
throw new NotImplementedException();
}
/// <summary>
/// Indicates that a property change should cause <see cref="InvalidateVisual"/> to be
/// called.
/// </summary>
/// <param name="property">The property.</param>
/// <remarks>
/// This method should be called in a control's static constructor for each property
/// on the control which when changed should cause a redraw. This is similar to WPF's
/// FrameworkPropertyMetadata.AffectsRender flag.
/// </remarks>
protected static void AffectsRender(PerspexProperty property)
{
property.Changed.Subscribe(AffectsRenderInvalidate);
}
