private static IEnumerable <Type> GetFilteredTypesFromAssembly(
Assembly assembly,
ClassTypeConstraintAttribute filter)
{
return(from type in GetVisibleTypesFromAssembly(assembly)
where type.IsVisible && type.IsClass
where FilterConstraintIsSatisfied(filter, type)
select type);
}
private static bool FilterConstraintIsSatisfied(ClassTypeConstraintAttribute filter, Type type)
{
if (filter == null)
{
return(true);
}
return(filter.IsConstraintSatisfied(type));
}
public static List <Type> GetFilteredTypesFromAssemblies(
IEnumerable <Assembly> assemblies,
ClassTypeConstraintAttribute filter)
{
var types = new List <Type>();
foreach (var assembly in assemblies)
{
types.AddRange(GetFilteredTypesFromAssembly(assembly, filter));
}
return(types);
}
private static List <Type> GetFilteredTypes(ClassTypeConstraintAttribute filter)
{
var types = new List <Type>();
var excludedTypes = (ExcludedTypeCollectionGetter != null ? ExcludedTypeCollectionGetter() : null);
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
FilterTypes(assembly, filter, excludedTypes, types);
}
types.Sort((a, b) => a.FullName.CompareTo(b.FullName));
return(types);
}
private static List <Type> GetFilteredTypes(ClassTypeConstraintAttribute filter)
{
var types = new List <Type>();
var assembly = Assembly.GetExecutingAssembly();
types.AddRange(GetFilteredAssemblyTypes(assembly, filter));
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
types.AddRange(GetFilteredAssemblyTypes(Assembly.Load(referencedAssembly), filter));
}
types.Sort((a, b) => a.FullName.CompareTo(b.FullName));
return(types);
}
private static List <Type> GetFilteredTypes(ClassTypeConstraintAttribute filter)
{
var types = new List <Type>();
var excludedTypes = (ExcludedTypeCollectionGetter != null ? ExcludedTypeCollectionGetter() : null);
var assembly = Assembly.GetExecutingAssembly();
FilterTypes(assembly, filter, excludedTypes, types);
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
FilterTypes(Assembly.Load(referencedAssembly), filter, excludedTypes, types);
}
types.Sort((a, b) => a.FullName.CompareTo(b.FullName));
return(types);
}
/// <summary>
/// Filters the types.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <param name="filter">The filter.</param>
/// <param name="output">The output.</param>
private static void FilterTypes(Assembly assembly, ClassTypeConstraintAttribute filter, List <Type> output)
{
foreach (var type in assembly.GetTypes())
{
if (!type.IsPublic || !type.IsClass)
{
continue;
}
if (filter != null && !filter.IsConstraintSatisfied(type))
{
continue;
}
if (type.GetCustomAttributes(typeof(HideInInspector), true).FirstOrDefault() != null)
{
continue;
}
output.Add(type);
}
}
private static List <Type> GetFilteredAssemblyTypes(Assembly assembly, ClassTypeConstraintAttribute filter)
{
var types = new List <Type>();
foreach (var type in assembly.GetTypes())
{
if (!type.IsVisible || !type.IsClass)
{
continue;
}
if (filter != null && !filter.IsConstraintSatisfied(type))
{
continue;
}
types.Add(type);
}
return(types);
}
private static void FilterTypes(Assembly assembly, ClassTypeConstraintAttribute filter, ICollection <Type> excludedTypes, List <Type> output)
{
foreach (var type in assembly.GetTypes())
{
if (!type.IsVisible || !type.IsClass)
{
continue;
}
if (filter != null && !filter.IsConstraintSatisfied(type))
{
continue;
}
if (excludedTypes != null && excludedTypes.Contains(type))
{
continue;
}
output.Add(type);
}
}
private void DrawTypeDropDown(Rect rect, SerializedProperty property, ClassTypeConstraintAttribute filter)
{
var refType = ResolveType(property.stringValue);
var refTypes = filter.GetFilteredTypes();
var menu = new GenericMenu();
menu.AddItem(new GUIContent("<None>"), refType == null, OnTypeSelected, null);
menu.AddSeparator("");
for (int i = 0; i < refTypes.Count; i++)
{
var type = refTypes[i];
var menuLabel = FormatGroupedTypeName(type, filter.Grouping);
if (string.IsNullOrEmpty(menuLabel))
{
continue;
}
menu.AddItem(new GUIContent(menuLabel), refType == type, OnTypeSelected, type);
}
menu.DropDown(rect);
}
public TypeDropDownDrawer(string typeName, ClassTypeConstraintAttribute constraints, Type declaringType)
{
_selectedType = CachedTypeReference.GetType(typeName);
_constraints = constraints;
_declaringType = declaringType;
}
private static void DrawTypeSelectionControl(Rect position, SerializedProperty property, GUIContent label, ClassTypeConstraintAttribute filter)
{
try {
bool restoreShowMixedValue = EditorGUI.showMixedValue;
EditorGUI.showMixedValue = property.hasMultipleDifferentValues;
property.stringValue = DrawTypeSelectionControl(position, label, property.stringValue, filter);
EditorGUI.showMixedValue = restoreShowMixedValue;
}
finally {
ExcludedTypeCollectionGetter = null;
}
}
private static string DrawTypeSelectionControl(Rect position, GUIContent label, string classRef, ClassTypeConstraintAttribute filter)
{
if (label != null && label != GUIContent.none)
{
position = EditorGUI.PrefixLabel(position, label);
}
int controlID = GUIUtility.GetControlID(s_ControlHint, FocusType.Keyboard, position);
bool triggerDropDown = false;
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.ExecuteCommand:
if (Event.current.commandName == "TypeReferenceUpdated")
{
if (s_SelectionControlID == controlID)
{
if (classRef != s_SelectedClassRef)
{
classRef = s_SelectedClassRef;
GUI.changed = true;
}
s_SelectionControlID = 0;
s_SelectedClassRef = null;
}
}
break;
case EventType.MouseDown:
if (GUI.enabled && position.Contains(Event.current.mousePosition))
{
GUIUtility.keyboardControl = controlID;
triggerDropDown = true;
Event.current.Use();
}
break;
case EventType.KeyDown:
if (GUI.enabled && GUIUtility.keyboardControl == controlID)
{
if (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.Space)
{
triggerDropDown = true;
Event.current.Use();
}
}
break;
case EventType.Repaint:
// Remove assembly name from content of popup control.
var classRefParts = classRef.Split(',');
s_TempContent.text = classRefParts[0].Trim();
if (s_TempContent.text == "")
{
s_TempContent.text = "(None)";
}
else if (ResolveType(classRef) == null)
{
s_TempContent.text += " {Missing}";
}
EditorStyles.popup.Draw(position, s_TempContent, controlID);
break;
}
if (triggerDropDown)
{
s_SelectionControlID = controlID;
s_SelectedClassRef = classRef;
var filteredTypes = GetFilteredTypes(filter);
DisplayDropDown(position, filteredTypes, ResolveType(classRef), filter.Grouping);
}
return(classRef);
}
private void DrawTypeSelectionRect(Rect position, SerializedProperty property, ClassTypeConstraintAttribute filter, GUIContent label)
{
if (label != null && label != GUIContent.none)
{
position = EditorGUI.PrefixLabel(position, label);
}
var evnt = Event.current;
var classRef = property.stringValue;
var controlID = GUIUtility.GetControlID(typeof(SerializedTypeReferenceDrawer).GetHashCode(), FocusType.Keyboard, position);
var triggerDropDown = false;
switch (evnt.GetTypeForControl(controlID))
{
case EventType.ExecuteCommand:
if (evnt.commandName == "TypeReferenceUpdated")
{
if (selectionControlID == controlID)
{
if (classRef != selectedClassRef)
{
classRef = selectedClassRef;
GUI.changed = true;
}
selectionControlID = 0;
selectedClassRef = null;
}
}
break;
case EventType.MouseDown:
if (GUI.enabled && position.Contains(evnt.mousePosition))
{
GUIUtility.keyboardControl = controlID;
triggerDropDown = true;
evnt.Use();
}
break;
case EventType.KeyDown:
if (GUI.enabled && GUIUtility.keyboardControl == controlID)
{
if (evnt.keyCode == KeyCode.Return || evnt.keyCode == KeyCode.Space)
{
triggerDropDown = true;
evnt.Use();
}
}
break;
case EventType.Repaint:
var classRefParts = classRef.Split(',');
var content = new GUIContent(classRefParts[0].Trim());
if (property.hasMultipleDifferentValues)
{
content.text = "[Multiple]";
}
else if (content.text == "")
{
content.text = "<None>";
}
else if (ResolveType(classRef) == null)
{
content.text += " {Missing}";
}
EditorStyles.popup.Draw(position, content, controlID);
break;
}
if (triggerDropDown)
{
selectedClassRef = classRef;
selectionControlID = controlID;
DrawTypeDropDown(position, property, filter);
}
property.stringValue = classRef;
}
/// <summary>
/// Draws the type selection control.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="property">The property.</param>
/// <param name="label">The label.</param>
/// <param name="filter">The filter.</param>
private static void DrawTypeSelectionControl(Rect position, SerializedProperty property, GUIContent label, ClassTypeConstraintAttribute filter)
{
//Debug.Log("Relative Property=" + property);
var restoreShowMixedValue = EditorGUI.showMixedValue;
EditorGUI.showMixedValue = property.hasMultipleDifferentValues;
property.stringValue = DrawTypeSelectionControl(position, label, property.stringValue, filter);
EditorGUI.showMixedValue = restoreShowMixedValue;
}
