Пример #1
0
 private void ValidateMemberOnType(XamlMember member, XamlType type)
 {
     if (member.IsUnknown || type.IsUnknown)
     {
         return;
     }
     if (member.IsDirective)
     {
         if (member == XamlLanguage.Items)
         {
             if (!type.IsCollection && !type.IsDictionary)
             {
                 ValidationError(SR.UnexpectedXamlDictionary(member.Name, GetXamlTypeName(_stack.TopFrame.Type)));
             }
         }
         if (member == XamlLanguage.Class && _stack.Depth > 1)
         {
             ValidationError(SR.UnexpectedXamlClass);
         }
     }
     else if (member.IsAttachable)
     {
         if (!type.CanAssignTo(member.TargetType))
         {
             ValidationError(SR.UnexpectedXamlAttachableMember(member.Name, GetXamlTypeName(member.TargetType)));
         }
     }
     else if (!member.IsDirective && !type.CanAssignTo(member.DeclaringType))
     {
         ValidationError(SR.UnexpectedXamlMemberNotAssignable(member.Name, GetXamlTypeName(type)));
     }
 }
Пример #2
0
        /// <SecurityNote>
        /// Because this is a public virtual method, idempotence cannot be guaranteed.
        /// S.X doesn't use this method at all; but any externals consumers who are doing security checks
        /// based on the returned method should make sure that they are resillient to changing results.
        /// </SecurityNote>
        public virtual MethodInfo GetAddMethod(XamlType contentType)
        {
            if (contentType == null)
            {
                throw new ArgumentNullException(nameof(contentType));
            }
            if (IsUnknown || _xamlType.ItemType == null)
            {
                return(null);
            }

            // Common case is that we match the item type. Short-circuit any additional lookup.
            if (contentType == _xamlType.ItemType ||
                (_xamlType.AllowedContentTypes.Count == 1 && contentType.CanAssignTo(_xamlType.ItemType)))
            {
                return(_xamlType.AddMethod);
            }

            // Only collections can have additional content types
            if (!_xamlType.IsCollection)
            {
                return(null);
            }

            // Populate the dictionary of all available Add methods
            MethodInfo addMethod;

            if (_addMethods == null)
            {
                Dictionary <XamlType, MethodInfo> addMethods = new Dictionary <XamlType, MethodInfo>();
                addMethods.Add(_xamlType.ItemType, _xamlType.AddMethod);
                foreach (XamlType type in _xamlType.AllowedContentTypes)
                {
                    addMethod = CollectionReflector.GetAddMethod(
                        _xamlType.UnderlyingType, type.UnderlyingType);
                    if (addMethod != null)
                    {
                        addMethods.Add(type, addMethod);
                    }
                }
                _addMethods = addMethods;
            }

            // First try the fast path.  Look for an exact match.
            if (_addMethods.TryGetValue(contentType, out addMethod))
            {
                return(addMethod);
            }

            // Next the slow path.  Check each one for is assignable from.
            foreach (KeyValuePair <XamlType, MethodInfo> pair in _addMethods)
            {
                if (contentType.CanAssignTo(pair.Key))
                {
                    return(pair.Value);
                }
            }

            return(null);
        }
Пример #3
0
        private void ValidateTypeToMemberOnStack(XamlType type)
        {
            if (type.IsUnknown)
            {
                return;
            }
            if (type == this.xNull)
            {
                ValidateValueToMemberOnStack(null);
            }
            XamlMember member = _stack.TopFrame.Member;

            if (member == XamlLanguage.PositionalParameters || type.IsMarkupExtension || member.IsUnknown)
            {
                return;
            }
            if (member == XamlLanguage.Items)
            {
                XamlType collectionType = GetCollectionTypeOnStack();
                if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null)
                {
                    return;
                }
                if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType)))
                {
                    ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType)));
                }
            }
            else if (member.IsDirective && (member.Type.IsCollection || member.Type.IsDictionary))
            {
                XamlType collectionType = member.Type;
                if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null)
                {
                    return;
                }
                if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType)))
                {
                    ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType)));
                }
            }
            else if (!type.CanAssignTo(member.Type))
            {
                if (member.DeferringLoader != null)
                {
                    return;
                }
                if (NodeType == XamlNodeType.Value)
                {
                    ValidationError(SR.UnassignableTypes(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name));
                }
                else
                {
                    ValidationError(SR.UnassignableTypesObject(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name));
                }
            }
        }
        public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot)
        {
            if (tagType == null)
            {
                throw new XamlInternalException(System.Xaml.SR.Get("ParentlessPropertyElement", new object[] { propName.ScopedName }));
            }
            XamlMember xamlAttachableProperty = null;
            XamlType   xamlType = null;
            string     propNs   = this.ResolveXamlNameNS(propName);

            if (propNs == null)
            {
                throw new XamlParseException(System.Xaml.SR.Get("PrefixNotFound", new object[] { propName.Prefix }));
            }
            XamlType rootTagType = tagIsRoot ? tagType : null;
            bool     flag        = false;

            if (tagType.IsGeneric)
            {
                flag = this.PropertyTypeMatchesGenericTagType(tagType, tagNamespace, propNs, propName.OwnerName);
                if (flag)
                {
                    xamlAttachableProperty = this.GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType);
                    if (xamlAttachableProperty != null)
                    {
                        return(xamlAttachableProperty);
                    }
                }
            }
            XamlTypeName typeName = new XamlTypeName(propNs, propName.Owner.Name);

            xamlType = this.GetXamlType(typeName, true);
            bool flag2 = tagType.CanAssignTo(xamlType);

            if (flag2)
            {
                xamlAttachableProperty = this.GetInstanceOrAttachableProperty(xamlType, propName.Name, rootTagType);
            }
            else
            {
                xamlAttachableProperty = this.GetXamlAttachableProperty(xamlType, propName.Name);
            }
            if (xamlAttachableProperty != null)
            {
                return(xamlAttachableProperty);
            }
            XamlType declaringType = flag ? tagType : xamlType;

            if (flag || flag2)
            {
                return(this.CreateUnknownMember(declaringType, propName.Name));
            }
            return(this.CreateUnknownAttachableMember(declaringType, propName.Name));
        }
        bool IsAssignableTo(XamlType type, Type assignableTo)
        {
            XamlType liveXamlType = this.schemaContext.GetXamlType(assignableTo);
            XamlType rolXamlType  = this.schemaContext.GetXamlType(new XamlTypeName(liveXamlType));

            if (rolXamlType == null)
            {
                // assignableTo is not in the project references, so project must not be deriving from it
                return(false);
            }
            return(type.CanAssignTo(rolXamlType));
        }
 public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot)
 {
     if (tagType == null)
     {
         throw new XamlInternalException(System.Xaml.SR.Get("ParentlessPropertyElement", new object[] { propName.ScopedName }));
     }
     XamlMember xamlAttachableProperty = null;
     XamlType xamlType = null;
     string propNs = this.ResolveXamlNameNS(propName);
     if (propNs == null)
     {
         throw new XamlParseException(System.Xaml.SR.Get("PrefixNotFound", new object[] { propName.Prefix }));
     }
     XamlType rootTagType = tagIsRoot ? tagType : null;
     bool flag = false;
     if (tagType.IsGeneric)
     {
         flag = this.PropertyTypeMatchesGenericTagType(tagType, tagNamespace, propNs, propName.OwnerName);
         if (flag)
         {
             xamlAttachableProperty = this.GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType);
             if (xamlAttachableProperty != null)
             {
                 return xamlAttachableProperty;
             }
         }
     }
     XamlTypeName typeName = new XamlTypeName(propNs, propName.Owner.Name);
     xamlType = this.GetXamlType(typeName, true);
     bool flag2 = tagType.CanAssignTo(xamlType);
     if (flag2)
     {
         xamlAttachableProperty = this.GetInstanceOrAttachableProperty(xamlType, propName.Name, rootTagType);
     }
     else
     {
         xamlAttachableProperty = this.GetXamlAttachableProperty(xamlType, propName.Name);
     }
     if (xamlAttachableProperty != null)
     {
         return xamlAttachableProperty;
     }
     XamlType declaringType = flag ? tagType : xamlType;
     if (flag || flag2)
     {
         return this.CreateUnknownMember(declaringType, propName.Name);
     }
     return this.CreateUnknownAttachableMember(declaringType, propName.Name);
 }
Пример #7
0
 public virtual MethodInfo GetAddMethod(XamlType contentType)
 {
     if (contentType == null)
     {
         throw new ArgumentNullException("contentType");
     }
     if (!this.IsUnknown && (this._xamlType.ItemType != null))
     {
         MethodInfo addMethod;
         if ((contentType == this._xamlType.ItemType) || ((this._xamlType.AllowedContentTypes.Count == 1) && contentType.CanAssignTo(this._xamlType.ItemType)))
         {
             return(this._xamlType.AddMethod);
         }
         if (!this._xamlType.IsCollection)
         {
             return(null);
         }
         if (this._addMethods == null)
         {
             Dictionary <XamlType, MethodInfo> dictionary = new Dictionary <XamlType, MethodInfo>();
             dictionary.Add(this._xamlType.ItemType, this._xamlType.AddMethod);
             foreach (XamlType type in this._xamlType.AllowedContentTypes)
             {
                 addMethod = CollectionReflector.GetAddMethod(this._xamlType.UnderlyingType, type.UnderlyingType);
                 if (addMethod != null)
                 {
                     dictionary.Add(type, addMethod);
                 }
             }
             this._addMethods = dictionary;
         }
         if (this._addMethods.TryGetValue(contentType, out addMethod))
         {
             return(addMethod);
         }
         foreach (KeyValuePair <XamlType, MethodInfo> pair in this._addMethods)
         {
             if (contentType.CanAssignTo(pair.Key))
             {
                 return(pair.Value);
             }
         }
     }
     return(null);
 }
Пример #8
0
        internal XamlMember GetProperty(Int16 propertyId, XamlType parentType)
        {
            BamlProperty bamlProperty;
            XamlMember   xamlMember;

            if (TryGetBamlProperty(propertyId, out bamlProperty, out xamlMember))
            {
                if (xamlMember != null)
                {
                    return(xamlMember);
                }
                XamlType declaringType = GetXamlType(bamlProperty.DeclaringTypeId);

                // If the parent type & declaring type are assignable, then it could
                // be either a regular property or attachable.
                if (parentType.CanAssignTo(declaringType))
                {
                    xamlMember = declaringType.GetMember(bamlProperty.Name);
                    if (xamlMember == null)
                    {
                        xamlMember = declaringType.GetAttachableMember(bamlProperty.Name);
                    }
                }
                else
                {
                    //If not assignable, it has to be an attachable member
                    xamlMember = declaringType.GetAttachableMember(bamlProperty.Name);
                }
                lock (_syncObject)
                {
                    _bamlProperty[propertyId] = xamlMember;
                }
                return(xamlMember);
            }

            throw new KeyNotFoundException();
        }
Пример #9
0
        // Token: 0x0600226B RID: 8811 RVA: 0x000AAF38 File Offset: 0x000A9138
        internal static void TransformNodes(XamlReader xamlReader, XamlObjectWriter xamlWriter, bool onlyLoadOneNode, bool skipJournaledProperties, bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer, XamlContextStack <WpfXamlFrame> stack, IStyleConnector styleConnector)
        {
            while (xamlReader.Read())
            {
                if (shouldPassLineNumberInfo && xamlLineInfo.LineNumber != 0)
                {
                    xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition);
                }
                switch (xamlReader.NodeType)
                {
                case XamlNodeType.StartObject:
                    WpfXamlLoader.WriteStartObject(xamlReader, xamlWriter, stack);
                    break;

                case XamlNodeType.GetObject:
                    xamlWriter.WriteNode(xamlReader);
                    if (stack.CurrentFrame.Type != null)
                    {
                        stack.PushScope();
                    }
                    stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type;
                    break;

                case XamlNodeType.EndObject:
                {
                    xamlWriter.WriteNode(xamlReader);
                    if (stack.CurrentFrame.FreezeFreezable)
                    {
                        Freezable freezable = xamlWriter.Result as Freezable;
                        if (freezable != null && freezable.CanFreeze)
                        {
                            freezable.Freeze();
                        }
                    }
                    DependencyObject dependencyObject = xamlWriter.Result as DependencyObject;
                    if (dependencyObject != null && stack.CurrentFrame.XmlSpace != null)
                    {
                        XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve");
                    }
                    stack.PopScope();
                    break;
                }

                case XamlNodeType.StartMember:
                    if ((!xamlReader.Member.IsDirective || !(xamlReader.Member == XamlReaderHelper.Freeze)) && xamlReader.Member != WpfXamlLoader.XmlSpace.Value && xamlReader.Member != XamlLanguage.Space)
                    {
                        xamlWriter.WriteNode(xamlReader);
                    }
                    stack.CurrentFrame.Property = xamlReader.Member;
                    if (skipJournaledProperties && !stack.CurrentFrame.Property.IsDirective)
                    {
                        WpfXamlMember wpfXamlMember = stack.CurrentFrame.Property as WpfXamlMember;
                        if (wpfXamlMember != null)
                        {
                            DependencyProperty dependencyProperty = wpfXamlMember.DependencyProperty;
                            if (dependencyProperty != null)
                            {
                                FrameworkPropertyMetadata frameworkPropertyMetadata = dependencyProperty.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata;
                                if (frameworkPropertyMetadata != null && frameworkPropertyMetadata.Journal)
                                {
                                    int num = 1;
                                    while (xamlReader.Read())
                                    {
                                        switch (xamlReader.NodeType)
                                        {
                                        case XamlNodeType.StartObject:
                                        {
                                            XamlType type      = xamlReader.Type;
                                            XamlType xamlType  = type.SchemaContext.GetXamlType(typeof(BindingBase));
                                            XamlType xamlType2 = type.SchemaContext.GetXamlType(typeof(DynamicResourceExtension));
                                            if (num == 1 && (type.CanAssignTo(xamlType) || type.CanAssignTo(xamlType2)))
                                            {
                                                num = 0;
                                                WpfXamlLoader.WriteStartObject(xamlReader, xamlWriter, stack);
                                            }
                                            break;
                                        }

                                        case XamlNodeType.StartMember:
                                            num++;
                                            break;

                                        case XamlNodeType.EndMember:
                                            num--;
                                            if (num == 0)
                                            {
                                                xamlWriter.WriteNode(xamlReader);
                                                stack.CurrentFrame.Property = null;
                                            }
                                            break;

                                        case XamlNodeType.Value:
                                        {
                                            DynamicResourceExtension dynamicResourceExtension = xamlReader.Value as DynamicResourceExtension;
                                            if (dynamicResourceExtension != null)
                                            {
                                                WpfXamlLoader.WriteValue(xamlReader, xamlWriter, stack, styleConnector);
                                            }
                                            break;
                                        }
                                        }
                                        if (num == 0)
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;

                case XamlNodeType.EndMember:
                {
                    WpfXamlFrame currentFrame = stack.CurrentFrame;
                    XamlMember   property     = currentFrame.Property;
                    if ((!property.IsDirective || !(property == XamlReaderHelper.Freeze)) && property != WpfXamlLoader.XmlSpace.Value && property != XamlLanguage.Space)
                    {
                        xamlWriter.WriteNode(xamlReader);
                    }
                    currentFrame.Property = null;
                    break;
                }

                case XamlNodeType.Value:
                    WpfXamlLoader.WriteValue(xamlReader, xamlWriter, stack, styleConnector);
                    break;

                case XamlNodeType.NamespaceDeclaration:
                    xamlWriter.WriteNode(xamlReader);
                    if (stack.Depth == 0 || stack.CurrentFrame.Type != null)
                    {
                        stack.PushScope();
                        for (WpfXamlFrame wpfXamlFrame = stack.CurrentFrame; wpfXamlFrame != null; wpfXamlFrame = (WpfXamlFrame)wpfXamlFrame.Previous)
                        {
                            if (wpfXamlFrame.XmlnsDictionary != null)
                            {
                                stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary(wpfXamlFrame.XmlnsDictionary);
                                break;
                            }
                        }
                        if (stack.CurrentFrame.XmlnsDictionary == null)
                        {
                            stack.CurrentFrame.XmlnsDictionary = new XmlnsDictionary();
                        }
                    }
                    stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace);
                    break;

                default:
                    xamlWriter.WriteNode(xamlReader);
                    break;
                }
                if (onlyLoadOneNode)
                {
                    return;
                }
            }
        }
 private void ValidateTypeToMemberOnStack(XamlType type)
 {
     if (type.IsUnknown)
     {
         return;
     }
     if (type == this.xNull)
     {
         ValidateValueToMemberOnStack(null);
     }
     XamlMember member = _stack.TopFrame.Member;
     if (member == XamlLanguage.PositionalParameters || type.IsMarkupExtension || member.IsUnknown)
     {
         return;
     }
     if (member == XamlLanguage.Items)
     {
         XamlType collectionType = GetCollectionTypeOnStack();
         if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null)
         {
             return;
         }
         if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType)))
         {
             ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType)));
         }
     }
     else if (member.IsDirective && (member.Type.IsCollection || member.Type.IsDictionary))
     {
         XamlType collectionType = member.Type;
         if (collectionType == null || collectionType.IsUnknown || collectionType.AllowedContentTypes == null)
         {
             return;
         }
         if (!collectionType.AllowedContentTypes.Any(contentType => type.CanAssignTo(contentType)))
         {
             ValidationError(SR.UnassignableCollection(GetXamlTypeName(type), GetXamlTypeName(collectionType.ItemType), GetXamlTypeName(collectionType)));
         }
     }
     else if (!type.CanAssignTo(member.Type))
     {
         if (member.DeferringLoader != null)
         {
             return;
         }
         if (NodeType == XamlNodeType.Value)
         {
             ValidationError(SR.UnassignableTypes(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name));
         }
         else
         {
             ValidationError(SR.UnassignableTypesObject(GetXamlTypeName(type), GetXamlTypeName(member.Type), member.Name));
         }
     }
 }
 private void ValidateMemberOnType(XamlMember member, XamlType type)
 {
     if (member.IsUnknown || type.IsUnknown)
     {
         return;
     }
     if (member.IsDirective)
     {
         if (member == XamlLanguage.Items)
         {
             if (!type.IsCollection && !type.IsDictionary)
             {
                 ValidationError(SR.UnexpectedXamlDictionary(member.Name, GetXamlTypeName(_stack.TopFrame.Type)));
             }
         }
         if (member == XamlLanguage.Class && _stack.Depth > 1)
         {
             ValidationError(SR.UnexpectedXamlClass);
         }
     }
     else if (member.IsAttachable)
     {
         if (!type.CanAssignTo(member.TargetType))
         {
             ValidationError(SR.UnexpectedXamlAttachableMember(member.Name, GetXamlTypeName(member.TargetType)));
         }
     }
     else if (!member.IsDirective && !type.CanAssignTo(member.DeclaringType))
     {
         ValidationError(SR.UnexpectedXamlMemberNotAssignable(member.Name, GetXamlTypeName(type)));
     }
 }
Пример #12
0
        internal XamlMember GetProperty(Int16 propertyId, XamlType parentType)
        {
            BamlProperty bamlProperty;
            XamlMember xamlMember;

            if (TryGetBamlProperty(propertyId, out bamlProperty, out xamlMember))
            {
                if (xamlMember != null)
                {
                    return xamlMember;
                }
                XamlType declaringType = GetXamlType(bamlProperty.DeclaringTypeId);

                // If the parent type & declaring type are assignable, then it could
                // be either a regular property or attachable.
                if (parentType.CanAssignTo(declaringType))
                {
                    xamlMember = declaringType.GetMember(bamlProperty.Name);
                    if (xamlMember == null)
                    {
                        xamlMember = declaringType.GetAttachableMember(bamlProperty.Name);
                    }
                }
                else
                {
                    //If not assignable, it has to be an attachable member
                    xamlMember = declaringType.GetAttachableMember(bamlProperty.Name);
                }
                lock (_syncObject)
                {
                    _bamlProperty[propertyId] = xamlMember;
                }
                return xamlMember;
            }

            throw new KeyNotFoundException();
        }
        internal static void TransformNodes(System.Xaml.XamlReader xamlReader, System.Xaml.XamlObjectWriter xamlWriter,
                                            bool onlyLoadOneNode,
                                            bool skipJournaledProperties,
                                            bool shouldPassLineNumberInfo, IXamlLineInfo xamlLineInfo, IXamlLineInfoConsumer xamlLineInfoConsumer,
                                            XamlContextStack <WpfXamlFrame> stack,
                                            IStyleConnector styleConnector)
        {
            while (xamlReader.Read())
            {
                if (shouldPassLineNumberInfo)
                {
                    if (xamlLineInfo.LineNumber != 0)
                    {
                        xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition);
                    }
                }

                switch (xamlReader.NodeType)
                {
                case System.Xaml.XamlNodeType.NamespaceDeclaration:
                    xamlWriter.WriteNode(xamlReader);
                    if (stack.Depth == 0 || stack.CurrentFrame.Type != null)
                    {
                        stack.PushScope();
                        // Need to create an XmlnsDictionary.
                        // Look up stack to see if we have one earlier
                        //  If so, use that.  Otherwise new a xmlnsDictionary
                        WpfXamlFrame iteratorFrame = stack.CurrentFrame;
                        while (iteratorFrame != null)
                        {
                            if (iteratorFrame.XmlnsDictionary != null)
                            {
                                stack.CurrentFrame.XmlnsDictionary =
                                    new XmlnsDictionary(iteratorFrame.XmlnsDictionary);
                                break;
                            }
                            iteratorFrame = (WpfXamlFrame)iteratorFrame.Previous;
                        }
                        if (stack.CurrentFrame.XmlnsDictionary == null)
                        {
                            stack.CurrentFrame.XmlnsDictionary =
                                new XmlnsDictionary();
                        }
                    }
                    stack.CurrentFrame.XmlnsDictionary.Add(xamlReader.Namespace.Prefix, xamlReader.Namespace.Namespace);
                    break;

                case System.Xaml.XamlNodeType.StartObject:
                    WriteStartObject(xamlReader, xamlWriter, stack);
                    break;

                case System.Xaml.XamlNodeType.GetObject:
                    xamlWriter.WriteNode(xamlReader);
                    // If there wasn't a namespace node before this get object, need to pushScope.
                    if (stack.CurrentFrame.Type != null)
                    {
                        stack.PushScope();
                    }
                    stack.CurrentFrame.Type = stack.PreviousFrame.Property.Type;
                    break;

                case System.Xaml.XamlNodeType.EndObject:
                    xamlWriter.WriteNode(xamlReader);
                    // Freeze if required
                    if (stack.CurrentFrame.FreezeFreezable)
                    {
                        Freezable freezable = xamlWriter.Result as Freezable;
                        if (freezable != null && freezable.CanFreeze)
                        {
                            freezable.Freeze();
                        }
                    }
                    DependencyObject dependencyObject = xamlWriter.Result as DependencyObject;
                    if (dependencyObject != null && stack.CurrentFrame.XmlSpace.HasValue)
                    {
                        XmlAttributeProperties.SetXmlSpace(dependencyObject, stack.CurrentFrame.XmlSpace.Value ? "default" : "preserve");
                    }
                    stack.PopScope();
                    break;

                case System.Xaml.XamlNodeType.StartMember:
                    // ObjectWriter should NOT process PresentationOptions:Freeze directive since it is Unknown
                    // The space directive node stream should not be written because it induces object instantiation,
                    // and the Baml2006Reader can produce space directives prematurely.
                    if (!(xamlReader.Member.IsDirective && xamlReader.Member == XamlReaderHelper.Freeze) &&
                        xamlReader.Member != XmlSpace.Value &&
                        xamlReader.Member != XamlLanguage.Space)
                    {
                        xamlWriter.WriteNode(xamlReader);
                    }

                    stack.CurrentFrame.Property = xamlReader.Member;
                    if (skipJournaledProperties)
                    {
                        if (!stack.CurrentFrame.Property.IsDirective)
                        {
                            System.Windows.Baml2006.WpfXamlMember wpfMember = stack.CurrentFrame.Property as System.Windows.Baml2006.WpfXamlMember;
                            if (wpfMember != null)
                            {
                                DependencyProperty prop = wpfMember.DependencyProperty;

                                if (prop != null)
                                {
                                    FrameworkPropertyMetadata metadata = prop.GetMetadata(stack.CurrentFrame.Type.UnderlyingType) as FrameworkPropertyMetadata;
                                    if (metadata != null && metadata.Journal == true)
                                    {
                                        // Ignore the BAML for this member, unless it declares a value that wasn't journaled - namely a binding or a dynamic resource
                                        int count = 1;
                                        while (xamlReader.Read())
                                        {
                                            switch (xamlReader.NodeType)
                                            {
                                            case System.Xaml.XamlNodeType.StartMember:
                                                count++;
                                                break;

                                            case System.Xaml.XamlNodeType.StartObject:
                                                XamlType xamlType            = xamlReader.Type;
                                                XamlType bindingBaseType     = xamlType.SchemaContext.GetXamlType(typeof(BindingBase));
                                                XamlType dynamicResourceType = xamlType.SchemaContext.GetXamlType(typeof(DynamicResourceExtension));
                                                if (count == 1 && (xamlType.CanAssignTo(bindingBaseType) || xamlType.CanAssignTo(dynamicResourceType)))
                                                {
                                                    count = 0;
                                                    WriteStartObject(xamlReader, xamlWriter, stack);
                                                }
                                                break;

                                            case System.Xaml.XamlNodeType.EndMember:
                                                count--;
                                                if (count == 0)
                                                {
                                                    xamlWriter.WriteNode(xamlReader);
                                                    stack.CurrentFrame.Property = null;
                                                }
                                                break;

                                            case System.Xaml.XamlNodeType.Value:
                                                DynamicResourceExtension value = xamlReader.Value as DynamicResourceExtension;
                                                if (value != null)
                                                {
                                                    WriteValue(xamlReader, xamlWriter, stack, styleConnector);
                                                }
                                                break;
                                            }
                                            if (count == 0)
                                            {
                                                break;
                                            }
                                        }

                                        System.Diagnostics.Debug.Assert(count == 0, "Mismatch StartMember/EndMember");
                                    }
                                }
                            }
                        }
                    }
                    break;

                case System.Xaml.XamlNodeType.EndMember:
                    WpfXamlFrame currentFrame    = stack.CurrentFrame;
                    XamlMember   currentProperty = currentFrame.Property;
                    // ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown
                    // The space directive node stream should not be written because it induces object instantiation,
                    // and the Baml2006Reader can produce space directives prematurely.
                    if (!(currentProperty.IsDirective && currentProperty == XamlReaderHelper.Freeze) &&
                        currentProperty != XmlSpace.Value &&
                        currentProperty != XamlLanguage.Space)
                    {
                        xamlWriter.WriteNode(xamlReader);
                    }
                    currentFrame.Property = null;
                    break;

                case System.Xaml.XamlNodeType.Value:
                    WriteValue(xamlReader, xamlWriter, stack, styleConnector);
                    break;

                default:
                    xamlWriter.WriteNode(xamlReader);
                    break;
                }

                //Only do this loop for one node if loadAsync
                if (onlyLoadOneNode)
                {
                    return;
                }
            }
        }
 public virtual MethodInfo GetAddMethod(XamlType contentType)
 {
     if (contentType == null)
     {
         throw new ArgumentNullException("contentType");
     }
     if (!this.IsUnknown && (this._xamlType.ItemType != null))
     {
         MethodInfo addMethod;
         if ((contentType == this._xamlType.ItemType) || ((this._xamlType.AllowedContentTypes.Count == 1) && contentType.CanAssignTo(this._xamlType.ItemType)))
         {
             return this._xamlType.AddMethod;
         }
         if (!this._xamlType.IsCollection)
         {
             return null;
         }
         if (this._addMethods == null)
         {
             Dictionary<XamlType, MethodInfo> dictionary = new Dictionary<XamlType, MethodInfo>();
             dictionary.Add(this._xamlType.ItemType, this._xamlType.AddMethod);
             foreach (XamlType type in this._xamlType.AllowedContentTypes)
             {
                 addMethod = CollectionReflector.GetAddMethod(this._xamlType.UnderlyingType, type.UnderlyingType);
                 if (addMethod != null)
                 {
                     dictionary.Add(type, addMethod);
                 }
             }
             this._addMethods = dictionary;
         }
         if (this._addMethods.TryGetValue(contentType, out addMethod))
         {
             return addMethod;
         }
         foreach (KeyValuePair<XamlType, MethodInfo> pair in this._addMethods)
         {
             if (contentType.CanAssignTo(pair.Key))
             {
                 return pair.Value;
             }
         }
     }
     return null;
 }
        private IEnumerable <XamlNode> LogicStream_CheckForStartGetCollectionFromMember()
        {
            XamlType   type1             = this._context.CurrentType;
            XamlMember currentMember     = this._context.CurrentMember;
            XamlType   type              = currentMember.Type;
            XamlType   iteratorVariable2 = (this._xamlScanner.NodeType == ScannerNodeType.TEXT) ? XamlLanguage.String : this._xamlScanner.Type;

            if (type.IsArray && (this._xamlScanner.Type != this.ArrayExtensionType))
            {
                IEnumerable <NamespaceDeclaration> newNamespaces = null;
                XamlTypeName           iteratorVariable4         = new XamlTypeName(type.ItemType);
                INamespacePrefixLookup prefixLookup = new NamespacePrefixLookup(out newNamespaces, new Func <string, string>(this._context.FindNamespaceByPrefix));
                string data = iteratorVariable4.ToString(prefixLookup);
                foreach (NamespaceDeclaration iteratorVariable7 in newNamespaces)
                {
                    yield return(new XamlNode(XamlNodeType.NamespaceDeclaration, iteratorVariable7));
                }
                yield return(this.Logic_StartObject(this.ArrayExtensionType, null));

                this._context.CurrentInImplicitArray = true;
                yield return(this.Logic_StartMember(this.ArrayTypeMember));

                yield return(new XamlNode(XamlNodeType.Value, data));

                yield return(this.Logic_EndMember());

                yield return(this.Logic_EndOfAttributes());

                yield return(this.Logic_StartMember(this.ItemsTypeMember));

                XamlType currentType = this._context.CurrentType;
                currentMember = this._context.CurrentMember;
                type          = currentMember.Type;
            }
            if (!currentMember.IsDirective && (type.IsCollection || type.IsDictionary))
            {
                bool iteratorVariable8 = false;
                if (currentMember.IsReadOnly || !this._context.CurrentMemberIsWriteVisible())
                {
                    iteratorVariable8 = true;
                }
                else if (((type.TypeConverter != null) && !currentMember.IsReadOnly) && (this._xamlScanner.NodeType == ScannerNodeType.TEXT))
                {
                    iteratorVariable8 = false;
                }
                else if (((iteratorVariable2 == null) || !iteratorVariable2.CanAssignTo(type)) && (iteratorVariable2 != null))
                {
                    if (!iteratorVariable2.IsMarkupExtension || this._xamlScanner.HasKeyAttribute)
                    {
                        iteratorVariable8 = true;
                    }
                    else if (iteratorVariable2 == XamlLanguage.Array)
                    {
                        iteratorVariable8 = true;
                    }
                }
                if (iteratorVariable8)
                {
                    yield return(this.Logic_StartGetObjectFromMember(type));

                    yield return(this.Logic_StartItemsProperty(type));
                }
            }
        }
Пример #16
0
        /// <summary>
        /// Resolves a property of the form 'Foo.Bar' or 'a:Foo.Bar', in
        /// in the context of a parent tag.  The parent tagType may or may not
        /// be covariant with the ownerType.  In the case of dotted attribute
        /// syntax, the namespace my be passed in.
        /// </summary>
        /// <param name="tagType">The xamlType of the enclosing Tag</param>
        /// <param name="tagNamespace">The namespace of the enclosing Tag</param>
        /// <param name="propName">The dotted name of the property</param>
        /// <param name="tagIsRoot">Whether the tag is the root of the document</param>
        /// <returns></returns>
        public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot)
        {
            if (tagType == null)
            {
                throw new XamlInternalException(SR.Get(SRID.ParentlessPropertyElement, propName.ScopedName));
            }
            XamlMember property  = null;
            XamlType   ownerType = null;
            string     ns        = ResolveXamlNameNS(propName);

            if (ns == null)
            {
                throw new XamlParseException(SR.Get(SRID.PrefixNotFound, propName.Prefix));
            }
            XamlType rootTagType = tagIsRoot ? tagType : null;

            // If we have <foo x:TA="" foo.bar=""/> we want foo in foo.bar to match the tag
            // type since there is no way to specify generic syntax in dotted property notation
            // If that fails, then we fall back to the non-generic case below.
            bool ownerTypeMatchesGenericTagType = false;

            if (tagType.IsGeneric)
            {
                ownerTypeMatchesGenericTagType = PropertyTypeMatchesGenericTagType(tagType, tagNamespace, ns, propName.OwnerName);
                if (ownerTypeMatchesGenericTagType)
                {
                    property = GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType);
                    if (property != null)
                    {
                        return(property);
                    }
                }
            }

            // Non-generic case, just resolve using the namespace and name
            XamlTypeName ownerTypeName = new XamlTypeName(ns, propName.Owner.Name);

            ownerType = GetXamlType(ownerTypeName, true);
            bool canAssignTagTypeToOwnerType = tagType.CanAssignTo(ownerType);

            if (canAssignTagTypeToOwnerType)
            {
                property = GetInstanceOrAttachableProperty(ownerType, propName.Name, rootTagType);
            }
            else
            {
                property = GetXamlAttachableProperty(ownerType, propName.Name);
            }
            if (property == null)
            {
                // This is an unknown property.
                // We don't know for sure whether or not it's attachable, so we go with our best guess.
                // If the owner type is same as the generic tag type, or is assignable to the tag type,
                // it's probably not attachable.
                XamlType declaringType = ownerTypeMatchesGenericTagType ? tagType : ownerType;
                if (ownerTypeMatchesGenericTagType || canAssignTagTypeToOwnerType)
                {
                    property = CreateUnknownMember(declaringType, propName.Name);
                }
                else
                {
                    property = CreateUnknownAttachableMember(declaringType, propName.Name);
                }
            }
            return(property);
        }
Пример #17
0
        private void InjectPropertyAndFrameIfNeeded(XamlType elementType, SByte flags)
        {
            // If we saved the Node stream for the first ME element of a dictionary to 
            // check if it had a key then process that now.
            if (_lookingForAKeyOnAMarkupExtensionInADictionaryDepth == _context.CurrentFrame.Depth) 
            { 
                RestoreSavedFirstItemInDictionary();
            } 

            XamlType parentType = _context.CurrentFrame.XamlType;
            XamlMember parentProperty = _context.CurrentFrame.Member;
 
            if (parentType != null)
            { 
                if (parentProperty == null) 
                {
                    // We have got two consecutive ElementStart records 
                    // We must insert an implicit content property between them
                    if (_context.CurrentFrame.ContentProperty != null)
                    {
                        _context.CurrentFrame.Member = parentProperty = _context.CurrentFrame.ContentProperty; 
                    }
                    else if (parentType.ContentProperty != null) 
                    { 
                        _context.CurrentFrame.Member = parentProperty = parentType.ContentProperty;
                    } 
                    else
                    {
                        if (parentType.IsCollection || parentType.IsDictionary)
                        { 
                            _context.CurrentFrame.Member = parentProperty = XamlLanguage.Items;
                        } 
                        else if (parentType.TypeConverter != null) 
                        {
                            _context.CurrentFrame.Member = parentProperty = XamlLanguage.Initialization; 
                        }
                        else
                        {
                            throw new XamlParseException(SR.Get(SRID.RecordOutOfOrder, parentType.Name)); 
                        }
                    } 
                    _context.CurrentFrame.Flags = Baml2006ReaderFrameFlags.HasImplicitProperty; 
                    _xamlNodesWriter.WriteStartMember(parentProperty);
 
                    // if we are NOT already spooling a template
                    if (_context.TemplateStartDepth < 0 && _isBinaryProvider)
                    {
                        if (parentProperty == BamlSchemaContext.FrameworkTemplateTemplateProperty) 
                        {
                            // If this is a template then spool the template into a Node List. 
                            _context.TemplateStartDepth = _context.CurrentFrame.Depth; 
                            _xamlTemplateNodeList = new XamlNodeList(_xamlNodesWriter.SchemaContext);
 
                            _xamlWriterStack.Push(_xamlNodesWriter);
                            _xamlNodesWriter = _xamlTemplateNodeList.Writer;
                        }
                    } 
                }
 
                XamlType parentPropertyType = parentProperty.Type; 
                // Normally an error except for collections
                if (parentPropertyType != null && (parentPropertyType.IsCollection || parentPropertyType.IsDictionary) && 
                    !parentProperty.IsDirective && (flags & ReaderFlags_AddedToTree) == 0)
                {
                    bool emitPreamble = false;
 
                    // If the collection property is Readonly then "retrieve" the collection.
                    if (parentProperty.IsReadOnly) 
                    { 
                        emitPreamble = true;
                    } 
                    // OR if the Value isn't assignable to the Collection emit the preable.
                    else if (!elementType.CanAssignTo(parentPropertyType))
                    {
                        // UNLESS: the Value is a Markup extension, then it is assumed that 
                        // the ProvidValue type will be AssignableFrom.
                        if (!elementType.IsMarkupExtension) 
                        { 
                            emitPreamble = true;
                        } 
                        // EXCEPT: if the BAML said it was Retrived
                        else if (_context.CurrentFrame.Flags == Baml2006ReaderFrameFlags.HasImplicitProperty)
                        {
                            emitPreamble = true; 
                        }
                        // OR: the ME is Array 
                        else if (elementType == XamlLanguage.Array) 
                        {
                            emitPreamble = true; 
                        }
                    }
                    if (emitPreamble)
                    { 
                        EmitGoItemsPreamble(parentPropertyType);
                    } 
 
                    // We may need to look for an x:Key on the ME in a dictionary.
                    // so save up the node stream for the whole element definition and check it 
                    // for an x:Key later.
                    if (!emitPreamble && parentPropertyType.IsDictionary && elementType.IsMarkupExtension)
                    {
                        StartSavingFirstItemInDictionary(); 
                    }
                } 
            } 
        }
Пример #18
0
        private IEnumerable <XamlNode> LogicStream_CheckForStartGetCollectionFromMember()
        {
            XamlType   currentType     = _context.CurrentType;
            XamlMember currentProperty = _context.CurrentMember;

            XamlType propertyType = currentProperty.Type;

            XamlType valueElementType = (_xamlScanner.NodeType == ScannerNodeType.TEXT)
                            ? XamlLanguage.String
                            : _xamlScanner.Type;

            if (propertyType.IsArray && _xamlScanner.Type != ArrayExtensionType)
            {
                IEnumerable <NamespaceDeclaration> newNamespaces = null;
                XamlTypeName           typeName       = new XamlTypeName(propertyType.ItemType);
                INamespacePrefixLookup prefixResolver = new NamespacePrefixLookup(out newNamespaces, _context.FindNamespaceByPrefix);
                string typeNameString = typeName.ToString(prefixResolver);    // SideEffects!!! prefixResolver will populate newNamespaces

                foreach (NamespaceDeclaration nsDecl in newNamespaces)
                {
                    yield return(new XamlNode(XamlNodeType.NamespaceDeclaration, nsDecl));
                }
                yield return(Logic_StartObject(ArrayExtensionType, null));

                _context.CurrentInImplicitArray = true;
                yield return(Logic_StartMember(ArrayTypeMember));

                yield return(new XamlNode(XamlNodeType.Value, typeNameString));

                yield return(Logic_EndMember());

                yield return(Logic_EndOfAttributes());

                yield return(Logic_StartMember(ItemsTypeMember));

                currentType     = _context.CurrentType;
                currentProperty = _context.CurrentMember;
                propertyType    = currentProperty.Type;
            }

            // Now Consider inserting special preamble to "Get" the collection:
            //   . GO
            //   . . SM _items
            if (!currentProperty.IsDirective && (propertyType.IsCollection || propertyType.IsDictionary))
            {
                bool emitPreamble = false;

                // If the collection property is Readonly then "Get" the collection.
                if (currentProperty.IsReadOnly || !_context.CurrentMemberIsWriteVisible())
                {
                    emitPreamble = true;
                }
                // If the collection is R/W and there is a type converter and we have Text
                // use the type converter rather than the GO; SM _items;
                else if (propertyType.TypeConverter != null && !currentProperty.IsReadOnly &&
                         _xamlScanner.NodeType == ScannerNodeType.TEXT)
                {
                    emitPreamble = false;
                }
                // Or if the Value (this is the first value in the collection)
                // isn't assignable to the Collection then "Get" the collection.
                else if (valueElementType == null || !valueElementType.CanAssignTo(propertyType))
                {
                    if (valueElementType != null)
                    {
                        // Unless: the Value is a Markup extension, in which case it is
                        // assumed that the ProvideValue() type will be AssignableFrom
                        // or If the next object has an x:Key in which case it must be
                        // a dictionary entry.
                        // so Don't "Get" the collection.
                        if (!valueElementType.IsMarkupExtension || _xamlScanner.HasKeyAttribute)
                        {
                            emitPreamble = true;
                        }
                        // Except: the Array Extension can never return a dictionary
                        // so for Array Extension do "Get" the collection.
                        // Note Array Extension would be suitable for List Collections
                        // Note: a fully validating parser should look at MarkupExtensionReturnType
                        // for this choice, there might be other MarkupExtensions that fit this.
                        else if (valueElementType == XamlLanguage.Array)
                        {
                            emitPreamble = true;
                        }
                    }
                }
                if (emitPreamble)
                {
                    yield return(Logic_StartGetObjectFromMember(propertyType));

                    yield return(Logic_StartItemsProperty(propertyType));
                }
            }
        }