private static RoutedEvent GetRoutedEvent(Type containingType, XamlName eventName) { string eventMemberName = eventName.MemberName; Type eventContainingType = eventName.IsMemberName ? TypeParser.ParseType(eventName.ContainingTypeName) : containingType; return(EventManager.GetOwnedRoutedEvent(containingType, eventMemberName)); }
public static IEventAdapter CreateAdapter(Type targetType, XamlName eventName) { RoutedEvent routedEvent = GetRoutedEvent(targetType, eventName); if (routedEvent != null) { return(new RoutedEventAdapter(routedEvent)); } EventInfo clrEvent = GetClrEvent(targetType, eventName); if (clrEvent != null) { return(new ClrEventAdapter(clrEvent)); } PropertyInfo eventProperty = GetEventProperty(targetType, eventName); if (eventProperty != null) { return(new EventPropertyAdapter(eventProperty)); } return(null); }
private static bool TryGetType(XamlName xamlName, out Type type) { if (Granular.Compatibility.String.StartsWith(xamlName.NamespaceName, ClrNamespacePrefix)) { string clrNamespace = GetClrNamespace(xamlName.NamespaceName.Substring(ClrNamespacePrefix.Length)); string assemblyName = GetAssemblyName(xamlName.NamespaceName.Substring(ClrNamespacePrefix.Length)); if (TryGetType(xamlName.LocalName, clrNamespace, assemblyName, out type)) { return(true); } return(false); } foreach (XmlnsDefinitionAttribute xmlnsDefinition in GetXmlnsDefinitionAttributes()) { if (xmlnsDefinition.XmlNamespace == xamlName.NamespaceName && TryGetType(xamlName.LocalName, xmlnsDefinition.ClrNamespace, xmlnsDefinition.AssemblyName, out type)) { return(true); } } type = null; return(false); }
private static EventInfo GetClrEvent(Type containingType, XamlName eventName) { string eventMemberName = eventName.MemberName; Type eventContainingType = eventName.IsMemberName ? TypeParser.ParseType(eventName.ContainingTypeName) : containingType; return(eventContainingType.GetEvent(eventMemberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy)); }
private static XamlMember CreateXamlMember(XAttribute attribute, XamlNamespaces namespaces, XamlNamespaces ignorableNamespaces, Uri sourceUri) { XamlName name = new XamlName(attribute.Name.LocalName, attribute.Name.NamespaceName.IsNullOrEmpty() ? namespaces.GetDefaultNamespace() : attribute.Name.NamespaceName); object value = MarkupExtensionParser.Parse(attribute.Value, namespaces, sourceUri); return(new XamlMember(name, namespaces, sourceUri, value)); }
private static PropertyInfo GetClrProperty(Type containingType, XamlName propertyName) { string propertyMemberName = propertyName.MemberName; Type propertyContainingType = propertyName.IsMemberName ? TypeParser.ParseType(propertyName.ContainingTypeName) : containingType; return(propertyContainingType.GetInstanceProperty(propertyMemberName)); }
private XamlName TryMatchPropertyName(XamlNamespaces namespaces) { if (!tokens.IsEmpty && tokens.Peek().Value == "(") { MatchTerminal("("); string propertyName = MatchValue(); if (!tokens.IsEmpty && tokens.Peek().Value == ".") { MatchTerminal("."); propertyName = String.Format("{0}.{1}", propertyName, MatchValue()); } MatchTerminal(")"); XamlName xamlName = XamlName.FromPrefixedName(propertyName, namespaces); if (xamlName.IsEmpty) { throw new Granular.Exception("Can't parse \"{0}\", Can't parse property name \"{1}\" at index {2}, is namespace missing?", text, propertyName, tokens.Peek().Start - propertyName.Length - 1); } return(xamlName); } if (!tokens.IsEmpty && (TokenType)tokens.Peek().Id == TokenType.Value) { return(new XamlName(MatchValue())); } return(XamlName.Empty); }
public XamlElement(XamlName name, XamlNamespaces namespaces, Uri sourceUri, IEnumerable <XamlMember> members = null, IEnumerable <object> values = null, IEnumerable <XamlMember> directives = null) : base(name, namespaces, sourceUri) { this.Members = members ?? EmptyMembers; this.Values = values ?? EmptyValues; this.Directives = directives ?? EmptyDirectives; }
public override bool Equals(object obj) { XamlName other = obj as XamlName; return(Object.ReferenceEquals(this, other) || !Object.ReferenceEquals(other, null) && this.LocalName == other.LocalName && this.NamespaceName == other.NamespaceName); }
private static PropertyInfo GetClrProperty(Type containingType, XamlName propertyName) { string propertyMemberName = propertyName.MemberName; Type propertyContainingType = propertyName.IsMemberName ? TypeParser.ParseType(propertyName.ContainingTypeName) : containingType; PropertyInfo propertyInfo = propertyContainingType.GetInstanceProperty(propertyMemberName); return(propertyInfo != null && !propertyInfo.IsDelegate() ? propertyInfo : null); }
private static PropertyInfo GetEventProperty(Type containingType, XamlName eventName) { string eventMemberName = eventName.MemberName; Type eventContainingType = eventName.IsMemberName ? TypeParser.ParseType(eventName.ContainingTypeName) : containingType; PropertyInfo eventProperty = eventContainingType.GetInstanceProperty(eventMemberName); return(eventProperty != null && eventProperty.IsDelegate() ? eventProperty : null); }
private static bool TryResolveType(XamlName name, out Type type) { if (XamlTypes.TryParseXamlType(name, out type)) { return(true); } XamlName extensionName = new XamlName(String.Format("{0}Extension", name.LocalName), name.NamespaceName); return(TryGetType(name, out type) || TryGetType(extensionName, out type)); }
public static Type ParseXamlType(XamlName xamlName) { Type type; if (!TryParseXamlType(xamlName, out type)) { throw new Granular.Exception("Type {0} wasn't found", xamlName); } return(type); }
public static Type ParseType(XamlName name) { Type type; if (!TryParseType(name, out type)) { throw new Granular.Exception("Type \"{0}\" wasn't found", name); } return(type); }
private IPropertyPathElement MatchElement(XamlNamespaces namespaces) { VerifyTokensExists(); XamlName propertyName = TryMatchPropertyName(namespaces); IEnumerable <string> indexRawValues = TryMatchIndexRawValues(); if (propertyName.IsEmpty && !indexRawValues.Any()) { throw new Granular.Exception("Can't parse \"{0}\", Property name or Index parameters were expected, \"{1}\" was found at index {2}", text, tokens.Peek().Value, tokens.Peek().Start); } return(indexRawValues.Any() ? (IPropertyPathElement) new IndexPropertyPathElement(propertyName, indexRawValues, namespaces) : new PropertyPathElement(propertyName)); }
private static XamlMember CreateXamlMember(XElement element, XamlNamespaces namespaces, XamlNamespaces ignorableNamespaces, Uri sourceUri) { XamlName name = new XamlName(element.Name.LocalName, element.Name.NamespaceName.IsNullOrEmpty() ? namespaces.GetDefaultNamespace() : element.Name.NamespaceName); if (element.Attributes().Any(attribute => !IsIgnorable(attribute.Name, ignorableNamespaces))) { throw new Granular.Exception("Member \"{0}\" cannot contain attributes", element.Name); } if (element.Elements().Any(child => !IsIgnorable(child.Name, ignorableNamespaces) && IsMemberName(child.Name))) { throw new Granular.Exception("Member \"{0}\" cannot contain member elements", element.Name); } return(new XamlMember(name, namespaces, sourceUri, CreateValues(element, namespaces, ignorableNamespaces, sourceUri))); }
public static bool TryParseXamlType(XamlName name, out Type type) { if (name == XamlLanguage.NullTypeName) { type = typeof(NullProvider); return(true); } if (name == XamlLanguage.TypeTypeName) { type = typeof(TypeProvider); return(true); } type = null; return(false); }
private static IEnumerable <IElementInitializer> CreateMemberInitializers(XamlElement element, Type elementType) { List <IElementInitializer> list = new List <IElementInitializer>(); int index = 0; foreach (XamlMember member in element.Members) { // markup extensions may contain members with an empty name, the name should be resolved from the member index XamlName memberName = member.Name.IsEmpty ? GetParameterName(elementType, index) : member.Name; list.Add(ElementMemberInitializer.Create(memberName.ResolveContainingType(elementType), memberName.MemberName, member.Values, member.Namespaces, member.SourceUri)); index++; } return(list); }
public static IElementInitializer Create(XamlName memberName, Type containingType, IEnumerable <object> values, XamlNamespaces namespaces) { IEventAdapter eventAdapter = EventAdapter.CreateAdapter(containingType, memberName); if (eventAdapter != null) { return(new ElementEventMemberInitializer(eventAdapter, GetEventHandlerName(memberName, values))); } IPropertyAdapter propertyAdapter = PropertyAdapter.CreateAdapter(containingType, memberName); if (propertyAdapter != null) { return(ElementPropertyMemberInitializer.Create(propertyAdapter, values, namespaces)); } throw new Granular.Exception("Type \"{0}\" does not contain a member named \"{1}\"", containingType.Name, memberName); }
public XamlName(string localName, string namespaceName = null) { this.LocalName = localName ?? String.Empty; this.NamespaceName = namespaceName ?? String.Empty; int typeSeparatorIndex = LocalName.IndexOf('.'); if (typeSeparatorIndex != -1) { MemberName = LocalName.Substring(typeSeparatorIndex + 1); ContainingTypeName = new XamlName(LocalName.Substring(0, typeSeparatorIndex), NamespaceName); IsMemberName = true; } else { MemberName = LocalName; } }
private static string GetEventHandlerName(XamlName memberName, IEnumerable <object> values) { if (!values.Any()) { throw new Granular.Exception("Member \"{0}\" doesn't have values", memberName); } if (values.Count() > 1) { throw new Granular.Exception("Member \"{0}\" cannot have multiple values", memberName); } if (!(values.First() is String)) { throw new Granular.Exception("Member \"{0}\" value is not an event handler name", memberName); } return((string)values.First()); }
public static IPropertyAdapter CreateAdapter(Type targetType, XamlName propertyName) { if (propertyName.IsEmpty) { return(null); } DependencyProperty dependencyProperty = DependencyProperty.GetProperty(targetType, propertyName); if (dependencyProperty != null) { return(new DependencyPropertyAdapter(dependencyProperty)); } PropertyInfo clrProperty = GetClrProperty(targetType, propertyName); if (clrProperty != null) { return(new ClrPropertyAdapter(clrProperty)); } return(null); }
public static bool TryParseType(string prefixedTypeName, XamlNamespaces namespaces, out Type type) { return(TryParseType(XamlName.FromPrefixedName(prefixedTypeName, namespaces), out type)); }
public static bool TryParseXamlType(XamlName name, out Type type) { return(TypeProviders.TryGetValue(name, out type)); }
public static bool TryParseType(XamlName name, out Type type) { return(resolvedTypesCache.TryGetValue(name, out type)); }
public static IEventAdapter CreateAdapter(Type targetType, XamlName eventName) { IEventAdapter eventAdapter; return(adaptersCache.TryGetValue(new TypeMemberKey(targetType, eventName), out eventAdapter) ? eventAdapter : null); }
public static Type ParseType(string prefixedTypeName, XamlNamespaces namespaces) { return(ParseType(XamlName.FromPrefixedName(prefixedTypeName, namespaces))); }
public static Type ResolveContainingType(this XamlName name, Type defaultContainingType) { return(name.HasContainingTypeName ? TypeParser.ParseType(new XamlName(name.ContainingTypeName, name.NamespaceName)) : defaultContainingType); }