/// <summary> /// Creates a new XamlObjectServiceProvider instance. /// </summary> public XamlObjectServiceProvider(XamlObject obj) { if (obj == null) { throw new ArgumentNullException("obj"); } XamlObject = obj; Resolver = new XamlTypeResolverProvider(obj); }
/// <summary> /// Gets whether shorthand XAML markup extension code can be generated for the object. /// </summary> public static bool CanPrint(XamlObject obj) { if (obj.ElementType == typeof(System.Windows.Data.MultiBinding) || obj.ElementType == typeof(System.Windows.Data.PriorityBinding)) { return(false); } return(CanPrint(obj, false, GetNonMarkupExtensionParent(obj))); }
void ParseObjectAttribute(XamlObject obj, XmlAttribute attribute) { try { ParseObjectAttribute(obj, attribute, true); } catch (Exception x) { ReportException(x, attribute); } }
static XamlProperty FindExistingXamlProperty(XamlObject obj, XamlPropertyInfo propertyInfo) { foreach (XamlProperty existing in obj.Properties) { if (existing.propertyInfo.FullyQualifiedName == propertyInfo.FullyQualifiedName) { return(existing); } } throw new XamlLoadException("Existing XamlProperty " + propertyInfo.FullyQualifiedName + " not found."); }
private static XamlObject GetNonMarkupExtensionParent(XamlObject markupExtensionObject) { System.Diagnostics.Debug.Assert(markupExtensionObject.IsMarkupExtension); XamlObject obj = markupExtensionObject; while (obj != null && obj.IsMarkupExtension) { obj = obj.ParentObject; } return(obj); }
// for use by parser only internal XamlProperty(XamlObject parentObject, XamlPropertyInfo propertyInfo, XamlPropertyValue propertyValue) : this(parentObject, propertyInfo) { PossiblyNameChanged(null, propertyValue); this.propertyValue = propertyValue; if (propertyValue != null) { propertyValue.ParentProperty = this; } UpdateValueOnInstance(); }
bool UpdateXmlAttribute(bool force, out XamlObject holder) { holder = FindXmlAttributeHolder(); if (holder == null && force && IsMarkupExtension) { holder = this; } if (holder != null && MarkupExtensionPrinter.CanPrint(holder)) { var s = MarkupExtensionPrinter.Print(holder); holder.XmlAttribute = holder.ParentProperty.SetAttribute(s); return(true); } return(false); }
internal XamlProperty(XamlObject parentObject, XamlPropertyInfo propertyInfo) { this.parentObject = parentObject; this.propertyInfo = propertyInfo; if (propertyInfo.IsCollection) { isCollection = true; collectionElements = new CollectionElementsCollection(this); collectionElements.CollectionChanged += OnCollectionChanged; if (propertyInfo.Name.Equals(XamlConstants.ResourcesPropertyName, StringComparison.Ordinal) && propertyInfo.ReturnType == typeof(ResourceDictionary)) { isResources = true; } } }
/// <summary> /// Gets the type descriptor context used for type conversions. /// </summary> /// <param name="containingObject">The containing object, used when the /// type descriptor context needs to resolve an XML namespace.</param> internal ITypeDescriptorContext GetTypeDescriptorContext(XamlObject containingObject) { IServiceProvider serviceProvider; if (containingObject != null) { if (containingObject.OwnerDocument != this) { throw new ArgumentException("Containing object must belong to the document!"); } serviceProvider = containingObject.ServiceProvider; } else { serviceProvider = this.ServiceProvider; } return(new DummyTypeDescriptorContext(serviceProvider)); }
public XamlPropertyInfo ResolveProperty(string propertyName) { string propertyNamespace; if (propertyName.Contains(":")) { propertyNamespace = ContainingElement.GetNamespaceOfPrefix(propertyName.Substring(0, propertyName.IndexOf(':'))); propertyName = propertyName.Substring(propertyName.IndexOf(':') + 1); } else { propertyNamespace = ContainingElement.GetNamespaceOfPrefix(""); } Type elementType = null; XamlObject obj = containingObject; while (obj != null) { Style style = obj.Instance as Style; if (style != null && style.TargetType != null) { elementType = style.TargetType; break; } obj = obj.ParentObject; } if (propertyName.Contains(".")) { var allPropertiesAllowed = this.containingObject is XamlObject && (((XamlObject)this.containingObject).ElementType == typeof(Setter) || ((XamlObject)this.containingObject).IsMarkupExtension); return(XamlParser.GetPropertyInfo(document.TypeFinder, null, elementType, propertyNamespace, propertyName, allPropertiesAllowed)); } else if (elementType != null) { return(XamlParser.FindProperty(null, elementType, propertyName)); } else { return(null); } }
public object FindResource(object key) { XamlObject obj = containingObject; while (obj != null) { FrameworkElement el = obj.Instance as FrameworkElement; if (el != null) { object val = el.Resources[key]; if (val != null) { return(val); } } obj = obj.ParentObject; } return(null); }
/// <summary> /// Finds the XAML namescope for the specified object and uses it to unregister the old name and then register the new name. /// </summary> /// <param name="namedObject">The object where the name was changed.</param> /// <param name="oldName">The old name.</param> /// <param name="newName">The new name.</param> public static void NameChanged(XamlObject namedObject, string oldName, string newName) { var obj = namedObject; while (obj != null) { var nameScope = GetNameScopeFromObject(obj); if (nameScope != null) { if (oldName != null) { try { nameScope.UnregisterName(oldName); } catch (Exception x) { Debug.WriteLine(x.Message); } } if (newName != null) { nameScope.RegisterName(newName, namedObject.Instance); try { var prp = namedObject.ElementType.GetProperty(namedObject.RuntimeNameProperty); if (prp != null) { prp.SetValue(namedObject.Instance, newName, null); } } catch (Exception x) { Debug.WriteLine(x.Message); } } break; } obj = obj.ParentObject; } }
internal static object CreateObjectFromAttributeText(string valueText, XamlPropertyInfo targetProperty, XamlObject scope) { if (targetProperty.ReturnType == typeof(Uri)) { return(scope.OwnerDocument.TypeFinder.ConvertUriToLocalUri(new Uri(valueText, UriKind.RelativeOrAbsolute))); } else if (targetProperty.ReturnType == typeof(ImageSource)) { var uri = scope.OwnerDocument.TypeFinder.ConvertUriToLocalUri(new Uri(valueText, UriKind.RelativeOrAbsolute)); return(targetProperty.TypeConverter.ConvertFromString( scope.OwnerDocument.GetTypeDescriptorContext(scope), CultureInfo.InvariantCulture, uri.ToString())); } return(targetProperty.TypeConverter.ConvertFromString( scope.OwnerDocument.GetTypeDescriptorContext(scope), CultureInfo.InvariantCulture, valueText)); }
private static bool IsStaticResourceThatReferencesLocalResource(XamlObject obj, XamlObject nonMarkupExtensionParent) { var staticResource = obj.Instance as System.Windows.StaticResourceExtension; if (staticResource != null && staticResource.ResourceKey != null && nonMarkupExtensionParent != null) { var parentLocalResource = nonMarkupExtensionParent.ServiceProvider.Resolver.FindLocalResource(staticResource.ResourceKey); // If resource with the specified key is declared locally on the same object as the StaticResource is being used the markup extension // must be printed as element to find the resource, otherwise it will search from parent-parent and find none or another resource. if (parentLocalResource != null) { return(true); } } return(false); }
/// <summary> /// Removes namespace attributes defined in the root from the specified node and all child nodes. /// </summary> static void RemoveRootNamespacesFromNodeAndChildNodes(XamlObject root, XmlNode node) { foreach (XmlNode childNode in node.ChildNodes) { RemoveRootNamespacesFromNodeAndChildNodes(root, childNode); } if (node.Attributes != null) { List <XmlAttribute> removeAttributes = new List <XmlAttribute>(); foreach (XmlAttribute attrib in node.Attributes) { if (attrib.Name.StartsWith("xmlns:")) { var rootPrefix = root.OwnerDocument.GetPrefixForNamespace(attrib.Value); if (rootPrefix == null) { //todo: check if we can add to root, (maybe same ns exists) root.OwnerDocument.XmlDocument.Attributes.Append((XmlAttribute)attrib.CloneNode(true)); removeAttributes.Add(attrib); } else if (rootPrefix == attrib.Name.Substring("xmlns:".Length)) { removeAttributes.Add(attrib); } } else if (attrib.Name == "xmlns" && attrib.Value == XamlConstants.PresentationNamespace) { removeAttributes.Add(attrib); } } foreach (var removeAttribute in removeAttributes) { node.Attributes.Remove(removeAttribute); } } }
/// <summary> /// Method use to parse a piece of Xaml. /// </summary> /// <param name="root">The Root XamlObject of the current document.</param> /// <param name="xaml">The Xaml being parsed.</param> /// <param name="settings">Parser settings used by <see cref="XamlParser"/>.</param> /// <param name="parentObject">Parent Object, where the Parsed snippet will be inserted (Needed for Example for Bindings).</param> /// <returns>Returns the XamlObject of the parsed <paramref name="xaml"/>.</returns> public static XamlObject ParseSnippet(XamlObject root, string xaml, XamlParserSettings settings, XamlObject parentObject) { XmlTextReader reader = new XmlTextReader(new StringReader(xaml)); var element = root.OwnerDocument.XmlDocument.ReadNode(reader); if (element != null) { XmlAttribute xmlnsAttribute = null; foreach (XmlAttribute attrib in element.Attributes) { if (attrib.Name == "xmlns") { xmlnsAttribute = attrib; } } if (xmlnsAttribute != null) { element.Attributes.Remove(xmlnsAttribute); } XamlParser parser = new XamlParser(); parser.settings = settings; parser.errorSink = (IXamlErrorSink)settings.ServiceProvider.GetService(typeof(IXamlErrorSink)); parser.document = root.OwnerDocument; parser.currentXamlObject = parentObject; var xamlObject = parser.ParseObject(element as XmlElement); RemoveRootNamespacesFromNodeAndChildNodes(root, element); if (xamlObject != null) { return(xamlObject); } } return(null); }
/// <summary> /// Method use to parse a piece of Xaml. /// </summary> /// <param name="root">The Root XamlObject of the current document.</param> /// <param name="xaml">The Xaml being parsed.</param> /// <param name="settings">Parser settings used by <see cref="XamlParser"/>.</param> /// <returns>Returns the XamlObject of the parsed <paramref name="xaml"/>.</returns> public static XamlObject ParseSnippet(XamlObject root, string xaml, XamlParserSettings settings) { return(ParseSnippet(root, xaml, settings, null)); }
bool IsFirstChildResources(XamlObject obj) { return(obj.XmlElement.FirstChild != null && obj.XmlElement.FirstChild.Name.EndsWith("." + XamlConstants.ResourcesPropertyName) && obj.Properties.Where((prop) => prop.IsResources).FirstOrDefault() != null); }
internal static MarkupExtensionWrapper TryCreateWrapper(Type markupExtensionType, XamlObject xamlObject) { Type markupExtensionWrapperType; if (s_MarkupExtensionWrappers.TryGetValue(markupExtensionType, out markupExtensionWrapperType)) { return(CreateWrapper(markupExtensionWrapperType, xamlObject)); } return(null); }
/// <summary> /// Create a XamlPropertyValue for the specified value instance. /// </summary> public XamlPropertyValue CreatePropertyValue(object instance, XamlProperty forProperty) { if (instance == null) { throw new ArgumentNullException("instance"); } Type elementType = instance.GetType(); TypeConverter c = TypeDescriptor.GetConverter(instance); var ctx = new DummyTypeDescriptorContext(this.ServiceProvider); ctx.Instance = instance; bool hasStringConverter = c.CanConvertTo(ctx, typeof(string)) && c.CanConvertFrom(typeof(string)); if (forProperty != null && hasStringConverter) { if (instance is SolidColorBrush && _colorBrushDictionary.ContainsKey(((SolidColorBrush)instance).Color)) { var name = _colorBrushDictionary[((SolidColorBrush)instance).Color]; return(new XamlTextValue(this, name)); } return(new XamlTextValue(this, c.ConvertToInvariantString(ctx, instance))); } string ns = GetNamespaceFor(elementType); string prefix = GetPrefixForNamespace(ns); XmlElement xml = _xmlDoc.CreateElement(prefix, elementType.Name, ns); if (hasStringConverter && (XamlObject.GetContentPropertyName(elementType) != null || IsNativeType(instance))) { xml.InnerText = c.ConvertToInvariantString(instance); } else if (instance is Brush && forProperty != null) { // TODO: this is a hacky fix, because Brush Editor doesn't // edit Design Items and so we have no XML, only the Brush // object and we need to parse the Brush to XAML! var s = new MemoryStream(); XamlWriter.Save(instance, s); s.Seek(0, SeekOrigin.Begin); XmlDocument doc = new XmlDocument(); doc.Load(s); xml = (XmlElement)_xmlDoc.ImportNode(doc.DocumentElement, true); var attLst = xml.Attributes.Cast <XmlAttribute>().ToList(); foreach (XmlAttribute att in attLst) { if (att.Name.StartsWith(XamlConstants.Xmlns)) { var rootAtt = doc.DocumentElement.GetAttributeNode(att.Name); if (rootAtt != null && rootAtt.Value == att.Value) { xml.Attributes.Remove(att); } } } } return(new XamlObject(this, xml, elementType, instance)); }
public BindingWrapper(XamlObject xamlObject) : base(xamlObject) { }
XamlObject ParseObject(XmlElement element) { Type elementType = settings.TypeFinder.GetType(element.NamespaceURI, element.LocalName); if (typeof(FrameworkTemplate).IsAssignableFrom(elementType)) { var xamlObj = new XamlObject(document, element, elementType, TemplateHelper.GetFrameworkTemplate(element, currentXamlObject)); xamlObj.ParentObject = currentXamlObject; return(xamlObj); } if (elementType == null) { elementType = settings.TypeFinder.GetType(element.NamespaceURI, element.LocalName + "Extension"); if (elementType == null) { throw new XamlLoadException("Cannot find type " + element.Name); } } XmlSpace oldXmlSpace = currentXmlSpace; XamlObject parentXamlObject = currentXamlObject; if (element.HasAttribute("xml:space")) { currentXmlSpace = (XmlSpace)Enum.Parse(typeof(XmlSpace), element.GetAttribute("xml:space"), true); } XamlPropertyInfo defaultProperty = GetDefaultProperty(elementType); XamlTextValue initializeFromTextValueInsteadOfConstructor = null; if (defaultProperty == null) { int numberOfTextNodes = 0; bool onlyTextNodes = true; foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.Text) { numberOfTextNodes++; } else if (childNode.NodeType == XmlNodeType.Element) { onlyTextNodes = false; } } if (elementType == typeof(string) && numberOfTextNodes == 0) { initializeFromTextValueInsteadOfConstructor = new XamlTextValue(document, string.Empty); } else if (onlyTextNodes && numberOfTextNodes == 1) { foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.Text) { currentParsedNode = childNode; initializeFromTextValueInsteadOfConstructor = (XamlTextValue)ParseValue(childNode); } } } } currentParsedNode = element; object instance; if (initializeFromTextValueInsteadOfConstructor != null) { instance = TypeDescriptor.GetConverter(elementType) .ConvertFromString( document.GetTypeDescriptorContext(null), CultureInfo.InvariantCulture, initializeFromTextValueInsteadOfConstructor.Text); } else { instance = settings.CreateInstanceCallback(elementType, emptyObjectArray); } XamlObject obj = new XamlObject(document, element, elementType, instance); currentXamlObject = obj; obj.ParentObject = parentXamlObject; if (parentXamlObject == null && obj.Instance is DependencyObject) { NameScope.SetNameScope((DependencyObject)obj.Instance, new NameScope()); } ISupportInitialize iSupportInitializeInstance = instance as ISupportInitialize; if (iSupportInitializeInstance != null) { iSupportInitializeInstance.BeginInit(); } foreach (XmlAttribute attribute in element.Attributes) { if (attribute.Value.StartsWith("clr-namespace", StringComparison.OrdinalIgnoreCase)) { // the format is "clr-namespace:<Namespace here>;assembly=<Assembly name here>" var clrNamespace = attribute.Value.Split(new[] { ':', ';', '=' }); if (clrNamespace.Length == 4) { // get the assembly name var assembly = settings.TypeFinder.LoadAssembly(clrNamespace[3]); if (assembly != null) { settings.TypeFinder.RegisterAssembly(assembly); } } else { // if no assembly name is there, then load the assembly of the opened file. var assembly = settings.TypeFinder.LoadAssembly(null); if (assembly != null) { settings.TypeFinder.RegisterAssembly(assembly); } } } if (attribute.NamespaceURI == XamlConstants.XmlnsNamespace) { continue; } if (attribute.Name == "xml:space") { continue; } if (GetAttributeNamespace(attribute) == XamlConstants.XamlNamespace || GetAttributeNamespace(attribute) == XamlConstants.Xaml2009Namespace) { if (attribute.LocalName == "Name") { try { NameScopeHelper.NameChanged(obj, null, attribute.Value); } catch (Exception x) { ReportException(x, attribute); } } continue; } ParseObjectAttribute(obj, attribute); } ParseObjectContent(obj, element, defaultProperty, initializeFromTextValueInsteadOfConstructor); if (iSupportInitializeInstance != null) { iSupportInitializeInstance.EndInit(); } currentXmlSpace = oldXmlSpace; currentXamlObject = parentXamlObject; return(obj); }
void ParseObjectContent(XamlObject obj, XmlElement element, XamlPropertyInfo defaultProperty, XamlTextValue initializeFromTextValueInsteadOfConstructor) { bool isDefaultValueSet = false; XamlProperty collectionProperty = null; object collectionInstance = null; Type collectionType = null; XmlElement collectionPropertyElement = null; var elementChildNodes = GetNormalizedChildNodes(element); if (defaultProperty == null && obj.Instance != null && CollectionSupport.IsCollectionType(obj.Instance.GetType())) { XamlObject parentObj = obj.ParentObject; var parentElement = element.ParentNode; XamlPropertyInfo propertyInfo; if (parentObj != null) { propertyInfo = GetPropertyInfo(settings.TypeFinder, parentObj.Instance, parentObj.ElementType, parentElement.NamespaceURI, parentElement.LocalName); collectionProperty = FindExistingXamlProperty(parentObj, propertyInfo); } collectionInstance = obj.Instance; collectionType = obj.ElementType; collectionPropertyElement = element; } else if (defaultProperty != null && defaultProperty.IsCollection && !element.IsEmpty) { foreach (XmlNode childNode in elementChildNodes) { currentParsedNode = childNode; XmlElement childElement = childNode as XmlElement; if (childElement == null || !ObjectChildElementIsPropertyElement(childElement)) { obj.AddProperty(collectionProperty = new XamlProperty(obj, defaultProperty)); collectionType = defaultProperty.ReturnType; collectionInstance = defaultProperty.GetValue(obj.Instance); break; } } } currentParsedNode = element; if (collectionType != null && collectionInstance == null && elementChildNodes.Count() == 1) { var firstChild = elementChildNodes.First() as XmlElement; if (ObjectChildElementIsCollectionInstance(firstChild, collectionType)) { collectionInstance = ParseObject(firstChild); collectionProperty.PropertyValue = (XamlPropertyValue)collectionInstance; } else { throw new XamlLoadException("Collection Instance is null"); } } else { foreach (XmlNode childNode in elementChildNodes) { currentParsedNode = childNode; XmlElement childElement = childNode as XmlElement; if (childElement != null) { if (childElement.NamespaceURI == XamlConstants.XamlNamespace) { continue; } if (ObjectChildElementIsPropertyElement(childElement)) { ParseObjectChildElementAsPropertyElement(obj, childElement, defaultProperty); continue; } } if (initializeFromTextValueInsteadOfConstructor != null) { continue; } XamlPropertyValue childValue = ParseValue(childNode); if (childValue != null) { if (collectionProperty != null) { collectionProperty.ParserAddCollectionElement(collectionPropertyElement, childValue); CollectionSupport.AddToCollection(collectionType, collectionInstance, childValue); } else if (collectionProperty == null && collectionInstance is ResourceDictionary) { CollectionSupport.AddToCollection(collectionType, collectionInstance, childValue); } else { if (defaultProperty == null) { throw new XamlLoadException( "This element does not have a default value, cannot assign to it"); } if (isDefaultValueSet) { throw new XamlLoadException("default property may have only one value assigned"); } obj.AddProperty(new XamlProperty(obj, defaultProperty, childValue)); isDefaultValueSet = true; } } } } currentParsedNode = element; }
void ParseObjectChildElementAsPropertyElement(XamlObject obj, XmlElement element, XamlPropertyInfo defaultProperty) { Debug.Assert(element.LocalName.Contains(".")); // this is a element property syntax XamlPropertyInfo propertyInfo = GetPropertyInfo(settings.TypeFinder, obj.Instance, obj.ElementType, element.NamespaceURI, element.LocalName); bool valueWasSet = false; object collectionInstance = null; bool isElementChildACollectionForProperty = false; XamlProperty collectionProperty = null; if (propertyInfo.IsCollection) { if (defaultProperty != null && defaultProperty.FullyQualifiedName == propertyInfo.FullyQualifiedName) { foreach (XamlProperty existing in obj.Properties) { if (existing.propertyInfo == defaultProperty) { collectionProperty = existing; break; } } } if (collectionProperty == null) { obj.AddProperty(collectionProperty = new XamlProperty(obj, propertyInfo)); } isElementChildACollectionForProperty = IsElementChildACollectionForProperty(settings.TypeFinder, element, propertyInfo); if (isElementChildACollectionForProperty) { collectionProperty.ParserSetPropertyElement((XmlElement)element.ChildNodes.Cast <XmlNode>() .Where(x => !(x is XmlWhitespace)) .First()); } else { collectionInstance = collectionProperty.propertyInfo.GetValue(obj.Instance); collectionProperty.ParserSetPropertyElement(element); collectionInstance = collectionInstance ?? Activator.CreateInstance(collectionProperty.propertyInfo.ReturnType); } } XmlSpace oldXmlSpace = currentXmlSpace; if (element.HasAttribute("xml:space")) { currentXmlSpace = (XmlSpace)Enum.Parse(typeof(XmlSpace), element.GetAttribute("xml:space"), true); } foreach (XmlNode childNode in element.ChildNodes) { currentParsedNode = childNode; XamlPropertyValue childValue = ParseValue(childNode); if (childValue != null) { if (propertyInfo.IsCollection) { if (isElementChildACollectionForProperty) { collectionProperty.PropertyValue = childValue; } else { CollectionSupport.AddToCollection(propertyInfo.ReturnType, collectionInstance, childValue); collectionProperty.ParserAddCollectionElement(element, childValue); } } else { if (valueWasSet) { throw new XamlLoadException("non-collection property may have only one child element"); } valueWasSet = true; XamlProperty xp = new XamlProperty(obj, propertyInfo, childValue); xp.ParserSetPropertyElement(element); obj.AddProperty(xp); } } } currentParsedNode = element; currentXmlSpace = oldXmlSpace; }
internal override void OnParentPropertyChanged() { parentObject = (ParentProperty != null) ? ParentProperty.ParentObject : null; base.OnParentPropertyChanged(); }
/// <summary> /// Generates XAML markup extension code for the object. /// </summary> public static string Print(XamlObject obj) { StringBuilder sb = new StringBuilder(); sb.Append("{"); sb.Append(obj.GetNameForMarkupExtension()); bool first = true; var properties = obj.Properties.ToList(); if (obj.ElementType == typeof(Binding)) { var p = obj.Properties.FirstOrDefault(x => x.PropertyName == "Path"); if (p != null && p.IsSet) { sb.Append(" "); AppendPropertyValue(sb, p.PropertyValue, false); properties.Remove(p); first = false; } } else if (obj.ElementType == typeof(Reference)) { var p = obj.Properties.FirstOrDefault(x => x.PropertyName == "Name"); if (p != null && p.IsSet) { sb.Append(" "); AppendPropertyValue(sb, p.PropertyValue, false); properties.Remove(p); first = false; } } else if (obj.ElementType == typeof(StaticResourceExtension)) { var p = obj.Properties.FirstOrDefault(x => x.PropertyName == "ResourceKey"); if (p != null && p.IsSet) { sb.Append(" "); AppendPropertyValue(sb, p.PropertyValue, false); properties.Remove(p); first = false; } } foreach (var property in properties) { if (!property.IsSet) { continue; } if (first) { sb.Append(" "); } else { sb.Append(", "); } first = false; sb.Append(property.GetNameForMarkupExtension()); sb.Append("="); AppendPropertyValue(sb, property.PropertyValue, property.ReturnType == typeof(string)); } sb.Append("}"); return(sb.ToString()); }
internal static object CreateObjectFromAttributeText(string valueText, Type targetType, XamlObject scope) { var converter = XamlNormalPropertyInfo.GetCustomTypeConverter(targetType) ?? TypeDescriptor.GetConverter(targetType); return(converter.ConvertFromInvariantString( scope.OwnerDocument.GetTypeDescriptorContext(scope), valueText)); }
internal static MarkupExtensionWrapper CreateWrapper(Type markupExtensionWrapperType, XamlObject xamlObject) { return(Activator.CreateInstance(markupExtensionWrapperType, xamlObject) as MarkupExtensionWrapper); }
public StaticResourceWrapper(XamlObject xamlObject) : base(xamlObject) { }
/// <summary> /// Called by XamlParser to finish initializing the document. /// </summary> internal void ParseComplete(XamlObject rootElement) { this._rootElement = rootElement; }