/// <summary>
/// Processes type metadata.
/// </summary>
/// <param name="asmName">The name of the current assembly.</param>
/// <param name="typeElement">The XML node that defines the type metadata.</param>
private static void ProcessMetadataType(String asmName, XElement typeElement)
{
var name = typeElement.AttributeValueString("Name");
if (String.IsNullOrEmpty(name))
throw new InvalidOperationException("Invalid type name.");
var typeName = String.Format("{0}, {1}", name, asmName);
var type = Type.GetType(typeName, false);
if (type == null)
throw new InvalidOperationException(String.Format("Invalid type name '{0}'", typeName));
var attributes = new List<Attribute>();
foreach (var attributeElement in typeElement.Elements())
{
switch (attributeElement.Name.LocalName)
{
case "Editor":
attributes.Add(CreateEditorAttribute(attributeElement));
break;
case "TypeConverter":
attributes.Add(CreateTypeConverterAttribute(attributeElement));
break;
case "DefaultValue":
attributes.Add(CreateDefaultValueAttribute(attributeElement, type));
break;
case "Properties":
break;
default:
throw new InvalidOperationException(String.Format("Invalid element '{0}' in '{1}'", attributeElement.Name.LocalName, typeName));
}
}
if (attributes.Any())
{
TypeDescriptor.AddAttributes(type, attributes.ToArray());
}
var properties = typeElement.Element("Properties");
var propertyDescriptors = new List<PropertyDescriptor>();
if (properties != null)
{
foreach (var propertyElement in properties.Elements())
{
var propertyDescriptor = ProcessMetadataProperty(type, propertyElement);
propertyDescriptors.Add(propertyDescriptor);
}
}
var providerParent = TypeDescriptor.GetProvider(type);
var provider = new XmlDrivenCustomTypeDescriptionProvider(providerParent, propertyDescriptors);
TypeDescriptor.AddProvider(provider, type);
}
/// <summary>
/// Processes assembly metadata.
/// </summary>
/// <param name="asmElement">The XML node that defines the assembly metadata.</param>
private static void ProcessMetadataAssembly(XElement asmElement)
{
var name = asmElement.AttributeValueString("Name");
if (String.IsNullOrEmpty(name))
throw new InvalidOperationException("Invalid assembly name.");
var types = asmElement.Element("Types");
if (types != null)
{
foreach (var typeElement in types.Elements("Type"))
{
ProcessMetadataType(name, typeElement);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ContentManifestAsset"/> class.
/// </summary>
/// <param name="group">The <see cref="ContentManifestGroup"/> that owns the asset.</param>
/// <param name="element">The XML element that defines the asset.</param>
internal ContentManifestAsset(ContentManifestGroup group, XElement element)
{
Contract.Require(element, "element");
var name = element.AttributeValueString("Name");
if (String.IsNullOrEmpty(name))
throw new InvalidDataException(UltravioletStrings.InvalidContentManifestAssetName);
var path = element.Value;
if (String.IsNullOrEmpty(path))
throw new InvalidDataException(UltravioletStrings.InvalidContentManifestAssetPath.Format(name));
this.ManifestGroup = group;
this.Name = name;
this.RelativePath = path;
this.AbsolutePath = Path.Combine(group.Directory, path);
this.Type = group.Type;
}
/// <summary>
/// Creates a set of localized strings from the specified XML element.
/// </summary>
/// <param name="xml">The XML element that contains the string definition.</param>
/// <param name="strings">The dictionary to populate with strings for each loaded culture.</param>
/// <returns>The localization key for the created strings.</returns>
internal static String CreateFromXml(XElement xml, Dictionary<String, LocalizedString> strings)
{
Contract.Require(xml, "xml");
Contract.Require(strings, "strings");
strings.Clear();
var key = xml.AttributeValueString("Key");
if (String.IsNullOrEmpty(key))
throw new InvalidDataException(NucleusStrings.LocalizedStringMissingKey);
var html = xml.AttributeValueBoolean("Html") ?? false;
var pseudo = xml.AttributeValueBoolean("Pseudo") ?? true;
var cultures = xml.Elements();
foreach (var culture in cultures)
{
var cultureName = culture.Name.LocalName;
var cultureString = new LocalizedString(cultureName, key, html, !pseudo);
var stringPropertiesAttr = culture.Attribute("Properties");
if (stringPropertiesAttr != null)
{
var stringProperties = stringPropertiesAttr.Value.Split(',').Select(x => x.Trim());
foreach (var stringProperty in stringProperties)
{
cultureString.properties.Add(stringProperty, true);
}
}
var variants = culture.Elements("Variant");
foreach (var variant in variants)
{
var variantGroup = variant.AttributeValueString("Group") ?? "none";
var variantValue = variant.Value;
var variantProps = (variant.AttributeValueString("Properties") ?? String.Empty).Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
cultureString.variants[variantGroup] = new LocalizedStringVariant(cultureString, variantGroup, variantValue, variantProps);
}
strings[cultureName] = cultureString;
}
return key;
}
/// <summary>
/// Creates an instance of EditorAttribute from the specified XML element.
/// </summary>
/// <param name="element">The XML element from which to create the attribute.</param>
/// <returns>The attribute that was created.</returns>
private static Attribute CreateEditorAttribute(XElement element)
{
var editorType = Type.GetType(element.Value);
var editorBaseType = Type.GetType(element.AttributeValueString("BaseTypeName") ?? typeof(UITypeEditor).AssemblyQualifiedName);
return new EditorAttribute(editorType, editorBaseType);
}