void ISupportInitialize.EndInit()
{
if (this.propertyName != null)
{
if (this.TargetName == null)
{
this.Property = DependencyPropertyConverter.Resolve(this.serviceProvider, this.propertyName);
}
else
{
// TargetName is specified so we need to look in the containing template for the named element
IAmbientProvider ambient = (IAmbientProvider)this.serviceProvider.GetService(typeof(IAmbientProvider));
IXamlSchemaContextProvider schema = (IXamlSchemaContextProvider)this.serviceProvider.GetService(typeof(IXamlSchemaContextProvider));
// Look up the FrameworkTemplate.Template property in the xaml schema.
XamlType frameworkTemplateType = schema.SchemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlMember templateProperty = frameworkTemplateType.GetMember("Template");
// Get the value of the first ambient FrameworkTemplate.Template property.
TemplateContent templateContent = (TemplateContent)ambient.GetFirstAmbientValue(new[] { frameworkTemplateType }, templateProperty).Value;
// Look in the template for the type of TargetName.
Type targetType = templateContent.GetTypeForName(this.TargetName);
// Finally, find the dependency property on the type.
this.Property = DependencyObject.GetPropertyFromName(targetType, this.propertyName);
}
}
}
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object value)
{
String s = value as string;
if (null == s)
{
throw new ArgumentException("XAML can only convert from Strings");
}
ColorElement2 e = new ColorElement2();
IXamlSchemaContextProvider schemaContextProvider = (IXamlSchemaContextProvider)typeDescriptorContext.GetService(typeof(IXamlSchemaContextProvider));
IAmbientProvider iAmbient = (IAmbientProvider)typeDescriptorContext.GetService(typeof(IAmbientProvider));
XamlType ambientLabel = schemaContextProvider.SchemaContext.GetXamlType(typeof(DerivedFromHasAmbientLabel));
XamlMember label = ambientLabel.GetMember("Num");
AmbientPropertyValue apVal = iAmbient.GetFirstAmbientValue(null, label);
if (apVal == null)
{
e.ColorName = s;
}
else
{
e.ColorName = s + "-" + apVal.Value.ToString();
}
return(e);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
XamlSchemaContext xsc = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider).SchemaContext;
IAmbientProvider ambient = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
return((ambient.GetFirstAmbientValue(xsc.GetXamlType(typeof(AmbientType))) as AmbientType).Prop1);
}
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object value)
{
string s = value as string;
if (null == s)
{
throw new ArgumentException("XAML can only convert from Strings");
}
AmbientTC atc = new AmbientTC();
IXamlSchemaContextProvider xscProvider = (IXamlSchemaContextProvider)typeDescriptorContext.GetService(typeof(IXamlSchemaContextProvider));
IAmbientProvider iAmbient = (IAmbientProvider)typeDescriptorContext.GetService(typeof(IAmbientProvider));
XamlType ambientSP = xscProvider.SchemaContext.GetXamlType(typeof(FooAmbient));
XamlMember textProp = ambientSP.GetMember("AmbientTC");
AmbientPropertyValue ambientPropVal = iAmbient.GetFirstAmbientValue(null, textProp);
if (ambientPropVal == null)
{
atc.Text = s;
}
else
{
atc.Text = s + "-" + (ambientPropVal.Value as string);
}
return(atc);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IAmbientProvider ambient = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
ambient.GetAllAmbientValues(null);
return(new object());
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IXamlSchemaContextProvider service = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
IAmbientProvider provider = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
Debug.Assert(provider != null, "The provider should not be null!");
XamlSchemaContext schemaContext = service.SchemaContext;
XamlType[] types = new XamlType [] { schemaContext.GetXamlType(typeof(ResourcesDict)) };
// ResourceDict is marked as Ambient, so the instance current being deserialized should be in this list.
List <AmbientPropertyValue> list = provider.GetAllAmbientValues(null, false, types) as List <AmbientPropertyValue>;
if (list.Count != 1)
{
throw new Exception("expected ambient property count == 1 but " + list.Count);
}
AmbientPropertyValue value = list [0];
ResourcesDict dict = value.Value as ResourcesDict;
// For this example, we know that dict should not be null and that it is the only value in list.
object result = dict [this.Key];
return(result);
}
internal static object GetRootTemplatedActivity(IServiceProvider serviceProvider)
{
IRootObjectProvider service = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (service == null)
{
return(null);
}
IAmbientProvider provider2 = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (provider2 == null)
{
return(null);
}
IXamlSchemaContextProvider provider3 = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (provider3 == null)
{
return(null);
}
XamlMember member = GetXamlMember(provider3.SchemaContext, typeof(Activity), "Implementation");
XamlMember member2 = GetXamlMember(provider3.SchemaContext, typeof(DynamicActivity), "Implementation");
if ((member == null) || (member2 == null))
{
return(null);
}
if (provider2.GetFirstAmbientValue(null, new XamlMember[] { member, member2 }) == null)
{
return(null);
}
return(service.RootObject as Activity);
}
private AvaloniaXamlObjectWriter(
XamlSchemaContext schemaContext,
XamlObjectWriterSettings settings,
AvaloniaNameScope nameScope,
IAmbientProvider parentAmbientProvider)
: base(schemaContext, settings, parentAmbientProvider)
{
_nameScope = nameScope;
}
void Initialize(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider, IXamlObjectWriterFactory objectWriterFactory)
{
prefix_lookup = prefixLookup ?? throw new ArgumentNullException("prefixLookup");
sctx = schemaContext ?? throw new ArgumentNullException("schemaContext");
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
this.objectWriterFactory = objectWriterFactory;
}
public XamlObjectWriterInternal(
XamlObjectWriter source, XamlSchemaContext schemaContext,
XamlWriterStateManager manager, IAmbientProvider parentAmbientProvider)
: base(schemaContext, manager, parentAmbientProvider)
{
this.source = source;
var ext = source.Settings.ExternalNameScope;
name_scope = ext != null && source.Settings.RegisterNamesOnExternalNamescope ? ext : new NameScope(ext);
}
public ValueSerializerContext (PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider)
{
if (prefixLookup == null)
throw new ArgumentNullException ("prefixLookup");
if (schemaContext == null)
throw new ArgumentNullException ("schemaContext");
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver (prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver (namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
}
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object value)
{
String s = value as string;
if (String.IsNullOrEmpty(s))
{
throw new ArgumentException("XAML can only convert from Strings");
}
int dashIdx = s.IndexOf('-');
string color = s;
string colorType = String.Empty;
if (dashIdx > 1)
{
color = s.Substring(0, dashIdx);
colorType = s.Substring(dashIdx + 1);
}
ColorElement e = null;
if (colorType == "Duel")
{
e = new ColorElementDuel();
e.ColorName = color;
return(e);
}
else
{
e = new ColorElement();
}
IXamlSchemaContextProvider schemaContextProvider = (IXamlSchemaContextProvider)typeDescriptorContext.GetService(typeof(IXamlSchemaContextProvider));
IAmbientProvider iAmbient = (IAmbientProvider)typeDescriptorContext.GetService(typeof(IAmbientProvider));
XamlType ambientLabel = schemaContextProvider.SchemaContext.GetXamlType(typeof(HasAmbientLabel));
XamlMember label = ambientLabel.GetMember("Label");
AmbientPropertyValue apVal = iAmbient.GetFirstAmbientValue(null, label);
if (apVal == null)
{
e.ColorName = color;
}
else
{
e.ColorName = color + "-" + apVal.Value.ToString();
}
return(e);
}
public TemplateContent(IEnumerable <NamespaceDeclaration> namespaces, XamlReader reader,
IAmbientProvider ambientProvider)
{
ParentAmbientProvider = ambientProvider;
List = new XamlNodeList(reader.SchemaContext);
//we need to rpeserve all namespace and prefixes to writer
//otherwise they are lost. a bug in Portable.xaml or by design ??
foreach (var ns in namespaces)
{
List.Writer.WriteNamespace(ns);
}
XamlServices.Transform(reader, List.Writer);
}
public ValueSerializerContext (PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider)
{
if (prefixLookup == null)
throw new ArgumentNullException ("prefixLookup");
if (schemaContext == null)
throw new ArgumentNullException ("schemaContext");
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver (prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver (namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
}
public ValueSerializerContext(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider)
{
if (prefixLookup == null)
{
throw new ArgumentNullException("prefixLookup");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver(prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver(namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
}
internal static DependencyProperty Resolve(IServiceProvider serviceProvider, string value)
{
IAmbientProvider ambient = (IAmbientProvider)serviceProvider.GetService(typeof(IAmbientProvider));
IXamlSchemaContextProvider schema = (IXamlSchemaContextProvider)serviceProvider.GetService(typeof(IXamlSchemaContextProvider));
// Get the XamlType which represents the <Style> element.
XamlType styleType = schema.SchemaContext.GetXamlType(typeof(Style));
// The first ambient value should be the enclosing <Style>.
Style style = (Style)ambient.GetFirstAmbientValue(styleType);
// Get the target type for the style from this.
Type targetType = style.TargetType;
// And get the dependency property.
return(DependencyObject.GetPropertyFromName(targetType, value));
}
public ValueSerializerContext(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider, IXamlObjectWriterFactory objectWriterFactory)
{
if (prefixLookup == null)
{
throw new ArgumentNullException("prefixLookup");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
prefix_lookup = prefixLookup;
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
this.objectWriterFactory = objectWriterFactory;
}
// Setters and triggers may have a sourceName which we need to resolve
// This only works in templates and it works by looking up the mapping between
// name and type in the template. We use ambient lookup to find the Template property
// and then query it for the type.
private static Type GetTypeFromName(XamlSchemaContext schemaContext,
IAmbientProvider ambientProvider,
string target)
{
XamlType frameworkTemplateXType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlMember templateProperty = frameworkTemplateXType.GetMember("Template");
AmbientPropertyValue ambientValue =
ambientProvider.GetFirstAmbientValue(new XamlType[] { frameworkTemplateXType }, templateProperty);
TemplateContent templateHolder =
ambientValue.Value as System.Windows.TemplateContent;
if (templateHolder != null)
{
return(templateHolder.GetTypeForName(target).UnderlyingType);
}
return(null);
}
// Token: 0x0600210D RID: 8461 RVA: 0x00098390 File Offset: 0x00096590
private static Type GetTypeFromName(XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, string target)
{
XamlType xamlType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlMember member = xamlType.GetMember("Template");
AmbientPropertyValue firstAmbientValue = ambientProvider.GetFirstAmbientValue(new XamlType[]
{
xamlType
}, new XamlMember[]
{
member
});
TemplateContent templateContent = firstAmbientValue.Value as TemplateContent;
if (templateContent != null)
{
return(templateContent.GetTypeForName(target).UnderlyingType);
}
return(null);
}
public static AvaloniaXamlObjectWriter Create(
XamlSchemaContext schemaContext,
AvaloniaXamlContext context,
IAmbientProvider parentAmbientProvider = null)
{
var nameScope = new AvaloniaNameScope { Instance = context?.RootInstance };
var writerSettings = new XamlObjectWriterSettings()
{
ExternalNameScope = nameScope,
RegisterNamesOnExternalNamescope = true,
RootObjectInstance = context?.RootInstance
};
return new AvaloniaXamlObjectWriter(schemaContext,
writerSettings.WithContext(context),
nameScope,
parentAmbientProvider);
}
public ValueSerializerContext(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider)
{
if (prefixLookup == null)
{
throw new ArgumentNullException("prefixLookup");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver(prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver(namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
IXamlSchemaContextProvider schemaContextProvider =
(IXamlSchemaContextProvider)context.GetService(typeof(IXamlSchemaContextProvider));
IAmbientProvider ambientValueProvider =
(IAmbientProvider)context.GetService(typeof(IAmbientProvider));
IXamlNamespaceResolver namespaceResolver =
(IXamlNamespaceResolver)context.GetService(typeof(IXamlNamespaceResolver));
XamlTypeName typeName = XamlTypeName.Parse("TemplateClass2", namespaceResolver);
XamlType xamlType = schemaContextProvider.SchemaContext.GetXamlType(typeName);
XamlMember ambientProperty = xamlType.GetMember("Suffix");
IEnumerable <AmbientPropertyValue> propVals = ambientValueProvider.GetAllAmbientValues(null, ambientProperty);
string s = (string)value;
foreach (AmbientPropertyValue val in propVals)
{
s += (string)val.Value;
}
return(s);
}
internal static object GetRootTemplatedActivity(IServiceProvider serviceProvider)
{
// For now, we only support references to the root Activity when we're inside an Activity.Body
// Note that in the case of nested activity bodies, this gives us the outer activity
IRootObjectProvider rootProvider =
serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootProvider == null)
{
return(null);
}
IAmbientProvider ambientProvider =
serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider == null)
{
return(null);
}
IXamlSchemaContextProvider schemaContextProvider =
serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (schemaContextProvider == null)
{
return(null);
}
XamlMember activityBody = GetXamlMember(schemaContextProvider.SchemaContext, typeof(Activity), "Implementation");
XamlMember dynamicActivityBody = GetXamlMember(schemaContextProvider.SchemaContext, typeof(DynamicActivity), "Implementation");
if (activityBody == null || dynamicActivityBody == null)
{
return(null);
}
if (ambientProvider.GetFirstAmbientValue(null, activityBody, dynamicActivityBody) == null)
{
return(null);
}
object rootActivity = rootProvider.RootObject as Activity;
return(rootActivity);
}
protected XamlWriterInternalBase(XamlSchemaContext schemaContext, XamlWriterStateManager manager, IAmbientProvider parentAmbientProvider = null)
{
this.object_states = new ObjectStateStack(parentAmbientProvider);
this.sctx = schemaContext;
this.manager = manager;
var p = new PrefixLookup(sctx)
{
IsCollectingNamespaces = true
}; // it does not raise unknown namespace error.
service_provider = ValueSerializerContext.Create(p, schemaContext, object_states.GetAmbientProvider, this, this, this, this as IXamlObjectWriterFactory);
}
public StackItem(ObjectState objectState, IAmbientProvider provider = null)
{
ObjectState = objectState;
AmbientProvider = provider;
}
public XamlObjectWriter(XamlSchemaContext schemaContext, XamlObjectWriterSettings settings, IAmbientProvider parentAmbientProvider)
{
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
this.sctx = schemaContext;
this.settings = settings ?? new XamlObjectWriterSettings();
var manager = new XamlWriterStateManager <XamlObjectWriterException, XamlObjectWriterException>(false);
intl = new XamlObjectWriterInternal(this, sctx, manager, parentAmbientProvider);
}
// Setters and triggers may have a sourceName which we need to resolve
// This only works in templates and it works by looking up the mapping between
// name and type in the template. We use ambient lookup to find the Template property
// and then query it for the type.
private static Type GetTypeFromName(XamlSchemaContext schemaContext,
IAmbientProvider ambientProvider,
string target)
{
XamlType frameworkTemplateXType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlMember templateProperty = frameworkTemplateXType.GetMember("Template");
AmbientPropertyValue ambientValue =
ambientProvider.GetFirstAmbientValue(new XamlType[] { frameworkTemplateXType }, templateProperty);
TemplateContent templateHolder =
ambientValue.Value as System.Windows.TemplateContent;
if (templateHolder != null)
{
return templateHolder.GetTypeForName(target).UnderlyingType;
}
return null;
}
internal static object LoadFromReader(XamlReader reader, AvaloniaXamlContext context = null, IAmbientProvider parentAmbientProvider = null)
{
var writer = AvaloniaXamlObjectWriter.Create(
(AvaloniaXamlSchemaContext)reader.SchemaContext,
context,
parentAmbientProvider);
XamlServices.Transform(reader, writer);
writer.ApplyAllDelayedProperties();
return(writer.Result);
}
// Token: 0x06000865 RID: 2149 RVA: 0x0001B4E8 File Offset: 0x000196E8
private ResourceDictionary FindTheResourceDictionary(IServiceProvider serviceProvider, bool isDeferredContentSearch)
{
IXamlSchemaContextProvider xamlSchemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (xamlSchemaContextProvider == null)
{
throw new InvalidOperationException(SR.Get("MarkupExtensionNoContext", new object[]
{
base.GetType().Name,
"IXamlSchemaContextProvider"
}));
}
IAmbientProvider ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider == null)
{
throw new InvalidOperationException(SR.Get("MarkupExtensionNoContext", new object[]
{
base.GetType().Name,
"IAmbientProvider"
}));
}
XamlSchemaContext schemaContext = xamlSchemaContextProvider.SchemaContext;
XamlType xamlType = schemaContext.GetXamlType(typeof(FrameworkElement));
XamlType xamlType2 = schemaContext.GetXamlType(typeof(Style));
XamlType xamlType3 = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlType xamlType4 = schemaContext.GetXamlType(typeof(Application));
XamlType xamlType5 = schemaContext.GetXamlType(typeof(FrameworkContentElement));
XamlMember member = xamlType5.GetMember("Resources");
XamlMember member2 = xamlType.GetMember("Resources");
XamlMember member3 = xamlType2.GetMember("Resources");
XamlMember member4 = xamlType2.GetMember("BasedOn");
XamlMember member5 = xamlType3.GetMember("Resources");
XamlMember member6 = xamlType4.GetMember("Resources");
XamlType[] types = new XamlType[]
{
schemaContext.GetXamlType(typeof(ResourceDictionary))
};
IEnumerable <AmbientPropertyValue> allAmbientValues = ambientProvider.GetAllAmbientValues(null, isDeferredContentSearch, types, new XamlMember[]
{
member,
member2,
member3,
member4,
member5,
member6
});
List <AmbientPropertyValue> list = allAmbientValues as List <AmbientPropertyValue>;
for (int i = 0; i < list.Count; i++)
{
AmbientPropertyValue ambientPropertyValue = list[i];
if (ambientPropertyValue.Value is ResourceDictionary)
{
ResourceDictionary resourceDictionary = (ResourceDictionary)ambientPropertyValue.Value;
if (resourceDictionary.Contains(this.ResourceKey))
{
return(resourceDictionary);
}
}
if (ambientPropertyValue.Value is Style)
{
Style style = (Style)ambientPropertyValue.Value;
ResourceDictionary resourceDictionary2 = style.FindResourceDictionary(this.ResourceKey);
if (resourceDictionary2 != null)
{
return(resourceDictionary2);
}
}
}
return(null);
}
internal static DependencyProperty ResolveProperty(IServiceProvider serviceProvider,
string targetName, object source)
{
Type type = null;
string property = null;
DependencyProperty dProperty = source as DependencyProperty;
byte[] bytes;
String value;
if (dProperty != null)
{
return(dProperty);
}
// If it's a byte[] we got it from BAML. Let's resolve it using the schema context
else if ((bytes = source as byte[]) != null)
{
Baml2006SchemaContext schemaContext = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider))
as IXamlSchemaContextProvider).SchemaContext as Baml2006SchemaContext;
// Array with length of 2 means its an ID for a
// DependencyProperty in the Baml2006SchemaContext
if (bytes.Length == 2)
{
short propId = (short)(bytes[0] | (bytes[1] << 8));
return(schemaContext.GetDependencyProperty(propId));
}
else
{
// Otherwise it's a string with a TypeId encoded in front
using (BinaryReader reader = new BinaryReader(new MemoryStream(bytes)))
{
type = schemaContext.GetXamlType(reader.ReadInt16()).UnderlyingType;
property = reader.ReadString();
}
}
}
else if ((value = source as string) != null)
{
value = value.Trim();
// If it contains a . it means that it is a full name with type and property.
if (value.Contains("."))
{
// Prefixes could have .'s so we take the last one and do a type resolve against that
int lastIndex = value.LastIndexOf('.');
string typeName = value.Substring(0, lastIndex);
property = value.Substring(lastIndex + 1);
IXamlTypeResolver resolver = serviceProvider.GetService(typeof(IXamlTypeResolver))
as IXamlTypeResolver;
type = resolver.Resolve(typeName);
}
else
{
// Only have the property name
// Strip prefixes if there are any, v3 essentially discards the prefix in this case
int lastIndex = value.LastIndexOf(':');
property = value.Substring(lastIndex + 1);
}
}
else
{
throw new NotSupportedException(SR.Get(SRID.ParserCannotConvertPropertyValue, "Property", typeof(DependencyProperty).FullName));
}
// We got additional info from either Trigger.SourceName or Setter.TargetName
if (type == null && targetName != null)
{
IAmbientProvider ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider))
as System.Xaml.IAmbientProvider;
XamlSchemaContext schemaContext = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider))
as IXamlSchemaContextProvider).SchemaContext;
type = GetTypeFromName(schemaContext,
ambientProvider, targetName);
}
// Still don't have a Type so we need to loop up the chain and grab either Style.TargetType,
// DataTemplate.DataType, or ControlTemplate.TargetType
if (type == null)
{
IXamlSchemaContextProvider ixscp = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider))
as IXamlSchemaContextProvider);
if (ixscp == null)
{
throw new NotSupportedException(SR.Get(SRID.ParserCannotConvertPropertyValue, "Property", typeof(DependencyProperty).FullName));
}
XamlSchemaContext schemaContext = ixscp.SchemaContext;
XamlType styleXType = schemaContext.GetXamlType(typeof(Style));
XamlType frameworkTemplateXType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlType dataTemplateXType = schemaContext.GetXamlType(typeof(DataTemplate));
XamlType controlTemplateXType = schemaContext.GetXamlType(typeof(ControlTemplate));
List <XamlType> ceilingTypes = new List <XamlType>();
ceilingTypes.Add(styleXType);
ceilingTypes.Add(frameworkTemplateXType);
ceilingTypes.Add(dataTemplateXType);
ceilingTypes.Add(controlTemplateXType);
// We don't look for DataTemplate's DataType since we want to use the TargetTypeInternal instead
XamlMember styleTargetType = styleXType.GetMember("TargetType");
XamlMember templateProperty = frameworkTemplateXType.GetMember("Template");
XamlMember controlTemplateTargetType = controlTemplateXType.GetMember("TargetType");
IAmbientProvider ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider))
as System.Xaml.IAmbientProvider;
if (ambientProvider == null)
{
throw new NotSupportedException(SR.Get(SRID.ParserCannotConvertPropertyValue, "Property", typeof(DependencyProperty).FullName));
}
AmbientPropertyValue firstAmbientValue = ambientProvider.GetFirstAmbientValue(ceilingTypes, styleTargetType,
templateProperty, controlTemplateTargetType);
if (firstAmbientValue != null)
{
if (firstAmbientValue.Value is Type)
{
type = (Type)firstAmbientValue.Value;
}
else if (firstAmbientValue.Value is TemplateContent)
{
TemplateContent tempContent = firstAmbientValue.Value
as TemplateContent;
type = tempContent.OwnerTemplate.TargetTypeInternal;
}
else
{
throw new NotSupportedException(SR.Get(SRID.ParserCannotConvertPropertyValue, "Property", typeof(DependencyProperty).FullName));
}
}
}
if (type != null && property != null)
{
return(DependencyProperty.FromName(property, type));
}
throw new NotSupportedException(SR.Get(SRID.ParserCannotConvertPropertyValue, "Property", typeof(DependencyProperty).FullName));
}
// Token: 0x0600210C RID: 8460 RVA: 0x00097FBC File Offset: 0x000961BC
internal static DependencyProperty ResolveProperty(IServiceProvider serviceProvider, string targetName, object source)
{
Type type = null;
string text = null;
DependencyProperty dependencyProperty = source as DependencyProperty;
if (dependencyProperty != null)
{
return(dependencyProperty);
}
byte[] array;
if ((array = (source as byte[])) != null)
{
Baml2006SchemaContext baml2006SchemaContext = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider).SchemaContext as Baml2006SchemaContext;
if (array.Length == 2)
{
short propertyId = (short)((int)array[0] | (int)array[1] << 8);
return(baml2006SchemaContext.GetDependencyProperty(propertyId));
}
using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(array)))
{
type = baml2006SchemaContext.GetXamlType(binaryReader.ReadInt16()).UnderlyingType;
text = binaryReader.ReadString();
goto IL_142;
}
}
string text2;
if ((text2 = (source as string)) == null)
{
throw new NotSupportedException(SR.Get("ParserCannotConvertPropertyValue", new object[]
{
"Property",
typeof(DependencyProperty).FullName
}));
}
text2 = text2.Trim();
if (text2.Contains("."))
{
int num = text2.LastIndexOf('.');
string qualifiedTypeName = text2.Substring(0, num);
text = text2.Substring(num + 1);
IXamlTypeResolver xamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
type = xamlTypeResolver.Resolve(qualifiedTypeName);
}
else
{
int num2 = text2.LastIndexOf(':');
text = text2.Substring(num2 + 1);
}
IL_142:
if (type == null && targetName != null)
{
IAmbientProvider ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
XamlSchemaContext schemaContext = (serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider).SchemaContext;
type = DependencyPropertyConverter.GetTypeFromName(schemaContext, ambientProvider, targetName);
}
if (type == null)
{
IXamlSchemaContextProvider xamlSchemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (xamlSchemaContextProvider == null)
{
throw new NotSupportedException(SR.Get("ParserCannotConvertPropertyValue", new object[]
{
"Property",
typeof(DependencyProperty).FullName
}));
}
XamlSchemaContext schemaContext2 = xamlSchemaContextProvider.SchemaContext;
XamlType xamlType = schemaContext2.GetXamlType(typeof(Style));
XamlType xamlType2 = schemaContext2.GetXamlType(typeof(FrameworkTemplate));
XamlType xamlType3 = schemaContext2.GetXamlType(typeof(DataTemplate));
XamlType xamlType4 = schemaContext2.GetXamlType(typeof(ControlTemplate));
List <XamlType> list = new List <XamlType>();
list.Add(xamlType);
list.Add(xamlType2);
list.Add(xamlType3);
list.Add(xamlType4);
XamlMember member = xamlType.GetMember("TargetType");
XamlMember member2 = xamlType2.GetMember("Template");
XamlMember member3 = xamlType4.GetMember("TargetType");
IAmbientProvider ambientProvider2 = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider2 == null)
{
throw new NotSupportedException(SR.Get("ParserCannotConvertPropertyValue", new object[]
{
"Property",
typeof(DependencyProperty).FullName
}));
}
AmbientPropertyValue firstAmbientValue = ambientProvider2.GetFirstAmbientValue(list, new XamlMember[]
{
member,
member2,
member3
});
if (firstAmbientValue != null)
{
if (firstAmbientValue.Value is Type)
{
type = (Type)firstAmbientValue.Value;
}
else
{
if (!(firstAmbientValue.Value is TemplateContent))
{
throw new NotSupportedException(SR.Get("ParserCannotConvertPropertyValue", new object[]
{
"Property",
typeof(DependencyProperty).FullName
}));
}
TemplateContent templateContent = firstAmbientValue.Value as TemplateContent;
type = templateContent.OwnerTemplate.TargetTypeInternal;
}
}
}
if (type != null && text != null)
{
return(DependencyProperty.FromName(text, type));
}
throw new NotSupportedException(SR.Get("ParserCannotConvertPropertyValue", new object[]
{
"Property",
typeof(DependencyProperty).FullName
}));
}
public static ValueSerializerContext Create(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider, IXamlObjectWriterFactory objectWriterFactory)
{
#if !HAS_TYPE_CONVERTER
ValueSerializerContext context;
var type = GetValueSerializerType();
if (type != null)
{
context = Activator.CreateInstance(type) as ValueSerializerContext;
}
else
{
context = new ValueSerializerContext();
}
#else
var context = new ValueSerializerContext();
#endif
context.Initialize(prefixLookup, schemaContext, ambientProvider, provideValue, rootProvider, destinationProvider, objectWriterFactory);
return(context);
}
public ObjectStateStack(IAmbientProvider parentAmbientProvider = null)
{
this.parentAmbientProvider = parentAmbientProvider;
}
