public DynamicActivityXamlReader(bool isBuilder, XamlReader innerReader, XamlSchemaContext schemaContext) { this.isBuilder = isBuilder; this.innerReader = innerReader; this.schemaContext = schemaContext ?? innerReader.SchemaContext; this.xamlTypeXamlType = this.schemaContext.GetXamlType(typeof(XamlType)); this.typeXamlType = this.schemaContext.GetXamlType(typeof(System.Type)); this.baseActivityXamlType = this.schemaContext.GetXamlType(typeof(Activity)); this.activityPropertyXamlType = this.schemaContext.GetXamlType(typeof(DynamicActivityProperty)); this.activityPropertyType = this.activityPropertyXamlType.GetMember("Type"); this.activityPropertyName = this.activityPropertyXamlType.GetMember("Name"); this.activityPropertyValue = this.activityPropertyXamlType.GetMember("Value"); this.activityPropertyAttributes = this.activityPropertyXamlType.GetMember("Attributes"); this.namespaceTable = new NamespaceTable(); this.frontLoadedDirectives = true; this.nodeQueue = new XamlNodeQueue(this.schemaContext); this.nodeReader = this.nodeQueue.Reader; IXamlLineInfo info = innerReader as IXamlLineInfo; if ((info != null) && info.HasLineInfo) { this.innerReaderLineInfo = info; this.nodeReaderLineInfo = (IXamlLineInfo) this.nodeQueue.Reader; this.hasLineInfo = true; } }
public XamlBackgroundReader (XamlReader wrappedReader) { if (wrappedReader == null) throw new ArgumentNullException ("wrappedReader"); r = wrappedReader; q = new XamlNodeQueue (r.SchemaContext) { LineInfoProvider = r as IXamlLineInfo }; }
public XamlBackgroundReader(XamlReader wrappedReader) { if (wrappedReader == null) { throw new ArgumentNullException("wrappedReader"); } r = wrappedReader; q = new XamlNodeQueue(r.SchemaContext) { LineInfoProvider = r as IXamlLineInfo }; }
public void Read () { var q = new XamlNodeQueue (new XamlSchemaContext ()); Assert.IsFalse (q.Reader.Read (), "#1"); Assert.IsTrue (q.Reader.IsEof, "#1-2"); q.Writer.WriteStartObject (XamlLanguage.String); Assert.IsTrue (q.Reader.Read (), "#2"); Assert.IsFalse (q.Reader.IsEof, "#2-2"); Assert.AreEqual (XamlLanguage.String, q.Reader.Type, "#2-3"); Assert.IsNull (q.Reader.Member, "#2-4"); Assert.IsNull (q.Reader.Value, "#2-5"); Assert.IsFalse (q.Reader.Read (), "#3"); Assert.IsTrue (q.Reader.IsEof, "#3-2"); }
// We don't know what namespaces are actually used inside convertible values, so any namespaces // that were in the parent scope on load need to be regurgitated on save, unless the prefixes were // shadowed in the child scope. // This can potentially cause namespace bloat, but the alternative is emitting unloadable XAML. static XamlReader InsertNamespaces(XamlReader reader, IEnumerable<NamespaceDeclaration> parentNamespaces) { XamlNodeQueue namespaceNodes = new XamlNodeQueue(reader.SchemaContext); HashSet<string> childPrefixes = new HashSet<string>(); while (reader.Read() && reader.NodeType == XamlNodeType.NamespaceDeclaration) { childPrefixes.Add(reader.Namespace.Prefix); namespaceNodes.Writer.WriteNode(reader); } foreach (NamespaceDeclaration parentNamespace in parentNamespaces) { if (!childPrefixes.Contains(parentNamespace.Prefix) && !IsXmlNamespace(parentNamespace)) { namespaceNodes.Writer.WriteNamespace(parentNamespace); } } if (!reader.IsEof) { namespaceNodes.Writer.WriteNode(reader); } return new ConcatenatingXamlReader(namespaceNodes.Reader, reader); }
public PropertyValueNode(PropertyNode property, ActivityBuilderXamlWriter writer) : base(writer) { this.property = property; this.valueNodes = new XamlNodeQueue(writer.SchemaContext); base.CurrentWriter = this.valueNodes.Writer; }
public XamlNodeQueueWriter (XamlNodeQueue source) { this.source = source; }
static XamlNodeQueue StripTypeWrapping(XamlNodeQueue valueNodes, XamlType propertyType) { XamlNodeQueue targetNodes = new XamlNodeQueue(valueNodes.Reader.SchemaContext); XamlReader source = valueNodes.Reader; XamlWriter target = targetNodes.Writer; int depth = 0; bool consumeWrapperEndTags = false; bool hasBufferedStartObject = false; while (source.Read()) { switch (source.NodeType) { case XamlNodeType.StartObject: depth++; // only strip the wrapping type nodes if we have exactly this sequence: // StartObject StartMember(Intialization) Value EndMember EndObject. if (targetNodes.Count == 0 && depth == 1 && source.Type == propertyType && valueNodes.Count == 5) { hasBufferedStartObject = true; continue; } break; case XamlNodeType.GetObject: depth++; break; case XamlNodeType.StartMember: depth++; if (hasBufferedStartObject) { if (depth == 2 && source.Member == XamlLanguage.Initialization) { consumeWrapperEndTags = true; continue; } else { hasBufferedStartObject = false; targetNodes.Writer.WriteStartObject(propertyType); } } break; case XamlNodeType.EndMember: depth--; if (consumeWrapperEndTags && depth == 1) { continue; } break; case XamlNodeType.EndObject: depth--; if (consumeWrapperEndTags && depth == 0) { consumeWrapperEndTags = false; continue; } break; } target.WriteNode(source); } return targetNodes; }
public PropertiesNode(BuilderClassNode classNode, ActivityBuilderXamlWriter writer) : base(writer) { this.classNode = classNode; this.propertiesNodes = new XamlNodeQueue(writer.SchemaContext); base.CurrentWriter = this.propertiesNodes.Writer; CurrentWriter.WriteStartMember(XamlLanguage.Members); }
public void SetDefaultValue(XamlNodeQueue defaultValue) { this.defaultValue = defaultValue; }
// Attributes [DependsOn("Name")] public void SetAttributes(XamlNodeQueue attributeNodes) { this.xClassAttributeNodes = attributeNodes; }
void FlushPreamble() { if (this.otherNodes == null) // already flushed { return; } CurrentWriter = this.Writer.innerWriter; string classNamespace = null; // first, see if we need to emit a namespace corresponding to our class if (this.defaultValueNodes != null) { classNamespace = this.xClassNamespace; } this.rootNode.FlushPendingNodes(classNamespace); this.rootNode = null; // not needed anymore CurrentWriter.WriteStartObject(this.Writer.activityXamlType); // first dump x:Class if (this.xClassNodes == null) { SetXClass(null, null); // this will setup a default } XamlServices.Transform(this.xClassNodes.Reader, CurrentWriter, false); // String default values get written in attribute form immediately. // Other values get deferred until after x:Members, etc. XamlNodeQueue deferredPropertyNodes = null; if (this.defaultValueNodes != null) { foreach (KeyValuePair<string, XamlNodeQueue> defaultValueNode in this.defaultValueNodes) { XamlReader reader = defaultValueNode.Value.Reader; if (reader.Read()) { bool isStringValue = false; if (reader.NodeType == XamlNodeType.Value) { string stringValue = reader.Value as string; if (stringValue != null) { isStringValue = true; } } if (isStringValue) { CurrentWriter.WriteStartMember(new XamlMember(defaultValueNode.Key, this.xClassXamlType, true)); CurrentWriter.WriteNode(reader); XamlServices.Transform(defaultValueNode.Value.Reader, CurrentWriter, false); // don't need an EndMember since it will be sitting in the node list (we only needed to strip the StartMember) } else { // Else: We'll write this out in a minute, after the x:ClassAttributes and x:Properties if (deferredPropertyNodes == null) { deferredPropertyNodes = new XamlNodeQueue(Writer.SchemaContext); } deferredPropertyNodes.Writer.WriteStartMember(new XamlMember(defaultValueNode.Key, this.xClassXamlType, true)); deferredPropertyNodes.Writer.WriteNode(reader); XamlServices.Transform(defaultValueNode.Value.Reader, deferredPropertyNodes.Writer, false); } } } } // then dump x:ClassAttributes if we have any if (this.xClassAttributeNodes != null) { XamlServices.Transform(this.xClassAttributeNodes.Reader, CurrentWriter, false); } // and x:Properties if (this.xPropertiesNodes != null) { XamlServices.Transform(this.xPropertiesNodes.Reader, CurrentWriter, false); } if (deferredPropertyNodes != null) { XamlServices.Transform(deferredPropertyNodes.Reader, CurrentWriter, false); } if (this.otherNodes.Count > 0) { XamlServices.Transform(this.otherNodes.Reader, CurrentWriter, false); } this.otherNodes = null; // done with this }
public BuilderClassNode(RootNode rootNode, ActivityBuilderXamlWriter writer) : base(writer) { this.rootNode = rootNode; // by default, if we're not in a special sub-tree, ferret the nodes away on the side this.otherNodes = new XamlNodeQueue(writer.SchemaContext); base.CurrentWriter = this.otherNodes.Writer; }
public override bool Read() { switch (this.currentState) { case ActivityTemplateFactoryBuilderReaderStates.InitialState: bool hasMoreNodes = this.underlyingReader.Read(); if (this.underlyingReader.NodeType == XamlNodeType.StartObject && IsActivityTemplateFactoryType(this.underlyingReader.Type)) { Type underlyingType = this.underlyingReader.Type.UnderlyingType; Type targetType = underlyingType.IsGenericType ? underlyingType.GetGenericArguments()[0] : null; this.currentState = ActivityTemplateFactoryBuilderReaderStates.ReadingFromBufferState; this.queuedNodes = new XamlNodeQueue(this.schemaContext); this.queuedNodes.Writer.WriteStartObject(this.ActivityTemplateFactoryBuilderType, (IXamlLineInfo)this.underlyingReader); string className; while (this.underlyingReader.Read()) { if (this.underlyingReader.NodeType == XamlNodeType.StartMember && this.underlyingReader.Member == XamlLanguage.Class) { this.underlyingReader.Read(); className = (string)this.underlyingReader.Value; this.underlyingReader.Read(); this.queuedNodes.Writer.WriteStartMember(this.ActivityTemplateFactoryBuilderNameMember, (IXamlLineInfo)this.underlyingReader); this.queuedNodes.Writer.WriteValue(className, (IXamlLineInfo)this.underlyingReader); this.queuedNodes.Writer.WriteEndMember((IXamlLineInfo)this.underlyingReader); if (targetType != null) { this.queuedNodes.Writer.WriteStartMember(this.ActivityTemplateFactoryBuilderTargetTypeMember, (IXamlLineInfo)this.underlyingReader); object targetTypeString = targetType; this.queuedNodes.Writer.WriteValue(targetTypeString); this.queuedNodes.Writer.WriteEndMember(); } } else if (this.underlyingReader.NodeType == XamlNodeType.StartMember && this.IsActivityTemplateFactoryImplementationMember(this.underlyingReader.Member)) { this.queuedNodes.Writer.WriteStartMember(this.ActivityTemplateFactoryBuilderImplementationMember, (IXamlLineInfo)this.underlyingReader); return true; } } } return hasMoreNodes; case ActivityTemplateFactoryBuilderReaderStates.ReadingFromBufferState: if (this.queuedNodes.Reader.Read()) { return true; } else { this.currentState = ActivityTemplateFactoryBuilderReaderStates.BypassState; this.queuedNodes = null; return this.underlyingReader.Read(); } default: SharedFx.Assert(this.currentState == ActivityTemplateFactoryBuilderReaderStates.BypassState, "This is the only remaining ActivityTemplateFactoryBuilderReaderStates."); return this.underlyingReader.Read(); } }
public XamlNodeQueueReader(XamlNodeQueue source) { this.source = source; node = default(XamlNodeLineInfo); }
public bool ProcessNode(XamlReader reader, XamlWriter targetWriter, int currentDepth, IXamlLineInfo readerLineInfo) { if ((currentDepth == this.Depth) && ((reader.NodeType == XamlNodeType.NamespaceDeclaration) || (reader.NodeType == XamlNodeType.None))) { this.bufferedNodes.Writer.WriteNode(reader, readerLineInfo); reader.Read(); return true; } if ((((reader.NodeType == XamlNodeType.StartObject) && reader.Type.IsGeneric) && ((reader.Type.UnderlyingType != null) && (reader.Type.Name == "PropertyReferenceExtension"))) && (reader.Type.UnderlyingType.GetGenericTypeDefinition() == typeof(PropertyReferenceExtension<>))) { if (this.bufferedNodes.Count > 0) { XamlServices.Transform(this.bufferedNodes.Reader, targetWriter, false); this.bufferedNodes = null; } XamlType type = reader.Type; XamlReader reader2 = reader.ReadSubtree(); XamlType xamlType = reader.SchemaContext.GetXamlType(typeof(ActivityBuilder)); XamlType type3 = reader.SchemaContext.GetXamlType(typeof(ActivityPropertyReference)); targetWriter.WriteStartMember(xamlType.GetAttachableMember("PropertyReference"), readerLineInfo); reader2.Read(); targetWriter.WriteStartObject(type3, readerLineInfo); targetWriter.WriteStartMember(type3.GetMember("TargetProperty"), readerLineInfo); targetWriter.WriteValue(this.currentMember.Name, readerLineInfo); targetWriter.WriteEndMember(readerLineInfo); bool flag = reader2.Read(); bool flag2 = false; while (flag) { if (((reader2.NodeType == XamlNodeType.StartMember) && (reader2.Member.DeclaringType == type)) && (reader2.Member.Name == "PropertyName")) { flag2 = true; } else if (flag2) { if (reader2.NodeType == XamlNodeType.EndMember) { flag2 = false; } else if (reader2.NodeType == XamlNodeType.Value) { targetWriter.WriteStartMember(type3.GetMember("SourceProperty"), readerLineInfo); targetWriter.WriteValue((string) reader2.Value, readerLineInfo); targetWriter.WriteEndMember(readerLineInfo); } } flag = reader2.Read(); } targetWriter.WriteEndObject(readerLineInfo); targetWriter.WriteEndMember(readerLineInfo); this.ExitObject = true; reader2.Close(); } else { this.FlushBuffer(targetWriter); targetWriter.WriteNode(reader, readerLineInfo); } return false; }
public void FlushBuffer(XamlWriter targetWriter) { targetWriter.WriteStartMember(this.currentMember, this.currentMemberLineNumber, this.currentMemberLinePosition); XamlServices.Transform(this.bufferedNodes.Reader, targetWriter, false); this.bufferedNodes = null; }
public void SetXClass(string builderName, XamlNodeQueue nameNodes) { this.xClassNodes = new XamlNodeQueue(Writer.SchemaContext); this.xClassNodes.Writer.WriteStartMember(XamlLanguage.Class); this.xClassNamespace = null; string xClassName = builderName; if (string.IsNullOrEmpty(xClassName)) { xClassName = string.Format(CultureInfo.CurrentCulture, "_{0}", Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 4)); } if (nameNodes != null) { XamlServices.Transform(nameNodes.Reader, this.xClassNodes.Writer, false); } else { this.xClassNodes.Writer.WriteValue(xClassName); this.xClassNodes.Writer.WriteEndMember(); } int nameStartIndex = xClassName.LastIndexOf('.'); if (nameStartIndex > 0) { this.xClassNamespace = builderName.Substring(0, nameStartIndex); xClassName = builderName.Substring(nameStartIndex + 1); } this.xClassNamespace = string.Format(CultureInfo.CurrentUICulture, "clr-namespace:{0}", this.xClassNamespace ?? string.Empty); this.xClassXamlType = new XamlType(this.xClassNamespace, xClassName, null, Writer.SchemaContext); }
internal void SetUntransformedPropertyReferences(XamlMember propertyReferencesMember, XamlNodeQueue untransformedNodes) { ObjectFrame currentFrame = this.objectStack.Peek(); Fx.Assert(currentFrame.Type != null, "Should only create PropertyReferencesNode inside a StartObject"); currentFrame.AddMember(propertyReferencesMember, untransformedNodes); }
// Properties [DependsOn("Attributes")] public void SetProperties(XamlNodeQueue propertyNodes, List<KeyValuePair<string, XamlNodeQueue>> defaultValueNodes) { this.xPropertiesNodes = propertyNodes; this.defaultValueNodes = defaultValueNodes; // exiting the properties tag. So we've now accrued any instances of Name and Attributes // that could possibly be hit flush our preamble FlushPreamble(); }
public XamlWriter StartMember(XamlMember member, XamlWriter parentWriter) { this.CurrentMember = member; this.parentWriter = parentWriter; this.currentMemberNodes = new XamlNodeQueue(parentWriter.SchemaContext); return this.currentMemberNodes.Writer; }
public BuilderNameNode(BuilderClassNode classNode, ActivityBuilderXamlWriter writer) : base(writer) { this.classNode = classNode; this.nameNodes = new XamlNodeQueue(writer.SchemaContext); base.CurrentWriter = this.nameNodes.Writer; }
public XamlWriter EndMember() { AddMember(this.CurrentMember, this.currentMemberNodes); this.CurrentMember = null; this.currentMemberNodes = null; XamlWriter parentWriter = this.parentWriter; this.parentWriter = null; return parentWriter; }
public void AddDefaultValue(string propertyName, XamlNodeQueue value) { if (this.defaultValueNodes == null) { this.defaultValueNodes = new List<KeyValuePair<string, XamlNodeQueue>>(); } if (string.IsNullOrEmpty(propertyName)) { // default a name if one doesn't exist propertyName = string.Format(CultureInfo.CurrentCulture, "_{0}", Guid.NewGuid().ToString().Replace("-", string.Empty)); } this.defaultValueNodes.Add(new KeyValuePair<string, XamlNodeQueue>(propertyName, value)); }
public void AddMember(XamlMember member, XamlNodeQueue content) { if (this.Members == null) { this.Members = new List<KeyValuePair<XamlMember, XamlNodeQueue>>(); } this.Members.Add(new KeyValuePair<XamlMember, XamlNodeQueue>(member, content)); }
protected internal override void Complete() { if (this.defaultValue != null) { if (string.IsNullOrEmpty(this.propertyName)) { // default a name if one doesn't exist this.propertyName = string.Format(CultureInfo.CurrentCulture, "_{0}", Guid.NewGuid().ToString().Replace("-", string.Empty)); } if (this.defaultValue != null && this.propertyType != null) { // post-process the default value nodes to strip out // StartObject+StartMember _Initialization+EndMember+EndObject // wrapper nodes if the type of the object matches the // property Type (since we are moving from "object Value" to "T Value" this.defaultValue = StripTypeWrapping(this.defaultValue, this.propertyType); } this.properties.AddDefaultValue(this.propertyName, this.defaultValue); } }
public PropertyReferencesNode(ActivityBuilderXamlWriter writer, XamlMember originalStartMember, ImplementationNode parent) : base(writer) { this.untransformedNodes = new XamlNodeQueue(Writer.SchemaContext); this.originalStartMember = originalStartMember; this.Parent = parent; base.CurrentWriter = this.untransformedNodes.Writer; }
private void Initialize(Stream stream, Baml2006SchemaContext schemaContext, Baml2006ReaderSettings settings) { schemaContext.Settings = settings; _settings = settings; _context = new Baml2006ReaderContext(schemaContext); _xamlMainNodeQueue = new XamlNodeQueue(schemaContext); _xamlNodesReader = _xamlMainNodeQueue.Reader; _xamlNodesWriter = _xamlMainNodeQueue.Writer; _lookingForAKeyOnAMarkupExtensionInADictionaryDepth = -1; _isBinaryProvider = !settings.ValuesMustBeString; // Since the reader owns the stream and is responsible for its lifetime // it can safely hand out shared streams. if (_settings.OwnsStream) { stream = new SharedStream(stream); } _binaryReader = new BamlBinaryReader(stream); _context.TemplateStartDepth = -1; if (!_settings.IsBamlFragment) { Process_Header(); } }
public PropertyReferenceNode(ActivityBuilderXamlWriter writer, PropertyReferencesNode parent) : base(writer) { this.propertyReferenceNodes = new XamlNodeQueue(writer.SchemaContext); this.parent = parent; // save the untransformed output in case we're not able to perform the transformation base.CurrentWriter = this.propertyReferenceNodes.Writer; }
public XamlNodeQueueWriter(XamlNodeQueue source) { this.source = source; }
public RootNode(ActivityBuilderXamlWriter writer) : base(writer) { this.pendingNodes = new XamlNodeQueue(writer.SchemaContext); base.CurrentWriter = this.pendingNodes.Writer; }
public override void WriteStartObject(XamlType type) { switch (this.currentState) { case ActivityTemplateFactoryBuilderWriterStates.InitialState: if (type.Equals(new XamlType(typeof(ActivityTemplateFactoryBuilder), this.schemaContext))) { this.queuedNodes = new XamlNodeQueue(this.schemaContext); this.currentState = ActivityTemplateFactoryBuilderWriterStates.BufferingState; } else { this.currentState = ActivityTemplateFactoryBuilderWriterStates.BypassState; this.underlyingWriter.WriteStartObject(type); } break; case ActivityTemplateFactoryBuilderWriterStates.BypassState: this.underlyingWriter.WriteStartObject(type); break; default: SharedFx.Assert( this.currentState == ActivityTemplateFactoryBuilderWriterStates.BufferingState || this.currentState == ActivityTemplateFactoryBuilderWriterStates.BufferingNameState || this.currentState == ActivityTemplateFactoryBuilderWriterStates.BufferingTargetTypeState, "These are the only possible ActivityTemplateFactoryBuilderWriterStates."); SharedFx.Assert("It is impossible to start any object during the buffering state."); break; } }
public void FlushPendingNodes(string classNamespace) { base.CurrentWriter = this.Writer.innerWriter; if (!Writer.notRewriting) { // make sure we have any required namespaces if (!this.wroteXamlNamespace) { string xamlNamespaceAlias = GenerateNamespacePrefix(PreferredXamlNamespaceAlias); this.WriteNamespace(new NamespaceDeclaration(XamlLanguage.Xaml2006Namespace, xamlNamespaceAlias)); } // If there's an x:Class="Foo.Bar", add a namespace declaration for Foo in the local assembly so we can // say stuff like this:Bar.MyProperty later on. DON'T add the namespace declaration if somebody has already // declared the namespace in the nodestream though (duplicates are an error). if (classNamespace != null) { bool sawClassNamespace = false; XamlReader reader = this.pendingNodes.Reader; XamlWriter writer = this.Writer.innerWriter; while (reader.Read() && reader.NodeType == XamlNodeType.NamespaceDeclaration) { if (classNamespace.Equals(reader.Namespace.Namespace)) { sawClassNamespace = true; } writer.WriteNode(reader); } if (!sawClassNamespace) { string classNamespaceAlias = GenerateNamespacePrefix(PreferredClassAlias); writer.WriteNamespace(new NamespaceDeclaration(classNamespace, classNamespaceAlias)); } // We may have consumed the first non-namespace node off the reader in order // to check it for being a NamespaceDeclaration. Make sure it still gets written. if (!reader.IsEof) { writer.WriteNode(reader); } } this.rootLevelPrefixes = null; // not needed anymore } XamlServices.Transform(this.pendingNodes.Reader, this.Writer.innerWriter, false); this.pendingNodes = null; }