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)
{
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);
}
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);
}
}
}
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);
}
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 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);
}
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));
}
// 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);
}
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);
}
// 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
}));
}
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));
}
// 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;
}
/// <summary>
/// Convert a string like "Button.Click" into the corresponding RoutedEvent
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext,
CultureInfo cultureInfo,
object source)
{
string routedEventName = source as string;
RoutedEvent routedEvent = null;
if (routedEventName != null)
{
routedEventName = routedEventName.Trim();
IServiceProvider serviceProvider = typeDescriptorContext as IServiceProvider;
if (serviceProvider != null)
{
IXamlTypeResolver resolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
Type type = null;
if (resolver != null)
{
// Verify that there's at least one period. (A simple
// but not foolproof check for "[class].[event]")
int lastIndex = routedEventName.IndexOf('.');
if (lastIndex != -1)
{
string typeName = routedEventName.Substring(0, lastIndex);
routedEventName = routedEventName.Substring(lastIndex + 1);
type = resolver.Resolve(typeName);
}
}
if (type == null)
{
IXamlSchemaContextProvider schemaContextProvider = (typeDescriptorContext.
GetService(typeof(IXamlSchemaContextProvider))
as IXamlSchemaContextProvider);
IAmbientProvider iapp = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (schemaContextProvider != null && iapp != null)
{
XamlSchemaContext schemaContext = schemaContextProvider.SchemaContext;
XamlType styleXType = schemaContext.GetXamlType(typeof(Style));
List <XamlType> ceilingTypes = new List <XamlType>();
ceilingTypes.Add(styleXType);
XamlMember styleTargetType = styleXType.GetMember("TargetType");
AmbientPropertyValue firstAmbientValue = iapp.GetFirstAmbientValue(ceilingTypes, styleTargetType);
if (firstAmbientValue != null)
{
type = firstAmbientValue.Value as Type;
}
if (type == null)
{
type = typeof(FrameworkElement);
}
}
}
if (type != null)
{
Type currentType = type;
// Force load the Statics by walking up the hierarchy and running class constructors
while (null != currentType)
{
MS.Internal.WindowsBase.SecurityHelper.RunClassConstructor(currentType);
currentType = currentType.BaseType;
}
routedEvent = EventManager.GetRoutedEventFromName(routedEventName, type);
}
}
}
if (routedEvent == null)
{
// Falling through here means we are unable to perform the conversion.
throw GetConvertFromException(source);
}
return(routedEvent);
}
/// <summary>Attempts to convert the specified object to a <see cref="T:System.Windows.RoutedEvent" /> object, using the specified context.</summary>
/// <param name="typeDescriptorContext">A format context that provides information about the environment from which this converter is being invoked.</param>
/// <param name="cultureInfo">Culture specific information.</param>
/// <param name="source">The object to convert.</param>
/// <returns>The conversion result.</returns>
/// <exception cref="T:System.NotSupportedException">
/// <paramref name="source" /> is not a string or cannot be converted.</exception>
// Token: 0x0600223F RID: 8767 RVA: 0x000AA6D4 File Offset: 0x000A88D4
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object source)
{
string text = source as string;
RoutedEvent routedEvent = null;
if (text != null)
{
text = text.Trim();
if (typeDescriptorContext != null)
{
IXamlTypeResolver xamlTypeResolver = typeDescriptorContext.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
Type type = null;
if (xamlTypeResolver != null)
{
int num = text.IndexOf('.');
if (num != -1)
{
string qualifiedTypeName = text.Substring(0, num);
text = text.Substring(num + 1);
type = xamlTypeResolver.Resolve(qualifiedTypeName);
}
}
if (type == null)
{
IXamlSchemaContextProvider xamlSchemaContextProvider = typeDescriptorContext.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
IAmbientProvider ambientProvider = typeDescriptorContext.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (xamlSchemaContextProvider != null && ambientProvider != null)
{
XamlSchemaContext schemaContext = xamlSchemaContextProvider.SchemaContext;
XamlType xamlType = schemaContext.GetXamlType(typeof(Style));
List <XamlType> list = new List <XamlType>();
list.Add(xamlType);
XamlMember member = xamlType.GetMember("TargetType");
AmbientPropertyValue firstAmbientValue = ambientProvider.GetFirstAmbientValue(list, new XamlMember[]
{
member
});
if (firstAmbientValue != null)
{
type = (firstAmbientValue.Value as Type);
}
if (type == null)
{
type = typeof(FrameworkElement);
}
}
}
if (type != null)
{
Type type2 = type;
while (null != type2)
{
SecurityHelper.RunClassConstructor(type2);
type2 = type2.BaseType;
}
routedEvent = EventManager.GetRoutedEventFromName(text, type);
}
}
}
if (routedEvent == null)
{
throw base.GetConvertFromException(source);
}
return(routedEvent);
}