/// <summary>
/// Sets up the drawer so that it is ready to be used.
/// LateSetup should be called right after this.
/// </summary>
/// <param name="setStyle"> GUIStyle inside which to draw members. </param>
/// <param name="indentLevel"> How many levels of indentation to add when drawing members. </param>
/// <param name="setDrawHeader"> Should the prefix label header be drawn for the dataset. </param>
/// <param name="setValue"> The initial cached value of the drawers. </param>
/// <param name="setValueType"> Type constraint for the value. </param>
/// <param name="setMemberInfo"> LinkedMemberInfo for the field or property that these drawers represent. </param>
/// <param name="setParent"> Drawer whose member these Drawer are. Can be null. </param>
/// <param name="setLabel"> The label (name) of the field. Can be null. </param>
/// <param name="setReadOnly"> True if Drawer should be read only. </param>
private void Setup(GUIStyle setStyle, int indentLevel, bool setDrawHeader, object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
style = new GUIStyle(setStyle);
style.fixedHeight = 0f;
style.fixedWidth = 0f;
style.stretchHeight = true;
style.stretchWidth = true;
appendIndentLevel = indentLevel;
drawHeader = setDrawHeader;
if (setValueType == null)
{
#if DEV_MODE
Debug.LogWarning(GetType().Name + ".Setup called with null setValueType");
#endif
setValueType = DrawerUtility.GetType(setMemberInfo, setValue);
}
// This is an important step, because parent is referenced by DebugMode
parent = setParent;
drawInSingleRow = DrawerUtility.CanDrawInSingleRow(setValueType, DebugMode);
base.Setup(setValue, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
#if DEV_MODE && DEBUG_DRAW_IN_SINGLE_ROW
if (drawInSingleRow)
{
Debug.Log(Msg(ToString(setLabel, setMemberInfo) + ".Setup with drawInSingleRow=", drawInSingleRow, ", type=", setValueType, ", DebugMode=", DebugMode));
}
#endif
}
/// <inheritdoc />
public override void SetupInterface(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(DrawerUtility.GetType(setMemberInfo, setValue).GetArrayRank() == 3);
#endif
Setup(setValue as Array, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
}
/// <inheritdoc/>
protected override void Setup(Enum setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(DrawerUtility.GetType(setMemberInfo, setValue) != Types.Enum, "Fields of exact type Enum should use AnyEnumDrawer, not EnumDrawer!");
#endif
base.Setup(setValue, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
hasFlagsAttribute = Type.IsDefined(Types.FlagsAttribute, false);
}
/// <inheritdoc/>
public override void SetupInterface(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
var type = DrawerUtility.GetType(setMemberInfo, setValue);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(type != null);
Debug.Assert(setValue != null || setMemberInfo != null);
#endif
Setup(setValue, setMemberInfo, Nullable.GetUnderlyingType(type), setParent, setLabel, setReadOnly);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="value"> The starting cached value of the drawer. </param>
/// <param name="methodInfo"> LinkedMemberInfo of the method that the drawer represent. If represents an anonymous method, leave null. </param>
/// <param name="parent"> The parent drawer of this member. Can be null. </param>
/// <param name="label"> The label. </param>
/// <param name="setReadOnly"> True if control should be read only. </param>
/// <returns> The newly-created instance. </returns>
public static DelegateDrawer Create([CanBeNull] MulticastDelegate value, [CanBeNull] LinkedMemberInfo methodInfo, IParentDrawer parent, GUIContent label, bool setReadOnly)
{
DelegateDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new DelegateDrawer();
}
result.Setup(value, DrawerUtility.GetType(methodInfo, value), methodInfo, parent, label, setReadOnly);
result.LateSetup();
return(result);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="list"> The starting cached value of the drawer. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the field, property or parameter that the drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="readOnly"> True if control should be read only. </param>
/// <returns> The instance, ready to be used. </returns>
public static ListDrawer <T> Create(IList <T> list, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool readOnly)
{
ListDrawer <T> result;
if (!DrawerPool.TryGet(out result))
{
result = new ListDrawer <T>();
}
result.Setup(list, DrawerUtility.GetType(memberInfo, list), memberInfo, parent, label, readOnly);
result.LateSetup();
return(result);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="value"> The starting cached value of the drawer. </param>
/// <param name="keyType"> The type of the keys in the dictionary. </param>
/// <param name="valueType"> The type of the values in the dictionary. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the field, property or parameter that the drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="readOnly"> True if control should be read only. </param>
/// <returns> The instance, ready to be used. </returns>
public static DictionaryEntryDrawer Create(DictionaryEntry value, Type keyType, Type valueType, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool readOnly, Func <int, object[], bool> validateKey)
{
DictionaryEntryDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new DictionaryEntryDrawer();
}
result.Setup(value, DrawerUtility.GetType(memberInfo, value), keyType, valueType, memberInfo, parent, label, readOnly, validateKey);
result.LateSetup();
return(result);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="value"> The initial cached value of the drawer. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the class member that the created drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="readOnly"> True if drawer should be read only. </param>
/// <returns> The drawer instance, ready to be used. </returns>
public static AnyEnumDrawer Create(object value, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool readOnly)
{
AnyEnumDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new AnyEnumDrawer();
}
result.Setup(value, DrawerUtility.GetType(memberInfo, value), memberInfo, parent, label, readOnly);
result.LateSetup();
return(result);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="value"> The starting cached value of the drawer. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the field, property or parameter that the drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="setReadOnly"> True if control should be read only. </param>
/// <returns> The instance, ready to be used. </returns>
public static GradientDrawer Create(Gradient value, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool setReadOnly)
{
GradientDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new GradientDrawer();
}
result.Setup(value, DrawerUtility.GetType(memberInfo, value), memberInfo, parent, label, setReadOnly);
result.LateSetup();
return(result);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="style"> GUIStyle inside which to draw members. </param>
/// <param name="appendIndentLevel"> How many levels of indentation to add when drawing members. </param>
/// <param name="drawHeader"> Should the prefix label header be drawn for the dataset. </param>
/// <param name="value"> The starting cached value of the drawer. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the field, property or parameter that the drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="readOnly"> True if control should be read only. </param>
/// <returns> The instance, ready to be used. </returns>
public static StyledDataSetDrawer Create(GUIStyle style, int appendIndentLevel, bool drawHeader, object value, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool readOnly)
{
StyledDataSetDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new StyledDataSetDrawer();
}
result.Setup(style, appendIndentLevel, drawHeader, value, DrawerUtility.GetType(memberInfo, value), memberInfo, parent, label, readOnly);
result.LateSetup();
return(result);
}
/// <inheritdoc />
public override void SetupInterface(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
var type = DrawerUtility.GetType(setMemberInfo, setValue);
if (type.IsArray)
{
Setup(setValue as ParameterInfo[], setMemberInfo, setParent, setLabel, setReadOnly);
}
else
{
Setup(ArrayPool <ParameterInfo> .CreateWithContent(setValue as ParameterInfo), setMemberInfo, setParent, setLabel, setReadOnly);
}
}
/// <inheritdoc />
public override void SetupInterface(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
var array = setValue as Array;
#if DEV_MODE && PI_ASSERTATIONS
var type = DrawerUtility.GetType(setMemberInfo, array);
Debug.Assert(type != null, "ArrayDrawer - failed to figure out type from value / member info.");
var typeFullName = type.FullName;
Debug.Assert(type.IsArray, typeFullName + " not an array.");
Debug.Assert(type.GetArrayRank() == 1, typeFullName + " array rank not 1.");
#endif
Setup(array, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
}
private void Setup(object setValue, [CanBeNull] UnityEditor.PropertyDrawer setDrawerInstance, [NotNull] Type drawerType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(drawerType != null);
#endif
if (setDrawerInstance == null)
{
setDrawerInstance = (UnityEditor.PropertyDrawer)drawerType.CreateInstance();
}
drawerInstance = setDrawerInstance;
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(drawerInstance != null, "Failed to create PropertyDrawer instance of type " + StringUtils.ToString(drawerType) + " for field of type " + StringUtils.ToString(DrawerUtility.GetType(setMemberInfo, setValue)) + " and attribute " + StringUtils.TypeToString(setMemberInfo == null ? null : setMemberInfo.GetAttribute <PropertyAttribute>()));
#endif
memberInfo = setMemberInfo;
var serializedProperty = SerializedProperty;
if (serializedProperty != null)
{
// This is not fool-proof, because e.g. a custom property might use a foldout drawer
// but could not figure out a better solution yet
usesFoldout = serializedProperty.isArray;
}
else
{
usesFoldout = false;
}
var attField = drawerType.GetField("m_Attribute", BindingFlags.Instance | BindingFlags.NonPublic);
if (setMemberInfo != null)
{
var atts = setMemberInfo.GetAttributes(Types.PropertyAttribute);
if (atts.Length > 0)
{
attField.SetValue(drawerInstance, atts[0]);
}
attField = drawerType.GetField("m_FieldInfo", BindingFlags.Instance | BindingFlags.NonPublic);
attField.SetValue(drawerInstance, setMemberInfo.FieldInfo);
}
else
{
Debug.LogError("PropertyDrawerDrawer(\"" + (setLabel != null ? setLabel.text : "") + "\").Setup(" + drawerType.Name + ") - fieldInfo was null (parent=" + StringUtils.ToString(setParent) + ")");
}
base.Setup(setValue, DrawerUtility.GetType(setMemberInfo, setValue), setMemberInfo, setParent, setLabel, setReadOnly);
}
/// <summary> Creates a new instance of the drawer or returns a reusable instance from the pool. </summary>
/// <param name="array"> The starting cached value of the drawer. </param>
/// <param name="memberInfo"> LinkedMemberInfo for the field, property or parameter that the drawer represents. Can be null. </param>
/// <param name="parent"> The parent drawer of the created drawer. Can be null. </param>
/// <param name="label"> The prefix label. </param>
/// <param name="readOnly"> True if control should be read only. </param>
/// <returns> The instance, ready to be used. </returns>
public static Array2DDrawer Create(Array array, LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label, bool readOnly)
{
Array2DDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new Array2DDrawer();
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(DrawerUtility.GetType(memberInfo, array).GetArrayRank() == 2);
#endif
result.Setup(array, DrawerUtility.GetType(memberInfo, array), memberInfo, parent, label, readOnly);
result.LateSetup();
return(result);
}
public static ICollectionDrawer Create(Array value, LinkedMemberInfo memberInfo, [CanBeNull] IParentDrawer parent, GUIContent label, bool readOnly)
{
if (value == null)
{
#if DEV_MODE
Debug.Assert(memberInfo != null, "Array.Create - both value and memberInfo null!");
#endif
value = memberInfo.DefaultValue() as Array;
if (value == null)
{
#if DEV_MODE
Debug.LogError("Array.Create(" + memberInfo + ") of type " + StringUtils.ToString(memberInfo.Type) + ": value was null and memberInfo.DefaultValue() returned null!");
#endif
return(null);
}
if (memberInfo.CanWrite)
{
memberInfo.SetValue(value);
}
}
switch (value.Rank)
{
case 1:
break;
case 2:
return(Array2DDrawer.Create(value, memberInfo, parent, label, readOnly));
case 3:
return(Array3DDrawer.Create(value, memberInfo, parent, label, readOnly));
default:
return(null);
}
ArrayDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new ArrayDrawer();
}
result.Setup(value, DrawerUtility.GetType(memberInfo, value), memberInfo, parent, label, readOnly);
result.LateSetup();
return(result);
}
private void Setup(object setValue, [CanBeNull] object attribute, [CanBeNull] UnityEditor.PropertyDrawer setDrawerInstance, [NotNull] Type drawerType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(drawerType != null);
#endif
if (setDrawerInstance == null)
{
setDrawerInstance = (UnityEditor.PropertyDrawer)drawerType.CreateInstance();
}
drawerInstance = setDrawerInstance;
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(drawerInstance != null, "Failed to create PropertyDrawer instance of type " + StringUtils.ToString(drawerType) + " for field of type " + StringUtils.ToString(DrawerUtility.GetType(setMemberInfo, setValue)) + " and attribute " + StringUtils.TypeToString(setMemberInfo == null ? null : setMemberInfo.GetAttribute <PropertyAttribute>()));
#endif
memberInfo = setMemberInfo;
var attField = drawerType.GetField("m_Attribute", BindingFlags.Instance | BindingFlags.NonPublic);
if (setMemberInfo != null)
{
if (attribute != null)
{
#if DEV_MODE && DEBUG_ENABLED
Debug.Log("Setting field " + drawerType.Name + ".m_Attribute value to " + StringUtils.TypeToString(attribute));
#endif
attField.SetValue(drawerInstance, attribute);
}
attField = drawerType.GetField("m_FieldInfo", BindingFlags.Instance | BindingFlags.NonPublic);
attField.SetValue(drawerInstance, setMemberInfo.FieldInfo);
}
else
{
Debug.LogError("PropertyDrawerDrawer(\"" + (setLabel != null ? setLabel.text : "") + "\").Setup(" + drawerType.Name + ") - fieldInfo was null (parent=" + StringUtils.ToString(setParent) + ")");
}
base.Setup(setValue, DrawerUtility.GetType(setMemberInfo, setValue), setMemberInfo, setParent, setLabel, setReadOnly);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(SerializedProperty != null, StringUtils.ToColorizedString(GetDevInfo()));
#endif
}
public static new MethodButtonDrawer Create([NotNull] LinkedMemberInfo methodInfo, [CanBeNull] IParentDrawer parent, GUIContent label, bool setReadOnly)
{
#if GENERIC_METHODS_NOT_SUPPORTED
if (fieldInfo.MethodInfo.IsGenericMethod)
{
return(null);
}
#endif
MethodButtonDrawer result;
if (!DrawerPool.TryGet(out result))
{
result = new MethodButtonDrawer();
}
result.Setup(null, DrawerUtility.GetType <object>(methodInfo, null), methodInfo, parent, label, setReadOnly);
result.LateSetup();
return(result);
}
/// <inheritdoc />
protected override void Setup(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
if (setValueType == null)
{
#if DEV_MODE
Debug.LogWarning(GetType().Name + ".Setup called with setValueType=null");
#endif
setValueType = DrawerUtility.GetType(setMemberInfo, setValue);
}
var types = setValueType.GetGenericArguments();
var keyType = types[0];
var valueType = types[1];
drawInSingleRow = DrawerUtility.CanDrawMultipleControlsOfTypeInSingleRow(keyType) && DrawerUtility.CanDrawMultipleControlsOfTypeInSingleRow(valueType);
base.Setup(setValue, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
#if DEV_MODE && DEBUG_SETUP
Debug.Log(StringUtils.ToColorizedString("ReadOnly=", ReadOnly));
#endif
}
/// <inheritdoc />
protected override void Setup(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
if (allDelegateTypes == null)
{
allDelegateTypes = TypeExtensions.GetExtendingNonUnityObjectClassTypes(Types.MulticastDelegate, true);
}
if (setValueType == null)
{
#if DEV_MODE
Debug.LogError(GetType().Name + ".Setup called with setValueType null");
#endif
setValueType = DrawerUtility.GetType(setMemberInfo, setValue);
if (!typeof(Delegate).IsAssignableFrom(setValueType))
{
setValueType = typeof(MulticastDelegate);
}
}
base.Setup(setValue, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
}
/// <inheritdoc/>
protected override void Setup(object setValue, Type setValueType, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(memberBuildState == MemberBuildState.Unstarted);
#endif
if (setValue == null)
{
setValueType = DrawerUtility.GetType(setMemberInfo, setValue);
}
// This is an important step, because parent is referenced by DebugMode
parent = setParent;
drawInSingleRow = (setMemberInfo != null && setMemberInfo.GetAttribute <Attributes.DrawInSingleRowAttribute>() != null) || (setValueType != null && setValueType.GetCustomAttributes(typeof(Attributes.DrawInSingleRowAttribute), false).Length > 0) || DrawerUtility.CanDrawInSingleRow(setValueType, DebugMode);
base.Setup(setValue, setValueType, setMemberInfo, setParent, setLabel, setReadOnly);
#if DEV_MODE && DEBUG_DRAW_IN_SINGLE_ROW
if (drawInSingleRow)
{
Debug.Log(Msg(ToString(setLabel, setMemberInfo) + ".Setup with drawInSingleRow=", drawInSingleRow, ", setValueType=", setValueType, ", DebugMode=", DebugMode, ", setMemberInfo.Type=" + (setMemberInfo == null ? "n/a" : StringUtils.ToString(setMemberInfo.Type)) + ", setValue.GetType()=", StringUtils.TypeToString(setValue)));
}
#endif
}
/// <inheritdoc/>
public void SetupInterface(object attribute, object setValue, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
Setup(setValue, DrawerUtility.GetType(setMemberInfo, setValue), setMemberInfo, setParent, setLabel, setReadOnly);
}
public IDrawer GetForMethod(LinkedMemberInfo memberInfo, IParentDrawer parent, GUIContent label = null, bool readOnly = false)
{
return(GetForField(GetDrawerTypeForMethod(memberInfo.MethodInfo), null, DrawerUtility.GetType <object>(memberInfo, null), memberInfo, parent, label, readOnly));
}
public IDrawer GetForField([CanBeNull] object value, [CanBeNull] LinkedMemberInfo memberInfo, [CanBeNull] IParentDrawer parent, [CanBeNull] GUIContent label, bool readOnly)
{
return(GetForField(value, DrawerUtility.GetType(memberInfo, value), memberInfo, parent, label, readOnly));
}
/// <inheritdoc/>
public void SetupInterface(object attribute, object setValue, LinkedMemberInfo setMemberInfo, IParentDrawer setParent, GUIContent setLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(setValue != null || setMemberInfo != null);
#endif
Type propertyDrawerType;
if (attribute != null)
{
if (!CustomEditorUtility.TryGetPropertyDrawerType(attribute.GetType(), out propertyDrawerType))
{
#if DEV_MODE
Debug.LogError("CustomEditorUtility.TryGetPropertyDrawerType returned null for attribute " + StringUtils.TypeToString(attribute));
#endif
}
#if DEV_MODE && DEBUG_ENABLED
else
{
Debug.Log("Drawer type for attribute " + StringUtils.TypeToString(attribute) + ": " + StringUtils.ToString(propertyDrawerType));
}
#endif
}
else
{
if (setMemberInfo == null || !CustomEditorUtility.TryGetPropertyDrawerType(setMemberInfo.Type, out propertyDrawerType))
{
if (setValue == null || !CustomEditorUtility.TryGetPropertyDrawerType(setValue.GetType(), out propertyDrawerType))
{
propertyDrawerType = null;
#if DEV_MODE
if (setValue == null)
{
Debug.LogError("PropertyDrawerGUI.SetupInterface called with attribute=" + StringUtils.Null + ", setValue=" + StringUtils.Null + " and setMemberInfo=" + StringUtils.Null);
}
else
{
Debug.LogError("PropertyDrawerGUI.SetupInterface - TryGetPropertyDrawerType returned " + StringUtils.Null + " for type " + StringUtils.ToString(DrawerUtility.GetType(setMemberInfo, setValue)) + " with attribute " + StringUtils.Null);
}
#endif
}
}
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(propertyDrawerType != null);
#endif
Setup(setValue, attribute, null, propertyDrawerType, setMemberInfo, setParent, setLabel, setReadOnly);
}
/// <summary>
/// Sets up the drawer so that it is ready to be used.
/// LateSetup should be called right after this.
/// </summary>
/// <param name="setButtonText"> Text to shown on the button. </param>
/// <param name="setValue"> The initial cached value of the drawers. </param>
/// <param name="setMemberInfo"> LinkedMemberInfo for the field or property that these drawers represent. </param>
/// <param name="setParent"> Drawer whose member these Drawer are. Can be null. </param>
/// <param name="setLabel"> The prefix label to precede the button. Can be null. </param>
/// <param name="setReadOnly"> True if Drawer should be read only. </param>
protected virtual void Setup([NotNull] LinkedMemberInfo setMemberInfo, [CanBeNull] IParentDrawer setParent, [CanBeNull] GUIContent setPrefixLabel, [CanBeNull] GUIContent setButtonLabel, bool setReadOnly)
{
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(setMemberInfo != null);
#endif
result = null;
hasResult = false;
preferences = setParent != null ? setParent.Inspector.Preferences : InspectorUtility.Preferences;
if (setMemberInfo == null)
{
Debug.LogError("Null fieldInfo detected for \"" + (setPrefixLabel != null ? setPrefixLabel.text : "") + "\"");
return;
}
var methodInfo = setMemberInfo.MethodInfo;
if (methodInfo == null)
{
Debug.LogError("Null MethodInfo detected for \"" + (setPrefixLabel != null ? setPrefixLabel.text : "") + "\" / " + setMemberInfo.Name);
return;
}
#if DEV_MODE && DEBUG_SETUP
Debug.Log(Msg(ToString(setLabel, setMemberInfo), ".Setup with Type.ToString()=" + setMemberInfo.Type + ", Type.Name=" + setMemberInfo.Type.Name + ", ToString(Type)=" + StringUtils.ToString(setMemberInfo.Type)));
#endif
memberInfo = setMemberInfo;
hasParameters = methodInfo.GetParameters().Length > 0;
isGeneric = methodInfo.IsGenericMethod;
hasReturnValue = methodInfo.ReturnType != Types.Void;
isCoroutine = methodInfo.ReturnType == Types.IEnumerator;
monoBehaviour = UnityObject as MonoBehaviour;
if (setButtonLabel == null)
{
setButtonLabel = isCoroutine ? preferences.labels.startCoroutine : preferences.labels.invokeMethod;
}
buttonLabel = setButtonLabel;
if (InvokeMethodUtility.IsDisabled(setMemberInfo.UnityObjects, methodInfo))
{
#if DEV_MODE
Debug.LogWarning("Setting MethodDrawer(" + methodInfo.Name + ") to ReadOnly because InvokeMethodUtility.IsDisabled returned " + StringUtils.True);
#endif
setReadOnly = true;
}
base.Setup(null, DrawerUtility.GetType <object>(setMemberInfo, null), setMemberInfo, setParent, setPrefixLabel, setReadOnly);
// Make count be at least 1, so it works with static classes that have no targets
int count = Mathf.Max(MemberHierarchy.TargetCount, 1);
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(count >= 1);
#endif
ArrayPool <object> .Resize(ref results, count);
for (int n = count - 1; n >= 0; n--)
{
results[n] = null;
}
#if DEV_MODE && PI_ASSERTATIONS
Debug.Assert(results.Length == count);
Debug.Assert(results.Length >= 1);
#endif
#if DEV_MODE && DEBUG_SETUP
Debug.Log(ToString() + ".Setup()");
#endif
}
