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);
}
// 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());
}
// 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());
}
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);
}
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);
}
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);
}
// 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;
}
}
}
private void WriteWrappedMember(bool stripWhitespace)
{
this.nodeQueue.Writer.WriteGetObject(this.innerReaderLineInfo);
this.nodeQueue.Writer.WriteStartMember(XamlLanguage.Items, this.innerReaderLineInfo);
XamlReader reader = this.innerReader.ReadSubtree();
reader.Read();
reader.Read();
while (!reader.IsEof)
{
bool flag = false;
if (reader.NodeType == XamlNodeType.Value)
{
string str = reader.Value as string;
if ((str != null) && (str.Trim().Length == 0))
{
flag = true;
}
}
if (flag && stripWhitespace)
{
reader.Read();
}
else
{
XamlWriterExtensions.Transform(reader.ReadSubtree(), this.nodeQueue.Writer, this.innerReaderLineInfo, false);
}
}
this.nodeQueue.Writer.WriteEndObject(this.innerReaderLineInfo);
this.nodeQueue.Writer.WriteEndMember(this.innerReaderLineInfo);
reader.Close();
this.ExitObject();
}
public void Process(SkipMode mode)
{
switch (mode)
{
case SkipMode.Skip:
_mainReader.Skip();
break;
case SkipMode.ReadSubtree_discard:
DiscardSubtree(_mainReader.ReadSubtree());
break;
case SkipMode.ReadSubtree_build:
BuildSubtree(_mainReader.ReadSubtree(), _mainWriter);
break;
}
}
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;
}
}
// 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);
}
// 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;
}
}
}
// The xamlReader.ReadSubtree and subsequent while loop to get the Id member
// has moved the xamlReader forward to the next member. We need to check to see
// if it is an Attached Property that we care about. If it isn't then we need to
// skip it and not put it in the resulting XamlNodeList.
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();
}
private object TransformAndGetPropertySourceLocation(XamlReader reader, SourceTextScanner sourceTextScanner, SourceLocationFoundCallback sourceLocationFoundCallback)
{
// <property name, value's start location>
Dictionary <string, SourceLocation> propertyValueLocationMapping = new Dictionary <string, SourceLocation>();
object deserializedObject = null;
object earlyResult = null;
UsingXamlWriter(
new XamlObjectWriter(reader.SchemaContext),
delegate(XamlObjectWriter objectWriter)
{
if (this.XamlSchemaContext.HasLocalAssembly)
{
this.CopyNamespacesAndAddLocalAssembly(reader, objectWriter);
}
if (!(reader is IXamlLineInfo))
{
XamlServices.Transform(reader, objectWriter);
earlyResult = objectWriter.Result;
return;
}
XamlType dynamicActivityPropertyType = this.XamlSchemaContext.GetXamlType(typeof(DynamicActivityProperty));
while (reader.Read())
{
// read SubTree will moves the reader pointed to
// element after its EO. So, we need to use a while
while (!reader.IsEof && reader.NodeType == XamlNodeType.StartObject &&
dynamicActivityPropertyType == reader.Type)
{
KeyValuePair <string, SourceLocation> nameSourceLocation = this.TransformDynamicActivityProperty(reader.ReadSubtree(), objectWriter, sourceTextScanner);
if (nameSourceLocation.Key != null && nameSourceLocation.Value != null && !propertyValueLocationMapping.ContainsKey(nameSourceLocation.Key))
{
propertyValueLocationMapping.Add(nameSourceLocation.Key, nameSourceLocation.Value);
}
}
if (!reader.IsEof)
{
objectWriter.WriteNode(reader);
}
}
deserializedObject = objectWriter.Result;
});
if (earlyResult != null)
{
return(earlyResult);
}
ActivityBuilder activityBuilder = deserializedObject as ActivityBuilder;
if (activityBuilder == null)
{
return(deserializedObject);
}
foreach (KeyValuePair <string, SourceLocation> propertyValueLocation in propertyValueLocationMapping)
{
string propertyName = propertyValueLocation.Key;
SourceLocation propertyLocation = propertyValueLocation.Value;
if (!activityBuilder.Properties.Contains(propertyName))
{
SharedFx.Assert(string.Format(CultureInfo.CurrentCulture, "no such property:{0}", propertyName));
continue;
}
DynamicActivityProperty property = activityBuilder.Properties[propertyName];
if (property == null || property.Value == null)
{
SharedFx.Assert(string.Format(CultureInfo.CurrentCulture, "no such property value:{0}", propertyName));
continue;
}
object expression = (property.Value is Argument) ? ((Argument)property.Value).Expression : null;
if (expression != null)
{
sourceLocationFoundCallback(expression, propertyLocation);
}
else
{
sourceLocationFoundCallback(property.Value, propertyLocation);
}
}
return(deserializedObject);
}
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);
}
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 BufferDefinitions(DynamicActivityXamlReader parent)
{
XamlReader reader = parent.innerReader.ReadSubtree();
IXamlLineInfo innerReaderLineInfo = parent.innerReaderLineInfo;
reader.Read();
this.outerNodes.Writer.WriteStartMember(parent.activityReplacementXamlType.GetMember("Properties"), innerReaderLineInfo);
this.outerNodes.Writer.WriteGetObject(innerReaderLineInfo);
this.outerNodes.Writer.WriteStartMember(XamlLanguage.Items, innerReaderLineInfo);
bool flag = reader.Read();
while (flag)
{
if ((reader.NodeType == XamlNodeType.StartObject) && (reader.Type == XamlLanguage.Property))
{
ActivityPropertyHolder holder = new ActivityPropertyHolder(parent, reader.ReadSubtree());
this.PropertyHolders.Add(holder.Name, holder);
this.outerNodes.Writer.WriteValue(holder, innerReaderLineInfo);
}
else
{
this.outerNodes.Writer.WriteNode(reader, innerReaderLineInfo);
flag = reader.Read();
}
}
this.outerNodes.Writer.WriteEndObject(innerReaderLineInfo);
this.outerNodes.Writer.WriteEndMember(innerReaderLineInfo);
reader.Close();
this.alreadyBufferedDefinitions = true;
this.FlushValueHolders(parent);
}
// 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);
}