private void EnqueueTextNode() { Debug.Assert(_accumulatedText != null, "Creating unnecessary XamlText objects"); // Don't send the text if it is Whitespace outside the root tag. if (!(_scannerStack.Depth == 0 && AccumulatedText.IsWhiteSpaceOnly)) { XamlScannerNode node = new XamlScannerNode(_xmlLineInfo); node.NodeType = ScannerNodeType.TEXT; node.TextContent = AccumulatedText; _readNodesQueue.Enqueue(node); } }
private bool ReadObjectElement_Object(string xmlns, string name, XamlScannerNode node) { if (IsXDataElement(xmlns, name)) { // If XData don't Enqueue the <x:XData> node. // just queue the InnerXml as TEXT (w/ IsTextXML == true). // This will advance the "current" xml node to the </x:XData> // which will be skipped when we return and the main loop // Read()s to the "next" XmlNode. ReadInnerXDataSection(); return(true); } IList <XamlTypeName> typeArgs = null; if (_typeArgumentAttribute != null) { string error; typeArgs = XamlTypeName.ParseListInternal(_typeArgumentAttribute.Value, _parserContext.FindNamespaceByPrefix, out error); if (typeArgs == null) { throw new XamlParseException(_typeArgumentAttribute.LineNumber, _typeArgumentAttribute.LinePosition, error); } } XamlTypeName typeName = new XamlTypeName(xmlns, name, typeArgs); node.Type = _parserContext.GetXamlType(typeName, true); // Finish initializing the attributes in the context of the // current Element. PostprocessAttributes(node); if (_scannerStack.Depth > 0) { // Sub-elements (and Text) are the definition of Content _scannerStack.CurrentlyInContent = true; } if (!node.IsEmptyTag) { node.NodeType = ScannerNodeType.ELEMENT; _scannerStack.Push(node.Type, node.TypeNamespace); } else { node.NodeType = ScannerNodeType.EMPTYELEMENT; } return(false); }
private void EnqueuePrefixDefinition(XamlAttribute attr) { string prefix = attr.XmlNsPrefixDefined; string xamlNamespace = attr.XmlNsUriDefined; _parserContext.AddNamespacePrefix(prefix, xamlNamespace); XamlScannerNode node = new XamlScannerNode(attr); node.NodeType = ScannerNodeType.PREFIXDEFINITION; node.Prefix = prefix; node.TypeNamespace = xamlNamespace; _readNodesQueue.Enqueue(node); }
private void EnqueuePrefixDefinition(XamlAttribute attr) { string xmlNsPrefixDefined = attr.XmlNsPrefixDefined; string xmlNsUriDefined = attr.XmlNsUriDefined; this._parserContext.AddNamespacePrefix(xmlNsPrefixDefined, xmlNsUriDefined); XamlScannerNode item = new XamlScannerNode(attr) { NodeType = ScannerNodeType.PREFIXDEFINITION, Prefix = xmlNsPrefixDefined, TypeNamespace = xmlNsUriDefined }; this._readNodesQueue.Enqueue(item); }
private void ReadObjectElement_DirectiveProperty(XamlMember dirProperty, XamlScannerNode node) { node.PropertyElement = dirProperty; this.PostprocessAttributes(node); if (this._scannerStack.Depth > 0) { this._scannerStack.CurrentlyInContent = false; } if (!node.IsEmptyTag) { this._scannerStack.CurrentProperty = node.PropertyElement; } node.NodeType = ScannerNodeType.PROPERTYELEMENT; node.IsCtorForcingMember = false; }
private void ReadObjectElement_NoNamespace(XamlName name, XamlScannerNode node) { XamlType type = this.CreateErrorXamlType(name, string.Empty); node.Type = type; this.PostprocessAttributes(node); if (!node.IsEmptyTag) { node.NodeType = ScannerNodeType.ELEMENT; this._scannerStack.Push(node.Type, node.TypeNamespace); } else { node.NodeType = ScannerNodeType.EMPTYELEMENT; } }
private void ReadInnerXDataSection() { XamlScannerNode item = new XamlScannerNode(this._xmlLineInfo); this._xmlReader.MoveToContent(); string str = this._xmlReader.ReadInnerXml().Trim(); item.NodeType = ScannerNodeType.TEXT; item.IsTextXML = true; XamlText text = new XamlText(true); text.Paste(str, false); item.TextContent = text; this._readNodesQueue.Enqueue(item); this.ProcessCurrentXmlNode(); }
private void ReadEndElement() { this.EnqueueAnyText(); if (this._scannerStack.CurrentProperty != null) { this._scannerStack.CurrentProperty = null; this._scannerStack.CurrentlyInContent = false; } else { this._scannerStack.Pop(); } XamlScannerNode item = new XamlScannerNode(this._xmlLineInfo) { NodeType = ScannerNodeType.ENDTAG }; this._readNodesQueue.Enqueue(item); }
private void ReadInnerXDataSection() { XamlScannerNode node = new XamlScannerNode(_xmlLineInfo); _xmlReader.MoveToContent(); // skip whitespaces string xmlData = _xmlReader.ReadInnerXml(); xmlData = xmlData.Trim(); node.NodeType = ScannerNodeType.TEXT; node.IsXDataText = true; XamlText xmlText = new XamlText(true); xmlText.Paste(xmlData, false); node.TextContent = xmlText; _readNodesQueue.Enqueue(node); // Read InnerXml will advance over the End xData tag and // we need to process the current XML state w/o going back for a Read(). ProcessCurrentXmlNode(); }
private void ReadObjectElement_DirectiveProperty(XamlMember dirProperty, XamlScannerNode node) { node.PropertyElement = dirProperty; // node.Type is not set so any found attributes are and error. // We don't want to skip them silently. PostprocessAttributes(node); if (_scannerStack.Depth > 0) { // A property Element tag will be the end of content. _scannerStack.CurrentlyInContent = false; } if (!node.IsEmptyTag) { _scannerStack.CurrentProperty = node.PropertyElement; } node.NodeType = ScannerNodeType.PROPERTYELEMENT; node.IsCtorForcingMember = false; }
private bool ReadObjectElement_Object(string xmlns, string name, XamlScannerNode node) { if (this.IsXDataElement(xmlns, name)) { this.ReadInnerXDataSection(); return(true); } IList <XamlTypeName> typeArguments = null; if (this._typeArgumentAttribute != null) { string str; typeArguments = XamlTypeName.ParseListInternal(this._typeArgumentAttribute.Value, new Func <string, string>(this._parserContext.FindNamespaceByPrefix), out str); if (typeArguments == null) { throw new XamlParseException(this._typeArgumentAttribute.LineNumber, this._typeArgumentAttribute.LinePosition, str); } } XamlTypeName typeName = new XamlTypeName(xmlns, name, typeArguments); node.Type = this._parserContext.GetXamlType(typeName, true); this.PostprocessAttributes(node); if (this._scannerStack.Depth > 0) { this._scannerStack.CurrentlyInContent = true; } if (!node.IsEmptyTag) { node.NodeType = ScannerNodeType.ELEMENT; this._scannerStack.Push(node.Type, node.TypeNamespace); } else { node.NodeType = ScannerNodeType.EMPTYELEMENT; } return(false); }
private void ReadEndElement() { // Accumulated text is enqued at start of tags (element and property) // and at end tags. EnqueueAnyText(); // if we are ending a property element tag clear the current property // if we are ending an element then pop off the current frame. if (_scannerStack.CurrentProperty != null) { _scannerStack.CurrentProperty = null; // List of Content is considered separately for each property. _scannerStack.CurrentlyInContent = false; } else { _scannerStack.Pop(); } XamlScannerNode node = new XamlScannerNode(_xmlLineInfo); node.NodeType = ScannerNodeType.ENDTAG; _readNodesQueue.Enqueue(node); }
public void Read() { this.LoadQueue(); this._currentNode = this._readNodesQueue.Dequeue(); }
private void EnqueueAnotherAttribute(bool isEmptyTag) { XamlAttribute attr = _attributes[_nextAttribute++]; XamlScannerNode node = new XamlScannerNode(attr); switch (attr.Kind) { case ScannerAttributeKind.Directive: case ScannerAttributeKind.Name: case ScannerAttributeKind.CtorDirective: node.NodeType = ScannerNodeType.DIRECTIVE; break; case ScannerAttributeKind.XmlSpace: // Empty tags don't have a stack frame to write on. // Empty XML tags don't have content to process spaces. if (!isEmptyTag) { if (KS.Eq(attr.Value, KnownStrings.Preserve)) { _scannerStack.CurrentXmlSpacePreserve = true; } else { _scannerStack.CurrentXmlSpacePreserve = false; } } node.NodeType = ScannerNodeType.DIRECTIVE; break; case ScannerAttributeKind.Event: case ScannerAttributeKind.Property: node.IsCtorForcingMember = true; node.NodeType = ScannerNodeType.ATTRIBUTE; break; case ScannerAttributeKind.Unknown: XamlMember prop = attr.Property; Debug.Assert(prop.IsUnknown); // force use of Ctor for unknown simple properties only node.IsCtorForcingMember = !prop.IsAttachable && !prop.IsDirective; node.NodeType = ScannerNodeType.ATTRIBUTE; break; case ScannerAttributeKind.AttachableProperty: node.NodeType = ScannerNodeType.ATTRIBUTE; break; default: throw new XamlInternalException(SR.Get(SRID.AttributeUnhandledKind)); } // (GetFixedDocumentSequence raises Exception "UnicodeString property does not // contain enough characters to correspond to the contents of Indices property.") // // XamlText.Paste normally converts CRLF to LF, even in attribute values. // When the property is Glyphs.UnicodeString, disable this; // the length of the string must correspond to the number of entries in // the corresponding Glyphs.Indices property. XamlMember attrProperty = attr.Property; bool convertCRLFtoLF = !(attrProperty != null && attrProperty.Name == "UnicodeString" && attrProperty.DeclaringType.Name == "Glyphs"); node.PropertyAttribute = attrProperty; XamlText xamlText = new XamlText(true); // Don't collapse spaces in attributes xamlText.Paste(attr.Value, false, convertCRLFtoLF); node.PropertyAttributeText = xamlText; node.Prefix = attr.Name.Prefix; _readNodesQueue.Enqueue(node); if (_nextAttribute >= _attributes.Count) { _attributes = null; _nextAttribute = -1; } }
private void PostprocessAttributes(XamlScannerNode node) { if (_attributes == null) { return; } _nextAttribute = 0; // Attributes on Properties are errors // and don't need this detailed processing. if (node.Type == null) { if (_settings.IgnoreUidsOnPropertyElements) { StripUidProperty(); } return; } bool tagIsRoot = _scannerStack.Depth == 0; // Attributes are processed before frame is pushed foreach (XamlAttribute attr in _attributes) { attr.Initialize(_parserContext, node.Type, node.TypeNamespace, tagIsRoot); } // Sort the Attributes into the order the XAML parser likes. List <XamlAttribute> ctorDirectivesList = null; List <XamlAttribute> otherDirectivesList = null; List <XamlAttribute> otherPropertiesList = null; XamlAttribute nameAttribute = null; // The Name attribute foreach (XamlAttribute attr in _attributes) { switch (attr.Kind) { case ScannerAttributeKind.Name: nameAttribute = attr; break; case ScannerAttributeKind.CtorDirective: if (ctorDirectivesList == null) { ctorDirectivesList = new List <XamlAttribute>(); } ctorDirectivesList.Add(attr); break; case ScannerAttributeKind.Directive: case ScannerAttributeKind.XmlSpace: if (attr.Property == XamlLanguage.Key) { _hasKeyAttribute = true; } if (otherDirectivesList == null) { otherDirectivesList = new List <XamlAttribute>(); } otherDirectivesList.Add(attr); break; default: if (otherPropertiesList == null) { otherPropertiesList = new List <XamlAttribute>(); } otherPropertiesList.Add(attr); break; } } _attributes = new List <XamlAttribute>(); // First the Construction Directives if (ctorDirectivesList != null) { _attributes.AddRange(ctorDirectivesList); } if (otherDirectivesList != null) { _attributes.AddRange(otherDirectivesList); } // Next the aliased Name property before any other "real" properties. // (this is a WPF template requirement) if (nameAttribute != null) { _attributes.Add(nameAttribute); } // Then everything else if (otherPropertiesList != null) { _attributes.AddRange(otherPropertiesList); } }
public void Read() { LoadQueue(); _currentNode = _readNodesQueue.Dequeue(); }
private void ReadPropertyElement(XamlPropertyName name, XamlType tagType, string tagNamespace, bool isEmptyTag) { // <Button> <== currentElement // <FrameworkElement.Width> <== FrameworkElement is ownerType XamlScannerNode node = new XamlScannerNode(_xmlLineInfo); // Attributes aren't allowed on property elements. // but if they are there we need to scan them so the // XamlParser can error, or whatever. // (don't want to skip them w/o error) PreprocessAttributes(); // It is possible for an application to provide XML nodes via XmlNodeReader // where the URI is defined but there was no xmlns attribute for use to resolve against. // See app Paperboy Debug.Assert(_xmlReader.NodeType == XmlNodeType.Element); string ownerNamespace = _xmlReader.NamespaceURI; XamlMember property = null; bool tagIsRoot = _scannerStack.Depth == 1; // PEs are processed after frame is pushed property = _parserContext.GetDottedProperty(tagType, tagNamespace, name, tagIsRoot); node.Prefix = name.Prefix; node.TypeNamespace = ownerNamespace; node.IsEmptyTag = isEmptyTag; // node.Type is not set (this is a property) // so this processing does less. PostprocessAttributes(node); if (_scannerStack.Depth > 0) { // A property Element tag will be the end of content. // This also allows to to start content again. // That is an error, but at least the parser/scanner can // understand what is going on. _scannerStack.CurrentlyInContent = false; } node.PropertyElement = property; node.IsCtorForcingMember = !property.IsAttachable; if (!node.IsEmptyTag) { _scannerStack.CurrentProperty = node.PropertyElement; node.NodeType = ScannerNodeType.PROPERTYELEMENT; } else { node.NodeType = ScannerNodeType.EMPTYPROPERTYELEMENT; } _readNodesQueue.Enqueue(node); while (HaveUnprocessedAttributes) { EnqueueAnotherAttribute(isEmptyTag); } }
private void PostprocessAttributes(XamlScannerNode node) { if (this._attributes != null) { this._nextAttribute = 0; if (node.Type == null) { if (this._settings.IgnoreUidsOnPropertyElements) { this.StripUidProperty(); } } else { bool tagIsRoot = this._scannerStack.Depth == 0; foreach (XamlAttribute attribute in this._attributes) { attribute.Initialize(this._parserContext, node.Type, node.TypeNamespace, tagIsRoot); } List <XamlAttribute> collection = null; List <XamlAttribute> list2 = null; List <XamlAttribute> list3 = null; XamlAttribute item = null; foreach (XamlAttribute attribute3 in this._attributes) { switch (attribute3.Kind) { case ScannerAttributeKind.CtorDirective: if (collection == null) { collection = new List <XamlAttribute>(); } collection.Add(attribute3); break; case ScannerAttributeKind.Name: item = attribute3; break; case ScannerAttributeKind.Directive: case ScannerAttributeKind.XmlSpace: if (attribute3.Property == XamlLanguage.Key) { this._hasKeyAttribute = true; } if (list2 == null) { list2 = new List <XamlAttribute>(); } list2.Add(attribute3); break; default: if (list3 == null) { list3 = new List <XamlAttribute>(); } list3.Add(attribute3); break; } } this._attributes = new List <XamlAttribute>(); if (collection != null) { this._attributes.AddRange(collection); } if (list2 != null) { this._attributes.AddRange(list2); } if (item != null) { this._attributes.Add(item); } if (list3 != null) { this._attributes.AddRange(list3); } } } }
private void EnqueueAnotherAttribute(bool isEmptyTag) { XamlAttribute attr = this._attributes[this._nextAttribute++]; XamlScannerNode item = new XamlScannerNode(attr); switch (attr.Kind) { case ScannerAttributeKind.CtorDirective: case ScannerAttributeKind.Name: case ScannerAttributeKind.Directive: item.NodeType = ScannerNodeType.DIRECTIVE; goto Label_00F3; case ScannerAttributeKind.XmlSpace: if (!isEmptyTag) { if (!KS.Eq(attr.Value, "preserve")) { this._scannerStack.CurrentXmlSpacePreserve = false; break; } this._scannerStack.CurrentXmlSpacePreserve = true; } break; case ScannerAttributeKind.Event: case ScannerAttributeKind.Property: item.IsCtorForcingMember = true; item.NodeType = ScannerNodeType.ATTRIBUTE; goto Label_00F3; case ScannerAttributeKind.AttachableProperty: item.NodeType = ScannerNodeType.ATTRIBUTE; goto Label_00F3; case ScannerAttributeKind.Unknown: { XamlMember property = attr.Property; item.IsCtorForcingMember = !property.IsAttachable && !property.IsDirective; item.NodeType = ScannerNodeType.ATTRIBUTE; goto Label_00F3; } default: throw new XamlInternalException(System.Xaml.SR.Get("AttributeUnhandledKind")); } item.NodeType = ScannerNodeType.DIRECTIVE; Label_00F3: item.PropertyAttribute = attr.Property; XamlText text = new XamlText(true); text.Paste(attr.Value, false); item.PropertyAttributeText = text; item.Prefix = attr.Name.Prefix; this._readNodesQueue.Enqueue(item); if (this._nextAttribute >= this._attributes.Count) { this._attributes = null; this._nextAttribute = -1; } }