private static LayerMask DrawLayerMask(GUIContent guiContent, LayerMask layerMask)
{
if (FieldInspector.layerNames == null)
{
FieldInspector.InitLayers();
}
int num = 0;
for (int i = 0; i < FieldInspector.layerNames.Length; i++)
{
if ((layerMask.value & FieldInspector.maskValues[i]) == FieldInspector.maskValues[i])
{
num |= 1 << i;
}
}
int num2 = EditorGUILayout.MaskField(guiContent, num, FieldInspector.layerNames, new GUILayoutOption[0]);
if (num2 != num)
{
num = 0;
for (int j = 0; j < FieldInspector.layerNames.Length; j++)
{
if ((num2 & 1 << j) != 0)
{
num |= FieldInspector.maskValues[j];
}
}
layerMask.value = num;
}
return(layerMask);
}
private static object DrawField(Task task, GUIContent guiContent, FieldInfo fieldInfo, Type fieldType, object value)
{
if (typeof(IList).IsAssignableFrom(fieldType))
{
return(FieldInspector.DrawArrayField(task, guiContent, fieldInfo, fieldType, value));
}
return(FieldInspector.DrawSingleField(task, guiContent, fieldInfo, fieldType, value));
}
// Token: 0x060001A4 RID: 420 RVA: 0x0000EEF4 File Offset: 0x0000D0F4
public void OnFocus()
{
GlobalVariablesWindow.instance = this;
this.mVariableSource = GlobalVariables.Instance;
if (this.mVariableSource != null)
{
this.mVariableSource.CheckForSerialization(!Application.isPlaying);
}
FieldInspector.Init();
}
public static bool DrawFoldout(int hash, GUIContent guiContent)
{
bool flag = FieldInspector.FoldOut(hash);
bool flag2 = EditorGUILayout.Foldout(flag, guiContent);
if (flag2 != flag)
{
FieldInspector.SetFoldOut(hash, flag2);
}
return(flag2);
}
public void LoadNode(Task task, BehaviorSource behaviorSource, Vector2 offset, ref int id)
{
mTask = task;
mTask.Owner = (behaviorSource.Owner as Behavior);
mTask.ID = id++;
mTask.NodeData = new NodeData();
mTask.NodeData.Offset = offset;
mTask.NodeData.NodeDesigner = this;
LoadTaskIcon();
Init();
mTask.FriendlyName = taskName;
RequiredComponentAttribute[] array;
if (mTask.Owner != null && (array = (mTask.GetType().GetCustomAttributes(typeof(RequiredComponentAttribute), true) as RequiredComponentAttribute[])).Length > 0)
{
Type componentType = array[0].ComponentType;
if (typeof(Component).IsAssignableFrom(componentType) && mTask.Owner.gameObject.GetComponent(componentType) == null)
{
mTask.Owner.gameObject.AddComponent(componentType);
}
}
List <Type> baseClasses = FieldInspector.GetBaseClasses(mTask.GetType());
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
for (int i = baseClasses.Count - 1; i > -1; i--)
{
FieldInfo[] fields = baseClasses[i].GetFields(bindingAttr);
for (int j = 0; j < fields.Length; j++)
{
if (typeof(SharedVariable).IsAssignableFrom(fields[j].FieldType) && !fields[j].FieldType.IsAbstract)
{
SharedVariable sharedVariable = fields[j].GetValue(mTask) as SharedVariable;
if (sharedVariable == null)
{
sharedVariable = (Activator.CreateInstance(fields[j].FieldType) as SharedVariable);
}
if (TaskUtility.HasAttribute(fields[j], typeof(RequiredFieldAttribute)) || TaskUtility.HasAttribute(fields[j], typeof(SharedRequiredAttribute)))
{
sharedVariable.IsShared = true;
}
fields[j].SetValue(mTask, sharedVariable);
}
}
}
}
public static object DrawFields(Task task, object obj, GUIContent guiContent)
{
if (obj == null)
{
return(null);
}
List <Type> baseClasses = FieldInspector.GetBaseClasses(obj.GetType());
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
for (int i = baseClasses.Count - 1; i > -1; i--)
{
FieldInfo[] fields = baseClasses[i].GetFields(bindingAttr);
for (int j = 0; j < fields.Length; j++)
{
if (!BehaviorDesignerUtility.HasAttribute(fields[j], typeof(NonSerializedAttribute)) && !BehaviorDesignerUtility.HasAttribute(fields[j], typeof(HideInInspector)) && ((!fields[j].IsPrivate && !fields[j].IsFamily) || BehaviorDesignerUtility.HasAttribute(fields[j], typeof(SerializeField))) && (!(obj is ParentTask) || !fields[j].Name.Equals("children")))
{
if (guiContent == null)
{
string name = fields[j].Name;
BehaviorDesigner.Runtime.Tasks.TooltipAttribute[] array;
if ((array = (fields[j].GetCustomAttributes(typeof(BehaviorDesigner.Runtime.Tasks.TooltipAttribute), false) as BehaviorDesigner.Runtime.Tasks.TooltipAttribute[])).Length > 0)
{
guiContent = new GUIContent(BehaviorDesignerUtility.SplitCamelCase(name), array[0].Tooltip);
}
else
{
guiContent = new GUIContent(BehaviorDesignerUtility.SplitCamelCase(name));
}
}
EditorGUI.BeginChangeCheck();
object value = FieldInspector.DrawField(task, guiContent, fields[j], fields[j].GetValue(obj));
if (EditorGUI.EndChangeCheck())
{
fields[j].SetValue(obj, value);
GUI.changed = true;
}
guiContent = null;
}
}
}
return(obj);
}
// Token: 0x06000190 RID: 400 RVA: 0x0000DB64 File Offset: 0x0000BD64
public static object DrawField(Task task, GUIContent guiContent, FieldInfo field, object value)
{
if (field.FieldType.IsAbstract)
{
EditorGUILayout.LabelField(guiContent, new GUILayoutOption[0]);
return(null);
}
ObjectDrawer objectDrawer;
if ((objectDrawer = ObjectDrawerUtility.GetObjectDrawer(task, field)) != null)
{
if (value == null && !field.FieldType.IsAbstract)
{
value = Activator.CreateInstance(field.FieldType, true);
}
objectDrawer.Value = value;
objectDrawer.OnGUI(guiContent);
if (objectDrawer.Value != value)
{
value = objectDrawer.Value;
GUI.changed = true;
}
return(value);
}
ObjectDrawerAttribute[] array;
if ((array = (field.GetCustomAttributes(typeof(ObjectDrawerAttribute), true) as ObjectDrawerAttribute[])).Length > 0 && (objectDrawer = ObjectDrawerUtility.GetObjectDrawer(task, array[0])) != null)
{
if (value == null)
{
value = Activator.CreateInstance(field.FieldType, true);
}
objectDrawer.Value = value;
objectDrawer.OnGUI(guiContent);
if (objectDrawer.Value != value)
{
value = objectDrawer.Value;
GUI.changed = true;
}
return(value);
}
return(FieldInspector.DrawField(task, guiContent, field, field.FieldType, value));
}
private static bool DrawSharedVariable(IVariableSource variableSource, SharedVariable sharedVariable, bool selected)
{
if (sharedVariable == null || sharedVariable.GetType().GetProperty("Value") == null)
{
return(false);
}
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
bool result = false;
if (!string.IsNullOrEmpty(sharedVariable.PropertyMapping))
{
if (selected)
{
GUILayout.Label("Property", new GUILayoutOption[0]);
}
else
{
GUILayout.Label(sharedVariable.Name, new GUILayoutOption[0]);
}
string[] array = sharedVariable.PropertyMapping.Split(new char[]
{
'.'
});
GUILayout.Label(array[array.Length - 1].Replace('/', '.'), new GUILayoutOption[0]);
}
else
{
EditorGUI.BeginChangeCheck();
FieldInspector.DrawFields(null, sharedVariable, new GUIContent(sharedVariable.Name));
result = EditorGUI.EndChangeCheck();
}
if (!sharedVariable.IsGlobal && GUILayout.Button(BehaviorDesignerUtility.VariableMapButtonTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(19f)
}))
{
VariableInspector.ShowPropertyMappingMenu(variableSource as BehaviorSource, sharedVariable);
}
GUILayout.EndHorizontal();
return(result);
}
internal static SharedVariable DrawSharedVariableToggleSharedButton(SharedVariable sharedVariable)
{
if (sharedVariable == null)
{
return(null);
}
if (GUILayout.Button((!sharedVariable.IsShared) ? BehaviorDesignerUtility.VariableButtonTexture : BehaviorDesignerUtility.VariableButtonSelectedTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(15f)
}))
{
bool isShared = !sharedVariable.IsShared;
if (sharedVariable.GetType().Equals(typeof(SharedVariable)))
{
sharedVariable = (Activator.CreateInstance(FieldInspector.FriendlySharedVariableName(sharedVariable.GetType().GetProperty("Value").PropertyType), true) as SharedVariable);
}
else
{
sharedVariable = (Activator.CreateInstance(sharedVariable.GetType(), true) as SharedVariable);
}
sharedVariable.IsShared = isShared;
}
return(sharedVariable);
}
public void LoadTask(Task task, Behavior owner, ref int id)
{
if (task == null)
{
return;
}
mTask = task;
mTask.Owner = owner;
mTask.ID = id++;
mTask.NodeData.NodeDesigner = this;
mTask.NodeData.InitWatchedFields(mTask);
if (!mTask.NodeData.FriendlyName.Equals(string.Empty))
{
mTask.FriendlyName = mTask.NodeData.FriendlyName;
mTask.NodeData.FriendlyName = string.Empty;
}
LoadTaskIcon();
Init();
RequiredComponentAttribute[] array;
if (mTask.Owner != null && (array = (mTask.GetType().GetCustomAttributes(typeof(RequiredComponentAttribute), true) as RequiredComponentAttribute[])).Length > 0)
{
Type componentType = array[0].ComponentType;
if (typeof(Component).IsAssignableFrom(componentType) && mTask.Owner.gameObject.GetComponent(componentType) == null)
{
mTask.Owner.gameObject.AddComponent(componentType);
}
}
List <Type> baseClasses = FieldInspector.GetBaseClasses(mTask.GetType());
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
for (int i = baseClasses.Count - 1; i > -1; i--)
{
FieldInfo[] fields = baseClasses[i].GetFields(bindingAttr);
for (int j = 0; j < fields.Length; j++)
{
if (typeof(SharedVariable).IsAssignableFrom(fields[j].FieldType) && !fields[j].FieldType.IsAbstract)
{
SharedVariable sharedVariable = fields[j].GetValue(mTask) as SharedVariable;
if (sharedVariable == null)
{
sharedVariable = (Activator.CreateInstance(fields[j].FieldType) as SharedVariable);
}
if (TaskUtility.HasAttribute(fields[j], typeof(RequiredFieldAttribute)) || TaskUtility.HasAttribute(fields[j], typeof(SharedRequiredAttribute)))
{
sharedVariable.IsShared = true;
}
fields[j].SetValue(mTask, sharedVariable);
}
}
}
if (isParent)
{
ParentTask parentTask = this.mTask as ParentTask;
if (parentTask.Children != null)
{
for (int k = 0; k < parentTask.Children.Count; k++)
{
NodeDesigner nodeDesigner = CreateInstance <NodeDesigner>();
nodeDesigner.LoadTask(parentTask.Children[k], owner, ref id);
NodeConnection nodeConnection = CreateInstance <NodeConnection>();
nodeConnection.LoadConnection(this, NodeConnectionType.Fixed);
AddChildNode(nodeDesigner, nodeConnection, true, true, k);
}
}
mConnectionIsDirty = true;
}
}
private bool DrawSharedVariableSynchronizer(VariableSynchronizerInspector.Synchronizer synchronizer, Type valueType)
{
VariableSynchronizerInspector.DrawComponentSelector(synchronizer, typeof(Behavior), VariableSynchronizerInspector.ComponentListType.BehaviorDesignerGroup);
int num = 0;
int num2 = -1;
string[] array = null;
if (synchronizer.component != null)
{
Behavior behavior = synchronizer.component as Behavior;
num = FieldInspector.GetVariablesOfType(valueType, synchronizer.global, synchronizer.targetName, behavior.GetBehaviorSource(), out array, ref num2, valueType == null);
}
else
{
array = new string[]
{
"None"
};
}
EditorGUI.BeginChangeCheck();
num = EditorGUILayout.Popup("Shared Variable", num, array, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
if (num != 0)
{
if (num2 != -1 && num >= num2)
{
synchronizer.targetName = array[num].Substring(8, array[num].Length - 8);
synchronizer.global = true;
}
else
{
synchronizer.targetName = array[num];
synchronizer.global = false;
}
if (valueType == null)
{
SharedVariable variable;
if (synchronizer.global)
{
variable = GlobalVariables.Instance.GetVariable(synchronizer.targetName);
}
else
{
Behavior behavior2 = synchronizer.component as Behavior;
variable = behavior2.GetVariable(array[num]);
}
this.sharedVariableValueTypeName = variable.GetType().GetProperty("Value").PropertyType.FullName;
this.sharedVariableValueType = null;
}
}
else
{
synchronizer.targetName = null;
}
}
if (string.IsNullOrEmpty(synchronizer.targetName))
{
GUI.enabled = (false);
}
return(GUI.enabled);
}
public static object DrawFields(Task task, object obj)
{
return(FieldInspector.DrawFields(task, obj, null));
}
public static SharedVariable DrawSharedVariable(Task task, GUIContent guiContent, FieldInfo fieldInfo, Type fieldType, SharedVariable sharedVariable)
{
if (!fieldType.Equals(typeof(SharedVariable)) && sharedVariable == null)
{
sharedVariable = (Activator.CreateInstance(fieldType, true) as SharedVariable);
if (TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) || TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable.IsShared = true;
}
GUI.changed = true;
}
if (sharedVariable == null || sharedVariable.IsShared)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
string[] array = null;
int num = -1;
int num2 = FieldInspector.GetVariablesOfType((sharedVariable == null) ? null : sharedVariable.GetType().GetProperty("Value").PropertyType, sharedVariable != null && sharedVariable.IsGlobal, (sharedVariable == null) ? string.Empty : sharedVariable.Name, FieldInspector.behaviorSource, out array, ref num, fieldType.Equals(typeof(SharedVariable)));
Color backgroundColor = GUI.backgroundColor;
if (num2 == 0 && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
GUI.backgroundColor = Color.red;
}
int num3 = num2;
num2 = EditorGUILayout.Popup(guiContent.text, num2, array, BehaviorDesignerUtility.SharedVariableToolbarPopup, new GUILayoutOption[0]);
GUI.backgroundColor = backgroundColor;
if (num2 != num3)
{
if (num2 == 0)
{
if (fieldType.Equals(typeof(SharedVariable)))
{
sharedVariable = null;
}
else
{
sharedVariable = (Activator.CreateInstance(fieldType, true) as SharedVariable);
sharedVariable.IsShared = true;
}
}
else if (num != -1 && num2 >= num)
{
sharedVariable = GlobalVariables.Instance.GetVariable(array[num2].Substring(8, array[num2].Length - 8));
}
else
{
sharedVariable = FieldInspector.behaviorSource.GetVariable(array[num2]);
}
GUI.changed = true;
}
if (!fieldType.Equals(typeof(SharedVariable)) && !TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable = FieldInspector.DrawSharedVariableToggleSharedButton(sharedVariable);
GUILayout.Space(-3f);
}
GUILayout.EndHorizontal();
GUILayout.Space(3f);
}
else
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
ObjectDrawerAttribute[] array2;
ObjectDrawer objectDrawer;
if (fieldInfo != null && (array2 = (fieldInfo.GetCustomAttributes(typeof(ObjectDrawerAttribute), true) as ObjectDrawerAttribute[])).Length > 0 && (objectDrawer = ObjectDrawerUtility.GetObjectDrawer(task, array2[0])) != null)
{
objectDrawer.Value = sharedVariable;
objectDrawer.OnGUI(guiContent);
}
else
{
FieldInspector.DrawFields(task, sharedVariable, guiContent);
}
if (!TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable = FieldInspector.DrawSharedVariableToggleSharedButton(sharedVariable);
}
GUILayout.EndHorizontal();
}
return(sharedVariable);
}
private static object DrawSingleField(Task task, GUIContent guiContent, FieldInfo fieldInfo, Type fieldType, object value)
{
if (fieldType.Equals(typeof(int)))
{
return(EditorGUILayout.IntField(guiContent, (int)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(float)))
{
return(EditorGUILayout.FloatField(guiContent, (float)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(double)))
{
return(EditorGUILayout.FloatField(guiContent, Convert.ToSingle((double)value), new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(long)))
{
return((long)EditorGUILayout.IntField(guiContent, Convert.ToInt32((long)value), new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(bool)))
{
return(EditorGUILayout.Toggle(guiContent, (bool)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(string)))
{
return(EditorGUILayout.TextField(guiContent, (string)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(byte)))
{
return(Convert.ToByte(EditorGUILayout.IntField(guiContent, Convert.ToInt32(value), new GUILayoutOption[0])));
}
if (fieldType.Equals(typeof(Vector2)))
{
return(EditorGUILayout.Vector2Field(guiContent.text, (Vector2)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(Vector3)))
{
return(EditorGUILayout.Vector3Field(guiContent.text, (Vector3)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(Vector4)))
{
return(EditorGUILayout.Vector4Field(guiContent.text, (Vector4)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(Quaternion)))
{
Quaternion quaternion = (Quaternion)value;
Vector4 value2 = Vector4.zero;
value2.Set(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
value2 = EditorGUILayout.Vector4Field(guiContent.text, value2, new GUILayoutOption[0]);
quaternion.Set(value2.x, value2.y, value2.z, value2.w);
return(quaternion);
}
if (fieldType.Equals(typeof(Color)))
{
return(EditorGUILayout.ColorField(guiContent, (Color)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(Rect)))
{
return(EditorGUILayout.RectField(guiContent, (Rect)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(Matrix4x4)))
{
GUILayout.BeginVertical(new GUILayoutOption[0]);
if (FieldInspector.DrawFoldout(value.GetHashCode(), guiContent))
{
EditorGUI.indentLevel++;
Matrix4x4 matrix4x = (Matrix4x4)value;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
EditorGUI.BeginChangeCheck();
matrix4x[i, j] = EditorGUILayout.FloatField("E" + i.ToString() + j.ToString(), matrix4x[i, j], new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
GUI.changed = true;
}
}
}
value = matrix4x;
EditorGUI.indentLevel--;
}
GUILayout.EndVertical();
return(value);
}
if (fieldType.Equals(typeof(AnimationCurve)))
{
if (value == null)
{
value = new AnimationCurve();
}
return(EditorGUILayout.CurveField(guiContent, (AnimationCurve)value, new GUILayoutOption[0]));
}
if (fieldType.Equals(typeof(LayerMask)))
{
return(FieldInspector.DrawLayerMask(guiContent, (LayerMask)value));
}
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
return(FieldInspector.DrawSharedVariable(task, guiContent, fieldInfo, fieldType, value as SharedVariable));
}
if (typeof(UnityEngine.Object).IsAssignableFrom(fieldType))
{
return(EditorGUILayout.ObjectField(guiContent, (UnityEngine.Object)value, fieldType, true, new GUILayoutOption[0]));
}
if (fieldType.IsEnum)
{
return(EditorGUILayout.EnumPopup(guiContent, (Enum)value, new GUILayoutOption[0]));
}
if (!fieldType.IsClass && (!fieldType.IsValueType || fieldType.IsPrimitive))
{
EditorGUILayout.LabelField("Unsupported Type: " + fieldType, new GUILayoutOption[0]);
return(null);
}
int hashCode = guiContent.text.GetHashCode();
if (FieldInspector.drawnObjects.Contains(hashCode))
{
return(null);
}
FieldInspector.drawnObjects.Add(hashCode);
GUILayout.BeginVertical(new GUILayoutOption[0]);
if (fieldType.IsAbstract)
{
EditorGUILayout.LabelField(guiContent, new GUILayoutOption[0]);
GUILayout.EndVertical();
return(null);
}
if (value == null)
{
if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
fieldType = Nullable.GetUnderlyingType(fieldType);
}
value = Activator.CreateInstance(fieldType, true);
}
if (FieldInspector.DrawFoldout(value.GetHashCode(), guiContent))
{
EditorGUI.indentLevel++;
value = FieldInspector.DrawFields(task, value);
EditorGUI.indentLevel--;
}
GUILayout.EndVertical();
FieldInspector.drawnObjects.Remove(hashCode);
return(value);
}
public static void Init()
{
FieldInspector.InitLayers();
}
private static object DrawArrayField(Task task, GUIContent guiContent, FieldInfo fieldInfo, Type fieldType, object value)
{
Type type;
if (fieldType.IsArray)
{
type = fieldType.GetElementType();
}
else
{
Type type2 = fieldType;
while (!type2.IsGenericType)
{
type2 = type2.BaseType;
}
type = type2.GetGenericArguments()[0];
}
IList list;
if (value == null)
{
if (fieldType.IsGenericType || fieldType.IsArray)
{
list = (Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type
}), true) as IList);
}
else
{
list = (Activator.CreateInstance(fieldType, true) as IList);
}
if (fieldType.IsArray)
{
Array array = Array.CreateInstance(type, list.Count);
list.CopyTo(array, 0);
list = array;
}
GUI.changed = true;
}
else
{
list = (IList)value;
}
EditorGUILayout.BeginVertical(new GUILayoutOption[0]);
if (FieldInspector.DrawFoldout(list.GetHashCode(), guiContent))
{
EditorGUI.indentLevel++;
bool flag = guiContent.text.GetHashCode() == FieldInspector.editingFieldHash;
int num = (!flag) ? list.Count : FieldInspector.savedArraySize;
int num2 = EditorGUILayout.IntField("Size", num, new GUILayoutOption[0]);
if (flag && FieldInspector.editingArray && (GUIUtility.keyboardControl != FieldInspector.currentKeyboardControl || Event.current.keyCode == KeyCode.Return))
{
if (num2 != list.Count)
{
Array array2 = Array.CreateInstance(type, num2);
int num3 = -1;
for (int i = 0; i < num2; i++)
{
if (i < list.Count)
{
num3 = i;
}
if (num3 == -1)
{
break;
}
array2.SetValue(list[num3], i);
}
if (fieldType.IsArray)
{
list = array2;
}
else
{
if (fieldType.IsGenericType)
{
list = (Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type
}), true) as IList);
}
else
{
list = (Activator.CreateInstance(fieldType, true) as IList);
}
for (int j = 0; j < array2.Length; j++)
{
list.Add(array2.GetValue(j));
}
}
}
FieldInspector.editingArray = false;
FieldInspector.savedArraySize = -1;
FieldInspector.editingFieldHash = -1;
GUI.changed = true;
}
else if (num2 != num)
{
if (!FieldInspector.editingArray)
{
FieldInspector.currentKeyboardControl = GUIUtility.keyboardControl;
FieldInspector.editingArray = true;
FieldInspector.editingFieldHash = guiContent.text.GetHashCode();
}
FieldInspector.savedArraySize = num2;
}
for (int k = 0; k < list.Count; k++)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
guiContent.text = "Element " + k;
list[k] = FieldInspector.DrawField(task, guiContent, fieldInfo, type, list[k]);
GUILayout.Space(6f);
GUILayout.EndHorizontal();
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndVertical();
return(list);
}