public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter) { if (xamlReader == null) { throw new ArgumentNullException("xamlReader"); } if (xamlWriter == null) { throw new ArgumentNullException("xamlWriter"); } if (xamlReader.NodeType == XamlNodeType.None) { xamlReader.Read(); } while (!xamlReader.IsEof) { xamlWriter.WriteNode(xamlReader); xamlReader.Read(); } if (closeWriter) { xamlWriter.Close(); } }
public override bool Read() { if (started) { if (nest == 0) { source.Read(); return(false); // already consumed } if (!source.Read()) { return(false); } } else { started = true; } switch (source.NodeType) { case XamlNodeType.StartObject: case XamlNodeType.GetObject: case XamlNodeType.StartMember: nest++; break; case XamlNodeType.EndObject: case XamlNodeType.EndMember: nest--; break; } return(true); }
public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter) { if (xamlReader == null) { throw new ArgumentNullException("xamlReader"); } if (xamlWriter == null) { throw new ArgumentNullException("xamlWriter"); } if (xamlReader.NodeType == XamlNodeType.None) { xamlReader.Read(); } var xamlLineInfo = xamlReader as IXamlLineInfo; var xamlLineConsumer = xamlWriter as IXamlLineInfoConsumer; var shouldSetLineInfo = xamlLineInfo != null && xamlLineConsumer != null && xamlLineConsumer.ShouldProvideLineInfo && xamlLineInfo.HasLineInfo; while (!xamlReader.IsEof) { if (shouldSetLineInfo) { xamlLineConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition); } xamlWriter.WriteNode(xamlReader); xamlReader.Read(); } if (closeWriter) { xamlWriter.Close(); } }
// We get here when we are inside x:ClassAttributes or x:Property.Attributes. We expect the first element to be the Attribute SO. internal static AttributeData LoadAttributeData(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace) { AttributeData attributeData = null; reader.Read(); if (reader.NodeType == XamlNodeType.StartObject) { attributeData = new AttributeData { Type = reader.Type }; bool readNext = false; while (readNext || reader.Read()) { namespaceTable.ManageNamespace(reader); readNext = false; if (reader.NodeType == XamlNodeType.StartMember) { if (reader.Member == XamlLanguage.Arguments) { foreach (AttributeParameterData parameterData in ReadParameters(reader.ReadSubtree(), namespaceTable, rootNamespace)) { attributeData.Parameters.Add(parameterData); } readNext = true; } else if (!reader.Member.IsDirective) { KeyValuePair<string, AttributeParameterData> propertyInfo = ReadAttributeProperty(reader.ReadSubtree(), namespaceTable, rootNamespace); attributeData.Properties.Add(propertyInfo.Key, propertyInfo.Value); readNext = true; } } } } return attributeData; }
public override object Load(XamlReader xamlReader, IServiceProvider serviceProvider) { // Expects a nodestream produced by WriteNodesList xamlReader.Read(); xamlReader.Read(); xamlReader.Read(); Fx.Assert(xamlReader.NodeType == XamlNodeType.Value, "Expected Value node"); return (XamlNodeList)xamlReader.Value; }
private void InterruptableTransform(XamlReader reader, XamlWriter writer, bool closeWriter) { IXamlLineInfo info = reader as IXamlLineInfo; IXamlLineInfoConsumer consumer = writer as IXamlLineInfoConsumer; bool flag = false; if (((info != null) && info.HasLineInfo) && ((consumer != null) && consumer.ShouldProvideLineInfo)) { flag = true; } while (reader.Read()) { if (base.IsDisposed) { break; } if (flag && (info.LineNumber != 0)) { consumer.SetLineInfo(info.LineNumber, info.LinePosition); } writer.WriteNode(reader); } if (closeWriter) { writer.Close(); } }
// This method is a workaround for TFS bug #788190, since XamlReader.ReadSubtree() should (but doesn't) preserve IXamlLineInfo on the subreader public static void Transform(XamlReader reader, XamlWriter writer, IXamlLineInfo readerLineInfo, bool closeWriter) { IXamlLineInfoConsumer consumer = writer as IXamlLineInfoConsumer; SharedFx.Assert(consumer != null && consumer.ShouldProvideLineInfo, "Should only call this function to write into a XamlNodeQueue.Writer, which is always IXamlLineInfoConsumer"); bool shouldPassLineNumberInfo = false; if (readerLineInfo != null) { shouldPassLineNumberInfo = true; } while (reader.Read()) { if (shouldPassLineNumberInfo) { consumer.SetLineInfo(readerLineInfo.LineNumber, readerLineInfo.LinePosition); } writer.WriteNode(reader); } if (closeWriter) { writer.Close(); } }
public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter) { if (xamlReader == null) { throw new ArgumentNullException("xamlReader"); } if (xamlWriter == null) { throw new ArgumentNullException("xamlWriter"); } IXamlLineInfo info = xamlReader as IXamlLineInfo; IXamlLineInfoConsumer consumer = xamlWriter as IXamlLineInfoConsumer; bool flag = false; if (((info != null) && info.HasLineInfo) && ((consumer != null) && consumer.ShouldProvideLineInfo)) { flag = true; } while (xamlReader.Read()) { if (flag && (info.LineNumber != 0)) { consumer.SetLineInfo(info.LineNumber, info.LinePosition); } xamlWriter.WriteNode(xamlReader); } if (closeWriter) { xamlWriter.Close(); } }
public void StartThread(string threadName) { #if PCL136 ThreadPool.QueueUserWorkItem(state => #else if (thread != null) { throw new InvalidOperationException("Thread has already started"); } thread = Task.Run(() => #endif { try { while (do_work && r.Read()) { q.Writer.WriteNode(r); wait.Set(); } } catch (Exception ex) { lastError = ex; wait.Set(); } finally { read_all_done = true; } }); }
private void InterruptableTransform(XamlReader reader, XamlWriter writer, bool closeWriter) { IXamlLineInfo xamlLineInfo = reader as IXamlLineInfo; IXamlLineInfoConsumer xamlLineInfoConsumer = writer as IXamlLineInfoConsumer; bool shouldPassLineNumberInfo = false; if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) && (xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo)) { shouldPassLineNumberInfo = true; } while (reader.Read()) { if (IsDisposed) { break; } if (shouldPassLineNumberInfo) { if (xamlLineInfo.LineNumber != 0) { xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition); } } writer.WriteNode(reader); } if (closeWriter) { writer.Close(); } }
protected void Read_String (XamlReader r) { Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1"); Assert.IsNull (r.Member, "#2"); Assert.IsNull (r.Namespace, "#3"); Assert.IsNull (r.Member, "#4"); Assert.IsNull (r.Type, "#5"); Assert.IsNull (r.Value, "#6"); Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); Assert.IsNotNull (r.Type, "#23"); Assert.AreEqual (new XamlType (typeof (string), r.SchemaContext), r.Type, "#23-2"); Assert.IsNull (r.Namespace, "#25"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.IsNotNull (r.Member, "#33"); Assert.AreEqual (XamlLanguage.Initialization, r.Member, "#33-2"); Assert.IsNull (r.Type, "#34"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("foo", r.Value, "#43"); Assert.IsNull (r.Member, "#44"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsNull (r.Type, "#53"); Assert.IsNull (r.Member, "#54"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsNull (r.Type, "#63"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
public override object Load(XamlReader xamlReader, IServiceProvider serviceProvider) { IXamlObjectWriterFactory objectWriterFactory = (IXamlObjectWriterFactory) serviceProvider.GetService(typeof(IXamlObjectWriterFactory)); IXamlSchemaContextProvider schema = (IXamlSchemaContextProvider)serviceProvider.GetService(typeof(IXamlSchemaContextProvider)); XamlSchemaContext schemaContext = xamlReader.SchemaContext; XamlNodeList nodeList = new XamlNodeList(schema.SchemaContext); Dictionary<string, Type> typesByName = new Dictionary<string, Type>(); bool nextValueIsName = false; Type currentType = null; using (XamlWriter writer = nodeList.Writer) { while (xamlReader.Read()) { switch (xamlReader.NodeType) { case XamlNodeType.StartObject: currentType = xamlReader.Type.UnderlyingType; break; case XamlNodeType.StartMember: // HACK: This matches any Name property. Should probably just match // FrameworkElement and x:Name but this'll do for now... if (xamlReader.Member.Name == "Name") { nextValueIsName = true; } break; case XamlNodeType.Value: if (nextValueIsName) { typesByName.Add((string)xamlReader.Value, currentType); nextValueIsName = false; } break; } writer.WriteNode(xamlReader); } } return new DHierarchyTemplateContent(nodeList, typesByName); }
public TemplateContent(XamlReader xamlReader) { if (xamlReader == null) throw new ArgumentNullException("xamlReader"); _SchemaContext = xamlReader.SchemaContext; _Cache = new MemoryStream(); XamlXmlWriter writer = new XamlXmlWriter(_Cache, xamlReader.SchemaContext); //writer.WriteNamespace(xamlReader.Namespace); while (xamlReader.Read()) { writer.WriteNode(xamlReader); } writer.Close(); }
public void StartThread(string threadName) { if (thread != null) { throw new InvalidOperationException("Thread has already started"); } thread = new Thread(new ParameterizedThreadStart(delegate { while (do_work && r.Read()) { q.Writer.WriteNode(r); wait.Set(); } read_all_done = true; })) { Name = threadName }; thread.Start(); }
public static void Transform(XamlReader reader, XamlWriter writer, IXamlLineInfo readerLineInfo, bool closeWriter) { IXamlLineInfoConsumer consumer = writer as IXamlLineInfoConsumer; bool flag = false; if (readerLineInfo != null) { flag = true; } while (reader.Read()) { if (flag) { consumer.SetLineInfo(readerLineInfo.LineNumber, readerLineInfo.LinePosition); } writer.WriteNode(reader); } if (closeWriter) { writer.Close(); } }
// ---------- Private methods -------------- private bool LimitedRead() { if (IsEof) { return(false); } XamlNodeType nodeType = _reader.NodeType; if (_rootIsStartMember) { if (nodeType == XamlNodeType.StartMember) { _depth += 1; } else if (nodeType == XamlNodeType.EndMember) { _depth -= 1; } } else { if (nodeType == XamlNodeType.StartObject || nodeType == XamlNodeType.GetObject) { _depth += 1; } else if (nodeType == XamlNodeType.EndObject) { _depth -= 1; } } if (_depth == 0) { _done = true; } _reader.Read(); return(!IsEof); }
public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter) { if (xamlReader == null) { throw new ArgumentNullException(nameof(xamlReader)); } if (xamlWriter == null) { throw new ArgumentNullException(nameof(xamlWriter)); } IXamlLineInfo xamlLineInfo = xamlReader as IXamlLineInfo; IXamlLineInfoConsumer xamlLineInfoConsumer = xamlWriter as IXamlLineInfoConsumer; bool shouldPassLineNumberInfo = false; if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) && (xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo)) { shouldPassLineNumberInfo = true; } while (xamlReader.Read()) { if (shouldPassLineNumberInfo) { if (xamlLineInfo.LineNumber != 0) { xamlLineInfoConsumer.SetLineInfo(xamlLineInfo.LineNumber, xamlLineInfo.LinePosition); } } xamlWriter.WriteNode(xamlReader); } if (closeWriter) { xamlWriter.Close(); } }
// 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 static object Load(System.Xaml.XamlReader reader) { XamlObjectWriter writer = new XamlObjectWriter( new XamlSchemaContext(), new XamlObjectWriterSettings { XamlSetValueHandler = SetValue, }); while (reader.Read()) { writer.WriteNode(reader); } object result = writer.Result; DependencyObject dependencyObject = result as DependencyObject; if (dependencyObject != null) { NameScope.SetNameScope(dependencyObject, writer.RootNameScope); } return(result); }
protected object [] Read_AttributedArguments_String (XamlReader r, string [] argNames) // valid only for string arguments. { object [] ret = new object [argNames.Length]; Assert.IsTrue (r.Read (), "attarg.Arguments.Start1"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.Arguments.Start2"); Assert.IsNotNull (r.Member, "attarg.Arguments.Start3"); Assert.AreEqual (XamlLanguage.Arguments, r.Member, "attarg.Arguments.Start4"); for (int i = 0; i < argNames.Length; i++) { string arg = argNames [i]; Assert.IsTrue (r.Read (), "attarg.ArgStartObject1." + arg); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "attarg.ArgStartObject2." + arg); Assert.AreEqual (typeof (string), r.Type.UnderlyingType, "attarg.ArgStartObject3." + arg); Assert.IsTrue (r.Read (), "attarg.ArgStartMember1." + arg); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "attarg.ArgStartMember2." + arg); Assert.AreEqual (XamlLanguage.Initialization, r.Member, "attarg.ArgStartMember3." + arg); // (as the argument is string here by definition) Assert.IsTrue (r.Read (), "attarg.ArgValue1." + arg); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "attarg.ArgValue2." + arg); Assert.AreEqual (typeof (string), r.Value.GetType (), "attarg.ArgValue3." + arg); ret [i] = r.Value; Assert.IsTrue (r.Read (), "attarg.ArgEndMember1." + arg); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.ArgEndMember2." + arg); Assert.IsTrue (r.Read (), "attarg.ArgEndObject1." + arg); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "attarg.ArgEndObject2." + arg); } Assert.IsTrue (r.Read (), "attarg.Arguments.End1"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "attarg.Arguments.End2"); return ret; }
// almost identical to TypeExtension (only type/instance difference) protected void Read_StaticExtension (XamlReader r, XamlMember ctorArgMember) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); // Assert.IsNull (r.Instance, "#14"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); Assert.AreEqual (new XamlType (typeof (StaticExtension), r.SchemaContext), r.Type, "#23-2"); // Assert.IsTrue (r.Instance is StaticExtension, "#26"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (ctorArgMember, r.Member, "#33-2"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("FooBar", r.Value, "#43-2"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
protected void Read_NullOrNullExtension (XamlReader r, Action validateInstance) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); // Assert.IsNull (r.Instance, "#14"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); Assert.AreEqual (new XamlType (typeof (NullExtension), r.SchemaContext), r.Type, "#23-2"); if (validateInstance != null) validateInstance (); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
protected void Read_Reference (XamlReader r) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (typeof (Reference), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23-2"); // Assert.IsTrue (r.Instance is Reference, "#26"); Assert.IsNotNull (XamlLanguage.Type.SchemaContext, "#23-3"); Assert.IsNotNull (r.SchemaContext, "#23-4"); Assert.AreNotEqual (XamlLanguage.Type.SchemaContext, r.SchemaContext, "#23-5"); Assert.AreNotEqual (XamlLanguage.Reference.SchemaContext, xt.SchemaContext, "#23-6"); Assert.AreEqual (XamlLanguage.Reference, xt, "#23-7"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); // unlike TypeExtension there is no PositionalParameters. Assert.AreEqual (xt.GetMember ("Name"), r.Member, "#33-2"); // It is a ContentProperty (besides [ConstructorArgument]) Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("FooBar", r.Value, "#43-2"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
protected void Read_TypeOrTypeExtension2 (XamlReader r, Action validateInstance, XamlMember ctorArgMember) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); var defns = "clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name; Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#13-2"); Assert.AreEqual (defns, r.Namespace.Namespace, "#13-3:" + r.Namespace.Prefix); Assert.IsTrue (r.Read (), "#16"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#17"); Assert.IsNotNull (r.Namespace, "#18"); Assert.AreEqual ("x", r.Namespace.Prefix, "#18-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#18-3:" + r.Namespace.Prefix); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); Assert.AreEqual (new XamlType (typeof (TypeExtension), r.SchemaContext), r.Type, "#23-2"); if (validateInstance != null) validateInstance (); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (ctorArgMember, r.Member, "#33-2"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("TestClass1", r.Value, "#43-2"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
void ReadNamespace (XamlReader r, string prefix, string ns, string label) { Assert.IsTrue (r.Read (), label + "-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, label + "-2"); Assert.IsNotNull (r.Namespace, label + "-3"); Assert.AreEqual (prefix, r.Namespace.Prefix, label + "-4"); Assert.AreEqual (ns, r.Namespace.Namespace, label + "-5"); }
protected void ReadBase (XamlReader r) { Assert.IsTrue (r.Read (), "sbase#1"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "sbase#2"); Assert.AreEqual (XamlLanguage.Base, r.Member, "sbase#3"); Assert.IsTrue (r.Read (), "vbase#1"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "vbase#2"); Assert.IsTrue (r.Value is string, "vbase#3"); Assert.IsTrue (r.Read (), "ebase#1"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "ebase#2"); }
// from initial to StartObject protected void Read_CommonClrType (XamlReader r, object obj, params KeyValuePair<string,string> [] additionalNamespaces) { Assert.IsTrue (r.Read (), "ct#1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2"); Assert.IsNotNull (r.Namespace, "ct#3"); Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ct#3-2"); Assert.AreEqual ("clr-namespace:" + obj.GetType ().Namespace + ";assembly=" + obj.GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "ct#3-3"); foreach (var kvp in additionalNamespaces) { Assert.IsTrue (r.Read (), "ct#4." + kvp.Key); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#5." + kvp.Key); Assert.IsNotNull (r.Namespace, "ct#6." + kvp.Key); Assert.AreEqual (kvp.Key, r.Namespace.Prefix, "ct#6-2." + kvp.Key); Assert.AreEqual (kvp.Value, r.Namespace.Namespace, "ct#6-3." + kvp.Key); } Assert.IsTrue (r.Read (), "ct#7"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#8"); }
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: xamlWriter.WriteNode(xamlReader); // If there's a frame but no Type, that means there // was a namespace. Just set the Type if (stack.Depth != 0 && stack.CurrentFrame.Type == null) { stack.CurrentFrame.Type = xamlReader.Type; } else { // Propagate the FreezeFreezable property from the current stack frame stack.PushScope(); stack.CurrentFrame.Type = xamlReader.Type; if (stack.PreviousFrame.FreezeFreezable) { stack.CurrentFrame.FreezeFreezable = true; } } 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) { // int count = 1; while (xamlReader.Read()) { switch (xamlReader.NodeType) { case System.Xaml.XamlNodeType.StartMember: count++; break; case System.Xaml.XamlNodeType.EndMember: count--; if (count == 0) { xamlWriter.WriteNode(xamlReader); } break; } if (count == 0) { break; } } // shouldn't this have been a XamlReader.Skip()? 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: if (stack.CurrentFrame.Property.IsDirective && stack.CurrentFrame.Property == XamlLanguage.Shared) { bool isShared; if (bool.TryParse(xamlReader.Value as string, out isShared)) { if (!isShared) { if (!(xamlReader is Baml2006Reader)) { throw new XamlParseException(SR.Get(SRID.SharedAttributeInLooseXaml)); } } } } // ObjectWriter should not process PresentationOptions:Freeze directive nodes since it is unknown if (stack.CurrentFrame.Property.IsDirective && stack.CurrentFrame.Property == XamlReaderHelper.Freeze) { bool freeze = Convert.ToBoolean(xamlReader.Value, TypeConverterHelper.InvariantEnglishUS); stack.CurrentFrame.FreezeFreezable = freeze; var bamlReader = xamlReader as System.Windows.Baml2006.Baml2006Reader; if (bamlReader != null) { bamlReader.FreezeFreezables = freeze; } } // The space directive node stream should not be written because it induces object instantiation, // and the Baml2006Reader can produce space directives prematurely. else if (stack.CurrentFrame.Property == XmlSpace.Value || stack.CurrentFrame.Property == XamlLanguage.Space) { if (typeof(DependencyObject).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { System.Diagnostics.Debug.Assert(xamlReader.Value is string, "XmlAttributeProperties.XmlSpaceProperty has the type string."); stack.CurrentFrame.XmlSpace = (string)xamlReader.Value == "default"; } } else { // Ideally we should check if we're inside FrameworkTemplate's Content and not register those. // However, checking if the instance is null accomplishes the same with a much smaller perf impact. if (styleConnector != null && stack.CurrentFrame.Instance != null && stack.CurrentFrame.Property == XamlLanguage.ConnectionId && typeof(Style).IsAssignableFrom(stack.CurrentFrame.Type.UnderlyingType)) { styleConnector.Connect((int)xamlReader.Value, stack.CurrentFrame.Instance); } xamlWriter.WriteNode(xamlReader); } break; default: xamlWriter.WriteNode(xamlReader); break; } //Only do this loop for one node if loadAsync if (onlyLoadOneNode) { return; } } }
protected void Read_ListType (XamlReader r, bool isObjectReader) { Assert.IsTrue (r.Read (), "ns#1-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2"); var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib"; var defns2 = "clr-namespace:System;assembly=mscorlib"; var defns3 = "clr-namespace:System.Xaml;assembly=System.Xaml"; Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3"); Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4"); Assert.IsTrue (r.Read (), "ns#2-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2"); Assert.IsNotNull (r.Namespace, "ns#2-3"); Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-3-2"); Assert.AreEqual (defns2, r.Namespace.Namespace, "ns#2-3-3"); Assert.IsTrue (r.Read (), "ns#3-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#3-2"); Assert.IsNotNull (r.Namespace, "ns#3-3"); Assert.AreEqual ("sx", r.Namespace.Prefix, "ns#3-3-2"); Assert.AreEqual (defns3, r.Namespace.Namespace, "ns#3-3-3"); Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (typeof (List<Type>), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23"); Assert.IsTrue (xt.IsCollection, "#27"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("2", r.Value, "#43"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#72"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2"); Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3"); string [] values = {"x:Int32", "Dictionary(s:Type, sx:XamlType)"}; for (int i = 0; i < 2; i++) { Assert.IsTrue (r.Read (), i + "#73"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2"); // Here XamlObjectReader and XamlXmlReader significantly differs. (Lucky we can make this test conditional so simply) if (isObjectReader) Assert.AreEqual (XamlLanguage.PositionalParameters, r.Member, i + "#74-3"); else Assert.AreEqual (XamlLanguage.Type.GetMember ("Type"), r.Member, i + "#74-3"); Assert.IsTrue (r.Read (), i + "#75"); Assert.IsNotNull (r.Value, i + "#75-2"); Assert.AreEqual (values [i], r.Value, i + "#73-3"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2"); Assert.IsTrue (r.Read (), i + "#75"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2"); } Assert.IsTrue (r.Read (), "#81"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items Assert.IsTrue (r.Read (), "#87"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); Assert.IsFalse (r.Read (), "#89"); }
// from StartMember of Initialization to EndMember protected string Read_Initialization (XamlReader r, object comparableValue) { Assert.IsTrue (r.Read (), "init#1"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "init#2"); Assert.IsNotNull (r.Member, "init#3"); Assert.AreEqual (XamlLanguage.Initialization, r.Member, "init#3-2"); Assert.IsTrue (r.Read (), "init#4"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "init#5"); Assert.AreEqual (typeof (string), r.Value.GetType (), "init#6"); string ret = (string) r.Value; if (comparableValue != null) Assert.AreEqual (comparableValue.ToString (), r.Value, "init#6-2"); Assert.IsTrue (r.Read (), "init#7"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "init#8"); return ret; }
public static void Transform (XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter) { if (xamlReader == null) throw new ArgumentNullException ("xamlReader"); if (xamlWriter == null) throw new ArgumentNullException ("xamlWriter"); if (xamlReader.NodeType == XamlNodeType.None) xamlReader.Read (); while (!xamlReader.IsEof) { xamlWriter.WriteNode (xamlReader); xamlReader.Read (); } if (closeWriter) xamlWriter.Close (); }
protected void WriteNullMemberAsObject (XamlReader r, Action validateNullInstance) { Assert.AreEqual (XamlNodeType.None, r.NodeType, "#1"); Assert.IsTrue (r.Read (), "#6"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#7"); Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#7-2"); Assert.AreEqual ("clr-namespace:MonoTests.System.Xaml;assembly=" + GetType ().Assembly.GetName ().Name, r.Namespace.Namespace, "#7-3"); Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.AreEqual ("x", r.Namespace.Prefix, "#12-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#12-3"); Assert.IsTrue (r.Read (), "#16"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#17"); var xt = new XamlType (typeof (TestClass4), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#17-2"); // Assert.IsTrue (r.Instance is TestClass4, "#17-3"); Assert.AreEqual (2, xt.GetAllMembers ().Count, "#17-4"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#22"); Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#22-2"); Assert.IsTrue (r.Read (), "#26"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#27"); Assert.AreEqual (XamlLanguage.Null, r.Type, "#27-2"); if (validateNullInstance != null) validateNullInstance (); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#32"); Assert.IsTrue (r.Read (), "#36"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#37"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#42"); Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#42-2"); Assert.IsTrue (r.Read (), "#43"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#43-2"); Assert.AreEqual (XamlLanguage.Null, r.Type, "#43-3"); if (validateNullInstance != null) validateNullInstance (); Assert.IsTrue (r.Read (), "#44"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#44-2"); Assert.IsTrue (r.Read (), "#46"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#47"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#52"); Assert.IsFalse (r.Read (), "#56"); Assert.IsTrue (r.IsEof, "#57"); }
// It gives Type member, not PositionalParameters... and no Items member here. protected void Read_ArrayExtension2 (XamlReader r) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); // Assert.IsNull (r.Instance, "#14"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (typeof (ArrayExtension), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23-2"); // Assert.IsTrue (r.Instance is ArrayExtension, "#26"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33-2"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("x:Int32", r.Value, "#43-2"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
protected void Read_ArrayList (XamlReader r) { Assert.IsTrue (r.Read (), "ns#1-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2"); var defns = "clr-namespace:System.Collections;assembly=mscorlib"; Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3"); Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4"); Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (typeof (ArrayList), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23"); // Assert.AreEqual (obj, r.Instance, "#26"); Assert.IsTrue (xt.IsCollection, "#27"); if (r is XamlXmlReader) ReadBase (r); // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future. Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); // The value is implementation details, not testable. //Assert.AreEqual ("3", r.Value, "#43"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#72"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2"); Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3"); string [] values = {"5", "-3", "0"}; for (int i = 0; i < 3; i++) { Assert.IsTrue (r.Read (), i + "#73"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2"); Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3"); Assert.IsTrue (r.Read (), i + "#75"); Assert.IsNotNull (r.Value, i + "#75-2"); Assert.AreEqual (values [i], r.Value, i + "#73-3"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2"); Assert.IsTrue (r.Read (), i + "#75"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2"); } Assert.IsTrue (r.Read (), "#81"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items Assert.IsTrue (r.Read (), "#87"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); Assert.IsFalse (r.Read (), "#89"); }
protected void Read_ListArray (XamlReader r) { Assert.IsTrue (r.Read (), "ns#1-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#1-2"); var defns = "clr-namespace:System.Collections.Generic;assembly=mscorlib"; var defns2 = "clr-namespace:System;assembly=mscorlib"; var defns3 = "clr-namespace:System.Xaml;assembly=System.Xaml"; Assert.AreEqual (String.Empty, r.Namespace.Prefix, "ns#1-3"); Assert.AreEqual (defns, r.Namespace.Namespace, "ns#1-4"); Assert.IsTrue (r.Read (), "ns#2-1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ns#2-2"); Assert.IsNotNull (r.Namespace, "ns#2-3"); Assert.AreEqual ("s", r.Namespace.Prefix, "ns#2-3-2"); Assert.AreEqual (defns2, r.Namespace.Namespace, "ns#2-3-3"); Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (typeof (List<Array>), r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23"); Assert.IsTrue (xt.IsCollection, "#27"); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (xt.GetMember ("Capacity"), r.Member, "#33"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("2", r.Value, "#43"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#72"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2"); Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3"); string [] values = {"x:Int32", "x:String"}; for (int i = 0; i < 2; i++) { Assert.IsTrue (r.Read (), i + "#73"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2"); Assert.AreEqual (XamlLanguage.Array, r.Type, i + "#73-3"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2"); Assert.AreEqual (XamlLanguage.Array.GetMember ("Type"), r.Member, i + "#74-3"); Assert.IsTrue (r.Read (), i + "#75"); Assert.IsNotNull (r.Value, i + "#75-2"); Assert.AreEqual (values [i], r.Value, i + "#73-3"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2"); Assert.IsTrue (r.Read (), i + "#75"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#75-2"); Assert.AreEqual (XamlLanguage.Array.GetMember ("Items"), r.Member, i + "#75-3"); Assert.IsTrue (r.Read (), i + "#75-4"); Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, i + "#75-5"); Assert.IsTrue (r.Read (), i + "#75-7"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#75-8"); Assert.AreEqual (XamlLanguage.Items, r.Member, i + "#75-9"); for (int j = 0; j < 3; j++) { Assert.IsTrue (r.Read (), i + "#76-" + j); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#76-2"+ "-" + j); Assert.IsTrue (r.Read (), i + "#76-3"+ "-" + j); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#76-4"+ "-" + j); Assert.IsTrue (r.Read (), i + "#76-5"+ "-" + j); Assert.AreEqual (XamlNodeType.Value, r.NodeType, i + "#76-6"+ "-" + j); Assert.IsTrue (r.Read (), i + "#76-7"+ "-" + j); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#76-8"+ "-" + j); Assert.IsTrue (r.Read (), i + "#76-9"+ "-" + j); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#76-10"+ "-" + j); } Assert.IsTrue (r.Read (), i + "#77"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#77-2"); Assert.IsTrue (r.Read (), i + "#78"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#78-2"); Assert.IsTrue (r.Read (), i + "#79"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#79-2"); Assert.IsTrue (r.Read (), i + "#80"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#80-2"); } Assert.IsTrue (r.Read (), "#81"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items Assert.IsTrue (r.Read (), "#87"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); Assert.IsFalse (r.Read (), "#89"); }
protected void Read_CommonXamlType (XamlReader r, Action validateInstance) { Assert.IsTrue (r.Read (), "ct#1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "ct#2"); Assert.IsNotNull (r.Namespace, "ct#3"); Assert.AreEqual ("x", r.Namespace.Prefix, "ct#3-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "ct#3-3"); if (validateInstance != null) validateInstance (); Assert.IsTrue (r.Read (), "ct#5"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "ct#6"); }
protected void Read_ArrayOrArrayExtensionOrMyArrayExtension (XamlReader r, Action validateInstance, Type extType) { if (extType == typeof (MyArrayExtension)) { Assert.IsTrue (r.Read (), "#1"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#2"); Assert.IsNotNull (r.Namespace, "#3"); Assert.AreEqual (String.Empty, r.Namespace.Prefix, "#3-2"); } Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); var xt = new XamlType (extType, r.SchemaContext); Assert.AreEqual (xt, r.Type, "#23"); if (validateInstance != null) validateInstance (); if (r is XamlXmlReader) ReadBase (r); // This assumption on member ordering ("Type" then "Items") is somewhat wrong, and we might have to adjust it in the future. Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.AreEqual (xt.GetMember ("Type"), r.Member, "#33"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.AreEqual ("x:Int32", r.Value, "#43"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#62"); Assert.AreEqual (xt.GetMember ("Items"), r.Member, "#63"); Assert.IsTrue (r.Read (), "#71"); Assert.AreEqual (XamlNodeType.GetObject, r.NodeType, "#71-2"); Assert.IsNull (r.Type, "#71-3"); Assert.IsNull (r.Member, "#71-4"); Assert.IsNull (r.Value, "#71-5"); Assert.IsTrue (r.Read (), "#72"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#72-2"); Assert.AreEqual (XamlLanguage.Items, r.Member, "#72-3"); string [] values = {"5", "-3", "0"}; for (int i = 0; i < 3; i++) { Assert.IsTrue (r.Read (), i + "#73"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, i + "#73-2"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, i + "#74-2"); Assert.AreEqual (XamlLanguage.Initialization, r.Member, i + "#74-3"); Assert.IsTrue (r.Read (), i + "#75"); Assert.IsNotNull (r.Value, i + "#75-2"); Assert.AreEqual (values [i], r.Value, i + "#73-3"); Assert.IsTrue (r.Read (), i + "#74"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, i + "#74-2"); Assert.IsTrue (r.Read (), i + "#75"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, i + "#75-2"); } Assert.IsTrue (r.Read (), "#81"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#82"); // XamlLanguage.Items Assert.IsTrue (r.Read (), "#83"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#84"); // GetObject Assert.IsTrue (r.Read (), "#85"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#86"); // ArrayExtension.Items Assert.IsTrue (r.Read (), "#87"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#88"); // ArrayExtension Assert.IsFalse (r.Read (), "#89"); }
public override bool Read() { return(_internalReader.Read()); }
protected void Read_CustomMarkupExtension (XamlReader r) { r.Read (); // ns Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1"); r.Read (); // ns Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#1-2"); r.Read (); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#2-0"); Assert.IsFalse (r.IsEof, "#1"); var xt = r.Type; if (r is XamlXmlReader) ReadBase (r); r.Read (); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#2-1"); Assert.IsFalse (r.IsEof, "#2-2"); Assert.AreEqual (xt.GetMember ("Bar"), r.Member, "#2-3"); Assert.IsTrue (r.Read (), "#2-4"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#2-5"); Assert.AreEqual ("v2", r.Value, "#2-6"); Assert.IsTrue (r.Read (), "#2-7"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#2-8"); r.Read (); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#3-1"); Assert.IsFalse (r.IsEof, "#3-2"); Assert.AreEqual (xt.GetMember ("Baz"), r.Member, "#3-3"); Assert.IsTrue (r.Read (), "#3-4"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#3-5"); Assert.AreEqual ("v7", r.Value, "#3-6"); Assert.IsTrue (r.Read (), "#3-7"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#3-8"); r.Read (); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#4-1"); Assert.IsFalse (r.IsEof, "#4-2"); Assert.AreEqual (xt.GetMember ("Foo"), r.Member, "#4-3"); Assert.IsTrue (r.Read (), "#4-4"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#4-5"); Assert.AreEqual ("x:Int32", r.Value, "#4-6"); Assert.IsTrue (r.Read (), "#4-7"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#4-8"); Assert.IsTrue (r.Read (), "#5"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#5-2"); Assert.IsFalse (r.Read (), "#6"); }
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; } } }
private static void WalkSubTree(XamlReader subTreeReader, Dictionary<string, int> lineNumbersDictionary) { while (subTreeReader.Read()) { if (IsNamespaceString(subTreeReader)) { while (subTreeReader.NodeType != XamlNodeType.Value) { subTreeReader.Read(); } IXamlLineInfo ixamlLineInfo = (IXamlLineInfo)subTreeReader; string namespaceName = subTreeReader.Value as string; if (!string.IsNullOrEmpty(namespaceName)) { lineNumbersDictionary[namespaceName] = ixamlLineInfo.LineNumber; } } } }
protected void Read_TypeOrTypeExtension (XamlReader r, Action validateInstance, XamlMember ctorArgMember) { Assert.IsTrue (r.Read (), "#11"); Assert.AreEqual (XamlNodeType.NamespaceDeclaration, r.NodeType, "#12"); Assert.IsNotNull (r.Namespace, "#13"); Assert.AreEqual ("x", r.Namespace.Prefix, "#13-2"); Assert.AreEqual (XamlLanguage.Xaml2006Namespace, r.Namespace.Namespace, "#13-3"); // Assert.IsNull (r.Instance, "#14"); Assert.IsTrue (r.Read (), "#21"); Assert.AreEqual (XamlNodeType.StartObject, r.NodeType, "#22"); Assert.IsNotNull (r.Type, "#23"); Assert.AreEqual (XamlLanguage.Type, r.Type, "#23-2"); Assert.IsNull (r.Namespace, "#25"); if (validateInstance != null) validateInstance (); if (r is XamlXmlReader) ReadBase (r); Assert.IsTrue (r.Read (), "#31"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, "#32"); Assert.IsNotNull (r.Member, "#33"); Assert.AreEqual (ctorArgMember, r.Member, "#33-2"); Assert.IsNull (r.Type, "#34"); // Assert.IsNull (r.Instance, "#35"); Assert.IsTrue (r.Read (), "#41"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, "#42"); Assert.IsNotNull (r.Value, "#43"); Assert.AreEqual ("x:Int32", r.Value, "#43-2"); Assert.IsNull (r.Member, "#44"); // Assert.IsNull (r.Instance, "#45"); Assert.IsTrue (r.Read (), "#51"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, "#52"); Assert.IsNull (r.Type, "#53"); Assert.IsNull (r.Member, "#54"); // Assert.IsNull (r.Instance, "#55"); Assert.IsTrue (r.Read (), "#61"); Assert.AreEqual (XamlNodeType.EndObject, r.NodeType, "#62"); Assert.IsNull (r.Type, "#63"); Assert.IsFalse (r.Read (), "#71"); Assert.IsTrue (r.IsEof, "#72"); }
private void Transform(XamlReader reader, XamlWriter myWriter) { while (!reader.IsEof) { reader.Read(); myWriter.WriteNode(reader); } }
void ReadAttachedProperty (XamlReader r, XamlMember xm, string value, string label) { Assert.IsTrue (r.Read (), label + "#1-1"); Assert.AreEqual (XamlNodeType.StartMember, r.NodeType, label + "#1-2"); Assert.AreEqual (xm, r.Member, label + "#1-3"); Assert.IsTrue (r.Read (), label + "#2-1"); Assert.AreEqual (XamlNodeType.Value, r.NodeType, label + "#2-2"); Assert.AreEqual (value, r.Value, label + "2-3"); Assert.IsTrue (r.Read (), label + "#3-1"); Assert.AreEqual (XamlNodeType.EndMember, r.NodeType, label + "#3-2"); }