Hook up lists and make tree work with null

AssemblyRemapperGUI/Form1.cs

@@ -65,14 +65,14 @@ namespace AssemblyRemapperGUI
                     FieldCount = FieldCountEnabled.GetCount(FieldCountUpDown),
                     PropertyCount = PropertyCountEnabled.GetCount(PropertyCountUpDown),
                     NestedTypeCount = NestedTypeCountEnabled.GetCount(NestedTypeCountUpDown),
-                    IncludeMethods = [],
+                    IncludeMethods = GUI.GetAllEntriesFromListBox(MethodIncludeBox),
-                    ExcludeMethods = [],
+                    ExcludeMethods = GUI.GetAllEntriesFromListBox(MethodExcludeBox),
-                    IncludeFields = [],
+                    IncludeFields = GUI.GetAllEntriesFromListBox(FieldIncludeBox),
-                    ExcludeFields = [],
+                    ExcludeFields = GUI.GetAllEntriesFromListBox(FieldExcludeBox),
-                    IncludeProperties = [],
+                    IncludeProperties = GUI.GetAllEntriesFromListBox(PropertiesIncludeBox),
-                    ExcludeProperties = [],
+                    ExcludeProperties = GUI.GetAllEntriesFromListBox(PropertiesExcludeBox),
-                    IncludeNestedTypes = [],
+                    IncludeNestedTypes = GUI.GetAllEntriesFromListBox(NestedTypesIncludeBox),
-                    ExcludeNestedTypes = [],
+                    ExcludeNestedTypes = GUI.GetAllEntriesFromListBox(NestedTypesExcludeBox),
                 }
             };
 

AssemblyRemapperGUI/Utils/GUI.cs

@@ -1,4 +1,5 @@
 using AssemblyRemapper.Models;
+using AssemblyRemapper.Utils;
 
 namespace RemapperGUI.Utils;
 
@@ -52,16 +53,25 @@ internal static class GUI
 
         var remapTreeItem = new TreeNode($"Remap: {model.NewTypeName}");
 
-        var forceRenameNode = new TreeNode($"Force Rename: {model.UseForceRename}");
+        var forceRenameNode = new TreeNode($"Force Rename: {(model.UseForceRename ? model.UseForceRename : "Disabled")}");
-        var ispublicNode = new TreeNode($"IsPublic: {isPublic}");
+
-        var isAbstractNode = new TreeNode($"IsAbstract: {isAbstract}");
+        var ispublicNode = new TreeNode($"IsPublic: {(isPublic != null ? isPublic : "Disabled")}");
-        var isInterfaceNode = new TreeNode($"IsInterface: {isInterface}");
+
-        var IsEnumNode = new TreeNode($"IsEnum: {isEnum}");
+        var isAbstractNode = new TreeNode($"IsAbstract: {(isAbstract != null ? isAbstract : "Disabled")}");
-        var IsNestedNode = new TreeNode($"IsNested: {isNested}");
+
-        var IsSealedNode = new TreeNode($"IsSealed: {IsSealed}");
+        var isInterfaceNode = new TreeNode($"IsInterface: {(isInterface != null ? isInterface : "Disabled")}");
-        var HasAttrNode = new TreeNode($"HasAttribute: {HasAttribute}");
+
-        var IsDerivedNode = new TreeNode($"IsDerived: {IsDerived}");
+        var IsEnumNode = new TreeNode($"IsEnum: {(isEnum != null ? isEnum : "Disabled")}");
-        var HasGenericsNode = new TreeNode($"HasGenericParameters: {HasGenericParameters}");
+
+        var IsNestedNode = new TreeNode($"IsNested: {(isNested != null ? isNested : "Disabled")}");
+
+        var IsSealedNode = new TreeNode($"IsSealed: {(IsSealed != null ? IsSealed : "Disabled")}");
+
+        var HasAttrNode = new TreeNode($"HasAttribute: {(HasAttribute != null ? HasAttribute : "Disabled")}");
+
+        var IsDerivedNode = new TreeNode($"IsDerived: {(IsDerived != null ? IsDerived : "Disabled")}");
+
+        var HasGenericsNode = new TreeNode($"HasGenericParameters: {(HasGenericParameters != null ? HasGenericParameters : "Disabled")}");
 
         remapTreeItem.Nodes.Add(forceRenameNode);
         remapTreeItem.Nodes.Add(ispublicNode);
@@ -74,6 +84,106 @@ internal static class GUI
         remapTreeItem.Nodes.Add(IsDerivedNode);
         remapTreeItem.Nodes.Add(HasGenericsNode);
 
+        if (model.SearchParams.IncludeMethods.Count > 0)
+        {
+            var includeMethodsNode =
+                GenerateNodeFromList(model.SearchParams.IncludeMethods, "Include Methods");
+
+            remapTreeItem.Nodes.Add(includeMethodsNode);
+        }
+
+        if (model.SearchParams.ExcludeMethods.Count > 0)
+        {
+            var excludeMethodsNode =
+                GenerateNodeFromList(model.SearchParams.ExcludeMethods, "Exclude Methods");
+
+            remapTreeItem.Nodes.Add(excludeMethodsNode);
+        }
+
+        if (model.SearchParams.IncludeFields.Count > 0)
+        {
+            var includeFieldsNode =
+                GenerateNodeFromList(model.SearchParams.IncludeFields, "Include Fields");
+
+            remapTreeItem.Nodes.Add(includeFieldsNode);
+        }
+
+        if (model.SearchParams.ExcludeFields.Count > 0)
+        {
+            var excludeFieldsNode =
+                GenerateNodeFromList(model.SearchParams.ExcludeFields, "Exclude Fields");
+
+            remapTreeItem.Nodes.Add(excludeFieldsNode);
+        }
+
+        if (model.SearchParams.IncludeProperties.Count > 0)
+        {
+            var includeProperties =
+                GenerateNodeFromList(model.SearchParams.IncludeProperties, "Include Properties");
+
+            remapTreeItem.Nodes.Add(includeProperties);
+        }
+
+        if (model.SearchParams.ExcludeProperties.Count > 0)
+        {
+            var excludeProperties =
+                GenerateNodeFromList(model.SearchParams.ExcludeProperties, "Exclude Properties");
+
+            remapTreeItem.Nodes.Add(excludeProperties);
+        }
+
+        if (model.SearchParams.IncludeNestedTypes.Count > 0)
+        {
+            var includeNestedTypes =
+                GenerateNodeFromList(model.SearchParams.IncludeNestedTypes, "Include Nested Types");
+
+            remapTreeItem.Nodes.Add(includeNestedTypes);
+        }
+
+        if (model.SearchParams.IncludeNestedTypes.Count > 0)
+        {
+            var excludeNestedTypes =
+                GenerateNodeFromList(model.SearchParams.ExcludeNestedTypes, "Exclude Nested Types");
+
+            remapTreeItem.Nodes.Add(excludeNestedTypes);
+        }
+
         return remapTreeItem;
     }
+
+    /// <summary>
+    /// Generates a new node from a list of strings
+    /// </summary>
+    /// <param name="items"></param>
+    /// <param name="name"></param>
+    /// <returns>A new tree node, or null if the provided list is empty</returns>
+    private static TreeNode GenerateNodeFromList(List<string> items, string name)
+    {
+        var node = new TreeNode(name);
+
+        foreach (var item in items)
+        {
+            node.Nodes.Add(item);
+        }
+
+        return node;
+    }
+
+    /// <summary>
+    /// Buils a list of strings from list box entries
+    /// </summary>
+    /// <param name="lb"></param>
+    /// <returns></returns>
+    public static List<string> GetAllEntriesFromListBox(ListBox lb)
+    {
+        var tmp = new List<string>();
+
+        foreach (var entry in lb.Items)
+        {
+            Logger.Log(entry);
+            tmp.Add((string)entry);
+        }
+
+        return tmp;
+    }
 }