/// <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 }