public override void Apply(IStyledElement control)
{
try
{
Property.SetValue(control, Value(control));
}
catch (Exception e)
{
Logger.TryGet(LogEventLevel.Error, LogArea.Property)?.Log(
control,
"Error setting {Property} on {Target}: {Exception}",
Property.Name,
control,
e);
}
}
private ExpressionObserver CreateElementObserver(
IStyledElement target,
string elementName,
string path,
bool enableDataValidation)
{
Contract.Requires <ArgumentNullException>(target != null);
var description = $"#{elementName}.{path}";
var result = new ExpressionObserver(
ControlLocator.Track(target, elementName),
path,
enableDataValidation,
description);
return(result);
}
protected ExpressionObserver CreateElementObserver(
IStyledElement target,
string elementName,
ExpressionNode node)
{
_ = target ?? throw new ArgumentNullException(nameof(target));
if (NameScope is null || !NameScope.TryGetTarget(out var scope) || scope is null)
{
throw new InvalidOperationException("Name scope is null or was already collected");
}
var result = new ExpressionObserver(
NameScopeLocator.Track(scope, elementName),
node,
null);
return(result);
}
protected ExpressionObserver CreateElementObserver(
IStyledElement target,
string elementName,
ExpressionNode node)
{
Contract.Requires <ArgumentNullException>(target != null);
NameScope.TryGetTarget(out var scope);
if (scope == null)
{
throw new InvalidOperationException("Name scope is null or was already collected");
}
var result = new ExpressionObserver(
NameScopeLocator.Track(scope, elementName),
node,
null);
return(result);
}
/// <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(IStyledElement target, AvaloniaProperty property, IBinding binding)
{
if (target.IsInitialized)
{
target.Bind(property, binding);
}
else
{
if (!_entries.TryGetValue(target, out List <Entry> bindings))
{
bindings = new List <Entry>();
_entries.Add(target, bindings);
// TODO: Make this a weak event listener.
target.Initialized += ApplyBindings;
}
bindings.Add(new BindingEntry(property, binding));
}
}
/// <summary>
/// Adds a delayed value to a control.
/// </summary>
/// <param name="target">The control.</param>
/// <param name="property">The property on the control to bind to.</param>
/// <param name="value">A function which returns the value.</param>
public static void Add(IStyledElement target, PropertyInfo property, Func <IStyledElement, object> value)
{
if (target.IsInitialized)
{
property.SetValue(target, value(target));
}
else
{
if (!_entries.TryGetValue(target, out var bindings))
{
bindings = new List <Entry>();
_entries.Add(target, bindings);
// TODO: Make this a weak event listener.
target.Initialized += ApplyBindings;
}
bindings.Add(new ClrPropertyValueEntry(property, value));
}
}
public void SanityCheck()
{
var child = new Control();
var parent = new Decorator();
var grandParent = new Border();
var grandParent2 = new Border();
IStyledElement currentParent = null;
var subscription = AncestorFinder.Create(child, typeof(Border)).Subscribe(s => currentParent = s);
Assert.Null(currentParent);
parent.Child = child;
Assert.Null(currentParent);
grandParent.Child = parent;
Assert.Equal(grandParent, currentParent);
grandParent.Child = null;
grandParent2.Child = parent;
Assert.Equal(grandParent2, currentParent);
subscription.Dispose();
parent.Child = null;
Assert.Equal(grandParent2, currentParent);
}
private ExpressionObserver CreateFindAncestorObserver(
IStyledElement target,
RelativeSource relativeSource,
string path,
bool enableDataValidation)
{
Contract.Requires <ArgumentNullException>(target != null);
IObservable <object> controlLocator;
switch (relativeSource.Tree)
{
case TreeType.Logical:
controlLocator = ControlLocator.Track(
(ILogical)target,
relativeSource.AncestorLevel - 1,
relativeSource.AncestorType);
break;
case TreeType.Visual:
controlLocator = VisualLocator.Track(
(IVisual)target,
relativeSource.AncestorLevel - 1,
relativeSource.AncestorType);
break;
default:
throw new InvalidOperationException("Invalid tree to traverse.");
}
return(ExpressionObserverBuilder.Build(
controlLocator,
path,
enableDataValidation,
typeResolver: TypeResolver));
}
private object GetValue(IStyledElement control, Type targetType)
{
return(ColorToBrushConverter.Convert(control.FindResource(ResourceKey), targetType));
}
public override void Apply(IStyledElement control)
{
control.Bind(Property, Binding);
}
public abstract void Apply(IStyledElement control);
private object GetValue(IStyledElement control)
{
return(control.FindResource(ResourceKey));
}
public ResourceObservable(IStyledElement target, object key)
{
_target = target;
_key = key;
}
public static void SetClasses(IStyledElement element, Classes value)
{
element.SetValue(ClassesProperty, value);
OnClassesChanged(element, value);
}
public static Classes GetClasses(IStyledElement element)
{
return(element.GetValue(ClassesProperty));
}
/// <summary>
/// Style
/// </summary>
/// <param name="element"></param>
/// <param name="value"></param>
public static void SetStyle(IStyledElement element, IStyle value)
{
element.SetValue(StyleProperty, value);
OnStyleChanged(element, value);
}
/// <summary>
/// Style
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public static IStyle GetStyle(IStyledElement element)
{
return(element.GetValue(StyleProperty));
}
public BaseItem InsertText(string text, BaseItem afterElement, bool replace)
{
BaseItem lastElement = null;
if (!(afterElement is Paragraph paragraph))
{
paragraph = (Paragraph)Service.GetParent(afterElement, typeof(Paragraph));
}
if (paragraph == null)
{
return(null);
}
IStyledElement s = GetStyle(afterElement);
string[] split = text.Split(new string[] { "\n" }, StringSplitOptions.None);
if (split.Length == 0)
{
return(null);
}
text = split[0];
if (split.Length > 1)
{
Service.SeparateItem(paragraph, afterElement);
Paragraph pp = paragraph;
for (int i = 1; i < split.Length; i++)
{
Paragraph p = (Paragraph)pp.Clone();
if (s.Style is ParagraphStyle)
{
p.Style = s.Style as ParagraphStyle;
}
else
{
p.Style = new ParagraphStyle(this)
{
ParentStyleName = ((DefaultStyle)s.Style).Name
};
}
p.Clear();
List <BaseItem> list = ParseText(afterElement, split[i]);
foreach (BaseItem bi in list)
{
lastElement = bi;
p.Add(lastElement);
}
paragraph.Owner.InsertAfter(pp, p);
pp = p;
}
}
List <BaseItem> toReplace = ParseText(afterElement, text);
for (int i = 0; i < toReplace.Count; i++)
{
BaseItem bi = toReplace[i];
if (lastElement == null)
{
lastElement = bi;
}
if (afterElement != paragraph)
{
if (replace && i == 0)
{
afterElement.Owner.Replace(afterElement, bi);
}
else
{
afterElement.Owner.InsertAfter(afterElement, bi);
}
afterElement = bi;
}
else
{
paragraph.Add(bi);
}
}
return(lastElement);
}
public ResourceObservable(IStyledElement target, object key, Func <object?, object?>?converter)
{
_target = target;
_key = key;
_converter = converter;
}
public FinderNode(IStyledElement control, Type ancestorType)
{
_control = control;
_ancestorType = ancestorType;
}
private void OnChildValueChanged(IStyledElement control) => _subject.OnNext(control);
public static IDisposable BindClass(this IStyledElement target, string className, IBinding source, object anchor) => ClassBindingManager.Bind(target, className, source, anchor);
public static IObservable <T?> Create <T>(IStyledElement control)
where T : IStyledElement
{
return(Create(control, typeof(T)).Select(x => (T?)x));
}
public static IObservable <T> Create <T>(IStyledElement control)
where T : IStyledElement
{
return(Create(control, typeof(T)).Cast <T>());
}
