// 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;
}
// This method reads a ViewStateData node from the xaml nodestream. It outputs the Id property into viewStateId
// and the attached viewstate related properties in viewStateNodes. The input reader is positioned on a
// ViewStateData node within ViewStateManager.
static void ReadViewState(XamlType viewStateType, XamlReader xamlReader, out string viewStateId, out XamlNodeList viewStateNodes, out SourceLocation sourceLocation)
{
int globalMemberLevel = 0;
bool skippingUnexpectedAttachedProperty = false;
int skippingUnexpectedAttachedPropertyLevel = 0;
viewStateId = null;
viewStateNodes = new XamlNodeList(viewStateType.SchemaContext);
sourceLocation = null;
Stack<Frame> objectNodes = new Stack<Frame>();
XamlMember idMember = new XamlMember(typeof(ViewStateData).GetProperty("Id"), xamlReader.SchemaContext);
int[] viewStateDataSourceLocation = new int[4];
int sourceLocationIndex = -1;
IXamlLineInfo lineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer lineInfoComsumer = viewStateNodes.Writer as IXamlLineInfoConsumer;
bool shouldPassLineInfo = lineInfo != null && lineInfo.HasLineInfo && lineInfoComsumer != null && lineInfoComsumer.ShouldProvideLineInfo;
while (xamlReader.Read())
{
bool skipWritingToNodeList = false;
switch (xamlReader.NodeType)
{
case XamlNodeType.StartObject:
if (xamlReader.Type.Equals(viewStateType))
{
skipWritingToNodeList = true;
}
objectNodes.Push(new Frame { Type = xamlReader.Type });
break;
case XamlNodeType.GetObject:
objectNodes.Push(new Frame { Type = null });
break;
case XamlNodeType.StartMember:
globalMemberLevel++;
if (xamlReader.Member.Equals(idMember))
{
XamlReader idNode = xamlReader.ReadSubtree();
while (idNode.Read())
{
if (idNode.NodeType == XamlNodeType.Value)
{
viewStateId = idNode.Value as string;
}
}
}
else if (globalMemberLevel == 1 && !IsAttachablePropertyForConvert(xamlReader))
{
skippingUnexpectedAttachedProperty = true;
}
if (skippingUnexpectedAttachedProperty)
{
skippingUnexpectedAttachedPropertyLevel++;
}
sourceLocationIndex = GetViewStateDataSourceLocationIndexFromCurrentReader(xamlReader);
break;
case XamlNodeType.EndMember:
globalMemberLevel--;
if (skippingUnexpectedAttachedProperty)
{
skippingUnexpectedAttachedPropertyLevel--;
}
break;
case XamlNodeType.Value:
if (xamlReader.Value is int
&& sourceLocationIndex >= 0
&& sourceLocationIndex < viewStateDataSourceLocation.Length)
{
viewStateDataSourceLocation[sourceLocationIndex] = (int)xamlReader.Value;
}
break;
case XamlNodeType.EndObject:
Frame objectNode = objectNodes.Pop();
if (objectNode.Type != null && objectNode.Type.Equals(viewStateType))
{
skipWritingToNodeList = true;
// The ViewStateData's source location should be valid, because
// before each EndObject, its SourceLocation is injected.
// If not, an exception will be thrown from constructor
// of SourceLocation.
sourceLocation = new SourceLocation(null,
viewStateDataSourceLocation[0],
viewStateDataSourceLocation[1],
viewStateDataSourceLocation[2],
viewStateDataSourceLocation[3]
);
}
Array.Clear(viewStateDataSourceLocation, 0, viewStateDataSourceLocation.Length);
break;
};
if (!skipWritingToNodeList && !skippingUnexpectedAttachedProperty)
{
if (shouldPassLineInfo)
{
lineInfoComsumer.SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
}
viewStateNodes.Writer.WriteNode(xamlReader);
}
if (skippingUnexpectedAttachedPropertyLevel == 0)
{
skippingUnexpectedAttachedProperty = false;
}
}
viewStateNodes.Writer.Close();
}
// This method reads ViewStateManager nodes from the xaml nodestream and outputs that in the
// viewStateInfo dictionary. The input reader is positioned on the ViewStateManagerNode in the nodestream.
static void ReadViewStateInfo(XamlReader inputReader, out Dictionary<string, XamlNodeList> viewStateInfo, out Dictionary<string, SourceLocation> viewStateSourceLocationMap)
{
XamlType viewStateType = new XamlType(typeof(ViewStateData), inputReader.SchemaContext);
viewStateInfo = new Dictionary<string, XamlNodeList>();
viewStateSourceLocationMap = new Dictionary<string, SourceLocation>();
bool skipReading = false;
while (skipReading || inputReader.Read())
{
skipReading = false;
if (inputReader.NodeType == XamlNodeType.StartObject && inputReader.Type.Equals(viewStateType))
{
string id;
XamlNodeList viewStateNodeList;
SourceLocation viewStateSourceLocation = null;
ReadViewState(viewStateType, inputReader.ReadSubtree(), out id, out viewStateNodeList, out viewStateSourceLocation);
if (id != null)
{
viewStateInfo[id] = viewStateNodeList;
viewStateSourceLocationMap[id] = viewStateSourceLocation;
}
//inputReader will be positioned on the next node so no need to advance it.
skipReading = true;
}
}
}
// This method reads ViewStateManager nodes from the xaml nodestream and outputs that in the
// viewStateInfo dictionary. The input reader is positioned at the begining of the workflow definition.
// The method returns a reader positioned at the begining of the workflow definition with the ViewStateManager
// nodes removed.
static XamlReader StripViewStateElement(XamlReader inputReader, out Dictionary<string, XamlNodeList> viewStateInfo, out Dictionary<string, SourceLocation> viewStateSourceLocationMap)
{
viewStateSourceLocationMap = null;
XamlNodeList strippedNodeList = new XamlNodeList(inputReader.SchemaContext);
XamlMember viewStateManager = new XamlMember(ViewStateManager, GetViewStateManager, SetViewStateManager, inputReader.SchemaContext);
using (XamlWriter strippedWriter = strippedNodeList.Writer)
{
IXamlLineInfo lineInfo = inputReader as IXamlLineInfo;
IXamlLineInfoConsumer lineInfoComsumer = strippedWriter as IXamlLineInfoConsumer;
bool shouldPassLineInfo = lineInfo != null && lineInfo.HasLineInfo && lineInfoComsumer != null && lineInfoComsumer.ShouldProvideLineInfo;
viewStateInfo = null;
while (inputReader.Read())
{
if (inputReader.NodeType == XamlNodeType.StartMember && inputReader.Member.Equals(viewStateManager))
{
ReadViewStateInfo(inputReader.ReadSubtree(), out viewStateInfo, out viewStateSourceLocationMap);
}
if (shouldPassLineInfo)
{
lineInfoComsumer.SetLineInfo(lineInfo.LineNumber, lineInfo.LinePosition);
}
strippedWriter.WriteNode(inputReader);
}
}
return strippedNodeList.GetReader();
}
// Read the parameters on the Attribute. We expect the parameters to be in the order in which they are supposed to appear in the output code.
// Here we are inside x:Arguments and we expect a list of parameters.
private static IList<AttributeParameterData> ReadParameters(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
{
IList<AttributeParameterData> parameters = new List<AttributeParameterData>();
bool readNext = false;
while (readNext || reader.Read())
{
readNext = false;
if (reader.NodeType == XamlNodeType.StartObject)
{
AttributeParameterData paramInfo = new AttributeParameterData();
ReadParamInfo(reader.ReadSubtree(), null, namespaceTable, rootNamespace, paramInfo);
parameters.Add(paramInfo);
readNext = true;
}
}
return parameters;
}
// Read the actual parameter info, i.e. the type of the paramter and its value.
// The first element could be a V or an SO.
private static void ReadParamInfo(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, AttributeParameterData paramInfo)
{
reader.Read();
bool readNext = false;
do
{
readNext = false;
if (reader.NodeType == XamlNodeType.StartObject && reader.Type == XamlLanguage.Array)
{
paramInfo.IsArray = true;
XamlReader xamlArrayReader = reader.ReadSubtree();
xamlArrayReader.Read();
while (readNext || xamlArrayReader.Read())
{
readNext = false;
if (xamlArrayReader.NodeType == XamlNodeType.StartMember && xamlArrayReader.Member.Name == "Type")
{
xamlArrayReader.Read();
if (xamlArrayReader.NodeType == XamlNodeType.Value)
{
XamlType arrayType = XamlBuildTaskServices.GetXamlTypeFromString(xamlArrayReader.Value as string, namespaceTable, xamlArrayReader.SchemaContext);
if (arrayType.UnderlyingType != null)
{
paramInfo.Type = xamlArrayReader.SchemaContext.GetXamlType(arrayType.UnderlyingType.MakeArrayType());
}
else
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(arrayType)));
}
}
}
else if (xamlArrayReader.NodeType == XamlNodeType.StartObject)
{
AttributeParameterData arrayEntry = new AttributeParameterData();
ReadParamInfo(xamlArrayReader.ReadSubtree(), null, namespaceTable, rootNamespace, arrayEntry);
paramInfo.AddArrayContentsEntry(arrayEntry);
readNext = true;
}
}
}
else if (reader.NodeType == XamlNodeType.StartObject || reader.NodeType == XamlNodeType.Value)
{
paramInfo.IsArray = false;
string paramVal;
object paramObj = null;
XamlType paramType;
GetParamValueType(reader.ReadSubtree(), type, namespaceTable, rootNamespace, out paramVal, out paramType, out paramObj);
paramInfo.TextValue = paramVal;
paramInfo.Type = paramType;
paramInfo.Value = paramObj;
}
} while (readNext || reader.Read());
}
IEnumerable<PropertyData> ReadProperties(XamlReader reader)
{
IDictionary<string, PropertyData> members = new Dictionary<string, PropertyData>();
bool nextNodeRead = false;
while (nextNodeRead || reader.Read())
{
namespaceTable.ManageNamespace(reader);
nextNodeRead = false;
if (reader.NodeType == XamlNodeType.StartObject)
{
if (reader.Type == XamlLanguage.Property)
{
PropertyData xProperty = LoadProperty(reader.ReadSubtree());
nextNodeRead = true;
if (members.ContainsKey(xProperty.Name))
{
throw FxTrace.Exception.AsError(LogInvalidOperationException(reader, SR.DuplicatePropertyDefinition(xProperty.Name)));
}
members.Add(xProperty.Name, xProperty);
}
}
}
return members.Values;
}
PropertyData LoadProperty(XamlReader xamlReader)
{
if (xamlReader == null)
{
throw FxTrace.Exception.ArgumentNull("xamlReader");
}
PropertyData property = new PropertyData();
while (xamlReader.Read())
{
if (xamlReader.NodeType == XamlNodeType.StartMember)
{
XamlMember member = xamlReader.Member;
switch (member.Name)
{
case "Name":
property.Name = ReadValueAsString(xamlReader.ReadSubtree());
break;
case "Type":
property.Type = ReadPropertyType(xamlReader.ReadSubtree());
break;
case "Attributes":
foreach (AttributeData attribute in ReadAttributesCollection(xamlReader.ReadSubtree()))
{
property.Attributes.Add(attribute);
}
break;
case "Modifier":
string propertyModifier = ReadValueAsString(xamlReader.ReadSubtree());
property.Visibility = XamlBuildTaskServices.GetMemberVisibility(propertyModifier);
break;
default:
// Ignore AttachedProperties on property
if (!member.IsAttachable)
{
throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.UnknownPropertyMember(member.Name)));
}
break;
}
}
}
if (string.IsNullOrEmpty(property.Name))
{
throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.PropertyNameRequired));
}
if (property.Type == null)
{
throw FxTrace.Exception.AsError(LogInvalidOperationException(xamlReader, SR.PropertyTypeRequired(property.Name)));
}
return property;
}
bool ProcessDirective(XamlReader reader, ClassData classData,
NamedObject currentObject, bool isRootElement, XamlNodeList strippedXamlNodes, out bool readNextNode)
{
Fx.Assert(reader.NodeType == XamlNodeType.StartMember, "Current node should be a Start Member Node");
XamlMember member = reader.Member;
bool directiveRecognized = false;
readNextNode = false;
switch (member.Name)
{
case "Name":
// Unlike all the other directives that we process, x:Name should be written
// to the stripped output.
strippedXamlNodes.Writer.WriteStartMember(member);
string objectName = ReadAtom(reader, XamlLanguage.Name.Name);
if (!objectName.StartsWith(XamlBuildTaskServices.SerializerReferenceNamePrefix,
StringComparison.Ordinal))
{
currentObject.Name = objectName;
classData.NamedObjects.Add(currentObject);
}
strippedXamlNodes.Writer.WriteValue(objectName);
strippedXamlNodes.Writer.WriteEndMember();
directiveRecognized = true;
break;
case "Class":
if (isRootElement)
{
string fullClassName = ReadAtom(reader, XamlLanguage.Class.Name);
SetClassName(fullClassName, classData);
directiveRecognized = true;
}
break;
case "ClassModifier":
if (isRootElement)
{
string classModifier = ReadAtom(reader, XamlLanguage.ClassModifier.Name);
classData.IsPublic = XamlBuildTaskServices.IsPublic(classModifier);
directiveRecognized = true;
}
break;
case "FieldModifier":
string fieldModifier = ReadAtom(reader, XamlLanguage.FieldModifier.Name);
currentObject.Visibility = XamlBuildTaskServices.GetMemberVisibility(fieldModifier);
directiveRecognized = true;
break;
case "Code":
string codeSnippet = ReadAtom(reader, XamlLanguage.Code.Name);
classData.CodeSnippets.Add(codeSnippet);
directiveRecognized = true;
break;
case "Members":
foreach (PropertyData property in ReadProperties(reader.ReadSubtree()))
{
classData.Properties.Add(property);
}
if (!classData.RequiresCompilationPass2)
{
foreach (PropertyData property in classData.Properties)
{
if (property.Type.IsUnknown)
{
classData.RequiresCompilationPass2 = true;
break;
}
}
}
directiveRecognized = true;
readNextNode = true;
break;
case "ClassAttributes":
foreach (AttributeData attribute in ReadAttributesCollection(reader.ReadSubtree()))
{
classData.Attributes.Add(attribute);
}
directiveRecognized = true;
readNextNode = true;
break;
}
if (directiveRecognized == true && readNextNode == false)
{
reader.Read();
Fx.Assert(reader.NodeType == XamlNodeType.EndMember, "Current node should be a XamlEndmember");
}
return directiveRecognized;
}
private IList<AttributeData> ReadAttributesCollection(XamlReader reader)
{
IList<AttributeData> attributes = new List<AttributeData>();
bool nextNodeRead = false;
while (nextNodeRead || reader.Read())
{
this.namespaceTable.ManageNamespace(reader);
nextNodeRead = false;
if (reader.NodeType == XamlNodeType.StartObject && reader.Type != null)
{
AttributeData attribute = null;
try
{
attribute = AttributeData.LoadAttributeData(reader.ReadSubtree(), this.namespaceTable, this.rootNamespace);
}
catch (InvalidOperationException e)
{
throw FxTrace.Exception.AsError(LogInvalidOperationException(reader, e.Message));
}
nextNodeRead = true;
attributes.Add(attribute);
}
}
return attributes;
}
public bool ProcessNode(XamlReader reader, XamlWriter targetWriter, int currentDepth, IXamlLineInfo readerLineInfo)
{
if ((currentDepth == this.Depth) && ((reader.NodeType == XamlNodeType.NamespaceDeclaration) || (reader.NodeType == XamlNodeType.None)))
{
this.bufferedNodes.Writer.WriteNode(reader, readerLineInfo);
reader.Read();
return true;
}
if ((((reader.NodeType == XamlNodeType.StartObject) && reader.Type.IsGeneric) && ((reader.Type.UnderlyingType != null) && (reader.Type.Name == "PropertyReferenceExtension"))) && (reader.Type.UnderlyingType.GetGenericTypeDefinition() == typeof(PropertyReferenceExtension<>)))
{
if (this.bufferedNodes.Count > 0)
{
XamlServices.Transform(this.bufferedNodes.Reader, targetWriter, false);
this.bufferedNodes = null;
}
XamlType type = reader.Type;
XamlReader reader2 = reader.ReadSubtree();
XamlType xamlType = reader.SchemaContext.GetXamlType(typeof(ActivityBuilder));
XamlType type3 = reader.SchemaContext.GetXamlType(typeof(ActivityPropertyReference));
targetWriter.WriteStartMember(xamlType.GetAttachableMember("PropertyReference"), readerLineInfo);
reader2.Read();
targetWriter.WriteStartObject(type3, readerLineInfo);
targetWriter.WriteStartMember(type3.GetMember("TargetProperty"), readerLineInfo);
targetWriter.WriteValue(this.currentMember.Name, readerLineInfo);
targetWriter.WriteEndMember(readerLineInfo);
bool flag = reader2.Read();
bool flag2 = false;
while (flag)
{
if (((reader2.NodeType == XamlNodeType.StartMember) && (reader2.Member.DeclaringType == type)) && (reader2.Member.Name == "PropertyName"))
{
flag2 = true;
}
else if (flag2)
{
if (reader2.NodeType == XamlNodeType.EndMember)
{
flag2 = false;
}
else if (reader2.NodeType == XamlNodeType.Value)
{
targetWriter.WriteStartMember(type3.GetMember("SourceProperty"), readerLineInfo);
targetWriter.WriteValue((string) reader2.Value, readerLineInfo);
targetWriter.WriteEndMember(readerLineInfo);
}
}
flag = reader2.Read();
}
targetWriter.WriteEndObject(readerLineInfo);
targetWriter.WriteEndMember(readerLineInfo);
this.ExitObject = true;
reader2.Close();
}
else
{
this.FlushBuffer(targetWriter);
targetWriter.WriteNode(reader, readerLineInfo);
}
return false;
}
public ValueHolder(XamlSchemaContext schemaContext, XamlMember propertyValue, XamlReader reader, IXamlLineInfo lineInfo)
{
this.nodes = new XamlNodeQueue(schemaContext);
this.PropertyValue = propertyValue;
XamlWriterExtensions.Transform(reader.ReadSubtree(), this.nodes.Writer, lineInfo, true);
}
public void ProcessDefaultValue(XamlMember propertyValue, XamlReader subReader, IXamlLineInfo lineInfo)
{
XamlReader reader;
bool flag = false;
subReader.Read();
if (!subReader.Member.IsNameValid)
{
throw FxTrace.Exception.AsError(DynamicActivityXamlReader.CreateXamlException(System.Activities.SR.InvalidXamlMember(subReader.Member.Name), lineInfo));
}
this.nodes.Writer.WriteStartMember(propertyValue, lineInfo);
subReader.Read();
if (subReader.NodeType == XamlNodeType.GetObject)
{
subReader.Read();
subReader.Read();
reader = subReader.ReadSubtree();
reader.Read();
}
else
{
reader = subReader;
}
if ((reader.NodeType != XamlNodeType.EndMember) && (reader.NodeType != XamlNodeType.StartObject))
{
flag = true;
this.nodes.Writer.WriteStartObject(this.Type, lineInfo);
this.nodes.Writer.WriteStartMember(XamlLanguage.Initialization, lineInfo);
}
while (!reader.IsEof)
{
this.nodes.Writer.WriteNode(reader, lineInfo);
reader.Read();
}
reader.Close();
if (!object.ReferenceEquals(reader, subReader))
{
subReader.Read();
while (subReader.Read())
{
this.nodes.Writer.WriteNode(subReader, lineInfo);
}
}
if (flag)
{
this.nodes.Writer.WriteEndObject(lineInfo);
this.nodes.Writer.WriteEndMember(lineInfo);
}
subReader.Close();
}
public void BufferDefaultValue(string propertyName, XamlMember propertyValue, XamlReader reader, IXamlLineInfo lineInfo)
{
if (this.alreadyBufferedDefinitions)
{
this.ProcessDefaultValue(propertyName, propertyValue, reader.ReadSubtree(), lineInfo);
}
else
{
if (this.valueHolders == null)
{
this.valueHolders = new Dictionary<string, ValueHolder>();
}
ValueHolder holder = new ValueHolder(this.parent.SchemaContext, propertyValue, reader, lineInfo);
this.valueHolders[propertyName] = holder;
}
}
public void ProcessDefaultValue(XamlMember propertyValue, XamlReader subReader, IXamlLineInfo lineInfo)
{
bool addedStartObject = false;
// 1) swap out the start member with <ActivityProperty.Value>
subReader.Read();
if (!subReader.Member.IsNameValid)
{
throw FxTrace.Exception.AsError(CreateXamlException(SR.InvalidXamlMember(subReader.Member.Name), lineInfo));
}
this.nodes.Writer.WriteStartMember(propertyValue, lineInfo);
// temporary hack: read past GetObject/StartMember nodes that are added by
// the XAML stack. This has been fixed in the WPF branch, but we haven't FI'ed that yet
XamlReader valueReader;
subReader.Read();
if (subReader.NodeType == XamlNodeType.GetObject)
{
subReader.Read();
subReader.Read();
valueReader = subReader.ReadSubtree();
valueReader.Read();
}
else
{
valueReader = subReader;
}
// Add SO tag if necessary UNLESS there's no value to wrap (which means we're already at EO)
if (valueReader.NodeType != XamlNodeType.EndMember && valueReader.NodeType != XamlNodeType.StartObject)
{
addedStartObject = true;
// Add <TypeOfProperty> nodes so that type converters work correctly
this.nodes.Writer.WriteStartObject(this.Type, lineInfo);
this.nodes.Writer.WriteStartMember(XamlLanguage.Initialization, lineInfo);
}
// 3) copy over the value
while (!valueReader.IsEof)
{
this.nodes.Writer.WriteNode(valueReader, lineInfo);
valueReader.Read();
}
valueReader.Close();
// 4) close up the extra nodes
if (!object.ReferenceEquals(valueReader, subReader))
{
subReader.Read();
while (subReader.Read())
{
this.nodes.Writer.WriteNode(subReader, lineInfo);
}
}
if (addedStartObject)
{
this.nodes.Writer.WriteEndObject(lineInfo);
this.nodes.Writer.WriteEndMember(lineInfo);
}
subReader.Close();
}