/// <summary>
/// Sets the value of a dependency property on <paramref name="targetObject"/> using a markup extension.
/// </summary>
/// <remarks>This method does not support markup extensions like x:Static that depend on
/// having a XAML file as context.</remarks>
public static void SetValueToExtension(this DependencyObject targetObject, DependencyProperty property, MarkupExtension markupExtension)
{
if (targetObject == null)
throw new ArgumentNullException("targetObject");
if (property == null)
throw new ArgumentNullException("property");
if (markupExtension == null)
throw new ArgumentNullException("markupExtension");
var serviceProvider = new SetValueToExtensionServiceProvider(targetObject, property);
targetObject.SetValue(property, markupExtension.ProvideValue(serviceProvider));
}
/// <summary>
/// Sets the value of a dependency property on <paramref name="targetObject"/> using a markup extension.
/// </summary>
/// <remarks>This method does not support markup extensions like x:Static that depend on
/// having a XAML file as context.</remarks>
public static void SetValueToExtension(this DependencyObject targetObject, DependencyProperty property, MarkupExtension markupExtension) {
// This method was copied from ICSharpCode.Core.Presentation (with permission to switch license to X11)
if (targetObject == null)
throw new ArgumentNullException("targetObject");
if (property == null)
throw new ArgumentNullException("property");
if (markupExtension == null)
throw new ArgumentNullException("markupExtension");
var serviceProvider = new SetValueToExtensionServiceProvider(targetObject, property);
targetObject.SetValue(property, markupExtension.ProvideValue(serviceProvider));
}
public override object CallProvideValue(XAML3.MarkupExtension me, IServiceProvider serviceProvider)
{
try
{
object val = me.ProvideValue(serviceProvider);
return(val);
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
throw CreateException(SR.Get(SRID.ProvideValue, me.GetType()), e);
}
}
private object Logic_PushAndPopAProvideValueStackFrame(ObjectWriterContext ctx, XamlMember prop, MarkupExtension me, bool useIRME)
{
XamlMember currentProperty = ctx.CurrentProperty;
ctx.CurrentProperty = prop;
ctx.PushScope();
ctx.CurrentInstance = me;
object obj2 = null;
if (useIRME)
{
this.Logic_AssignProvidedValue(ctx);
}
else
{
obj2 = this.Runtime.CallProvideValue(me, ctx.ServiceProviderContext);
}
ctx.PopScope();
ctx.CurrentProperty = currentProperty;
return obj2;
}
public XamlSetMarkupExtensionEventArgs (XamlMember member, MarkupExtension value, IServiceProvider serviceProvider)
: base (member, null)
{
MarkupExtension = value;
ServiceProvider = serviceProvider;
}
internal XamlSetMarkupExtensionEventArgs(XamlMember member,
MarkupExtension value, IServiceProvider serviceProvider, object targetObject)
: this(member, value, serviceProvider)
{
TargetObject = targetObject;
}
public XamlSetMarkupExtensionEventArgs(XamlMember member,
MarkupExtension value, IServiceProvider serviceProvider) :
base(member, value)
{
ServiceProvider = serviceProvider;
}
/// <summary>
/// Checks if the given IProvideValueTarget can receive
/// a DynamicResource or Binding MarkupExtension.
/// </summary>
internal static void CheckCanReceiveMarkupExtension(
MarkupExtension markupExtension,
IProvideValueTarget provideValueTarget,
out DependencyObject targetDependencyObject,
out DependencyProperty targetDependencyProperty)
{
targetDependencyObject = null;
targetDependencyProperty = null;
if (provideValueTarget == null)
{
return;
}
object targetObject = provideValueTarget.TargetObject;
if (targetObject == null)
{
return;
}
Type targetType = targetObject.GetType();
object targetProperty = provideValueTarget.TargetProperty;
if (targetProperty != null)
{
targetDependencyProperty = targetProperty as DependencyProperty;
if (targetDependencyProperty != null)
{
// This is the DependencyProperty case
targetDependencyObject = targetObject as DependencyObject;
Debug.Assert(targetDependencyObject != null, "DependencyProperties can only be set on DependencyObjects");
}
else
{
MemberInfo targetMember = targetProperty as MemberInfo;
if (targetMember != null)
{
// This is the Clr Property case
// Setters, Triggers, DataTriggers & Conditions are the special cases of
// Clr properties where DynamicResource & Bindings are allowed. However
// StyleHelper.ProcessSharedPropertyValue avoids a call to ProvideValue
// in these cases and so there is no need for special code to handle them here.
// Find the MemberType
Debug.Assert(targetMember is PropertyInfo || targetMember is MethodInfo,
"TargetMember is either a Clr property or an attached static settor method");
Type memberType;
PropertyInfo propertyInfo = targetMember as PropertyInfo;
if (propertyInfo != null)
{
memberType = propertyInfo.PropertyType;
}
else
{
MethodInfo methodInfo = (MethodInfo)targetMember;
ParameterInfo[] parameterInfos = methodInfo.GetParameters();
Debug.Assert(parameterInfos.Length == 2, "The signature of a static settor must contain two parameters");
memberType = parameterInfos[1].ParameterType;
}
// Check if the MarkupExtensionType is assignable to the given MemberType
// This check is to allow properties such as the following
// - DataTrigger.Binding
// - Condition.Binding
// - HierarchicalDataTemplate.ItemsSource
// - GridViewColumn.DisplayMemberBinding
if (!typeof(MarkupExtension).IsAssignableFrom(memberType) ||
!memberType.IsAssignableFrom(markupExtension.GetType()))
{
throw new XamlParseException(SR.Get(SRID.MarkupExtensionDynamicOrBindingOnClrProp,
markupExtension.GetType().Name,
targetMember.Name,
targetType.Name));
}
}
else
{
// This is the Collection ContentProperty case
// Example:
// <DockPanel>
// <Button />
// <DynamicResource ResourceKey="foo" />
// </DockPanel>
// Collection<BindingBase> used in MultiBinding is a special
// case of a Collection that can contain a Binding.
if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) ||
!typeof(Collection<BindingBase>).IsAssignableFrom(targetProperty.GetType()))
{
throw new XamlParseException(SR.Get(SRID.MarkupExtensionDynamicOrBindingInCollection,
markupExtension.GetType().Name,
targetProperty.GetType().Name));
}
}
}
}
else
{
// This is the explicit Collection Property case
// Example:
// <DockPanel>
// <DockPanel.Children>
// <Button />
// <DynamicResource ResourceKey="foo" />
// </DockPanel.Children>
// </DockPanel>
// Collection<BindingBase> used in MultiBinding is a special
// case of a Collection that can contain a Binding.
if (!typeof(BindingBase).IsAssignableFrom(markupExtension.GetType()) ||
!typeof(Collection<BindingBase>).IsAssignableFrom(targetType))
{
throw new XamlParseException(SR.Get(SRID.MarkupExtensionDynamicOrBindingInCollection,
markupExtension.GetType().Name,
targetType.Name));
}
}
}
//+-----------------------------------------------------------------------------------------------------------------------
//
// ProvideValueFromMarkupExtension
//
// Given a MarkupExtension, call its ProvideValue, passing it the right IServiceProvider.
//
//+------------------------------------------------------------------------------------------------------------------------
internal object ProvideValueFromMarkupExtension(MarkupExtension markupExtension, object obj, object member)
{
object returnValue = null;
// Get the IServiceProvider
ProvideValueServiceProvider serviceProvider = ParserContext.ProvideValueProvider;
// Let it know the target object & property
serviceProvider.SetData(obj, member);
try
{
returnValue = markupExtension.ProvideValue(serviceProvider);
if( TraceMarkup.IsEnabled )
{
TraceMarkup.TraceActivityItem(
TraceMarkup.ProvideValue,
markupExtension,
obj,
member,
returnValue );
}
}
finally
{
serviceProvider.ClearData();
}
return returnValue;
}
public XamlSetMarkupExtensionEventArgs(XamlMember member,
MarkupExtension value, IServiceProvider serviceProvider) :
this(member, (IMarkupExtension)value, serviceProvider)
{
ServiceProvider = serviceProvider;
}
public override object CallProvideValue(System.Windows.Markup.MarkupExtension me, IServiceProvider serviceProvider)
{
// Once the ME is instantiated, invocation is always a public method call
return(_transparentRuntime.CallProvideValue(me, serviceProvider));
}
