/// <summary>
/// Applies a binding subject to a property on an instance.
/// </summary>
/// <param name="target">The target instance.</param>
/// <param name="property">The target property.</param>
/// <param name="subject">The binding subject.</param>
internal void Bind(IPerspexObject target, PerspexProperty property, ISubject <object> subject)
{
var mode = Mode == BindingMode.Default ?
property.GetMetadata(target.GetType()).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;
}
}
private ExpressionObserver CreateDataContexObserver(
IPerspexObject target,
string path,
bool targetIsDataContext)
{
Contract.Requires <ArgumentNullException>(target != null);
if (!targetIsDataContext)
{
var update = target.GetObservable(Control.DataContextProperty)
.Skip(1)
.Select(_ => Unit.Default);
var result = new ExpressionObserver(
() => target.GetValue(Control.DataContextProperty),
path,
update);
return(result);
}
else
{
return(new ExpressionObserver(
target.GetObservable(Visual.VisualParentProperty)
.OfType <IPerspexObject>()
.Select(x => x.GetObservable(Control.DataContextProperty))
.Switch(),
path));
}
}
/// <summary>
/// Binds a property to a subject according to a <see cref="BindingMode"/>.
/// </summary>
/// <param name="o">The object.</param>
/// <param name="property">The property to bind.</param>
/// <param name="source">The binding source.</param>
/// <param name="mode">The binding mode.</param>
/// <param name="priority">The binding priority.</param>
/// <returns>An <see cref="IDisposable"/> which can be used to cancel the binding.</returns>
public static IDisposable Bind(
this IPerspexObject o,
PerspexProperty property,
ISubject <object> source,
BindingMode mode,
BindingPriority priority = BindingPriority.LocalValue)
{
Contract.Requires <ArgumentNullException>(o != null);
Contract.Requires <ArgumentNullException>(property != null);
Contract.Requires <ArgumentNullException>(source != null);
switch (mode)
{
case BindingMode.Default:
case BindingMode.OneWay:
return(o.Bind(property, source, priority));
case BindingMode.TwoWay:
return(new CompositeDisposable(
o.Bind(property, source, priority),
o.GetObservable(property).Subscribe(source)));
case BindingMode.OneTime:
return(source.Take(1).Subscribe(x => o.SetValue(property, x, priority)));
case BindingMode.OneWayToSource:
return(o.GetObservable(property).Subscribe(source));
default:
throw new ArgumentException("Invalid binding mode.");
}
}
/// <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.");
}
}
/// <summary>
/// Gets an observable for a <see cref="PerspexProperty"/>.
/// </summary>
/// <param name="o">The object.</param>
/// <typeparam name="T">The property type.</typeparam>
/// <param name="property">The property.</param>
/// <returns>An observable.</returns>
public static IObservable <T> GetObservable <T>(this IPerspexObject o, PerspexProperty <T> property)
{
Contract.Requires <ArgumentNullException>(o != null);
Contract.Requires <ArgumentNullException>(property != null);
return(o.GetObservable((PerspexProperty)property).Cast <T>());
}
private ExpressionObserver CreateDataContexObserver(
IPerspexObject target,
string path,
bool targetIsDataContext,
object anchor)
{
Contract.Requires <ArgumentNullException>(target != null);
if (!(target is IControl))
{
target = anchor as IControl;
if (target == null)
{
throw new InvalidOperationException("Cannot find a DataContext to bind to.");
}
}
if (!targetIsDataContext)
{
var update = target.GetObservable(Control.DataContextProperty)
.Skip(1)
.Select(_ => Unit.Default);
var result = new ExpressionObserver(
() => target.GetValue(Control.DataContextProperty),
path,
update);
return(result);
}
else
{
return(new ExpressionObserver(
target.GetObservable(Visual.VisualParentProperty)
.OfType <IPerspexObject>()
.Select(x => x.GetObservable(Control.DataContextProperty))
.Switch(),
path));
}
}
private ExpressionObserver CreateTemplatedParentObserver(
IPerspexObject target,
string path)
{
Contract.Requires <ArgumentNullException>(target != null);
var update = target.GetObservable(Control.TemplatedParentProperty)
.Skip(1)
.Select(_ => Unit.Default);
var result = new ExpressionObserver(
() => target.GetValue(Control.TemplatedParentProperty),
path,
update);
return(result);
}
/// <summary>
/// Gets a subject for a <see cref="PerspexProperty"/>.
/// </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 IPerspexObject o,
PerspexProperty <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);
}
private ExpressionObserver CreateTemplatedParentObserver(
IPerspexObject target,
string path)
{
Contract.Requires<ArgumentNullException>(target != null);
var update = target.GetObservable(Control.TemplatedParentProperty)
.Skip(1)
.Select(_ => Unit.Default);
var result = new ExpressionObserver(
() => target.GetValue(Control.TemplatedParentProperty),
path,
update);
return result;
}
private ExpressionObserver CreateDataContexObserver(
IPerspexObject target,
string path,
bool targetIsDataContext)
{
Contract.Requires<ArgumentNullException>(target != null);
if (!targetIsDataContext)
{
var update = target.GetObservable(Control.DataContextProperty)
.Skip(1)
.Select(_ => Unit.Default);
var result = new ExpressionObserver(
() => target.GetValue(Control.DataContextProperty),
path,
update);
return result;
}
else
{
return new ExpressionObserver(
target.GetObservable(Visual.VisualParentProperty)
.OfType<IPerspexObject>()
.Select(x => x.GetObservable(Control.DataContextProperty))
.Switch(),
path);
}
}
/// <summary>
/// Applies a binding subject to a property on an instance.
/// </summary>
/// <param name="target">The target instance.</param>
/// <param name="property">The target property.</param>
/// <param name="subject">The binding subject.</param>
internal void Bind(IPerspexObject 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;
}
}
