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;
}
}
}
public void Write(System.Xml.XmlWriter writer)
{
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter(0,false);
System.IO.StringWriter tw = new System.IO.StringWriter();
System.Xml.XmlReader nr;
rdfxmlwriter.Save(this,tw);
string str = tw.ToString().Remove(0, @"<?xml version=""1.0"" encoding=""utf-16"">".Length+3);
nr = System.Xml.XmlNodeReader.Create(new System.IO.MemoryStream(System.Text.Encoding.Unicode.GetBytes(str)));
writer.WriteNode(nr, true);
}
