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");
}
