/// <summary>Handles cases where a markup extension provides a value for a property of <see cref="T:System.Windows.Setter" /> object.</summary>
/// <param name="targetObject">The object where the markup extension sets the value.</param>
/// <param name="eventArgs">Data that is relevant for markup extension processing.</param>
// Token: 0x0600089C RID: 2204 RVA: 0x0001BFD0 File Offset: 0x0001A1D0
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException("targetObject");
}
if (eventArgs == null)
{
throw new ArgumentNullException("eventArgs");
}
Setter setter = targetObject as Setter;
if (setter == null || eventArgs.Member.Name != "Value")
{
return;
}
MarkupExtension markupExtension = eventArgs.MarkupExtension;
if (markupExtension is StaticResourceExtension)
{
StaticResourceExtension staticResourceExtension = markupExtension as StaticResourceExtension;
setter.Value = staticResourceExtension.ProvideValueInternal(eventArgs.ServiceProvider, true);
eventArgs.Handled = true;
return;
}
if (markupExtension is DynamicResourceExtension || markupExtension is BindingBase)
{
setter.Value = markupExtension;
eventArgs.Handled = true;
}
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException("targetObject");
}
if (eventArgs == null)
{
throw new ArgumentNullException("eventArgs");
}
Setter setter = targetObject as Setter;
if (setter == null || eventArgs.Member.Name != "Value")
{
return;
}
MarkupExtension me = eventArgs.MarkupExtension;
if (me is StaticResourceExtension)
{
var sr = me as StaticResourceExtension;
setter.Value = sr.ProvideValueInternal(eventArgs.ServiceProvider, true /*allowDeferedReference*/);
eventArgs.Handled = true;
}
else if (me is DynamicResourceExtension || me is BindingBase)
{
setter.Value = me;
eventArgs.Handled = true;
}
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
//if (eventArgs.Value.GetType().Name == "TypeConverterMarkupExtension")
//{
// eventArgs.Value.SetFieldValue("_converter", new CustomTimeSpanConverter());
//}
TypeConverterInjectionCore.HandleMarkupExtensionTypeConverterInject(targetObject, eventArgs);
//if (eventArgs.Handled)
// return;
}
/// <summary>Handles cases where a markup extension provides a value for a property of a <see cref="T:System.Windows.Condition" /> object</summary>
/// <param name="targetObject">The object where the markup extension sets the value.</param>
/// <param name="eventArgs">Data that is relevant for markup extension processing.</param>
// Token: 0x0600035A RID: 858 RVA: 0x00009960 File Offset: 0x00007B60
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException("targetObject");
}
if (eventArgs == null)
{
throw new ArgumentNullException("eventArgs");
}
Condition condition = targetObject as Condition;
if (condition != null && eventArgs.Member.Name == "Binding" && eventArgs.MarkupExtension is BindingBase)
{
condition.Binding = (eventArgs.MarkupExtension as BindingBase);
eventArgs.Handled = true;
}
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (eventArgs.MarkupExtension.GetType() != typeof(MyBinding))
{
throw new Exception("Expected a markupExtension that is of type MyBinding, but got one of type:" + eventArgs.MarkupExtension.GetType());
}
MySetter setter = targetObject as MySetter;
if (setter == null)
{
throw new Exception("Expected a MySetter but got one of type:" + targetObject.GetType());
}
setter.Value = eventArgs.MarkupExtension;
eventArgs.Handled = true;
}
/// <summary>Handles cases where a markup extension provides a value for a property of a <see cref="T:System.Windows.DataTrigger" /> object.</summary>
/// <param name="targetObject">The object where the markup extension sets the value.</param>
/// <param name="eventArgs">Data that is relevant for markup extension processing.</param>
// Token: 0x0600039A RID: 922 RVA: 0x0000A564 File Offset: 0x00008764
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException("targetObject");
}
if (eventArgs == null)
{
throw new ArgumentNullException("eventArgs");
}
DataTrigger dataTrigger = targetObject as DataTrigger;
if (dataTrigger != null && eventArgs.Member.Name == "Binding" && eventArgs.MarkupExtension is BindingBase)
{
dataTrigger.Binding = (eventArgs.MarkupExtension as BindingBase);
eventArgs.Handled = true;
return;
}
eventArgs.CallBase();
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException(nameof(targetObject));
}
if (eventArgs == null)
{
throw new ArgumentNullException(nameof(eventArgs));
}
var setter = targetObject as IterativeReaction;
if (setter == null || eventArgs.Member.Name != nameof(IterationTargetPropertyName))
{
return;
}
var markupExtension = eventArgs.MarkupExtension;
if (markupExtension is StaticResourceExtension)
{
var resourceExtension = markupExtension as StaticResourceExtension;
setter.IterationTargetPropertyName = resourceExtension.InvokeInternalMethod <string>(
"ProvideValueInternal", eventArgs.ServiceProvider, true);
eventArgs.Handled = true;
}
else
{
if (!(markupExtension is DynamicResourceExtension) && !(markupExtension is BindingBase))
{
return;
}
throw new NotImplementedException();
//setter.IterationTargetPropertyName = markupExtension;
//eventArgs.Handled = true;
}
}
public static void HandleMarkupExtensionTypeConverterInject(
[NotNull] object targetObject,
[NotNull] XamlSetMarkupExtensionEventArgs eventArgs)
{
targetObject.IsNotNull(nameof(targetObject));
eventArgs.IsNotNull(nameof(eventArgs));
var injectedTypeConverterAttribute = eventArgs
.Member
.UnderlyingMember
.GetCustomAttribute <InjectTypeConverterAttribute>();
if (injectedTypeConverterAttribute != null)
{
var converterType = Type.GetType(
injectedTypeConverterAttribute.AssemblyQualifiedTypeName);
if (converterType == null)
{
throw new TypeLoadException(
$"Type reference cannot be loaded from the assembly qualified type name " +
$"\'{injectedTypeConverterAttribute.AssemblyQualifiedTypeName}\'. The " +
$"TypeConverter type cannot be injected.");
}
var converterInstanceBoxed = converterType
.Reflect()
.CreateInstance(MemberDescriptor.Any);
var converterInstance = converterInstanceBoxed as TypeConverter;
if (converterInstance == null)
{
throw new NotSupportedException(
$"The type \'{converterInstanceBoxed.GetType().Name}\' is not a valid " +
$"type to use in this context. Injected Xaml markup type converters must " +
$"derive from the framework type \'System.ComponentModel.TypeConverter\'.");
}
if (eventArgs.Value.GetType().Name == "TypeConverterMarkupExtension")
{
eventArgs.Value
.Reflect()
.SetFieldValue(MemberDescriptor.Any, "_converter", converterInstance);
eventArgs.Handled = true;
}
var unresolvedValue = eventArgs.Value;
if (eventArgs.Value.GetType().Name == "TypeConverterMarkupExtension")
{
unresolvedValue = eventArgs.Value
.Reflect()
.GetFieldValue(MemberDescriptor.Any, "_value");
}
var convertedValue = converterInstance.ConvertFrom(unresolvedValue);
if (convertedValue == null)
{
throw new NullReferenceException(nameof(convertedValue));
}
var memberInvoker = eventArgs.Member.Invoker;
memberInvoker.SetValue(targetObject, convertedValue);
eventArgs.Handled = true;
}
//if (eventArgs.MarkupExtension is )
}
public static void ReceiveMarkupExtensionDelegate(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
eventArgs.Handled = true;
}
// must be static
public void HandleMarkupExtension(object o, XamlSetMarkupExtensionEventArgs a)
{
}
// must be static
public void HandleMarkupExtension (object o, XamlSetMarkupExtensionEventArgs a)
{
}
public static void HandlePropertySetFromMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
if (targetObject == null)
{
throw new ArgumentNullException(nameof(targetObject));
}
if (eventArgs == null)
{
throw new ArgumentNullException(nameof(eventArgs));
}
var injectedTypeConverterAttributes = eventArgs.Member.UnderlyingMember
.GetCustomAttributes(typeof(InjectTypeConverterAttribute), true)
.OfType <InjectTypeConverterAttribute>()
.ToArray();
if (injectedTypeConverterAttributes.Any())
{
if (injectedTypeConverterAttributes.Length > 1)
{
throw new NotSupportedException("Multiple \'InjectTypeConverterAttribute\' attributes discovered.");
}
var injectedTypeConverterAttribute = injectedTypeConverterAttributes.Single();
var converterType = Type.GetType(injectedTypeConverterAttribute.AssemblyQualifiedTypeName);
if (converterType == null)
{
throw new TypeLoadException("Injected type converter type cannot be resolved.");
}
var constructor = converterType.GetConstructor(new Type[] { });
if (constructor == null)
{
throw new NotSupportedException("Injected type converter constructor must have a parameterless constructor.");
}
var converterTypeInstance = constructor.Invoke(new object[] { });
var converter = converterTypeInstance as TypeConverter;
if (converter == null)
{
throw new Exception($"Type \'{converterTypeInstance.GetType().Name}\' not valid. Must be of type \'TypeConverter\'.");
}
var unresolvedValue = eventArgs.Value;
if (eventArgs.Value.GetType().Name == "TypeConverterMarkupExtension")
{
unresolvedValue = eventArgs.Value.GetFieldValue <object>("_value");
}
var convertedValue = converter.ConvertFrom(unresolvedValue);
if (convertedValue == null)
{
throw new NullReferenceException(nameof(convertedValue));
}
var inv = eventArgs.Member.Invoker;
inv.SetValue(targetObject, convertedValue);
eventArgs.Handled = true;
}
//if (eventArgs.MarkupExtension is )
}
// Token: 0x060064CC RID: 25804 RVA: 0x001C4434 File Offset: 0x001C2634
internal static void CheckCanReceiveMarkupExtension(MarkupExtension markupExtension, IServiceProvider serviceProvider, out DependencyObject targetDependencyObject, out DependencyProperty targetDependencyProperty)
{
targetDependencyObject = null;
targetDependencyProperty = null;
IProvideValueTarget provideValueTarget = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
if (provideValueTarget == null)
{
return;
}
object targetObject = provideValueTarget.TargetObject;
if (targetObject == null)
{
return;
}
Type type = targetObject.GetType();
object targetProperty = provideValueTarget.TargetProperty;
if (targetProperty != null)
{
targetDependencyProperty = (targetProperty as DependencyProperty);
if (targetDependencyProperty != null)
{
targetDependencyObject = (targetObject as DependencyObject);
return;
}
MemberInfo memberInfo = targetProperty as MemberInfo;
if (memberInfo != null)
{
PropertyInfo propertyInfo = memberInfo as PropertyInfo;
EventHandler <XamlSetMarkupExtensionEventArgs> eventHandler = Helper.LookupSetMarkupExtensionHandler(type);
if (eventHandler != null && propertyInfo != null)
{
IXamlSchemaContextProvider xamlSchemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (xamlSchemaContextProvider != null)
{
XamlSchemaContext schemaContext = xamlSchemaContextProvider.SchemaContext;
XamlType xamlType = schemaContext.GetXamlType(type);
if (xamlType != null)
{
XamlMember member = xamlType.GetMember(propertyInfo.Name);
if (member != null)
{
XamlSetMarkupExtensionEventArgs xamlSetMarkupExtensionEventArgs = new XamlSetMarkupExtensionEventArgs(member, markupExtension, serviceProvider);
eventHandler(targetObject, xamlSetMarkupExtensionEventArgs);
if (xamlSetMarkupExtensionEventArgs.Handled)
{
return;
}
}
}
}
}
Type type2;
if (propertyInfo != null)
{
type2 = propertyInfo.PropertyType;
}
else
{
MethodInfo methodInfo = (MethodInfo)memberInfo;
ParameterInfo[] parameters = methodInfo.GetParameters();
type2 = parameters[1].ParameterType;
}
if (!typeof(MarkupExtension).IsAssignableFrom(type2) || !type2.IsAssignableFrom(markupExtension.GetType()))
{
throw new System.Windows.Markup.XamlParseException(SR.Get("MarkupExtensionDynamicOrBindingOnClrProp", new object[]
{
markupExtension.GetType().Name,
memberInfo.Name,
type.Name
}));
}
}
else if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) || !typeof(Collection <BindingBase>).IsAssignableFrom(targetProperty.GetType()))
{
throw new System.Windows.Markup.XamlParseException(SR.Get("MarkupExtensionDynamicOrBindingInCollection", new object[]
{
markupExtension.GetType().Name,
targetProperty.GetType().Name
}));
}
}
else if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) || !typeof(Collection <BindingBase>).IsAssignableFrom(type))
{
throw new System.Windows.Markup.XamlParseException(SR.Get("MarkupExtensionDynamicOrBindingInCollection", new object[]
{
markupExtension.GetType().Name,
type.Name
}));
}
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
}
internal static void HandleBindingSet(object?sender, XamlSetMarkupExtensionEventArgs args)
{
}
public static void ReceiveMarkupExtension(object targetObject, XamlSetMarkupExtensionEventArgs eventArgs)
{
var methodCallReaction = targetObject as MethodCallReaction;
if (methodCallReaction == null)
{
return;
}
eventArgs.ThrowIfNull();
eventArgs.MarkupExtension.ThrowIfNull();
//reactiveSetter.ServiceProvider = eventArgs.ServiceProvider;
if (eventArgs.Member.Name == "TargetObject")
{
// ReSharper disable once CanBeReplacedWithTryCastAndCheckForNull
// ReSharper disable once UseNullPropagation
if (eventArgs.MarkupExtension is Binding)
{
var binding = (Binding)eventArgs.MarkupExtension;
if (binding.RelativeSource != null)
{
// TargetObject is being set to a Binding with a RelativeSource that
// relies on traversing the visual tree.
if (binding.RelativeSource.Mode == RelativeSourceMode.FindAncestor)
{
if (!methodCallReaction.IsAssociated)
{
//reactiveSetter.TargetObject = targetObject as DependencyObject;
methodCallReaction._eventArgs = eventArgs;
methodCallReaction._deferMarkupExtensionResolve = true;
//TODO eventArgs.Handled = true;?
return;
}
methodCallReaction.TargetObject = null;
methodCallReaction._eventArgs = null;
methodCallReaction._deferMarkupExtensionResolve = false;
var frameworkElement = methodCallReaction.AssociatedObject as FrameworkElement;
if (frameworkElement == null)
{
throw new NotSupportedException();
}
var resolvedVisualAncestor = frameworkElement.FindParent(
binding.RelativeSource.AncestorType,
binding.RelativeSource.AncestorLevel);
var adjustedBinding = new Binding
{
Source = resolvedVisualAncestor,
Path = binding.Path
};
BindingOperations.SetBinding(methodCallReaction, TargetObjectProperty, adjustedBinding);
eventArgs.Handled = true;
}
}
}
else if (eventArgs.MarkupExtension is StaticResourceExtension)
{
var staticResourceExtension = (StaticResourceExtension)eventArgs.MarkupExtension;
var effectiveTargetObject = staticResourceExtension.Reflect().Invoke <DependencyObject>(
ReflectionVisibility.InstanceNonPublic,
"ProvideValueInternal",
eventArgs.ServiceProvider, true);
if (effectiveTargetObject == null)
{
throw new NullReferenceException(
"The provided value from the StaticResourceExtension " +
$"\'{eventArgs.MarkupExtension.GetType().Name}\' is null.");
}
methodCallReaction.TargetObject = effectiveTargetObject;
eventArgs.Handled = true;
}
else if (eventArgs.MarkupExtension is DynamicResourceExtension)
{
var dynamicResourceExtension = (DynamicResourceExtension)eventArgs.MarkupExtension;
var effectiveTargetObject = dynamicResourceExtension.Reflect().Invoke <DependencyObject>(
ReflectionVisibility.InstanceNonPublic,
"ProvideValueInternal",
eventArgs.ServiceProvider, true);
if (effectiveTargetObject == null)
{
throw new NullReferenceException(
"The provided value from the DynamicResourceExtension " +
$"\'{eventArgs.MarkupExtension.GetType().Name}\' is null.");
}
methodCallReaction.TargetObject = effectiveTargetObject;
eventArgs.Handled = true;
}
else
{
var effectiveTargetObject = eventArgs.MarkupExtension.Reflect().Invoke <DependencyObject>(
ReflectionVisibility.InstanceNonPublic,
"ProvideValueInternal", eventArgs.ServiceProvider, true);
if (effectiveTargetObject == null)
{
throw new NotSupportedException(
"The provided value from the MarkupExtension " +
$"\'{eventArgs.MarkupExtension.GetType().Name}\' is null.");
}
methodCallReaction.TargetObject = effectiveTargetObject;
eventArgs.Handled = true;
}
}
}
internal static void CheckCanReceiveMarkupExtension(MarkupExtension markupExtension, IServiceProvider serviceProvider, out DependencyObject targetDependencyObject, out DependencyProperty targetDependencyProperty)
{
targetDependencyObject = null;
targetDependencyProperty = null;
var provideValueTarget = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
if (provideValueTarget == null)
{
return;
}
var targetObject = provideValueTarget.TargetObject;
if (targetObject == null)
{
return;
}
var type = targetObject.GetType();
var targetProperty = provideValueTarget.TargetProperty;
if (targetProperty != null)
{
targetDependencyProperty = targetProperty as DependencyProperty;
if (targetDependencyProperty != null)
{
targetDependencyObject = targetObject as DependencyObject;
}
else
{
var memberInfo = targetProperty as MemberInfo;
if (memberInfo != null)
{
var propertyInfo = memberInfo as PropertyInfo;
EventHandler <XamlSetMarkupExtensionEventArgs> eventHandler = LookupSetMarkupExtensionHandler(type);
if (eventHandler != null && propertyInfo != null)
{
var schemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (schemaContextProvider != null)
{
var xamlType = schemaContextProvider.SchemaContext.GetXamlType(type);
if (xamlType != null)
{
var member = xamlType.GetMember(propertyInfo.Name);
if (member != null)
{
var e = new XamlSetMarkupExtensionEventArgs(member, markupExtension, serviceProvider);
eventHandler(targetObject, e);
if (e.Handled)
{
return;
}
}
}
}
}
var c = !(propertyInfo != null) ? ((MethodBase)memberInfo).GetParameters()[1].ParameterType : propertyInfo.PropertyType;
if (!typeof(MarkupExtension).IsAssignableFrom(c) || !c.IsAssignableFrom(markupExtension.GetType()))
{
throw new System.Windows.Markup.XamlParseException(__SR.Get("MarkupExtensionDynamicOrBindingOnClrProp",
markupExtension.GetType().Name, memberInfo.Name, type.Name));
}
}
else if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) || !typeof(Collection <BindingBase>).IsAssignableFrom(targetProperty.GetType()))
{
throw new System.Windows.Markup.XamlParseException(__SR.Get("MarkupExtensionDynamicOrBindingInCollection",
markupExtension.GetType().Name, targetProperty.GetType().Name));
}
}
}
else if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) || !typeof(Collection <BindingBase>).IsAssignableFrom(type))
{
throw new System.Windows.Markup.XamlParseException(__SR.Get("MarkupExtensionDynamicOrBindingInCollection",
markupExtension.GetType().Name, type.Name));
}
}
