// 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 void WriteNode (XamlReader reader)
{
if (reader == null)
throw new ArgumentNullException ("reader");
switch (reader.NodeType) {
case XamlNodeType.StartObject:
WriteStartObject (reader.Type);
break;
case XamlNodeType.GetObject:
WriteGetObject ();
break;
case XamlNodeType.EndObject:
WriteEndObject ();
break;
case XamlNodeType.StartMember:
WriteStartMember (reader.Member);
break;
case XamlNodeType.EndMember:
WriteEndMember ();
break;
case XamlNodeType.Value:
WriteValue (reader.Value);
break;
case XamlNodeType.NamespaceDeclaration:
WriteNamespace (reader.Namespace);
break;
default:
throw NotImplemented (); // documented behavior
}
}
private void Initialize(XamlReader wrappedReader, int bufferSize)
{
XamlNodeNextDelegate delegate4;
this._providerFullEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
this._dataReceivedEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
this._incoming = new XamlNode[bufferSize];
this._outgoing = new XamlNode[bufferSize];
this._wrappedReader = wrappedReader;
this._wrappedReaderHasLineInfo = ((IXamlLineInfo) this._wrappedReader).HasLineInfo;
XamlNodeAddDelegate add = new XamlNodeAddDelegate(this.Add);
XamlLineInfoAddDelegate addlineInfoDelegate = null;
if (this._wrappedReaderHasLineInfo)
{
addlineInfoDelegate = new XamlLineInfoAddDelegate(this.AddLineInfo);
}
this._writer = new WriterDelegate(add, addlineInfoDelegate, this._wrappedReader.SchemaContext);
if (this._wrappedReaderHasLineInfo)
{
delegate4 = new XamlNodeNextDelegate(this.Next_ProcessLineInfo);
}
else
{
delegate4 = new XamlNodeNextDelegate(this.Next);
}
this._internalReader = new ReaderDelegate(this._wrappedReader.SchemaContext, delegate4, this._wrappedReaderHasLineInfo);
this._currentNode = new XamlNode(XamlNode.InternalNodeType.StartOfStream);
}
public void ManageNamespace(XamlReader reader)
{
switch (reader.NodeType)
{
case XamlNodeType.StartObject:
case XamlNodeType.GetObject:
case XamlNodeType.StartMember:
this.EnterScope();
return;
case XamlNodeType.EndObject:
case XamlNodeType.EndMember:
this.ExitScope();
break;
case XamlNodeType.Value:
break;
case XamlNodeType.NamespaceDeclaration:
this.AddNamespace(reader.Namespace);
return;
default:
return;
}
}
// 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 void ManageNamespace(XamlReader reader)
{
switch (reader.NodeType)
{
case XamlNodeType.NamespaceDeclaration:
tempNamespaceList.Add(reader.Namespace.Prefix,
new NamespaceDeclaration(
XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(reader.Namespace.Namespace, this.localAssemblyName),
reader.Namespace.Prefix));
break;
case XamlNodeType.StartObject:
case XamlNodeType.StartMember:
case XamlNodeType.GetObject:
if (tempNamespaceList != null)
{
namespaceStack.Push(tempNamespaceList);
tempNamespaceList = new Dictionary<string, NamespaceDeclaration>();
}
break;
case XamlNodeType.EndMember:
case XamlNodeType.EndObject:
namespaceStack.Pop();
break;
default:
break;
}
}
public override object Load(XamlReader xamlReader, IServiceProvider serviceProvider)
{
IXamlObjectWriterFactory settings = serviceProvider.GetService(typeof(IXamlObjectWriterFactory)) as IXamlObjectWriterFactory;
System.Windows.Markup.IProvideValueTarget provideValueService = serviceProvider.GetService(typeof(System.Windows.Markup.IProvideValueTarget)) as System.Windows.Markup.IProvideValueTarget;
Type propertyType = null;
// IProvideValueTarget.TargetProperty can return DP, Attached Property or MemberInfo for clr property
// In this case it should always be a regular clr property here.
PropertyInfo propertyInfo = provideValueService.TargetProperty as PropertyInfo;
if (propertyInfo != null)
{
propertyType = propertyInfo.PropertyType;
}
else
{
return null;
}
object instance = Activator.CreateInstance(
typeof(FuncFactory<>).MakeGenericType(propertyType.GetGenericArguments()),
settings,
xamlReader);
return Delegate.CreateDelegate(propertyType, instance, instance.GetType().GetMethod("Evaluate"));
}
static void Main(string[] args)
{
Xaml.XamlReader reader = new Xaml.XamlReader();
Page page = (Page)reader.Load("Test.xaml");
Console.WriteLine(page.Title);
var stream = File.Open("Test.html", FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
StreamWriter writer = new StreamWriter(stream);
page.Render(writer);
//writer.Flush();
//writer.Close();
Console.ReadLine();
//XmlWriterSettings setting = new XmlWriterSettings();
//setting.Encoding = new UTF8Encoding(false);
//XmlWriter xmlWriter = XmlWriter.Create(writer, setting);
//xmlWriter.WriteStartDocument();
//xmlWriter.WriteStartElement("html");
//xmlWriter.WriteStartElement("span");
//xmlWriter.WriteString("test");
//xmlWriter.WriteEndElement();
//xmlWriter.WriteEndElement();
//xmlWriter.WriteEndDocument();
//xmlWriter.Flush();
//xmlWriter.Close();
//Console.ReadLine();
}
public bool ValidateXaml(XamlReader xamlReader, bool failOnFirstError, string assemblyName, out IList<LogData> validationErrors)
{
if (xamlReader == null)
{
throw FxTrace.Exception.ArgumentNull("xamlReader");
}
validationErrors = null;
// We loop through the provided XAML using a XamlValidatingReader to ensure that:
// 1. XAML is valid.
// 2. All types referenced in XAML are validate-able. At this point, any types defined in the local
// assembly should be referenced, so this should be possible.
XamlValidatingReader reader = new XamlValidatingReader(xamlReader, this.localAssembly, rootNamespace, assemblyName);
reader.OnValidationError += new EventHandler<ValidationEventArgs>(reader_OnValidationError);
while (reader.Read())
{
if (this.eventArgs != null && failOnFirstError)
{
validationErrors = this.eventArgs;
return false;
}
}
validationErrors = this.eventArgs;
if (validationErrors != null && validationErrors.Count > 0)
{
return false;
}
return true;
}
public override XamlReader Save(object value, IServiceProvider context)
{
FuncFactory factory = (FuncFactory)(((Delegate)value).Target);
System.Xaml.XamlReader reader = factory._nodes.GetReader();
return(reader);
}
public XamlBackgroundReader (XamlReader wrappedReader)
{
if (wrappedReader == null)
throw new ArgumentNullException ("wrappedReader");
r = wrappedReader;
q = new XamlNodeQueue (r.SchemaContext) { LineInfoProvider = r as IXamlLineInfo };
}
public DynamicActivityXamlReader(bool isBuilder, XamlReader innerReader, XamlSchemaContext schemaContext)
: base()
{
this.isBuilder = isBuilder;
this.innerReader = innerReader;
this.schemaContext = schemaContext ?? innerReader.SchemaContext;
this.xamlTypeXamlType = this.schemaContext.GetXamlType(typeof(XamlType));
this.typeXamlType = this.schemaContext.GetXamlType(typeof(Type));
this.baseActivityXamlType = this.schemaContext.GetXamlType(typeof(Activity));
this.activityPropertyXamlType = this.schemaContext.GetXamlType(typeof(DynamicActivityProperty));
this.activityPropertyType = this.activityPropertyXamlType.GetMember("Type");
this.activityPropertyName = this.activityPropertyXamlType.GetMember("Name");
this.activityPropertyValue = this.activityPropertyXamlType.GetMember("Value");
this.activityPropertyAttributes = this.activityPropertyXamlType.GetMember("Attributes");
this.namespaceTable = new NamespaceTable();
this.frontLoadedDirectives = true;
// we pump items through this node-list when rewriting
this.nodeQueue = new XamlNodeQueue(this.schemaContext);
this.nodeReader = this.nodeQueue.Reader;
IXamlLineInfo lineInfo = innerReader as IXamlLineInfo;
if (lineInfo != null && lineInfo.HasLineInfo)
{
this.innerReaderLineInfo = lineInfo;
this.nodeReaderLineInfo = (IXamlLineInfo)nodeQueue.Reader;
this.hasLineInfo = true;
}
}
public DynamicActivityXamlReader(bool isBuilder, XamlReader innerReader, XamlSchemaContext schemaContext)
{
this.isBuilder = isBuilder;
this.innerReader = innerReader;
this.schemaContext = schemaContext ?? innerReader.SchemaContext;
this.xamlTypeXamlType = this.schemaContext.GetXamlType(typeof(XamlType));
this.typeXamlType = this.schemaContext.GetXamlType(typeof(System.Type));
this.baseActivityXamlType = this.schemaContext.GetXamlType(typeof(Activity));
this.activityPropertyXamlType = this.schemaContext.GetXamlType(typeof(DynamicActivityProperty));
this.activityPropertyType = this.activityPropertyXamlType.GetMember("Type");
this.activityPropertyName = this.activityPropertyXamlType.GetMember("Name");
this.activityPropertyValue = this.activityPropertyXamlType.GetMember("Value");
this.activityPropertyAttributes = this.activityPropertyXamlType.GetMember("Attributes");
this.namespaceTable = new NamespaceTable();
this.frontLoadedDirectives = true;
this.nodeQueue = new XamlNodeQueue(this.schemaContext);
this.nodeReader = this.nodeQueue.Reader;
IXamlLineInfo info = innerReader as IXamlLineInfo;
if ((info != null) && info.HasLineInfo)
{
this.innerReaderLineInfo = info;
this.nodeReaderLineInfo = (IXamlLineInfo) this.nodeQueue.Reader;
this.hasLineInfo = true;
}
}
public XamlBackgroundReader(XamlReader wrappedReader)
{
if (wrappedReader == null)
{
throw new ArgumentNullException("wrappedReader");
}
this.Initialize(wrappedReader, 0x40);
}
internal XamlWrappingReader(XamlReader underlyingReader)
{
if (underlyingReader == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("underlyingReader"));
}
_underlyingReader = underlyingReader;
}
public static XamlReader CreateReader(XamlReader innerReader)
{
if (innerReader == null)
{
throw FxTrace.Exception.ArgumentNull("innerReader");
}
return new DynamicActivityXamlReader(innerReader);
}
public static Object Load (XamlReader xamlReader)
{
if (xamlReader == null)
throw new ArgumentNullException ("xamlReader");
var w = new XamlObjectWriter (xamlReader.SchemaContext);
Transform (xamlReader, w);
return w.Result;
}
public static object Load(System.Xaml.XamlReader xamlReader, bool skipJournaledProperties, Uri baseUri)
{
XamlObjectWriterSettings settings = XamlReader.CreateObjectWriterSettings();
object result = WpfXamlLoader.Load(xamlReader, null, skipJournaledProperties, null, settings, baseUri);
EnsureXmlNamespaceMaps(result, xamlReader.SchemaContext);
return(result);
}
public static object LoadDeferredContent(System.Xaml.XamlReader xamlReader, IXamlObjectWriterFactory writerFactory,
bool skipJournaledProperties, Object rootObject, XamlObjectWriterSettings parentSettings, Uri baseUri)
{
XamlObjectWriterSettings settings = XamlReader.CreateObjectWriterSettings(parentSettings);
// Don't set settings.RootObject because this isn't the real root
return(Load(xamlReader, writerFactory, skipJournaledProperties, rootObject, settings, baseUri));
}
public static XamlDomNode Load(XamlReader xxr)
{
var ixli = xxr as IXamlLineInfo;
var dw = new XamlDomWriter(xxr.SchemaContext);
XamlServices.Transform(xxr, dw);
return dw.RootNode;
}
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;
}
public FakeFrameworkElement Evaluate()
{
FailIfDisposed();
XamlObjectWriter writer = _xamlObjectWriterFactory.GetXamlObjectWriter(null);
System.Xaml.XamlReader reader = CreateReader();
XamlServices.Transform(reader, writer);
return((FakeFrameworkElement)writer.Result);
}
public XamlSubreader(XamlReader reader)
{
this._reader = reader;
this._lineInfoReader = reader as IXamlLineInfo;
this._done = false;
this._depth = 0;
this._firstRead = true;
this._rootIsStartMember = reader.NodeType == XamlNodeType.StartMember;
}
public XamlValidatingReader(XamlReader underlyingReader, Assembly assembly, string rootNamespace, string realAssemblyName)
: base(underlyingReader)
{
this.assembly = assembly;
this.definedType = null;
this.rootNamespace = rootNamespace;
this.localAssemblyName = assembly != null ? assembly.GetName().Name : null;
this.realAssemblyName = realAssemblyName;
this.xNull = underlyingReader.SchemaContext.GetXamlType(new XamlTypeName(XamlLanguage.Null));
}
public static object Load(XamlReader xamlReader)
{
if (xamlReader == null)
{
throw new ArgumentNullException("xamlReader");
}
XamlObjectWriter xamlWriter = new XamlObjectWriter(xamlReader.SchemaContext);
Transform(xamlReader, xamlWriter);
return xamlWriter.Result;
}
public XamlLegacyXibReader(string file)
{
IdToObjectMap = new Dictionary<string, XamlDomObject>();
var objectNode = CreateXamlDom(XDocument.Load(file));
var processor = new PostProcessor(objectNode);
objectNode = processor.Process();
_underlyingReader = new XamlDomReader(objectNode, objectNode.SchemaContext);
}
private static string CreateXamlString(XamlReader reader)
{
var stringBuilder = new StringBuilder();
var xmlWriterSettings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true };
using (var xmlWriter = XmlWriter.Create(stringBuilder, xmlWriterSettings))
using (var writer = new XamlXmlWriter(xmlWriter, reader.SchemaContext))
XamlServices.Transform(reader, writer);
return stringBuilder.ToString();
}
public override XamlReader Save(object value, IServiceProvider context)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
XamlFactory factory = (XamlFactory)value;
System.Xaml.XamlReader reader = factory._nodes.GetReader();
return(reader);
}
public static object LoadBaml(System.Xaml.XamlReader xamlReader, bool skipJournaledProperties,
Object rootObject, XamlAccessLevel accessLevel, Uri baseUri)
{
XamlObjectWriterSettings settings = XamlReader.CreateObjectWriterSettingsForBaml();
settings.RootObjectInstance = rootObject;
settings.AccessLevel = accessLevel;
object result = Load(xamlReader, null, skipJournaledProperties, rootObject, settings, baseUri);
EnsureXmlNamespaceMaps(result, xamlReader.SchemaContext);
return(result);
}
public static XamlReader CreateReader(XamlReader innerReader, XamlSchemaContext schemaContext)
{
if (innerReader == null)
{
throw FxTrace.Exception.ArgumentNull("innerReader");
}
if (schemaContext == null)
{
throw FxTrace.Exception.ArgumentNull("schemaContext");
}
return new DynamicActivityXamlReader(innerReader, schemaContext);
}
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);
}
// Copy the root namespaces from a reader to a writer.
// DesignTimeXamlWriter follows proper XAML convention by omitting the assembly name from
// clr-namespaces in the local assembly. However, VB Expressions aren't local-assembly-aware,
// and require an assembly name. So for every clr-namespace with no assembly name, we add an
// additional namespace record with an assembly name, to support VB.
// We only do this at the root level, since the designer only writes out namespaces at the root level.
internal void CopyNamespacesAndAddLocalAssembly(System.Xaml.XamlReader activityBuilderReader, System.Xaml.XamlWriter objectWriter)
{
// Designer loads alwas provide line info
IXamlLineInfo lineInfo = (IXamlLineInfo)activityBuilderReader;
IXamlLineInfoConsumer lineInfoConsumer = (IXamlLineInfoConsumer)objectWriter;
HashSet <string> definedPrefixes = new HashSet <string>();
List <NamespaceDeclaration> localAsmNamespaces = null;
while (activityBuilderReader.Read())
{
lineInfoConsumer.SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
if (activityBuilderReader.NodeType == XamlNodeType.NamespaceDeclaration)
{
definedPrefixes.Add(activityBuilderReader.Namespace.Prefix);
if (this.XamlSchemaContext.IsClrNamespaceWithNoAssembly(activityBuilderReader.Namespace.Namespace))
{
if (localAsmNamespaces == null)
{
localAsmNamespaces = new List <NamespaceDeclaration>();
}
localAsmNamespaces.Add(activityBuilderReader.Namespace);
}
objectWriter.WriteNode(activityBuilderReader);
}
else
{
if (localAsmNamespaces != null)
{
foreach (NamespaceDeclaration ns in localAsmNamespaces)
{
string prefix = null;
int i = 0;
do
{
i++;
prefix = ns.Prefix + i.ToString(CultureInfo.InvariantCulture);
}while (definedPrefixes.Contains(prefix));
string fullNs = this.XamlSchemaContext.AddLocalAssembly(ns.Namespace);
objectWriter.WriteNamespace(new NamespaceDeclaration(fullNs, prefix));
definedPrefixes.Add(prefix);
}
}
objectWriter.WriteNode(activityBuilderReader);
return;
}
}
}
public override object StandardXamlLoader(string xamlString)
{
XamlSchemaContext xsc = System.Windows.Markup.XamlReader.GetWpfSchemaContext();
XamlNodeList xamlNodeList = new XamlNodeList(xsc);
XamlServices.Transform(new XamlXmlReader(XmlReader.Create(new StringReader(xamlString)), xsc), xamlNodeList.Writer);
NodeListValidator.Validate(xamlNodeList);
System.Xaml.XamlReader reader = xamlNodeList.GetReader();
object root = System.Windows.Markup.XamlReader.Load(reader);
if (root == null)
{
throw new NullReferenceException("Load returned null Root");
}
return(root);
}
public void ManageNamespace(XamlReader reader)
{
switch (reader.NodeType)
{
case XamlNodeType.NamespaceDeclaration:
AddNamespace(reader.Namespace);
break;
case XamlNodeType.StartObject:
case XamlNodeType.StartMember:
case XamlNodeType.GetObject:
EnterScope();
break;
case XamlNodeType.EndMember:
case XamlNodeType.EndObject:
ExitScope();
break;
}
}
//从[ActivityBuilder]对象得到[xaml]å—串
public static ActivityBuilder activityBuilderFromXaml(string xaml)
{
ActivityBuilder activityBuilder = null;
System.IO.StringReader stringReader = new System.IO.StringReader(xaml);
System.Xaml.XamlXmlReader xamlXmlReader = new System.Xaml.XamlXmlReader(stringReader);
System.Xaml.XamlReader xamlReader = ActivityXamlServices.CreateBuilderReader(xamlXmlReader);
activityBuilder = System.Xaml.XamlServices.Load(xamlReader) as ActivityBuilder;
if (activityBuilder != null)
{
return(activityBuilder);
}
else
{
return(null);
}
}
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;
}
}
}
}
public void WriteNode(XamlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
switch (reader.NodeType)
{
case XamlNodeType.None:
return;
case XamlNodeType.StartObject:
this.WriteStartObject(reader.Type);
return;
case XamlNodeType.GetObject:
this.WriteGetObject();
return;
case XamlNodeType.EndObject:
this.WriteEndObject();
return;
case XamlNodeType.StartMember:
this.WriteStartMember(reader.Member);
return;
case XamlNodeType.EndMember:
this.WriteEndMember();
return;
case XamlNodeType.Value:
this.WriteValue(reader.Value);
return;
case XamlNodeType.NamespaceDeclaration:
this.WriteNamespace(reader.Namespace);
return;
}
throw new NotImplementedException(System.Xaml.SR.Get("MissingCaseXamlNodes"));
}
public static object Load(System.Xaml.XamlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
object root = null;
try
{
root = Load(reader, null);
}
catch (Exception e)
{
IUriContext uriContext = reader as IUriContext;
Uri baseUri = (uriContext != null) ? uriContext.BaseUri : null;
// Don't wrap critical exceptions or already-wrapped exceptions.
if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !ShouldReWrapException(e, baseUri))
{
throw;
}
RewrapException(e, baseUri);
}
finally
{
if (TraceMarkup.IsEnabled)
{
TraceMarkup.Trace(TraceEventType.Stop, TraceMarkup.Load, root);
}
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml, EventTrace.Event.WClientParseXmlEnd);
#if DEBUG_CLR_MEM
if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance))
{
CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass);
}
#endif // DEBUG_CLR_MEM
}
return(root);
}
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();
}
}
internal static object Load(
System.Xaml.XamlReader xamlReader,
ParserContext parserContext)
{
if (parserContext == null)
{
parserContext = new ParserContext();
}
// In some cases, the application constructor is not run prior to loading,
// causing the loader not to recognize URIs beginning with "pack:" or "application:".
MS.Internal.WindowsBase.SecurityHelper.RunClassConstructor(typeof(System.Windows.Application));
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseXamlBegin, parserContext.BaseUri);
object root = WpfXamlLoader.Load(xamlReader, parserContext.SkipJournaledProperties, parserContext.BaseUri);
DependencyObject dObject = root as DependencyObject;
if (dObject != null)
{
if (parserContext.BaseUri != null && !String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
{
dObject.SetValue(BaseUriHelper.BaseUriProperty, parserContext.BaseUri);
}
}
Application app = root as Application;
if (app != null)
{
app.ApplicationMarkupBaseUri = GetBaseUri(parserContext.BaseUri);
}
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientParseXamlEnd, parserContext.BaseUri);
return(root);
}
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 void ReadBase(XamlReader r)
{
if (!(r is XamlXmlReader))
{
return;
}
#if !PCL
if (Type.GetType("Mono.Runtime") == null)
{
return;
}
#endif
// we include the xml declaration, MS.NET does not?
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");
}
/// <summary>
/// called when in async mode when get a time slice to read and load the Tree
/// </summary>
internal virtual void HandleAsyncQueueItem()
{
try
{
int startTickCount = MS.Win32.SafeNativeMethods.GetTickCount();
//bool moreData = true;
// for debugging, can set the Maximum Async records to
// read via markup
// x:AsyncRecords="3" would loop three times
// Todo: This should either be removed at some point
int maxRecords = _maxAsynxRecords;
System.Xaml.XamlReader xamlReader = _textReader;
IXamlLineInfo xamlLineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer xamlLineInfoConsumer = _objectWriter as IXamlLineInfoConsumer;
bool shouldPassLineNumberInfo = false;
if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
(xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
{
shouldPassLineNumberInfo = true;
}
XamlMember synchronousRecordProperty = _textReader.SchemaContext.GetXamlDirective(XamlLanguage.Xaml2006Namespace, "AsyncRecords");
while (!xamlReader.IsEof && !_parseCancelled)
{
WpfXamlLoader.TransformNodes(xamlReader, _objectWriter, true /*onlyLoadOneNode*/, _skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, _stack, _styleConnector);
if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value && _stack.CurrentFrame.Property == synchronousRecordProperty)
{
if (xamlReader.Value is int)
{
_maxAsynxRecords = (int)xamlReader.Value;
}
else if (xamlReader.Value is String)
{
_maxAsynxRecords = Int32.Parse(xamlReader.Value as String, TypeConverterHelper.InvariantEnglishUS);
}
maxRecords = _maxAsynxRecords;
}
//Debug.Assert (1 >= RootList.Count, "Multiple roots not supported in async mode");
// check the timeout
int elapsed = MS.Win32.SafeNativeMethods.GetTickCount() - startTickCount;
// check for rollover
if (elapsed < 0)
{
startTickCount = 0; // reset to 0,
}
else if (elapsed > AsyncLoopTimeout)
{
break;
}
// decrement and compare with zero so the unitialized -1 and zero case
// doesn't break the loop.
if (--maxRecords == 0)
{
break;
}
}
}
catch (XamlParseException e)
{
_parseException = e;
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e) || !XamlReader.ShouldReWrapException(e, _baseUri))
{
_parseException = e;
}
else
{
_parseException = XamlReader.WrapException(e, null, _baseUri);
}
}
finally
{
if (_parseException != null || _parseCancelled)
{
TreeBuildComplete();
}
else
{
// if not at the EndOfDocument then post another work item
if (false == _textReader.IsEof)
{
Post();
}
else
{
// Building of the Tree is complete.
TreeBuildComplete();
}
}
}
}
private object LoadAsync(XmlReader reader, ParserContext parserContext)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (parserContext == null)
{
parserContext = new ParserContext();
}
_xmlReader = reader;
object rootObject = null;
if (parserContext.BaseUri == null ||
String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
{
if (reader.BaseURI == null ||
String.IsNullOrEmpty(reader.BaseURI.ToString()))
{
parserContext.BaseUri = BaseUriHelper.PackAppBaseUri;
}
else
{
parserContext.BaseUri = new Uri(reader.BaseURI);
}
}
_baseUri = parserContext.BaseUri;
System.Xaml.XamlXmlReaderSettings settings = new System.Xaml.XamlXmlReaderSettings();
settings.IgnoreUidsOnPropertyElements = true;
settings.BaseUri = parserContext.BaseUri;
settings.ProvideLineInfo = true;
XamlSchemaContext schemaContext = parserContext.XamlTypeMapper != null ?
parserContext.XamlTypeMapper.SchemaContext : GetWpfSchemaContext();
try
{
_textReader = new System.Xaml.XamlXmlReader(reader, schemaContext, settings);
_stack = new XamlContextStack <WpfXamlFrame>(() => new WpfXamlFrame());
System.Xaml.XamlObjectWriterSettings objectSettings = XamlReader.CreateObjectWriterSettings();
objectSettings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args)
{
if (rootObject == null)
{
rootObject = args.Instance;
_styleConnector = rootObject as IStyleConnector;
}
UIElement uiElement = args.Instance as UIElement;
if (uiElement != null)
{
uiElement.SetPersistId(_persistId++);
}
DependencyObject dObject = args.Instance as DependencyObject;
if (dObject != null && _stack.CurrentFrame.XmlnsDictionary != null)
{
XmlnsDictionary dictionary = _stack.CurrentFrame.XmlnsDictionary;
dictionary.Seal();
XmlAttributeProperties.SetXmlnsDictionary(dObject, dictionary);
}
};
_objectWriter = new System.Xaml.XamlObjectWriter(_textReader.SchemaContext, objectSettings);
_parseCancelled = false;
_skipJournaledProperties = parserContext.SkipJournaledProperties;
XamlMember synchronousModeProperty = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "SynchronousMode");
XamlMember synchronousRecordProperty = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "AsyncRecords");
System.Xaml.XamlReader xamlReader = _textReader;
IXamlLineInfo xamlLineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer xamlLineInfoConsumer = _objectWriter as IXamlLineInfoConsumer;
bool shouldPassLineNumberInfo = false;
if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
(xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
{
shouldPassLineNumberInfo = true;
}
bool async = false;
bool lastPropWasSyncMode = false;
bool lastPropWasSyncRecords = false;
while (!_textReader.IsEof)
{
WpfXamlLoader.TransformNodes(xamlReader, _objectWriter, true /*onlyLoadOneNode*/, _skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, _stack, _styleConnector);
if (xamlReader.NodeType == System.Xaml.XamlNodeType.StartMember)
{
if (xamlReader.Member == synchronousModeProperty)
{
lastPropWasSyncMode = true;
}
else if (xamlReader.Member == synchronousRecordProperty)
{
lastPropWasSyncRecords = true;
}
}
else if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value)
{
if (lastPropWasSyncMode == true)
{
if (xamlReader.Value as String == "Async")
{
async = true;
}
}
else if (lastPropWasSyncRecords == true)
{
if (xamlReader.Value is int)
{
_maxAsynxRecords = (int)xamlReader.Value;
}
else if (xamlReader.Value is String)
{
_maxAsynxRecords = Int32.Parse(xamlReader.Value as String, TypeConverterHelper.InvariantEnglishUS);
}
}
}
else if (xamlReader.NodeType == System.Xaml.XamlNodeType.EndMember)
{
lastPropWasSyncMode = false;
lastPropWasSyncRecords = false;
}
if (async && rootObject != null)
{
break;
}
}
}
catch (Exception e)
{
// Don't wrap critical exceptions or already-wrapped exceptions.
if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !ShouldReWrapException(e, parserContext.BaseUri))
{
throw;
}
RewrapException(e, parserContext.BaseUri);
}
if (!_textReader.IsEof)
{
Post();
//ThreadStart threadStart = new ThreadStart(ReadXamlAsync);
//Thread thread = new Thread(threadStart);
//thread.Start();
}
else
{
TreeBuildComplete();
}
if (rootObject is DependencyObject)
{
if (parserContext.BaseUri != null && !String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
{
(rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, parserContext.BaseUri);
}
//else
// (rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, BaseUriHelper.PackAppBaseUri);
WpfXamlLoader.EnsureXmlNamespaceMaps(rootObject, schemaContext);
}
Application app = rootObject as Application;
if (app != null)
{
app.ApplicationMarkupBaseUri = GetBaseUri(settings.BaseUri);
}
return(rootObject);
}
public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter)
{
// arguments are validated by the callee here.
Transform(xamlReader, xamlWriter, true);
}
internal XamlSubtreeReader(XamlReader source)
{
this.source = source;
}
static void testReadXaml()
{
string[] resources = typeof(SESampleProcess2).Assembly.GetManifestResourceNames();
string resourceName = null;
for (int i = 0; (i < resources.Length); i = (i + 1))
{
resourceName = resources[i];
if ((resourceName.Contains(".SESampleProcess2.g.xaml") || resourceName.Equals("SESampleProcess2.g.xaml")))
{
break;
}
}
//resourceName=@"D:\WorkSpaces\Tracking\TrackingStateMachine\SESampleProcess2.xaml";
//System.IO.Stream initializeXaml = new FileStream(resourceName,FileMode.Open);// typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName);
System.IO.Stream initializeXaml = typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName);
StreamReader sr = new StreamReader(initializeXaml);
Console.WriteLine(sr.ReadToEnd());
//System.Xml.XmlReader xmlReader = null;
System.Xaml.XamlReader reader = null;
System.Xaml.XamlSchemaContext schemaContext = XamlStaticHelperNamespace._XamlStaticHelper.SchemaContext;
//xmlReader = System.Xml.XmlReader.Create(initializeXaml);
System.Xaml.XamlXmlReaderSettings readerSettings = new System.Xaml.XamlXmlReaderSettings();
readerSettings.LocalAssembly = System.Reflection.Assembly.GetExecutingAssembly();
reader = new XamlXmlReader(initializeXaml, schemaContext, readerSettings);
Activity a = ActivityXamlServices.Load(reader);
StateMachine sm = (StateMachine)a;
Console.WriteLine();
//ShitProcess sp = new ShitProcess();
//SESampleProcess2 ss = new SESampleProcess2();
//StateMachine sm = new StateMachine();
//string[] resources = typeof(SESampleProcess2).Assembly.GetManifestResourceNames();
//string resourceName = null;
//for (int i = 0; (i < resources.Length); i = (i + 1))
//{
// resourceName = resources[i];
// if ((resourceName.Contains(".SESampleProcess2.g.xaml") || resourceName.Equals("SESampleProcess2.g.xaml")))
// {
// break;
// }
//}
//System.IO.Stream initializeXaml = typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName);
//Console.WriteLine(initializeXaml.ToString());
//System.Xml.XmlReader xmlReader = null;
//System.Xaml.XamlReader reader = null;
//System.Xaml.XamlObjectWriter objectWriter = null;
//try
//{
// System.Xaml.XamlSchemaContext schemaContext = XamlStaticHelperNamespace._XamlStaticHelper.SchemaContext;
// xmlReader = System.Xml.XmlReader.Create(initializeXaml);
// System.Xaml.XamlXmlReaderSettings readerSettings = new System.Xaml.XamlXmlReaderSettings();
// readerSettings.LocalAssembly = System.Reflection.Assembly.GetExecutingAssembly();
// readerSettings.AllowProtectedMembersOnRoot = true;
// reader = new System.Xaml.XamlXmlReader(xmlReader, schemaContext, readerSettings);
// System.Xaml.XamlObjectWriterSettings writerSettings = new System.Xaml.XamlObjectWriterSettings();
// writerSettings.RootObjectInstance = sm;
// writerSettings.AccessLevel = System.Xaml.Permissions.XamlAccessLevel.PrivateAccessTo(typeof(SESampleProcess2));
// objectWriter = new System.Xaml.XamlObjectWriter(schemaContext, writerSettings);
// System.Xaml.XamlServices.Transform(reader, objectWriter);
//}
//finally
//{
// if ((xmlReader != null))
// {
// ((System.IDisposable)(xmlReader)).Dispose();
// }
// if ((reader != null))
// {
// ((System.IDisposable)(reader)).Dispose();
// }
// if ((objectWriter != null))
// {
// ((System.IDisposable)(objectWriter)).Dispose();
// }
//}
Console.WriteLine();
//string resourceName = this.FindResource();
//System.IO.Stream initializeXaml = typeof(SESampleProcess2).Assembly.GetManifestResourceStream(resourceName);
}
private static object Load(System.Xaml.XamlReader xamlReader, IXamlObjectWriterFactory writerFactory,
bool skipJournaledProperties, Object rootObject, XamlObjectWriterSettings settings, Uri baseUri)
{
XamlObjectWriter xamlWriter = null;
XamlContextStack <WpfXamlFrame> stack = new XamlContextStack <WpfXamlFrame>(() => new WpfXamlFrame());
int persistId = 1;
settings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args)
{
if (EventTrace.IsEnabled(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Verbose))
{
IXamlLineInfo ixli = xamlReader as IXamlLineInfo;
int lineNumber = -1;
int linePosition = -1;
if (ixli != null && ixli.HasLineInfo)
{
lineNumber = ixli.LineNumber;
linePosition = ixli.LinePosition;
}
EventTrace.EventProvider.TraceEvent(
EventTrace.Event.WClientParseXamlBamlInfo,
EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Verbose,
args.Instance == null ? 0 : PerfService.GetPerfElementID(args.Instance),
lineNumber,
linePosition);
}
UIElement uiElement = args.Instance as UIElement;
if (uiElement != null)
{
uiElement.SetPersistId(persistId++);
}
XamlSourceInfoHelper.SetXamlSourceInfo(args.Instance, args, baseUri);
DependencyObject dObject = args.Instance as DependencyObject;
if (dObject != null && stack.CurrentFrame.XmlnsDictionary != null)
{
XmlnsDictionary dictionary = stack.CurrentFrame.XmlnsDictionary;
dictionary.Seal();
XmlAttributeProperties.SetXmlnsDictionary(dObject, dictionary);
}
stack.CurrentFrame.Instance = args.Instance;
};
if (writerFactory != null)
{
xamlWriter = writerFactory.GetXamlObjectWriter(settings);
}
else
{
xamlWriter = new System.Xaml.XamlObjectWriter(xamlReader.SchemaContext, settings);
}
IXamlLineInfo xamlLineInfo = null;
try
{
//Handle Line Numbers
xamlLineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer xamlLineInfoConsumer = xamlWriter as IXamlLineInfoConsumer;
bool shouldPassLineNumberInfo = false;
if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
(xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
{
shouldPassLineNumberInfo = true;
}
IStyleConnector styleConnector = rootObject as IStyleConnector;
TransformNodes(xamlReader, xamlWriter,
false /*onlyLoadOneNode*/,
skipJournaledProperties,
shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer,
stack, styleConnector);
xamlWriter.Close();
return(xamlWriter.Result);
}
catch (Exception e)
{
// Don't wrap critical exceptions or already-wrapped exceptions.
if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !XamlReader.ShouldReWrapException(e, baseUri))
{
throw;
}
XamlReader.RewrapException(e, xamlLineInfo, baseUri);
return(null); // this should never be executed
}
}
public XamlReaderMarkupFactory(System.Xaml.XamlReader reader, IXamlObjectWriterFactory xamlObjectWriterFactory)
{
_xamlObjectWriterFactory = xamlObjectWriterFactory;
_xamlNodeList = new XamlNodeList(reader.SchemaContext);
XamlServices.Transform(reader, _xamlNodeList.Writer);
}
public abstract object Load(XamlReader xamlReader, IServiceProvider serviceProvider);
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;
}
}
}
public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter)
{
Transform(xamlReader, xamlWriter, true);
}
internal FakeFrameworkElementFactory(System.Xaml.XamlReader reader, IXamlObjectWriterFactory xamlObjectWriterFactory)
{
impl = new XamlReaderMarkupFactory(reader, xamlObjectWriterFactory);
}
public XamlBackgroundReader(XamlReader wrappedReader)
{
throw new NotImplementedException();
}
private object DeserializeString(string text, DeserializationMode mode, out IList <XamlLoadErrorInfo> loadErrors, out Dictionary <object, SourceLocation> sourceLocations)
{
object result = null;
loadErrors = null;
Dictionary <object, SourceLocation> collectingSourceLocations = new Dictionary <object, SourceLocation>(ObjectReferenceEqualityComparer <object> .Default);
SourceLocationFoundCallback sourceLocationFoundCallback = new SourceLocationFoundCallback((obj, sourceLocation) =>
{
// If an object appear more than once in the XAML stream (e.g. System.Type, which is cached by reflection)
// we count the first occurrence.
if (!collectingSourceLocations.ContainsKey(obj))
{
collectingSourceLocations.Add(obj, sourceLocation);
}
this.OnSourceLocationFound(obj, sourceLocation);
});
this.XamlSchemaContext.ContainsConversionRequiredType = false;
Dictionary <string, SourceLocation> viewStateDataSourceLocationMapping = null;
using (XamlDebuggerXmlReader debuggerReader = new XamlDebuggerXmlReader(new StringReader(text), this.XamlSchemaContext))
{
using (System.Xaml.XamlReader activityBuilderReader = ActivityXamlServices.CreateBuilderReader(debuggerReader))
{
using (System.Xaml.XamlReader activityTemplateFactoryBuilderReader = new ActivityTemplateFactoryBuilderReader(activityBuilderReader, this.XamlSchemaContext))
{
debuggerReader.SourceLocationFound += delegate(object sender, SourceLocationFoundEventArgs args)
{
sourceLocationFoundCallback(args.Target, args.SourceLocation);
};
this.OnBeforeDeserialize();
debuggerReader.CollectNonActivitySourceLocation = this.FrameworkName.Is45OrHigher();
using (System.Xaml.XamlReader reader = ViewStateXamlHelper.ConvertViewStateToAttachedProperties(activityTemplateFactoryBuilderReader, this.IdManager, out viewStateDataSourceLocationMapping))
{
switch (mode)
{
#if ERROR_TOLERANT_SUPPORT
case DeserializationMode.ErrorTolerant:
{
ErrorTolerantObjectWriter tolerantWriter = new ErrorTolerantObjectWriter(reader.SchemaContext);
tolerantWriter.LocalAssemblyName = this.LocalAssemblyName;
XamlServices.Transform(reader, tolerantWriter);
loadErrors = this.CheckFileFormatError(tolerantWriter.LoadErrors);
result = tolerantWriter.Result;
ErrorActivity.SetHasErrorActivities(result, true);
}
break;
#endif
case DeserializationMode.Default:
{
result = this.TransformAndGetPropertySourceLocation(reader, new SourceTextScanner(text), sourceLocationFoundCallback);
loadErrors = this.CheckFileFormatError(loadErrors);
}
break;
}
}
}
}
}
sourceLocations = collectingSourceLocations;
this.OnAfterDeserialize(viewStateDataSourceLocationMapping);
return(result);
}
public TestFactory(IXamlObjectWriterFactory context, System.Xaml.XamlReader reader)
: base(context, reader)
{
}
private void Transform(XamlReader reader, XamlWriter myWriter)
{
while (!reader.IsEof)
{
reader.Read();
myWriter.WriteNode(reader);
}
}
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;
}
}
}
