Mostly implement parsing generic types from the search bar

Author: Banane9

ComponentSelectorAdditions/ComponentResult.cs

@@ -42,6 +42,11 @@ public sealed class ComponentResult
         [MemberNotNullWhen(true, nameof(Group), nameof(GroupName))]
         public bool HasGroup => Group is not null;
 
+        /// <summary>
+        /// Gets whether this <see cref="Type">Type</see> is a concrete generic.
+        /// </summary>
+        public bool IsConcreteGeneric => Type.IsGenericType && !IsGeneric;
+
         /// <summary>
         /// Gets whether this <see cref="Type">Type</see> is a generic type definition.
         /// </summary>

ComponentSelectorAdditions/DefaultConfig.cs

@@ -18,6 +18,8 @@ public sealed class DefaultConfig : ConfigSection
             new ConfigKeyRange<float>(32, 64)
         };
 
+        private static readonly DefiningConfigKey<bool> _useSeparateConcreteGenericColor = new("UseSeparateConcreteGenericColor", "Use a blend between the generic component buttons' green and the non-generic component buttons' cyan for concrete generics.", () => true);
+
         /// <summary>
         /// Gets this config's instance.
         /// </summary>
@@ -41,6 +43,11 @@ public sealed class DefaultConfig : ConfigSection
         /// <value>The height in canvas units.</value>
         public float IndirectButtonHeight => _indirectButtonHeight;
 
+        /// <summary>
+        /// Gets whether to use a blend between the generic component buttons' green and the non-generic component buttons' cyan for concrete generics.
+        /// </summary>
+        public bool UseSeperateConcreteGenericColor => _useSeparateConcreteGenericColor;
+
         /// <inheritdoc/>
         public override Version Version { get; } = new Version(1, 0, 0);
 

ComponentSelectorAdditions/DefaultHandler.cs

@@ -23,6 +23,8 @@ public sealed class DefaultHandler : ConfiguredResoniteMonkey<DefaultHandler, De
         ICancelableEventHandler<BuildCategoryButtonEvent>, ICancelableEventHandler<BuildGroupButtonEvent>, ICancelableEventHandler<BuildComponentButtonEvent>,
         IEventHandler<BuildCustomGenericBuilder>, IEventHandler<EnumerateConcreteGenericsEvent>
     {
+        private static colorX _presetConcreteColor = MathX.Average(RadiantUI_Constants.Sub.GREEN, RadiantUI_Constants.Sub.CYAN);
+
         /// <inheritdoc/>
         public int Priority => HarmonyLib.Priority.Normal;
 
@@ -197,8 +199,11 @@ void ICancelableEventHandler<BuildComponentButtonEvent>.Handle(BuildComponentBut
             var selector = eventData.Selector;
             var component = eventData.Component;
 
+            var tint = component.IsConcreteGeneric && ConfigSection.UseSeperateConcreteGenericColor
+                ? _presetConcreteColor
+                : component.IsGeneric ? RadiantUI_Constants.Sub.GREEN : RadiantUI_Constants.Sub.CYAN;
+
             var category = GetPrettyPath(component.Category, eventData.RootCategory);
-            var tint = component.IsGeneric ? RadiantUI_Constants.Sub.GREEN : RadiantUI_Constants.Sub.CYAN;
             ButtonEventHandler<string> callback = component.IsGeneric ? selector.OpenGenericTypesPressed : selector.OnAddComponentPressed;
             var argument = $"{(component.IsGeneric ? $"{path.Path}/{component.Type.AssemblyQualifiedName}" : selector.World.Types.EncodeType(component.Type))}{(component.IsGeneric && path.HasGroup ? $"?{path.Group}" : "")}";
 

ComponentSelectorAdditions/SearchBar.cs

@@ -3,7 +3,6 @@
 using FrooxEngine;
 using MonkeyLoader.Patching;
 using MonkeyLoader.Resonite;
-using MonkeyLoader.Resonite.UI;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,15 +11,17 @@
 using MonkeyLoader.Events;
 using System.Threading;
 using System.Globalization;
+using MonkeyLoader;
 
 namespace ComponentSelectorAdditions
 {
     internal sealed class SearchBar : ConfiguredResoniteMonkey<SearchBar, SearchConfig>, IEventHandler<BuildSelectorHeaderEvent>,
         ICancelableEventHandler<EnumerateCategoriesEvent>, ICancelableEventHandler<EnumerateComponentsEvent>
     {
         private const string ProtoFluxPath = "/ProtoFlux/Runtimes/Execution/Nodes";
-        private static readonly char[] _searchSplits = new[] { ' ', ',', '+', '|' };
+
         public override bool CanBeDisabled => true;
+
         public int Priority => HarmonyLib.Priority.VeryHigh;
 
         public bool SkipCanceled => true;
@@ -60,12 +61,10 @@ public void Handle(BuildSelectorHeaderEvent eventData)
 
         public void Handle(EnumerateCategoriesEvent eventData)
         {
-            if (!eventData.Path.HasSearch || ((eventData.Path.IsSelectorRoot || ConfigSection.AlwaysSearchRoot) && eventData.Path.Search.Length < 3))
+            if (!eventData.Path.HasSearch || ((eventData.Path.IsSelectorRoot || ConfigSection.AlwaysSearchRoot) && eventData.Path.Search.Length < 3 && eventData.Path.SearchFragments.Length > 0))
                 return;
 
-            var search = eventData.Path.Search.Split(_searchSplits, StringSplitOptions.RemoveEmptyEntries);
-
-            foreach (var category in SearchCategories(PickSearchCategory(eventData), search))
+            foreach (var category in SearchCategories(PickSearchCategory(eventData), eventData.Path.SearchFragments))
                 eventData.AddItem(category);
 
             eventData.Canceled = true;
@@ -76,26 +75,46 @@ public void Handle(EnumerateComponentsEvent eventData)
             if (!eventData.Path.HasSearch || (eventData.Path.IsSelectorRoot && eventData.Path.Search.Length < 3))
                 return;
 
-            var search = eventData.Path.Search.Split(_searchSplits, StringSplitOptions.RemoveEmptyEntries);
             var searchCategory = PickSearchCategory(eventData);
 
             var results = searchCategory.Elements
-                .Select(type => (Category: searchCategory, Type: type, Matches: SearchContains(type.Name, search)))
+                .Select(type => (Category: searchCategory, Type: type, Matches: SearchContains(type.Name, eventData.Path.SearchFragments)))
                 .Concat(
                     SearchCategories(searchCategory)
                     .SelectMany(category => category.Elements
-                        .Select(type => (Category: category, Type: type, Matches: SearchContains(type.Name, search)))))
-                .Where(match => match.Matches > 0)
-                .OrderByDescending(match => match.Matches)
+                        .Select(type => (Category: category, Type: type, Matches: SearchContains(type.Name, eventData.Path.SearchFragments)))))
+                .Where(match => match.Matches > 0) // Extra weight for generic results when there's a generic in the search:
+                .OrderByDescending(match => match.Type.IsGenericTypeDefinition && eventData.Path.HasSearchGeneric ? match.Matches + 100 : match.Matches)
                 .ThenBy(match => match.Type.Name)
                 .Select(match => (Component: new ComponentResult(match.Category, match.Type), Order: -match.Matches));
 
             var remaining = ConfigSection.MaxResultCount;
             var knownGroups = new HashSet<string>();
+            var parsedGeneric = eventData.Path.HasSearchGeneric ? eventData.Selector.World.Types.ParseNiceType(eventData.Path.SearchGeneric, true) : null;
 
             foreach (var result in results.TakeWhile(result => (!result.Component.HasGroup || knownGroups.Add(result.Component.Group) ? --remaining : remaining) >= 0))
+            {
                 eventData.AddItem(result.Component, result.Order);
 
+                if (result.Component.IsGeneric && parsedGeneric is not null)
+                {
+                    try
+                    {
+                        var concreteType = result.Component.Type.MakeGenericType(parsedGeneric);
+
+                        if (!concreteType.IsValidGenericType(true))
+                            continue;
+
+                        --remaining;
+                        eventData.AddItem(new(result.Component.Category, concreteType), result.Order - 1);
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Warn(ex.LogFormat($"Failed to make generic type for component [{result.Component.NiceName}] with [{parsedGeneric.GetNiceName()}] (from \"{eventData.Path.GenericType}\")!"));
+                    }
+                }
+            }
+
             eventData.Canceled = true;
         }
 

ComponentSelectorAdditions/SelectorPath.cs

@@ -18,8 +18,13 @@ public sealed class SelectorPath
         /// </summary>
         public const string SearchSegment = "Search";
 
+        private static readonly char _genericParamEnd = '>';
+        private static readonly char _genericParamStart = '<';
+
         private static readonly char[] _pathSeparators = { '/', '\\' };
 
+        private static readonly char[] _searchSplits = new[] { ' ', ',', '+', '|' };
+
         /// <summary>
         /// Gets whether this path targets a generic type.
         /// </summary>
@@ -42,6 +47,12 @@ public sealed class SelectorPath
         [MemberNotNullWhen(true, nameof(Search))]
         public bool HasSearch => !string.IsNullOrWhiteSpace(Search);
 
+        /// <summary>
+        /// Gets whether this path has a <see cref="SearchGeneric">generic argument</see> for the search.
+        /// </summary>
+        [MemberNotNullWhen(true, nameof(SearchGeneric))]
+        public bool HasSearchGeneric => !string.IsNullOrWhiteSpace(SearchGeneric);
+
         /// <summary>
         /// Gets whether this path targets the root category.
         /// </summary>
@@ -72,9 +83,42 @@ public sealed class SelectorPath
         /// </summary>
         public string? Search { get; }
 
+        /// <summary>
+        /// Gets this path's search fragments (before the <see cref="SearchGeneric">generic argument</see>).
+        /// </summary>
+        public string[] SearchFragments { get; } = Array.Empty<string>();
+
+        /// <summary>
+        /// Gets this path's generic argument for the search.
+        /// </summary>
+        public string? SearchGeneric { get; }
+
         internal SelectorPath(string? rawPath, string? search, bool genericType, string? group, bool isSelectorRoot)
         {
             Search = search;
+
+            if (!string.IsNullOrWhiteSpace(search))
+            {
+                var genericParamStartIndex = search!.IndexOf(_genericParamStart);
+
+                if (genericParamStartIndex > 0)
+                {
+                    var generic = search[(genericParamStartIndex + 1)..];
+                    var starts = generic.Count(static c => c == _genericParamStart);
+                    var ends = generic.Count(static c => c == _genericParamEnd);
+
+                    if (starts > ends) // Automatically add any missing >
+                        generic += new string(_genericParamEnd, starts - ends);
+                    else if (ends > starts) // Probably not gonna happen often, but if someone adds a closing > to much...
+                        generic = generic.Remove(generic.Length - (ends - starts));
+
+                    SearchGeneric = generic;
+                    search = search[..genericParamStartIndex];
+                }
+
+                SearchFragments = search.Split(_searchSplits, StringSplitOptions.RemoveEmptyEntries);
+            }
+
             GenericType = genericType;
             Group = group;
             IsSelectorRoot = isSelectorRoot;