internal void GetAttributeInfoFromId(short id, out short ownerTypeId, out string name, out BamlAttributeUsage attributeUsage)
{
if (id < 0)
{
KnownProperties knownId = (KnownProperties)(-id);
name = GetAttributeNameFromKnownId(knownId);
ownerTypeId = (short)-(short)KnownTypes.GetKnownElementFromKnownCommonProperty(knownId);
attributeUsage = GetAttributeUsageFromKnownAttribute(knownId);
}
else
{
BamlAttributeInfoRecord record = (BamlAttributeInfoRecord)AttributeIdMap[id];
name = record.Name;
ownerTypeId = record.OwnerTypeId;
attributeUsage = record.AttributeUsage;
}
}
internal short AddAttributeInfoMap(
BinaryWriter binaryWriter,
string assemblyFullName, // Name of assembly for owning or declaring type
string typeFullName, // Type name of object that owns or declares this attribute
Type owningType, // Actual type of the object the owns or declares this attribute
string fieldName, // Name of the attribute
Type attributeType, // Type of the attribute or property itself; not its owner type
BamlAttributeUsage attributeUsage, // Special flags for how this attribute is used.
out BamlAttributeInfoRecord bamlAttributeInfoRecord) // Record if not a known DP
{
short typeId;
// If we do not already have a type record for the type associated with
// this attribute, then recurse and write out the TypeInfo first.
if (!GetTypeInfoId(binaryWriter, assemblyFullName, typeFullName, out typeId))
{
// Get id for Type that owns or has this attribute declared on it. This is
// refered to in the attribute info record and is also part of the key for
// seeing if we already have an attribute info record for this attribute.
Type serializerType = XamlTypeMapper.GetXamlSerializerForType(owningType);
string serializerTypeAssemblyName = serializerType == null ?
string.Empty : serializerType.Assembly.FullName;
string serializerTypeName = serializerType == null ?
string.Empty : serializerType.FullName;
typeId = AddTypeInfoMap(binaryWriter, assemblyFullName, typeFullName,
owningType, serializerTypeAssemblyName,
serializerTypeName);
}
else if (typeId < 0)
{
// Only known types will have known properties
short attributeId = (short)-KnownTypes.GetKnownPropertyAttributeId((KnownElements)(-typeId), fieldName);
if (attributeId < 0)
{
// The property is known and doesn't need a record created.
bamlAttributeInfoRecord = null;
return attributeId;
}
}
object key = GetAttributeInfoKey(typeFullName, fieldName);
bamlAttributeInfoRecord = (BamlAttributeInfoRecord)GetHashTableData(key);
if (null == bamlAttributeInfoRecord)
{
// The property is new and needs a record created.
bamlAttributeInfoRecord = new BamlAttributeInfoRecord();
bamlAttributeInfoRecord.Name = fieldName;
bamlAttributeInfoRecord.OwnerTypeId = typeId;
bamlAttributeInfoRecord.AttributeId = (short)AttributeIdMap.Add(bamlAttributeInfoRecord);
bamlAttributeInfoRecord.AttributeUsage = attributeUsage;
// add to the hash
ObjectHashTable.Add(key, bamlAttributeInfoRecord);
// Write to BAML
bamlAttributeInfoRecord.Write(binaryWriter);
}
return bamlAttributeInfoRecord.AttributeId;
}
internal bool DoesAttributeMatch(short id, BamlAttributeUsage attributeUsage)
{
if (id < 0)
{
return attributeUsage == GetAttributeUsageFromKnownAttribute((KnownProperties)(-id));
}
else
{
BamlAttributeInfoRecord record = (BamlAttributeInfoRecord)AttributeIdMap[id];
return attributeUsage == record.AttributeUsage;
}
}
internal XamlPropertyNode(
int lineNumber,
int linePosition,
int depth,
object propertyMember, // DependencyProperty, MethodInfo or PropertyInfo
string assemblyName,
string typeFullName,
string propertyName,
string value,
BamlAttributeUsage attributeUsage,
bool complexAsSimple,
bool isDefinitionName) : this(lineNumber,
linePosition,
depth,
propertyMember,
assemblyName,
typeFullName,
propertyName,
value,
attributeUsage,
complexAsSimple)
{
_isDefinitionName = isDefinitionName;
}
// Return the attribute info record that corresponds to the passed type and field name.
// If one does not already exist, then create a new one. This can involve first creating
// a type info record that corresponds to the owner type and the attribute type.
// This method also checks if the attributeType is custom serializable or convertible.
internal short AddAttributeInfoMap(
BinaryWriter binaryWriter,
string assemblyFullName, // Name of assembly for owning or declaring type
string typeFullName, // Type name of object that owns or declares this attribute
Type owningType, // Actual type of the object the owns or declares this attribute
string fieldName, // Name of the attribute
Type attributeType, // Type of the attribute or property itself; not its owner type
BamlAttributeUsage attributeUsage) // Special flags for how this attribute is used.
{
BamlAttributeInfoRecord record;
return AddAttributeInfoMap(binaryWriter, assemblyFullName, typeFullName, owningType, fieldName, attributeType, attributeUsage, out record);
}
/// <summary>
/// Constructor
/// </summary>
internal XamlDefAttributeNode(
int lineNumber,
int linePosition,
int depth,
string name,
string value,
BamlAttributeUsage bamlAttributeUsage)
: base (XamlNodeType.DefAttribute,lineNumber,linePosition,depth,value)
{
_attributeUsage = bamlAttributeUsage;
_name = name;
}
/// <summary>
/// Constructor
/// </summary>
internal XamlPropertyNode(
int lineNumber,
int linePosition,
int depth,
object propertyMember, // DependencyProperty, MethodInfo or PropertyInfo
string assemblyName,
string typeFullName,
string propertyName,
string value,
BamlAttributeUsage attributeUsage,
bool complexAsSimple) : base (XamlNodeType.Property,
lineNumber,
linePosition,
depth,
propertyMember,
assemblyName,
typeFullName,
propertyName)
{
_value = value;
_attributeUsage = attributeUsage;
_complexAsSimple = complexAsSimple;
}
/// <summary>
/// Write simple property information to baml.
/// </summary>
/// <remarks>
/// If the type of this property supports
/// custom serialization using a XamlSerializer and custom serialization
/// is chosen, then write out a
/// Custom serialization record. Note that for custom serialization
/// to work, the assembly that contains the property's type must be
/// loaded. If custom serialization is not chosen, then
/// write out a 'normal' record, which will cause type conversion to happen
/// at load time from the stored string.
/// </remarks>
public void WriteProperty(
string assemblyName,
string ownerTypeFullName,
string propName,
string value,
BamlAttributeUsage propUsage)
{
VerifyWriteState();
BamlRecordType parentType = PeekRecordType();
if (parentType != BamlRecordType.ElementStart)
{
throw new InvalidOperationException(SR.Get(SRID.BamlWriterNoInElement,
"WriteProperty",
parentType.ToString()));
}
object dpOrPi;
Type declaringType;
GetDpOrPi(assemblyName, ownerTypeFullName, propName, out dpOrPi, out declaringType);
// Check if the value is a MarkupExtension. If so it must be expanded into
// a series of baml records. Otherwise just write out the property.
AttributeData data = _extensionParser.IsMarkupExtensionAttribute(
declaringType,
propName,
ref value,
0, // No line numbers for baml
0,
0,
dpOrPi);
if (data == null)
{
XamlPropertyNode propNode = new XamlPropertyNode(
0,
0,
_depth,
dpOrPi,
assemblyName,
ownerTypeFullName,
propName,
value,
propUsage,
false);
Type propType = XamlTypeMapper.GetPropertyType(dpOrPi);
if (propType == typeof(DependencyProperty))
{
Type ownerType = null;
_dpProperty = XamlTypeMapper.ParsePropertyName(_parserContext, value, ref ownerType);
if (_bamlRecordWriter != null && _dpProperty != null)
{
short typeId;
short propertyId = _parserContext.MapTable.GetAttributeOrTypeId(_bamlRecordWriter.BinaryWriter,
ownerType,
_dpProperty.Name,
out typeId);
if (propertyId < 0)
{
propNode.ValueId = propertyId;
propNode.MemberName = null;
}
else
{
propNode.ValueId = typeId;
propNode.MemberName = _dpProperty.Name;
}
}
}
else if (_dpProperty != null)
{
propNode.ValuePropertyType = _dpProperty.PropertyType;
propNode.ValuePropertyMember = _dpProperty;
propNode.ValuePropertyName = _dpProperty.Name;
propNode.ValueDeclaringType = _dpProperty.OwnerType;
string propAssemblyName = _dpProperty.OwnerType.Assembly.FullName;
_dpProperty = null;
}
_bamlRecordWriter.WriteProperty(propNode);
}
else
{
if (data.IsSimple)
{
if (data.IsTypeExtension)
{
Type typeValue = _xamlTypeMapper.GetTypeFromBaseString(data.Args,
_parserContext,
true);
Debug.Assert(typeValue != null);
XamlPropertyWithTypeNode xamlPropertyWithTypeNode =
new XamlPropertyWithTypeNode(0,
0,
_depth,
dpOrPi,
assemblyName,
ownerTypeFullName,
propName,
typeValue.FullName,
typeValue.Assembly.FullName,
typeValue,
string.Empty,
string.Empty);
_bamlRecordWriter.WritePropertyWithType(xamlPropertyWithTypeNode);
}
else
{
XamlPropertyWithExtensionNode xamlPropertyWithExtensionNode =
new XamlPropertyWithExtensionNode(0,
0,
_depth,
dpOrPi,
assemblyName,
ownerTypeFullName,
propName,
data.Args,
data.ExtensionTypeId,
data.IsValueNestedExtension,
data.IsValueTypeExtension);
_bamlRecordWriter.WritePropertyWithExtension(xamlPropertyWithExtensionNode);
}
}
else
{
_extensionParser.CompileAttribute(
_markupExtensionNodes, data);
}
}
}
/// <summary>
/// Constructor
/// </summary>
internal XamlUnknownAttributeNode(
int lineNumber,
int linePosition,
int depth,
string xmlNamespace,
string name,
string value,
BamlAttributeUsage attributeUsage)
: base(XamlNodeType.UnknownAttribute,lineNumber,linePosition,
depth,value)
{
_xmlNamespace = xmlNamespace;
_name = name;
_attributeUsage = attributeUsage;
}
/// <summary>
/// Write out a property that is represented as a complex property as if it were
/// a regular attribute.
/// </summary>
void WriteComplexAsSimpleProperty(
string propertyName, // String name of the property in xaml markup
string propertyNamespaceUri, // Namespace corresponding to the property name
object propertyMember, // DependencyProperty, PropertyInfo or MethodInfo for static setter
string assemblyName, // Assembly where type of the CLR property is defined
Type declaringType, // Type that corresponds to declaringTypeFullName (where the property is declared)
string declaringTypeFullName, // Full name of the type where the property is declared
string value, // String value of the property
BamlAttributeUsage usage) // Defines special usage for this property, such as xml:lang
{
CheckDuplicateProperty(ParentProperties, propertyName, propertyMember);
// Validate that enum values aren't pure digits.
Type propType = XamlTypeMapper.GetPropertyType(propertyMember);
XamlTypeMapper.ValidateEnums(propertyName, propType, value);
// See if this is the property that maps to x:Name, and if so, set the usage flag.
string parentName = declaringType != null ? declaringType.Name : string.Empty;
if (IsNameProperty(value, parentName, propertyName, propertyNamespaceUri, GetRuntimeNamePropertyName(declaringType)))
{
usage = BamlAttributeUsage.RuntimeName;
}
AddNodeToCollection(new XamlPropertyNode(
LineNumber, LinePosition, XmlReader.Depth, propertyMember,
assemblyName, declaringTypeFullName, propertyName, value, usage, true));
}
internal BamlPropertyNode(
string assemblyName,
string ownerTypeFullName,
string propertyName,
string value,
BamlAttributeUsage usage
): base(assemblyName, ownerTypeFullName, propertyName)
{
_value = value;
_attributeUsage = usage;
_nodeType = BamlNodeType.Property;
}
/// <summary>
/// Write out a property that is represented as an attribute on a tag.
/// </summary>
void WriteProperty(
string propertyName, // String name of the property in xaml markup
object propertyMember, // DependencyProperty, PropertyInfo or MethodInfo for static setter
string assemblyName, // Assembly of the type where the property is declared
string declaringTypeFullName, // Full name of the type where the property is declared
string value, // String value of the property
BamlAttributeUsage usage) // Defines special usage for this property, such as xml:lang
{
bool isName = usage == BamlAttributeUsage.RuntimeName;
AddNodeToCollection(new XamlPropertyNode(
LineNumber, LinePosition, XmlReader.Depth, propertyMember,
assemblyName, declaringTypeFullName, propertyName, value, usage, false), isName, isName);
}
/// <summary>
/// Write out an attribute in the definition namespace
/// </summary>
void WriteDefAttribute(string name, string value, BamlAttributeUsage bamlAttributeUsage)
{
AddNodeToCollection(new XamlDefAttributeNode(LineNumber, LinePosition, XmlReader.Depth,
name, value, bamlAttributeUsage));
}
// Token: 0x06006E81 RID: 28289 RVA: 0x001FC15C File Offset: 0x001FA35C
internal BamlPropertyNode(string assemblyName, string ownerTypeFullName, string propertyName, string value, BamlAttributeUsage usage) : base(assemblyName, ownerTypeFullName, propertyName)
{
this._value = value;
this._attributeUsage = usage;
this._nodeType = BamlNodeType.Property;
}
// Token: 0x060022B8 RID: 8888 RVA: 0x000AC148 File Offset: 0x000AA348
internal XamlPropertyNode(int lineNumber, int linePosition, int depth, object propertyMember, string assemblyName, string typeFullName, string propertyName, string value, BamlAttributeUsage attributeUsage, bool complexAsSimple) : base(XamlNodeType.Property, lineNumber, linePosition, depth, propertyMember, assemblyName, typeFullName, propertyName)
{
this._value = value;
this._attributeUsage = attributeUsage;
this._complexAsSimple = complexAsSimple;
}
// Token: 0x060022B9 RID: 8889 RVA: 0x000AC180 File Offset: 0x000AA380
internal XamlPropertyNode(int lineNumber, int linePosition, int depth, object propertyMember, string assemblyName, string typeFullName, string propertyName, string value, BamlAttributeUsage attributeUsage, bool complexAsSimple, bool isDefinitionName) : this(lineNumber, linePosition, depth, propertyMember, assemblyName, typeFullName, propertyName, value, attributeUsage, complexAsSimple)
{
this._isDefinitionName = isDefinitionName;
}
