Add initial implementation of moving component categories

Author: Banane9

ComponentSelectorAdditions/CategoryOverride.cs

@@ -0,0 +1,25 @@
+using ComponentSelectorAdditions.Events;
+using FrooxEngine;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ComponentSelectorAdditions
+{
+    // Make this have source and target to actually remove the types from the source?
+    // Removal would be optional, of course
+    public sealed class CategoryOverride
+    {
+        private readonly Func<EnumerateComponentsEvent, IEnumerable<ComponentResult>> _getAdditionalComponents;
+        public CategoryNode<Type> TargetCategory { get; }
+
+        public CategoryOverride(CategoryNode<Type> targetCategory, Func<EnumerateComponentsEvent, IEnumerable<ComponentResult>> getAdditionalComponents)
+        {
+            TargetCategory = targetCategory;
+            _getAdditionalComponents = getAdditionalComponents;
+        }
+
+        public IEnumerable<ComponentResult> GetAdditionalComponents(EnumerateComponentsEvent eventData)
+            => _getAdditionalComponents(eventData);
+    }
+}

ComponentSelectorAdditions/CategoryOverrideHandler.cs

@@ -0,0 +1,63 @@
+using ComponentSelectorAdditions.Events;
+using EnumerableToolkit;
+using FrooxEngine;
+using MonkeyLoader.Resonite;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+
+namespace ComponentSelectorAdditions
+{
+    public sealed class CategoryOverrideHandler : ResoniteCancelableEventHandlerMonkey<CategoryOverrideHandler, EnumerateComponentsEvent>
+    {
+        private static readonly Dictionary<CategoryNode<Type>, HashSet<CategoryOverride>> _overridesByCategory = new();
+
+        /// <inheritdoc/>
+        public override int Priority => HarmonyLib.Priority.VeryLow;
+
+        /// <inheritdoc/>
+        public override bool SkipCanceled => false;
+
+        public static bool AddOverride(CategoryOverride categoryOverride)
+            => _overridesByCategory.GetOrCreateValue(categoryOverride.TargetCategory).Add(categoryOverride);
+
+        public static IEnumerable<CategoryOverride> GetOverrides(CategoryNode<Type> category)
+            => _overridesByCategory.TryGetValue(category, out var overrides) ? overrides.AsSafeEnumerable() : Enumerable.Empty<CategoryOverride>();
+
+        public static bool HasAnyOverride(CategoryNode<Type> category)
+            => _overridesByCategory.TryGetValue(category, out var overrides) && overrides.Count > 0;
+
+        public static bool HasOverride(CategoryOverride categoryOverride)
+            => _overridesByCategory.TryGetValue(categoryOverride.TargetCategory, out var overrides) && overrides.Contains(categoryOverride);
+
+        public static bool RemoveOverride(CategoryOverride categoryOverride)
+            => _overridesByCategory.TryGetValue(categoryOverride.TargetCategory, out var overrides) && overrides.Remove(categoryOverride);
+
+        /// <inheritdoc/>
+        protected override void Handle(EnumerateComponentsEvent eventData)
+        {
+            foreach (var categoryOverride in GetOverrides(eventData.RootCategory))
+            {
+                foreach (var additionalResult in categoryOverride.GetAdditionalComponents(eventData))
+                    eventData.AddItem(additionalResult);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override bool OnEngineReady()
+        {
+            var transformDriversCategory = WorkerInitializer.ComponentLibrary.GetSubcategory("Transform/Drivers");
+
+            var convertibleValueDrivers = WorkerInitializer.ComponentLibrary.GetSubcategory("Uncategorized").Elements
+                .Where(type => type.Name.StartsWith("Convertible") && type.Name.Contains("Driver"))
+                .Select(type => new ComponentResult(transformDriversCategory, type, "Convertible Value Driver"))
+                .ToImmutableArray();
+
+            AddOverride(new(transformDriversCategory, _ => convertibleValueDrivers));
+
+            return base.OnEngineReady();
+        }
+    }
+}

ComponentSelectorAdditions/ComponentResult.cs

@@ -63,10 +63,20 @@ public sealed class ComponentResult
         /// <param name="category">The category that should be shown as the <see cref="Type">Type's</see> parent.</param>
         /// <param name="type">The component / node <see cref="System.Type"/>.</param>
         public ComponentResult(CategoryNode<Type>? category, Type type)
+            : this(category, type, type.GetCustomAttribute<GroupingAttribute>()?.GroupName)
+        { }
+
+        /// <summary>
+        /// Creates a new component / node <see cref="System.Type"/> result with the given category and group.
+        /// </summary>
+        /// <param name="category">The category that should be shown as the <see cref="Type">Type's</see> parent.</param>
+        /// <param name="type">The component / node <see cref="System.Type"/>.</param>
+        /// <param name="group">The full name of the <paramref name="type"/>'s <see cref="GroupingAttribute.GroupName">group</see> <see cref="Group">identifier</see>.</param>
+        public ComponentResult(CategoryNode<Type>? category, Type type, string? group)
         {
             Type = type;
             Category = category;
-            Group = type.GetCustomAttribute<GroupingAttribute>()?.GroupName;
+            Group = group;
             GroupName = Group?.Split('.').Last();
         }
 

ComponentSelectorAdditions/Events/EnumerateCategoriesEvent.cs

@@ -16,6 +16,7 @@ public override IEnumerable<CategoryNode<Type>> Items
         public SelectorPath Path { get; }
 
         public CategoryNode<Type> RootCategory { get; }
+
         public ComponentSelector Selector { get; }
 
         /// <inheritdoc/>