public ImGuiInstanceMethodDefinition(string name, string linkName, List <object> argsT, string parentType, string returnType, bool isGeneric, Dictionary <string, object> defaults) : base(name, linkName, argsT, parentType, isGeneric, defaults)
{
ReturnType = ImGui.FixType(returnType);
var pOuts = Args.Where(a => a.Name == "pOut");
if (pOuts.Count() == 1)
{
ReturnType = pOuts.Single().Type.Trim('*');
}
if (IsGeneric)
{
var originalArgs = Args.Where(a => a.Type.Replace("*", "") == ParentType);
var newArgs = new Dictionary <int, ImGuiMethodParameter>();
foreach (var originalArg in originalArgs)
{
var originalArgType = originalArg.Type.Replace("*", "");
var newArg = new ImGuiMethodParameter(originalArg.Name, originalArg.Type.Replace(originalArgType, $"{originalArgType}<T>"));
var index = Args.IndexOf(originalArg);
newArgs[index] = newArg;
}
foreach (var newArg in newArgs)
{
Args.RemoveAt(newArg.Key);
Args.Insert(newArg.Key, newArg.Value);
}
}
}
public static string FixType(string type)
{
if (type.Contains("_") && !IsFunctionPointer(type) && !type.EndsWith("_t") && !type.EndsWith("_t*"))
{
return(FixTemplate(type));
}
var fixedType = type;
fixedType = fixedType.Replace("const ", "");
fixedType = fixedType.Replace(" const", "");
fixedType = fixedType.Replace("unsigned ", "u");
fixedType = fixedType.Replace("signed ", "");
fixedType = fixedType.Replace("_t", "");
fixedType = RemovePrefix(fixedType);
if (fixedType.EndsWith("int"))
{
fixedType += "32";
}
else if (fixedType.EndsWith("int*"))
{
fixedType = $"{fixedType.Remove(fixedType.Length - 4, 4)}int32*";
}
if (IsFunctionPointer(fixedType))
{
var returnType = fixedType.Substring(0, fixedType.IndexOf('('));
var args = ImGuiMethodParameter.From(fixedType.Substring(fixedType.IndexOf(')') + 1));
fixedType = $"function {returnType}({args.ToLinkableDefinitionArg()})";
}
return(fixedType);
}
private static int DefaultValueComparison(ImGuiMethodParameter left, ImGuiMethodParameter right)
{
if (left.DefaultValue == "" && right.DefaultValue == "" ||
left.DefaultValue != "" && right.DefaultValue != "")
{
return(0);
}
if (left.DefaultValue != "")
{
return(1);
}
if (right.DefaultValue != "")
{
return(-1);
}
return(0);
}
public ImGuiConstructorDefinition(string linkName, List <object> argsT, string structType, bool isGeneric, Dictionary <string, object> defaults) : base("this", linkName, argsT, structType, isGeneric, defaults)
{
if (IsGeneric)
{
var originalArgs = Args.Where(a => a.Type.Replace("*", "") == ParentType);
var newArgs = new Dictionary <int, ImGuiMethodParameter>();
foreach (var originalArg in originalArgs)
{
var originalArgType = originalArg.Type.Replace("*", "");
var newArg = new ImGuiMethodParameter(originalArg.Name, originalArg.Type.Replace(originalArgType, $"{originalArgType}<T>"));
var index = Args.IndexOf(originalArg);
newArgs[index] = newArg;
}
foreach (var newArg in newArgs)
{
Args.RemoveAt(newArg.Key);
Args.Insert(newArg.Key, newArg.Value);
}
}
}
public ImGuiMethodDefinition(string name, string linkName, List <object> argsT, Dictionary <string, object> defaults)
{
Name = name.ToPascalCase();
LinkName = linkName;
Args = ImGuiMethodParameter.From(argsT.ConvertAll(a => (Dictionary <string, object>)a), defaults);
}
public static List <ImGuiStruct> From(Dictionary <string, object> structs, ref List <ImGuiMethodDefinition> methods)
{
var structList = new List <ImGuiStruct>();
var constructors = methods.Where(m => m is ImGuiConstructorDefinition).ToList().ConvertAll(m => m as ImGuiConstructorDefinition);
var destructors = methods.Where(m => m is ImGuiDestructorDefinition).ToList().ConvertAll(m => m as ImGuiDestructorDefinition);
var instanceMethods = methods.Where(m => m is ImGuiInstanceMethodDefinition).ToList().ConvertAll(m => m as ImGuiInstanceMethodDefinition);
var vectorProps = new List <dynamic>();
var prop1 = new Dictionary <string, object>();
prop1["name"] = "Size";
prop1["type"] = "int";
vectorProps.Add(prop1);
var prop2 = new Dictionary <string, object>();
prop2["name"] = "Capacity";
prop2["type"] = "int";
vectorProps.Add(prop2);
var prop3 = new Dictionary <string, object>();
prop3["name"] = "Data";
prop3["type"] = "T*";
vectorProps.Add(prop3);
structs["ImVector"] = vectorProps;
foreach (var name in structs.Keys)
{
var fixedName = ImGui.RemovePrefix(name);
var structMethods = new List <ImGuiStructMethodDefinition>();
structMethods.AddRange(constructors.Where(m => m.ParentType == fixedName));
structMethods.AddRange(destructors.Where(m => m.ParentType == fixedName));
structMethods.AddRange(instanceMethods.Where(m => m.ParentType == fixedName));
bool isGeneric = false;
foreach (var structMethod in structMethods)
{
methods.Remove(structMethod);
if (structMethod is ImGuiInstanceMethodDefinition i)
{
instanceMethods.Remove(i);
if (i.IsGeneric)
{
isGeneric = true;
}
}
}
var properties = new List <ImGuiStructProperty>();
var unions = new List <ImGuiStructUnion>();
foreach (var property in (List <dynamic>)structs[name])
{
if (ImGui.IsUnion((string)property["type"]))
{
var unionName = $"{ImGui.RemovePrefix(name)}Union{unions.Count}";
var unionProperties = ImGui.GetUnionProperties((string)property["type"]);
var unionPropertyName = $"Union{unions.Count}";
var structPropertyForwarders = new List <ImGuiStructProperty>();
foreach (var unionProperty in unionProperties)
{
structPropertyForwarders.Add(new ImGuiStructProperty(
unionProperty.Name,
unionProperty.Type,
$"{{ get {{ return {unionPropertyName}.{unionProperty.Name}; }} set mut {{ {unionPropertyName}.{unionProperty.Name} = value; }} }}"));
}
properties.Add(new ImGuiStructProperty(unionPropertyName, unionName, "= .()", "private"));
properties.AddRange(structPropertyForwarders);
unions.Add(new ImGuiStructUnion(unionName, unionProperties, new List <ImGuiStructMethodDefinition>(), new List <ImGuiStructUnion>()));
}
else
{
var size = -1;
if (property.ContainsKey("size"))
{
size = (int)property["size"];
}
var type = (string)property["type"];
if (property.ContainsKey("template_type"))
{
var templateType = (string)property["template_type"];
var underscoreTemplate = templateType.Replace(' ', '_');
type = type.Replace(underscoreTemplate, templateType);
}
properties.Add(new ImGuiStructProperty((string)property["name"], type, size: size));
}
}
structList.Add(new ImGuiStruct(name, properties, structMethods, unions, isGeneric));
}
// Leftover methods without a valid parent
foreach (var method in instanceMethods)
{
ImGuiStruct parent = null;
if (!structList.Any(s => s.Name == ImGui.RemovePrefix(method.ParentType)))
{
parent = new ImGuiStruct(method.ParentType, new List <ImGuiStructProperty>(), new List <ImGuiStructMethodDefinition>(), new List <ImGuiStructUnion>(), method.IsGeneric);
structList.Add(parent);
}
else
{
parent = structList.Single(s => s.Name == ImGui.RemovePrefix(method.ParentType));
}
parent.Methods.Add(method);
var originalArgs = method.Args.Where(a => a.Type.Replace("*", "") == parent.Name);
var newArgs = new Dictionary <int, ImGuiMethodParameter>();
foreach (var originalArg in originalArgs)
{
var originalArgType = originalArg.Type.Replace("*", "");
var newArg = new ImGuiMethodParameter(originalArg.Name, originalArg.Type.Replace(originalArgType, $"{originalArgType}<T>"));
var index = method.Args.IndexOf(originalArg);
newArgs[index] = newArg;
}
foreach (var newArg in newArgs)
{
method.Args.RemoveAt(newArg.Key);
method.Args.Insert(newArg.Key, newArg.Value);
}
}
methods.RemoveAll(m => m is ImGuiConstructorDefinition);
methods.RemoveAll(m => m is ImGuiDestructorDefinition);
methods.RemoveAll(m => m is ImGuiInstanceMethodDefinition);
return(structList);
}
