/// <summary>
/// Register an attached dependency / bindable property
/// </summary>
/// <param name="name">The property name</param>
/// <param name="propertyType">The property type</param>
/// <param name="ownerType">The owner type</param>
/// <param name="defaultValue">The default value</param>
/// <param name="propertyChangedCallback">Callback to executed on property changed</param>
/// <returns>The registred attached dependecy property</returns>
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, object defaultValue = null, PropertyChangedCallback propertyChangedCallback = null)
{
#if XFORMS
return(DependencyProperty.CreateAttached(name, propertyType, ownerType, defaultValue, propertyChanged: (obj, oldValue, newValue) => {
if (propertyChangedCallback != null)
{
propertyChangedCallback(obj, new DependencyPropertyChangedEventArgs(newValue, oldValue, null));
}
}));
#else
return(DependencyProperty.RegisterAttached(name, propertyType, ownerType, new PropertyMetadata(defaultValue, propertyChangedCallback)));
#endif
}
/// <summary>
/// Applies the binding expression to a previously set source or target.
/// </summary>
void ApplyCore(object sourceObject, BindableObject target, BindableProperty property, bool fromTarget = false)
{
BindingMode mode = Binding.GetRealizedMode(_targetProperty);
if ((mode == BindingMode.OneWay || mode == BindingMode.OneTime) && fromTarget)
{
return;
}
bool needsGetter = (mode == BindingMode.TwoWay && !fromTarget) || mode == BindingMode.OneWay || mode == BindingMode.OneTime;
bool needsSetter = !needsGetter && ((mode == BindingMode.TwoWay && fromTarget) || mode == BindingMode.OneWayToSource);
object current = sourceObject;
object previous = null;
BindingExpressionPart part = null;
for (var i = 0; i < _parts.Count; i++)
{
part = _parts[i];
bool isLast = i + 1 == _parts.Count;
if (!part.IsSelf && current != null)
{
// Allow the object instance itself to provide its own TypeInfo
TypeInfo currentType = current is IReflectableType reflectable?reflectable.GetTypeInfo() : current.GetType().GetTypeInfo();
if (part.LastGetter == null || !part.LastGetter.DeclaringType.GetTypeInfo().IsAssignableFrom(currentType))
{
SetupPart(currentType, part);
}
if (!isLast)
{
part.TryGetValue(current, out current);
}
}
if (!part.IsSelf &&
current != null &&
((needsGetter && part.LastGetter == null) ||
(needsSetter && part.NextPart == null && part.LastSetter == null)))
{
Log.Warning("Binding", PropertyNotFoundErrorMessage, part.Content, current, target.GetType(), property.PropertyName);
break;
}
if (part.NextPart != null && (mode == BindingMode.OneWay || mode == BindingMode.TwoWay) &&
current is INotifyPropertyChanged inpc)
{
part.Subscribe(inpc);
}
previous = current;
}
Debug.Assert(part != null, "There should always be at least the self part in the expression.");
if (needsGetter)
{
object value = property.DefaultValue;
if (part.TryGetValue(current, out value) || part.IsSelf)
{
value = Binding.GetSourceValue(value, property.ReturnType);
}
else
{
value = Binding.FallbackValue ?? property.GetDefaultValue(target);
}
if (!TryConvert(ref value, property, property.ReturnType, true))
{
Log.Warning("Binding", "{0} can not be converted to type '{1}'", value, property.ReturnType);
return;
}
target.SetValueCore(property, value, SetValueFlags.ClearDynamicResource, BindableObject.SetValuePrivateFlags.Default | BindableObject.SetValuePrivateFlags.Converted);
}
else if (needsSetter && part.LastSetter != null && current != null)
{
object value = Binding.GetTargetValue(target.GetValue(property), part.SetterType);
if (!TryConvert(ref value, property, part.SetterType, false))
{
Log.Warning("Binding", "{0} can not be converted to type '{1}'", value, part.SetterType);
return;
}
object[] args;
if (part.IsIndexer)
{
args = new object[part.Arguments.Length + 1];
part.Arguments.CopyTo(args, 0);
args[args.Length - 1] = value;
}
else if (part.IsBindablePropertySetter)
{
args = new[] { part.BindablePropertyField, value };
}
else
{
args = new[] { value };
}
part.LastSetter.Invoke(current, args);
}
}
internal void SubscribeToTemplatedParentChanges(Element target, BindableProperty targetProperty)
{
_targetProperty = targetProperty;
target.TemplatedParentChanged += OnTargetTemplatedParentChanged;
_trackingTemplatedParent = true;
}
public BindingCondition()
{
_boundProperty = BindableProperty.CreateAttached("Bound", typeof(object), typeof(DataTrigger), null, propertyChanged: OnBoundPropertyChanged);
}
