Пример #1
0
        bool ProcessDirective(XamlReader reader, ClassData classData,
                              NamedObject currentObject, bool isRootElement, XamlNodeList strippedXamlNodes, out bool readNextNode)
        {
            Fx.Assert(reader.NodeType == XamlNodeType.StartMember, "Current node should be a Start Member Node");

            XamlMember member = reader.Member;
            bool       directiveRecognized = false;

            readNextNode = false;

            switch (member.Name)
            {
            case "Name":
                // Unlike all the other directives that we process, x:Name should be written
                // to the stripped output.
                strippedXamlNodes.Writer.WriteStartMember(member);

                string objectName = ReadAtom(reader, XamlLanguage.Name.Name);
                if (!objectName.StartsWith(XamlBuildTaskServices.SerializerReferenceNamePrefix,
                                           StringComparison.Ordinal))
                {
                    currentObject.Name = objectName;
                    classData.NamedObjects.Add(currentObject);
                }

                strippedXamlNodes.Writer.WriteValue(objectName);
                strippedXamlNodes.Writer.WriteEndMember();
                directiveRecognized = true;
                break;

            case "Class":
                if (isRootElement)
                {
                    string fullClassName = ReadAtom(reader, XamlLanguage.Class.Name);
                    SetClassName(fullClassName, classData);
                    directiveRecognized = true;
                }
                break;

            case "ClassModifier":
                if (isRootElement)
                {
                    string classModifier = ReadAtom(reader, XamlLanguage.ClassModifier.Name);
                    classData.IsPublic  = XamlBuildTaskServices.IsPublic(classModifier);
                    directiveRecognized = true;
                }
                break;

            case "FieldModifier":
                string fieldModifier = ReadAtom(reader, XamlLanguage.FieldModifier.Name);
                currentObject.Visibility = XamlBuildTaskServices.GetMemberVisibility(fieldModifier);
                directiveRecognized      = true;
                break;

            case "Code":
                string codeSnippet = ReadAtom(reader, XamlLanguage.Code.Name);
                classData.CodeSnippets.Add(codeSnippet);
                directiveRecognized = true;
                break;

            case "Members":
                foreach (PropertyData property in ReadProperties(reader.ReadSubtree()))
                {
                    classData.Properties.Add(property);
                }
                if (!classData.RequiresCompilationPass2)
                {
                    foreach (PropertyData property in classData.Properties)
                    {
                        if (property.Type.IsUnknown)
                        {
                            classData.RequiresCompilationPass2 = true;
                            break;
                        }
                    }
                }
                directiveRecognized = true;
                readNextNode        = true;
                break;

            case "ClassAttributes":
                foreach (AttributeData attribute in ReadAttributesCollection(reader.ReadSubtree()))
                {
                    classData.Attributes.Add(attribute);
                }
                directiveRecognized = true;
                readNextNode        = true;
                break;
            }

            if (directiveRecognized == true && readNextNode == false)
            {
                reader.Read();
                Fx.Assert(reader.NodeType == XamlNodeType.EndMember, "Current node should be a XamlEndmember");
            }

            return(directiveRecognized);
        }