public D2DTypes(XmlBindings.D2DTypes xmlData, Overrides.XmlBindings.Settings overrides, Dictionary<string, QualifiableType> typeDictionary, OutputDataTypes outputDataTypes)
{
const Namespace globalNamespace = null; // Using null as the namespace parameter indicates the global namespace.
m_primitiveList = new List<Primitive>();
foreach(XmlBindings.Primitive p in xmlData.Primitives)
{
Overrides.XmlBindings.Primitive overridePrimitive = null;
if (overrides != null) overridePrimitive = overrides.Primitives.Find(x => x.Name == p.Name);
m_primitiveList.Add(new Primitive(p, overridePrimitive, typeDictionary));
}
m_structList = new List<Struct>();
foreach (XmlBindings.Struct s in xmlData.Structs)
{
Overrides.XmlBindings.Struct overrideStruct = null;
if (overrides != null) overrideStruct = overrides.Structs.Find(x => x.Name == s.Name);
m_structList.Add(new Struct(globalNamespace, s, overrideStruct, typeDictionary, outputDataTypes));
}
m_namespaceList = new List<Namespace>();
foreach (XmlBindings.Namespace n in xmlData.Namespaces)
{
Overrides.XmlBindings.Namespace overrideNamespace = null;
if (overrides != null) overrideNamespace = overrides.Namespaces.Find(x => x.Name == n.Name);
m_namespaceList.Add(new Namespace(n, overrideNamespace, overrides.RootNamespace.Value, typeDictionary, outputDataTypes));
}
}
public Interface(Namespace parentNamespace, XmlBindings.Interface xmlData, Overrides.XmlBindings.Interface overrides, Dictionary<string, QualifiableType> typeDictionary)
{
Debug.Assert(xmlData.Name.StartsWith("I"));
string unprefixed = xmlData.Name.Substring(1);
m_stylizedName = Formatter.Prefix + unprefixed;
m_innerName = "I" + parentNamespace.ApiName + unprefixed;
m_nativeNameOfInheritanceParent = xmlData.Extends;
if (overrides != null && overrides.IsProjectedAsAbstract)
{
m_stylizedName = "I" + Formatter.Prefix + unprefixed;
}
m_methods = new List<Method>();
foreach (XmlBindings.Method xmlMethod in xmlData.Methods)
{
Method m = new Method(xmlMethod);
m_methods.Add(m);
}
typeDictionary[parentNamespace.RawName + "::" + xmlData.Name] = this;
}
static string GetValueExpression(XmlBindings.EnumValue xmlData)
{
//
// Value and NumericalValue seem like they should be the same, but they're not.
//
// Value may be an int literal, or some other symbol.
// NumericalValue is always an int literal (may be hex or dec)
//
// NumericalValue is used for Direct2D's internal codegen, in cases where the
// symbol used for Value can't be referenced in the event manifest.
//
// And so, the int literal is decided according to the following priority
// 1. NumericalValue if avail
// 2. Value, must always be parseable as int literal
//
if (xmlData.NumericalValue != null)
{
return xmlData.NumericalValue;
}
else
{
Debug.Assert(xmlData.Value != null);
return xmlData.Value;
}
}
public Namespace(XmlBindings.Namespace xmlData, Overrides.XmlBindings.Namespace overrides, string rootProjectedNamespace, Dictionary<string, QualifiableType> typeDictionary, OutputDataTypes outputDataTypes)
{
m_rawName = xmlData.Name;
if (overrides != null && overrides.NameOverride != null)
{
m_apiName = overrides.NameOverride;
}
else
{
m_apiName = xmlData.Name;
}
m_enums = new List<Enum>();
foreach (XmlBindings.Enum enumXml in xmlData.Enums)
{
Overrides.XmlBindings.Enum overridesEnum = null;
if (overrides != null) overridesEnum = overrides.Enums.Find(x => x.Name == enumXml.Name);
m_enums.Add(new Enum(this, rootProjectedNamespace, enumXml, overridesEnum, typeDictionary, outputDataTypes));
}
m_structs = new List<Struct>();
foreach (XmlBindings.Struct structXml in xmlData.Structs)
{
Overrides.XmlBindings.Struct overridesStruct = null;
if (overrides != null) overridesStruct = overrides.Structs.Find(x => x.Name == structXml.Name);
m_structs.Add(new Struct(this, structXml, overridesStruct, typeDictionary, outputDataTypes));
}
m_interfaces = new List<Interface>();
foreach (XmlBindings.Interface interfaceXml in xmlData.Interfaces)
{
Overrides.XmlBindings.Interface overridesInterface = null;
if (overrides != null) overridesInterface = overrides.Interfaces.Find(x => x.Name == interfaceXml.Name);
m_interfaces.Add(new Interface(this, interfaceXml, overridesInterface, typeDictionary));
}
foreach (XmlBindings.Typedef t in xmlData.Typedefs)
{
// In the types XML, often times types are declared as one type,
// then typedefs to something else, and referenced thereafter
// as that second type. And so, typedefs must be handled here.
//
// In the XML, the 'Name' field in each typedef is unqualified,
// but the 'From' field is qualified.
// For example, <Typedef Name="COLOR_F" From="D2D::COLOR_F"/>
//
// So, the entries are added to the type dictionary here
// under the qualified name.
//
string qualified = xmlData.Name + "::" + t.Name;
typeDictionary[qualified] = typeDictionary[t.From];
}
}
public Primitive(XmlBindings.Primitive xmlData, Overrides.XmlBindings.Primitive overrides, Dictionary<string, QualifiableType> typeDictionary)
{
m_name = xmlData.Name;
typeDictionary[m_name] = this;
m_projectedName = m_name;
if(overrides != null && overrides.ProjectedNameOverride != null)
{
m_projectedName = overrides.ProjectedNameOverride;
}
}
public StructField(XmlBindings.StructField xmlData)
{
// The projected classes use a private member variable for each
// attribute. These are given a prefix, as per convention.
if (xmlData.Name.StartsWith("_"))
{
m_privateMemberName = "m" + xmlData.Name;
}
else
{
m_privateMemberName = "m_" + xmlData.Name;
}
m_propertyName = Formatter.StylizeWithCapitalLeadingLetter(xmlData.Name);
m_typeName = xmlData.Type;
}
public Interface(Namespace parentNamespace, XmlBindings.Interface xmlData, Overrides.XmlBindings.Interface overrides, Dictionary<string, QualifiableType> typeDictionary)
{
Debug.Assert(xmlData.Name.StartsWith("I"));
string unprefixed = xmlData.Name.Substring(1);
m_stylizedName = Formatter.Prefix + unprefixed;
m_innerName = "I" + parentNamespace.ApiName + unprefixed;
if(overrides != null && overrides.IsProjectedAsAbstract)
{
m_stylizedName = "I" + Formatter.Prefix + unprefixed;
}
typeDictionary[parentNamespace.RawName + "::" + xmlData.Name] = this;
}
public EnumValue(XmlBindings.EnumValue xmlData, Overrides.XmlBindings.EnumValue overrides)
{
m_nativeName = xmlData.Name;
m_stylizedName = Formatter.StylizeNameFromUnderscoreSeparators(xmlData.Name);
m_shouldProject = true;
if (overrides != null)
{
if (overrides.ProjectedNameOverride != null)
{
m_stylizedName = overrides.ProjectedNameOverride;
}
m_shouldProject = overrides.ShouldProject;
}
m_valueExpression = GetValueExpression(xmlData);
}
public Struct(Namespace parentNamespace, XmlBindings.Struct xmlData, Overrides.XmlBindings.Struct overrideData, Dictionary<string, QualifiableType> typeDictionary, OutputDataTypes outputDataTypes)
{
if (parentNamespace != null)
{
m_rawName = parentNamespace.ApiName + "_" + xmlData.Name;
typeDictionary[parentNamespace.RawName + "::" + xmlData.Name] = this;
}
else
{
m_rawName = xmlData.Name;
typeDictionary[xmlData.Name] = this;
}
m_stylizedName = Formatter.Prefix + Formatter.StylizeNameFromUnderscoreSeparators(xmlData.Name);
if(overrideData != null)
{
if(overrideData.Guid != null)
{
m_guid = overrideData.Guid;
}
if(overrideData.ProjectedNameOverride != null)
{
if (overrideData.ShouldProject)
m_stylizedName = Formatter.Prefix + overrideData.ProjectedNameOverride;
else
m_stylizedName = overrideData.ProjectedNameOverride;
}
if(overrideData.IdlNamespaceQualifier != null)
{
m_idlTypeNameQualifier = overrideData.IdlNamespaceQualifier;
}
}
m_idlInterfaceName = "I" + m_stylizedName;
m_structFields = new List<StructField>();
foreach(XmlBindings.StructField structXmlData in xmlData.Fields)
{
m_structFields.Add(new StructField(structXmlData));
}
if (xmlData.Extends != null)
{
m_extendsTypeName = xmlData.Extends;
// Note: the Extends field is already qualified. See D2DTypes.xml. Example: Extends="D2D1::IImage"
QualifiableType parentType = typeDictionary[m_extendsTypeName];
Struct parentAsStruct = parentType as Struct; // Structs should only be deriving from struct types
m_structFields.InsertRange(0, parentAsStruct.Fields);
Debug.Assert(parentAsStruct.ExtendsTypeName == null); // Multiple levels in the hierarchy are not supported at this time.
}
// For the time being, unions are not output (they are very uncommon).
bool usesUnions = xmlData.Fields == null;
// Structs in the global namespace are defined as aliases only. By convention, only structs in a namespace are output.
if (parentNamespace != null && !usesUnions && (overrideData != null && overrideData.ShouldProject))
{
outputDataTypes.AddStruct(this);
}
}
public Parameter(XmlBindings.Parameter xmlData)
{
m_name = xmlData.Name;
m_nativeTypeName = xmlData.Type;
m_form = xmlData.Form;
m_isArray = xmlData.IsArray;
}
public Method(XmlBindings.Method xmlData)
{
m_name = xmlData.Name;
m_nativeReturnType = xmlData.Return;
m_parameters = new List<Parameter>();
foreach (XmlBindings.Parameter parameterXml in xmlData.Parameters)
{
Parameter p = new Parameter(parameterXml);
m_parameters.Add(p);
}
m_isOverload = xmlData.OverloadId != null;
m_isConst = xmlData.IsConst;
}
public Enum(Namespace parentNamespace, XmlBindings.Enum xmlData, Overrides.XmlBindings.Enum overrides, Dictionary<string, QualifiableType> typeDictionary, OutputDataTypes outputDataTypes)
{
m_stylizedName = Formatter.Prefix + Formatter.StylizeNameFromUnderscoreSeparators(xmlData.Name);
if (parentNamespace != null)
{
m_rawName = parentNamespace.ApiName + "_" + xmlData.Name;
typeDictionary[parentNamespace.RawName + "::" + xmlData.Name] = this;
}
else
{
//
// Namespace of NULL indicates the global namespace.
// These types aren't D2D types, and their full native name is
// exactly what's in the name field (no need to prepend anything).
//
m_rawName = xmlData.Name;
typeDictionary[xmlData.Name] = this;
}
m_isFlags = xmlData.IsFlags;
m_enumValues = new List<EnumValue>();
foreach (XmlBindings.EnumValue valueXml in xmlData.EnumValues)
{
Overrides.XmlBindings.EnumValue overridesEnumValue = null;
if (overrides != null) overridesEnumValue = overrides.Values.Find(x => x.Name == valueXml.Name);
m_enumValues.Add(new EnumValue(valueXml, overridesEnumValue));
}
bool shouldProject = false;
if(overrides != null)
{
shouldProject = overrides.ShouldProject;
if(overrides.ProjectedNameOverride != null)
{
m_stylizedName = Formatter.Prefix + overrides.ProjectedNameOverride;
}
}
// Enums in the global namespace are defined as aliases only. By convention, only enums in a namespace are output.
if (parentNamespace != null && shouldProject)
{
outputDataTypes.AddEnum(this);
}
}
