You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1001 lines
38 KiB
C#
1001 lines
38 KiB
C#
// UltEvents // Copyright 2020 Kybernetik //
|
|
|
|
#if UNITY_EDITOR
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace UltEvents.Editor
|
|
{
|
|
/// <summary>[Editor-Only]
|
|
/// Manages the construction of menus for selecting methods for <see cref="PersistentCall"/>s.
|
|
/// </summary>
|
|
internal static class MethodSelectionMenu
|
|
{
|
|
/************************************************************************************************************************/
|
|
#region Fields
|
|
/************************************************************************************************************************/
|
|
|
|
/// <summary>
|
|
/// The drawer state from when the menu was opened which needs to be restored when a method is selected because
|
|
/// menu items are executed after the frame finishes and the drawer state is cleared.
|
|
/// </summary>
|
|
private static readonly DrawerState
|
|
CachedState = new DrawerState();
|
|
|
|
private static readonly StringBuilder
|
|
LabelBuilder = new StringBuilder();
|
|
|
|
// These fields should really be passed around as parameters, but they make all the method signatures annoyingly long.
|
|
private static MethodBase _CurrentMethod;
|
|
private static BindingFlags _Bindings;
|
|
private static GenericMenu _Menu;
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Entry Point
|
|
/************************************************************************************************************************/
|
|
|
|
/// <summary>Opens the menu near the specified `area`.</summary>
|
|
public static void ShowMenu(Rect area)
|
|
{
|
|
CachedState.CopyFrom(DrawerState.Current);
|
|
|
|
_CurrentMethod = CachedState.call.GetMethodSafe();
|
|
_Bindings = GetBindingFlags();
|
|
_Menu = new GenericMenu();
|
|
|
|
BoolPref.AddDisplayOptions(_Menu);
|
|
|
|
Object[] targetObjects;
|
|
var targets = GetObjectReferences(CachedState.TargetProperty, out targetObjects);
|
|
|
|
AddCoreItems(targets);
|
|
|
|
// Populate the main contents of the menu.
|
|
{
|
|
if (targets == null)
|
|
{
|
|
var serializedMethodName = CachedState.MethodNameProperty.stringValue;
|
|
Type declaringType;
|
|
string methodName;
|
|
PersistentCall.GetMethodDetails(serializedMethodName, null, out declaringType, out methodName);
|
|
|
|
// If we have no target, but do have a type, populate the menu with that type's statics.
|
|
if (declaringType != null)
|
|
{
|
|
PopulateMenuWithStatics(targetObjects, declaringType);
|
|
|
|
goto ShowMenu;
|
|
}
|
|
else// If we have no type either, pretend the inspected objects are the targets.
|
|
{
|
|
targets = targetObjects;
|
|
}
|
|
}
|
|
|
|
// Ensure that all targets share the same type.
|
|
var firstTarget = ValidateTargetsAndGetFirst(targets);
|
|
if (firstTarget == null)
|
|
{
|
|
targets = targetObjects;
|
|
firstTarget = targets[0];
|
|
}
|
|
|
|
// Add menu items according to the type of the target.
|
|
if (firstTarget is GameObject)
|
|
PopulateMenuForGameObject("", false, targets);
|
|
else if (firstTarget is Component)
|
|
PopulateMenuForComponent(targets);
|
|
else
|
|
PopulateMenuForObject(targets);
|
|
}
|
|
|
|
ShowMenu:
|
|
|
|
_Menu.DropDown(area);
|
|
|
|
GC.Collect();
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static BindingFlags GetBindingFlags()
|
|
{
|
|
var bindings = BindingFlags.Public | BindingFlags.Instance;
|
|
|
|
if (BoolPref.ShowNonPublicMethods)
|
|
bindings |= BindingFlags.NonPublic;
|
|
|
|
if (BoolPref.ShowStaticMethods)
|
|
bindings |= BindingFlags.Static;
|
|
|
|
return bindings;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void AddCoreItems(Object[] targets)
|
|
{
|
|
_Menu.AddItem(new GUIContent("Null"), _CurrentMethod == null, () =>
|
|
{
|
|
DrawerState.Current.CopyFrom(CachedState);
|
|
|
|
if (targets != null)
|
|
{
|
|
PersistentCallDrawer.SetMethod(null);
|
|
}
|
|
else
|
|
{
|
|
// For a static method, remove the method name but keep the declaring type.
|
|
var methodName = CachedState.MethodNameProperty.stringValue;
|
|
var lastDot = methodName.LastIndexOf('.');
|
|
if (lastDot < 0)
|
|
CachedState.MethodNameProperty.stringValue = null;
|
|
else
|
|
CachedState.MethodNameProperty.stringValue = methodName.Substring(0, lastDot + 1);
|
|
|
|
CachedState.PersistentArgumentsProperty.arraySize = 0;
|
|
|
|
CachedState.MethodNameProperty.serializedObject.ApplyModifiedProperties();
|
|
}
|
|
|
|
DrawerState.Current.Clear();
|
|
});
|
|
|
|
var isStatic = _CurrentMethod != null && _CurrentMethod.IsStatic;
|
|
if (targets != null && !isStatic)
|
|
{
|
|
_Menu.AddItem(new GUIContent("Static Method"), isStatic, () =>
|
|
{
|
|
DrawerState.Current.CopyFrom(CachedState);
|
|
|
|
PersistentCallDrawer.SetTarget(null);
|
|
|
|
DrawerState.Current.Clear();
|
|
});
|
|
}
|
|
|
|
_Menu.AddSeparator("");
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static Object[] GetObjectReferences(SerializedProperty property, out Object[] targetObjects)
|
|
{
|
|
targetObjects = property.serializedObject.targetObjects;
|
|
|
|
if (property.hasMultipleDifferentValues)
|
|
{
|
|
var references = new Object[targetObjects.Length];
|
|
for (int i = 0; i < references.Length; i++)
|
|
{
|
|
using (var serializedObject = new SerializedObject(targetObjects[i]))
|
|
{
|
|
references[i] = serializedObject.FindProperty(property.propertyPath).objectReferenceValue;
|
|
}
|
|
}
|
|
return references;
|
|
}
|
|
else
|
|
{
|
|
var target = property.objectReferenceValue;
|
|
if (target != null)
|
|
return new Object[] { target };
|
|
else
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static Object ValidateTargetsAndGetFirst(Object[] targets)
|
|
{
|
|
var firstTarget = targets[0];
|
|
if (firstTarget == null)
|
|
return null;
|
|
|
|
var targetType = firstTarget.GetType();
|
|
|
|
// Make sure all targets have the exact same type.
|
|
// Unfortunately supporting inheritance would be more complicated.
|
|
|
|
var i = 1;
|
|
for (; i < targets.Length; i++)
|
|
{
|
|
var obj = targets[i];
|
|
if (obj == null || obj.GetType() != targetType)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return firstTarget;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static T[] GetRelatedObjects<T>(Object[] objects, Func<Object, T> getRelatedObject)
|
|
{
|
|
var relatedObjects = new T[objects.Length];
|
|
|
|
for (int i = 0; i < relatedObjects.Length; i++)
|
|
{
|
|
relatedObjects[i] = getRelatedObject(objects[i]);
|
|
}
|
|
|
|
return relatedObjects;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Populate for Objects
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuWithStatics(Object[] targets, Type type)
|
|
{
|
|
var firstTarget = targets[0];
|
|
var component = firstTarget as Component;
|
|
if (!ReferenceEquals(component, null))
|
|
{
|
|
var gameObjects = GetRelatedObjects(targets, (target) => (target as Component).gameObject);
|
|
PopulateMenuForGameObject("", true, gameObjects);
|
|
}
|
|
else
|
|
{
|
|
PopulateMenuForObject(firstTarget.GetType().GetNameCS(BoolPref.ShowFullTypeNames) + " ->/", targets);
|
|
}
|
|
|
|
_Menu.AddSeparator("");
|
|
|
|
var bindings = BindingFlags.Static | BindingFlags.Public;
|
|
if (BoolPref.ShowNonPublicMethods)
|
|
bindings |= BindingFlags.NonPublic;
|
|
|
|
PopulateMenuWithMembers(type, bindings, "", null);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuForGameObject(string prefix, bool putGameObjectInSubMenu, Object[] targets)
|
|
{
|
|
var header = new GUIContent(prefix + "Selected GameObject and its Components");
|
|
|
|
var gameObjectPrefix = prefix;
|
|
if (putGameObjectInSubMenu)
|
|
{
|
|
_Menu.AddDisabledItem(header);
|
|
gameObjectPrefix += "GameObject ->/";
|
|
}
|
|
|
|
PopulateMenuForObject(gameObjectPrefix, targets);
|
|
|
|
if (!putGameObjectInSubMenu)
|
|
{
|
|
_Menu.AddSeparator(prefix);
|
|
_Menu.AddDisabledItem(header);
|
|
}
|
|
|
|
var gameObjects = GetRelatedObjects(targets, (target) => target as GameObject);
|
|
PopulateMenuForComponents(prefix, gameObjects);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuForComponents(string prefix, GameObject[] gameObjects)
|
|
{
|
|
var firstGameObject = gameObjects[0];
|
|
var components = firstGameObject.GetComponents<Component>();
|
|
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
var component = components[i];
|
|
|
|
var targets = new Object[gameObjects.Length];
|
|
targets[0] = component;
|
|
|
|
Type type;
|
|
var typeIndex = GetComponentTypeIndex(component, components, out type);
|
|
|
|
int minTypeCount;
|
|
Component unused;
|
|
GetComponent(firstGameObject, type, typeIndex, out minTypeCount, out unused);
|
|
|
|
var j = 1;
|
|
for (; j < gameObjects.Length; j++)
|
|
{
|
|
int typeCount;
|
|
Component targetComponent;
|
|
GetComponent(gameObjects[j], type, typeIndex, out typeCount, out targetComponent);
|
|
if (typeCount <= typeIndex)
|
|
goto NextComponent;
|
|
|
|
targets[j] = targetComponent;
|
|
|
|
if (minTypeCount > typeCount)
|
|
minTypeCount = typeCount;
|
|
}
|
|
|
|
var name = type.GetNameCS(BoolPref.ShowFullTypeNames) + " ->/";
|
|
|
|
if (minTypeCount > 1)
|
|
name = UltEventUtils.GetPlacementName(typeIndex) + " " + name;
|
|
|
|
PopulateMenuForObject(prefix + name, targets);
|
|
}
|
|
|
|
NextComponent:;
|
|
}
|
|
|
|
private static int GetComponentTypeIndex(Component component, Component[] components, out Type type)
|
|
{
|
|
type = component.GetType();
|
|
|
|
var count = 0;
|
|
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
var c = components[i];
|
|
if (c == component)
|
|
break;
|
|
else if (c.GetType() == type)
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
private static void GetComponent(GameObject gameObject, Type type, int targetIndex, out int numberOfComponentsOfType, out Component targetComponent)
|
|
{
|
|
numberOfComponentsOfType = 0;
|
|
targetComponent = null;
|
|
|
|
var components = gameObject.GetComponents(type);
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
var component = components[i];
|
|
if (component.GetType() == type)
|
|
{
|
|
if (numberOfComponentsOfType == targetIndex)
|
|
targetComponent = component;
|
|
|
|
numberOfComponentsOfType++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuForComponent(Object[] targets)
|
|
{
|
|
var gameObjects = GetRelatedObjects(targets, (target) => (target as Component).gameObject);
|
|
|
|
PopulateMenuForGameObject("", true, gameObjects);
|
|
_Menu.AddSeparator("");
|
|
|
|
PopulateMenuForObject(targets);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuForObject(Object[] targets)
|
|
{
|
|
PopulateMenuForObject("", targets);
|
|
}
|
|
|
|
private static void PopulateMenuForObject(string prefix, Object[] targets)
|
|
{
|
|
PopulateMenuWithMembers(targets[0].GetType(), _Bindings, prefix, targets);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Populate for Types
|
|
/************************************************************************************************************************/
|
|
|
|
private static void PopulateMenuWithMembers(Type type, BindingFlags bindings, string prefix, Object[] targets)
|
|
{
|
|
var members = GetSortedMembers(type, bindings);
|
|
var previousDeclaringType = type;
|
|
|
|
var firstSeparator = true;
|
|
var firstProperty = true;
|
|
var firstMethod = true;
|
|
var firstBaseType = true;
|
|
var nameMatchesNextMethod = false;
|
|
|
|
var i = 0;
|
|
while (i < members.Count)
|
|
{
|
|
ParameterInfo[] parameters;
|
|
MethodInfo getter;
|
|
var member = GetNextSupportedMember(members, ref i, out parameters, out getter);
|
|
|
|
GotMember:
|
|
|
|
if (member == null)
|
|
return;
|
|
|
|
i++;
|
|
|
|
if (BoolPref.SubMenuForEachBaseType)
|
|
{
|
|
if (firstBaseType && member.DeclaringType != type)
|
|
{
|
|
if (firstSeparator)
|
|
firstSeparator = false;
|
|
else
|
|
_Menu.AddSeparator(prefix);
|
|
|
|
var baseTypesOf = "Base Types of " + type.GetNameCS();
|
|
if (BoolPref.SubMenuForBaseTypes)
|
|
{
|
|
prefix += baseTypesOf + " ->/";
|
|
}
|
|
else
|
|
{
|
|
_Menu.AddDisabledItem(new GUIContent(prefix + baseTypesOf));
|
|
}
|
|
firstProperty = false;
|
|
firstMethod = false;
|
|
firstBaseType = false;
|
|
}
|
|
|
|
if (previousDeclaringType != member.DeclaringType)
|
|
{
|
|
previousDeclaringType = member.DeclaringType;
|
|
firstProperty = true;
|
|
firstMethod = true;
|
|
firstSeparator = true;
|
|
}
|
|
}
|
|
|
|
var property = member as PropertyInfo;
|
|
if (property != null)
|
|
{
|
|
AppendGroupHeader(prefix, "Properties in ", member.DeclaringType, type, ref firstProperty, ref firstSeparator);
|
|
|
|
AddSelectPropertyItem(prefix, targets, type, property, getter);
|
|
continue;
|
|
}
|
|
|
|
var method = member as MethodBase;
|
|
if (method != null)
|
|
{
|
|
AppendGroupHeader(prefix, "Methods in ", member.DeclaringType, type, ref firstMethod, ref firstSeparator);
|
|
|
|
// Check if the method name matched the previous or next method to group them.
|
|
if (BoolPref.GroupMethodOverloads)
|
|
{
|
|
var nameMatchedPreviousMethod = nameMatchesNextMethod;
|
|
|
|
ParameterInfo[] nextParameters;
|
|
MethodInfo nextGetter;
|
|
var nextMember = GetNextSupportedMember(members, ref i, out nextParameters, out nextGetter);
|
|
|
|
nameMatchesNextMethod = nextMember != null && method.Name == nextMember.Name;
|
|
|
|
if (nameMatchedPreviousMethod || nameMatchesNextMethod)
|
|
{
|
|
AddSelectMethodItem(prefix, targets, type, true, method, parameters);
|
|
|
|
if (i < members.Count)
|
|
{
|
|
member = nextMember;
|
|
parameters = nextParameters;
|
|
getter = nextGetter;
|
|
goto GotMember;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Otherwise just build the label normally.
|
|
AddSelectMethodItem(prefix, targets, type, false, method, parameters);
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void AppendGroupHeader(string prefix, string name, Type declaringType, Type currentType, ref bool firstInGroup, ref bool firstSeparator)
|
|
{
|
|
if (firstInGroup)
|
|
{
|
|
LabelBuilder.Length = 0;
|
|
LabelBuilder.Append(prefix);
|
|
|
|
if (BoolPref.SubMenuForEachBaseType && declaringType != currentType)
|
|
AppendDeclaringTypeSubMenu(LabelBuilder, declaringType, currentType);
|
|
|
|
if (firstSeparator)
|
|
firstSeparator = false;
|
|
else
|
|
_Menu.AddSeparator(LabelBuilder.ToString());
|
|
|
|
LabelBuilder.Append(name);
|
|
|
|
if (BoolPref.SubMenuForEachBaseType)
|
|
LabelBuilder.Append(declaringType.GetNameCS());
|
|
else
|
|
LabelBuilder.Append(currentType.GetNameCS());
|
|
|
|
_Menu.AddDisabledItem(new GUIContent(LabelBuilder.ToString()));
|
|
firstInGroup = false;
|
|
}
|
|
}
|
|
|
|
private static void AppendDeclaringTypeSubMenu(StringBuilder text, Type declaringType, Type currentType)
|
|
{
|
|
if (BoolPref.SubMenuForEachBaseType)
|
|
{
|
|
if (BoolPref.SubMenuForRootBaseType || declaringType != currentType)
|
|
{
|
|
text.Append(declaringType.GetNameCS());
|
|
text.Append(" ->/");
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void AddSelectPropertyItem(string prefix, Object[] targets, Type currentType, PropertyInfo property, MethodInfo getter)
|
|
{
|
|
var defaultMethod = getter;
|
|
|
|
MethodInfo setter = null;
|
|
if (IsSupported(property.PropertyType))
|
|
{
|
|
setter = property.GetSetMethod(true);
|
|
if (setter != null)
|
|
defaultMethod = setter;
|
|
}
|
|
|
|
LabelBuilder.Length = 0;
|
|
LabelBuilder.Append(prefix);
|
|
|
|
// Declaring Type.
|
|
AppendDeclaringTypeSubMenu(LabelBuilder, property.DeclaringType, currentType);
|
|
|
|
// Non-Public Grouping.
|
|
if (BoolPref.GroupNonPublicMethods && !IsPublic(property))
|
|
LabelBuilder.Append("Non-Public Properties ->/");
|
|
|
|
// Property Type and Name.
|
|
LabelBuilder.Append(property.PropertyType.GetNameCS(BoolPref.ShowFullTypeNames));
|
|
LabelBuilder.Append(' ');
|
|
LabelBuilder.Append(property.Name);
|
|
|
|
// Get and Set.
|
|
LabelBuilder.Append(" { ");
|
|
if (getter != null) LabelBuilder.Append("get; ");
|
|
if (setter != null) LabelBuilder.Append("set; ");
|
|
LabelBuilder.Append('}');
|
|
|
|
var label = LabelBuilder.ToString();
|
|
AddSetCallItem(label, defaultMethod, targets);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void AddSelectMethodItem(string prefix, Object[] targets, Type currentType, bool methodNameSubMenu,
|
|
MethodBase method, ParameterInfo[] parameters)
|
|
{
|
|
LabelBuilder.Length = 0;
|
|
LabelBuilder.Append(prefix);
|
|
|
|
// Declaring Type.
|
|
AppendDeclaringTypeSubMenu(LabelBuilder, method.DeclaringType, currentType);
|
|
|
|
// Non-Public Grouping.
|
|
if (BoolPref.GroupNonPublicMethods && !IsPublic(method))
|
|
LabelBuilder.Append("Non-Public Methods ->/");
|
|
|
|
// Overload Grouping.
|
|
if (methodNameSubMenu)
|
|
LabelBuilder.Append(method.Name).Append(" ->/");
|
|
|
|
// Method Signature.
|
|
LabelBuilder.Append(GetMethodSignature(method, parameters, true));
|
|
|
|
var label = LabelBuilder.ToString();
|
|
|
|
AddSetCallItem(label, method, targets);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static void AddSetCallItem(string label, MethodBase method, Object[] targets)
|
|
{
|
|
_Menu.AddItem(
|
|
new GUIContent(label),
|
|
method == _CurrentMethod,
|
|
(userData) =>
|
|
{
|
|
DrawerState.Current.CopyFrom(CachedState);
|
|
|
|
var i = 0;
|
|
CachedState.CallProperty.ModifyValues<PersistentCall>((call) =>
|
|
{
|
|
var target = targets != null ? targets[i % targets.Length] : null;
|
|
call.SetMethod(method, target);
|
|
i++;
|
|
}, "Set Persistent Call");
|
|
|
|
DrawerState.Current.Clear();
|
|
},
|
|
null);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Member Gathering
|
|
/************************************************************************************************************************/
|
|
|
|
private static readonly Dictionary<BindingFlags, Dictionary<Type, List<MemberInfo>>>
|
|
MemberCache = new Dictionary<BindingFlags, Dictionary<Type, List<MemberInfo>>>();
|
|
|
|
internal static void ClearMemberCache()
|
|
{
|
|
MemberCache.Clear();
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static List<MemberInfo> GetSortedMembers(Type type, BindingFlags bindings)
|
|
{
|
|
// Get the cache for the specified bindings.
|
|
Dictionary<Type, List<MemberInfo>> memberCache;
|
|
if (!MemberCache.TryGetValue(bindings, out memberCache))
|
|
{
|
|
memberCache = new Dictionary<Type, List<MemberInfo>>();
|
|
MemberCache.Add(bindings, memberCache);
|
|
}
|
|
|
|
// If the members for the specified type aren't cached for those bindings, gather and sort them.
|
|
List<MemberInfo> members;
|
|
if (!memberCache.TryGetValue(type, out members))
|
|
{
|
|
var properties = type.GetProperties(bindings);
|
|
var methods = type.GetMethods(bindings);
|
|
|
|
// When gathering static members, also include instance constructors.
|
|
var constructors = ((bindings & BindingFlags.Static) == BindingFlags.Static) ?
|
|
type.GetConstructors((bindings & ~BindingFlags.Static) | BindingFlags.Instance) :
|
|
null;
|
|
|
|
var capacity = properties.Length + methods.Length;
|
|
if (constructors != null)
|
|
capacity += constructors.Length;
|
|
|
|
members = new List<MemberInfo>(capacity);
|
|
members.AddRange(properties);
|
|
if (constructors != null)
|
|
members.AddRange(constructors);
|
|
members.AddRange(methods);
|
|
|
|
// If the bindings include static, add static members from each base type.
|
|
if ((bindings & BindingFlags.Static) == BindingFlags.Static && type.BaseType != null)
|
|
{
|
|
members.AddRange(GetSortedMembers(type.BaseType, bindings & ~BindingFlags.Instance));
|
|
}
|
|
|
|
UltEventUtils.StableInsertionSort(members, CompareMembers);
|
|
|
|
memberCache.Add(type, members);
|
|
}
|
|
|
|
return members;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static int CompareMembers(MemberInfo a, MemberInfo b)
|
|
{
|
|
if (BoolPref.SubMenuForEachBaseType)
|
|
{
|
|
var result = CompareChildBeforeBase(a.DeclaringType, b.DeclaringType);
|
|
if (result != 0)
|
|
return result;
|
|
}
|
|
|
|
// Compare types (properties before methods).
|
|
if (a is PropertyInfo)
|
|
{
|
|
if (!(b is PropertyInfo))
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
if (b is PropertyInfo)
|
|
return 1;
|
|
}
|
|
|
|
// Non-Public Sub-Menu.
|
|
if (BoolPref.GroupNonPublicMethods)
|
|
{
|
|
if (IsPublic(a))
|
|
{
|
|
if (!IsPublic(b))
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
if (IsPublic(b))
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Compare names.
|
|
return a.Name.CompareTo(b.Name);
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static int CompareChildBeforeBase(Type a, Type b)
|
|
{
|
|
if (a == b)
|
|
return 0;
|
|
|
|
while (true)
|
|
{
|
|
a = a.BaseType;
|
|
|
|
if (a == null)
|
|
return 1;
|
|
|
|
if (a == b)
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static readonly Dictionary<MemberInfo, bool>
|
|
MemberToIsPublic = new Dictionary<MemberInfo, bool>();
|
|
|
|
private static bool IsPublic(MemberInfo member)
|
|
{
|
|
bool isPublic;
|
|
if (!MemberToIsPublic.TryGetValue(member, out isPublic))
|
|
{
|
|
switch (member.MemberType)
|
|
{
|
|
case MemberTypes.Constructor:
|
|
case MemberTypes.Method:
|
|
isPublic = (member as MethodBase).IsPublic;
|
|
break;
|
|
|
|
case MemberTypes.Property:
|
|
isPublic =
|
|
(member as PropertyInfo).GetGetMethod() != null ||
|
|
(member as PropertyInfo).GetSetMethod() != null;
|
|
break;
|
|
|
|
default:
|
|
throw new ArgumentException("Unhandled member type", "member");
|
|
}
|
|
|
|
MemberToIsPublic.Add(member, isPublic);
|
|
}
|
|
|
|
return isPublic;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Supported Checks
|
|
/************************************************************************************************************************/
|
|
|
|
private static bool IsSupported(MethodBase method, out ParameterInfo[] parameters)
|
|
{
|
|
if (method.IsGenericMethod ||
|
|
(method.IsSpecialName && (!method.IsConstructor || method.IsStatic)) ||
|
|
method.Name.Contains("<") ||
|
|
method.IsDefined(typeof(ObsoleteAttribute), true))
|
|
{
|
|
parameters = null;
|
|
return false;
|
|
}
|
|
|
|
// Most UnityEngine.Object types shouldn't be constructed directly.
|
|
if (method.IsConstructor)
|
|
{
|
|
if (typeof(Component).IsAssignableFrom(method.DeclaringType) ||
|
|
typeof(ScriptableObject).IsAssignableFrom(method.DeclaringType))
|
|
{
|
|
parameters = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
parameters = method.GetParameters();
|
|
if (!IsSupported(parameters))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private static bool IsSupported(PropertyInfo property, out MethodInfo getter)
|
|
{
|
|
if (property.IsSpecialName ||
|
|
property.IsDefined(typeof(ObsoleteAttribute), true))// Obsolete.
|
|
{
|
|
getter = null;
|
|
return false;
|
|
}
|
|
|
|
getter = property.GetGetMethod(true);
|
|
if (getter == null && !IsSupported(property.PropertyType))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
/// <summary>
|
|
/// Returns true if the specified `type` can be represented by a <see cref="PersistentArgument"/>.
|
|
/// </summary>
|
|
public static bool IsSupported(Type type)
|
|
{
|
|
if (PersistentCall.IsSupportedNative(type))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
int linkIndex;
|
|
PersistentArgumentType linkType;
|
|
return DrawerState.Current.TryGetLinkable(type, out linkIndex, out linkType);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the type of each of the `parameters` can be represented by a <see cref="PersistentArgument"/>.
|
|
/// </summary>
|
|
public static bool IsSupported(ParameterInfo[] parameters)
|
|
{
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
if (!IsSupported(parameters[i].ParameterType))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static MemberInfo GetNextSupportedMember(List<MemberInfo> members, ref int startIndex, out ParameterInfo[] parameters, out MethodInfo getter)
|
|
{
|
|
while (startIndex < members.Count)
|
|
{
|
|
var member = members[startIndex];
|
|
var property = member as PropertyInfo;
|
|
if (property != null && IsSupported(property, out getter))
|
|
{
|
|
parameters = null;
|
|
return member;
|
|
}
|
|
|
|
var method = member as MethodBase;
|
|
if (method != null && IsSupported(method, out parameters))
|
|
{
|
|
getter = null;
|
|
return member;
|
|
}
|
|
|
|
startIndex++;
|
|
}
|
|
|
|
parameters = null;
|
|
getter = null;
|
|
return null;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
#region Method Signatures
|
|
/************************************************************************************************************************/
|
|
|
|
private static readonly Dictionary<MethodBase, string>
|
|
MethodSignaturesWithParameters = new Dictionary<MethodBase, string>(),
|
|
MethodSignaturesWithoutParameters = new Dictionary<MethodBase, string>();
|
|
private static readonly StringBuilder
|
|
MethodSignatureBuilder = new StringBuilder();
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
public static string GetMethodSignature(MethodBase method, ParameterInfo[] parameters, bool includeParameterNames)
|
|
{
|
|
if (method == null)
|
|
return null;
|
|
|
|
var signatureCache = includeParameterNames ? MethodSignaturesWithParameters : MethodSignaturesWithoutParameters;
|
|
|
|
string signature;
|
|
if (!signatureCache.TryGetValue(method, out signature))
|
|
{
|
|
signature = BuildAndCacheSignature(method, parameters, includeParameterNames, signatureCache);
|
|
}
|
|
|
|
return signature;
|
|
}
|
|
|
|
public static string GetMethodSignature(MethodBase method, bool includeParameterNames)
|
|
{
|
|
if (method == null)
|
|
return null;
|
|
|
|
var signatureCache = includeParameterNames ? MethodSignaturesWithParameters : MethodSignaturesWithoutParameters;
|
|
|
|
string signature;
|
|
if (!signatureCache.TryGetValue(method, out signature))
|
|
{
|
|
signature = BuildAndCacheSignature(method, method.GetParameters(), includeParameterNames, signatureCache);
|
|
}
|
|
|
|
return signature;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
|
|
private static string BuildAndCacheSignature(MethodBase method, ParameterInfo[] parameters, bool includeParameterNames,
|
|
Dictionary<MethodBase, string> signatureCache)
|
|
{
|
|
MethodSignatureBuilder.Length = 0;
|
|
|
|
var returnType = method.GetReturnType();
|
|
MethodSignatureBuilder.Append(returnType.GetNameCS(false));
|
|
MethodSignatureBuilder.Append(' ');
|
|
|
|
MethodSignatureBuilder.Append(method.Name);
|
|
|
|
MethodSignatureBuilder.Append(" (");
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
if (i > 0)
|
|
MethodSignatureBuilder.Append(", ");
|
|
|
|
var parameter = parameters[i];
|
|
|
|
MethodSignatureBuilder.Append(parameter.ParameterType.GetNameCS(false));
|
|
if (includeParameterNames)
|
|
{
|
|
MethodSignatureBuilder.Append(' ');
|
|
MethodSignatureBuilder.Append(parameter.Name);
|
|
}
|
|
}
|
|
MethodSignatureBuilder.Append(')');
|
|
|
|
var signature = MethodSignatureBuilder.ToString();
|
|
MethodSignatureBuilder.Length = 0;
|
|
signatureCache.Add(method, signature);
|
|
|
|
return signature;
|
|
}
|
|
|
|
/************************************************************************************************************************/
|
|
#endregion
|
|
/************************************************************************************************************************/
|
|
}
|
|
}
|
|
|
|
#endif
|