public DataItemAttribute(
 bool writableName, 
 ReorderableListFlags listFlags, 
 bool autoGenerate,
 Type scriptBaseType)
 {
     _writableName = writableName;
     _listFlags = listFlags;
     _autoGenerate = autoGenerate;
     _scriptBaseType = scriptBaseType;
 }
 /// <summary>
 /// Calculate height of list field for adapted collection.
 /// </summary>
 /// <param name="adaptor">Reorderable list adaptor.</param>
 /// <param name="flags">Optional flags to pass into list field.</param>
 /// <returns>Required list height in pixels.</returns>
 public static float CalculateListFieldHeight(IReorderableListAdaptor adaptor, ReorderableListFlags flags)
 {
     // We need to push/pop flags so that nested controls are properly
     // calculated.
     var restoreFlags = defaultListControl.flags;
     try {
         defaultListControl.flags = flags;
         return defaultListControl.CalculateListHeight(adaptor);
     }
     finally {
         defaultListControl.flags = restoreFlags;
     }
 }
Exemplo n.º 3
0
        /// <summary>
        /// Draw list field control.
        /// </summary>
        /// <param name="list">The list which can be reordered.</param>
        /// <param name="drawItem">Callback to draw list item.</param>
        /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
        /// <param name="itemHeight">Height of a single list item.</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        /// <typeparam name="T">Type of list item.</typeparam>
        private static void DoListField <T>(IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListControl.DrawEmpty drawEmpty, float itemHeight, ReorderableListFlags flags)
        {
            var adaptor = new GenericListAdaptor <T>(list, drawItem, itemHeight);

            ReorderableListControl.DrawControlFromState(adaptor, drawEmpty, flags);
        }
Exemplo n.º 4
0
        public virtual void DrawVariablesGUI()
        {
            serializedObject.Update();

            Flowchart t = target as Flowchart;

            if (t.variables.Count == 0)
            {
                t.variablesExpanded = true;
            }

            if (!t.variablesExpanded)
            {
                if (GUILayout.Button("Variables (" + t.variables.Count + ")", GUILayout.Height(24)))
                {
                    t.variablesExpanded = true;
                }

                // Draw disclosure triangle
                Rect lastRect = GUILayoutUtility.GetLastRect();
                lastRect.x += 5;
                lastRect.y += 5;
                EditorGUI.Foldout(lastRect, false, "");
            }
            else
            {
                Rect listRect = new Rect();

                if (t.variables.Count > 0)
                {
                    // Remove any null variables from the list
                    // Can sometimes happen when upgrading to a new version of Fungus (if .meta GUID changes for a variable class)
                    for (int i = t.variables.Count - 1; i >= 0; i--)
                    {
                        if (t.variables[i] == null)
                        {
                            t.variables.RemoveAt(i);
                        }
                    }

                    ReorderableListGUI.Title("Variables");
                    VariableListAdaptor adaptor = new VariableListAdaptor(variablesProp, 0);

                    ReorderableListFlags flags = ReorderableListFlags.DisableContextMenu | ReorderableListFlags.HideAddButton;

                    ReorderableListControl.DrawControlFromState(adaptor, null, flags);
                    listRect = GUILayoutUtility.GetLastRect();
                }
                else
                {
                    GUILayoutUtility.GetRect(300, 24);
                    listRect    = GUILayoutUtility.GetLastRect();
                    listRect.y += 20;
                }

                float plusWidth  = 32;
                float plusHeight = 24;

                Rect  buttonRect   = listRect;
                float buttonHeight = 24;
                buttonRect.x      = 4;
                buttonRect.y     -= buttonHeight - 1;
                buttonRect.height = buttonHeight;
                if (!Application.isPlaying)
                {
                    buttonRect.width -= 30;
                }

                if (GUI.Button(buttonRect, "Variables"))
                {
                    t.variablesExpanded = false;
                }

                // Draw disclosure triangle
                Rect lastRect = buttonRect;
                lastRect.x += 5;
                lastRect.y += 5;
                EditorGUI.Foldout(lastRect, true, "");

                Rect plusRect = listRect;
                plusRect.x     += plusRect.width - plusWidth;
                plusRect.y     -= plusHeight - 1;
                plusRect.width  = plusWidth;
                plusRect.height = plusHeight;

                if (!Application.isPlaying &&
                    GUI.Button(plusRect, addTexture))
                {
                    GenericMenu        menu  = new GenericMenu();
                    List <System.Type> types = FindAllDerivedTypes <Variable>();

                    // Add variable types without a category
                    foreach (System.Type type in types)
                    {
                        VariableInfoAttribute variableInfo = VariableEditor.GetVariableInfo(type);
                        if (variableInfo == null ||
                            variableInfo.Category != "")
                        {
                            continue;
                        }

                        AddVariableInfo addVariableInfo = new AddVariableInfo();
                        addVariableInfo.flowchart    = t;
                        addVariableInfo.variableType = type;

                        GUIContent typeName = new GUIContent(variableInfo.VariableType);

                        menu.AddItem(typeName, false, AddVariable, addVariableInfo);
                    }

                    // Add types with a category
                    foreach (System.Type type in types)
                    {
                        VariableInfoAttribute variableInfo = VariableEditor.GetVariableInfo(type);
                        if (variableInfo == null ||
                            variableInfo.Category == "")
                        {
                            continue;
                        }

                        AddVariableInfo info = new AddVariableInfo();
                        info.flowchart    = t;
                        info.variableType = type;

                        GUIContent typeName = new GUIContent(variableInfo.Category + "/" + variableInfo.VariableType);

                        menu.AddItem(typeName, false, AddVariable, info);
                    }

                    menu.ShowAsContext();
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
        /// <summary>
        /// Calculate height of list field for adapted collection.
        /// </summary>
        /// <param name="adaptor">Reorderable list adaptor.</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        /// <returns>
        /// Required list height in pixels.
        /// </returns>
        public static float CalculateListFieldHeight(IReorderableListAdaptor adaptor, ReorderableListFlags flags)
        {
            // We need to push/pop flags so that nested controls are properly calculated.
            var restoreFlags = DefaultListControl.Flags;

            try {
                DefaultListControl.Flags = flags;
                return(DefaultListControl.CalculateListHeight(adaptor));
            }
            finally {
                DefaultListControl.Flags = restoreFlags;
            }
        }
        private static void DrawIndentedList <T>(IList <T> list,
                                                 ReorderableListFlags flags, Func <Rect, T, T> drawer)
        {
            if (list.Count == 0)
            {
                EditorGUILayout.HelpBox("No items in list", MessageType.Info);
                return;
            }

            var enableReordering = (flags & ReorderableListFlags.EnableReordering) != 0;
            var showIndices      = (flags & ReorderableListFlags.ShowIndices) != 0;
            var indentLevel      = EditorGUI.indentLevel;

            using (IndentLevelScope(-EditorGUI.indentLevel))
            {
                for (var i = 0; i < list.Count; i++)
                {
                    var item        = list[i];
                    var controlRect = EditorGUILayout.GetControlRect(false);

                    using (IndentLevelScope(indentLevel))
                    {
                        controlRect = EditorGUI.IndentedRect(controlRect);
                    }

                    if (showIndices)
                    {
                        var indexContent = new GUIContent(i.ToString());
                        var indexRect    = new Rect(controlRect);
                        indexRect.width = GUI.skin.label.CalcSize(indexContent).x;

                        GUI.Label(indexRect, indexContent);

                        controlRect.x     += indexRect.width + 5;
                        controlRect.width -= indexRect.width + 5;
                    }

                    var drawerRect = new Rect(controlRect);

                    if (enableReordering)
                    {
                        drawerRect.width -= 40;
                    }

                    drawer(drawerRect, item);

                    if (enableReordering)
                    {
                        var buttonRect = new Rect(controlRect);
                        buttonRect.x     = buttonRect.xMax - 40;
                        buttonRect.width = 20;

                        using (new EditorGUI.DisabledScope(i == 0))
                        {
                            if (GUI.Button(buttonRect, MoveUpButtonContents))
                            {
                                SwapInList(list, i, i - 1);
                            }
                        }

                        buttonRect.x += 20;

                        using (new EditorGUI.DisabledScope(i == list.Count - 1))
                        {
                            if (GUI.Button(buttonRect, MoveDownButtonContents))
                            {
                                SwapInList(list, i, i + 1);
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 7
0
		/// <summary>
		/// Generate and draw control from state object.
		/// </summary>
		/// <param name="position">Position of control.</param>
		/// <param name="adaptor">Reorderable list adaptor.</param>
		/// <param name="drawEmpty">Delegate for drawing empty list.</param>
		/// <param name="flags">Optional flags to pass into list field.</param>
		public static void DrawControlFromState(Rect position, IReorderableListAdaptor adaptor, DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags) {
			int controlID = GUIUtility.GetControlID(FocusType.Passive);

			var control = GUIUtility.GetStateObject(typeof(ReorderableListControl), controlID) as ReorderableListControl;
			control.Flags = flags;
			control.Draw(position, controlID, adaptor, drawEmpty);
		}
 /// <summary>
 /// Draw list field control for adapted collection.
 /// </summary>
 /// <param name="position">Position of control.</param>
 /// <param name="adaptor">Reorderable list adaptor.</param>
 /// <param name="drawEmpty">
 /// Callback to draw custom content for empty list (optional).
 /// </param>
 /// <param name="flags">Optional flags to pass into list field.</param>
 private static void DoListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags)
 {
     ReorderableListControl.DrawControlFromState(position, adaptor, drawEmpty, flags);
 }
 /// <inheritdoc cref="DoListField{T}(IList{T}, ReorderableListControl.ItemDrawer{T}, ReorderableListControl.DrawEmpty, float, ReorderableListFlags)"/>
 public static void ListField <T>(IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListFlags flags)
 {
     DoListField <T>(list, drawItem, null, DefaultItemHeight, flags);
 }
Exemplo n.º 10
0
 /// <inheritdoc cref="DoListFieldAbsolute{T}(Rect, IList{T}, ReorderableListControl.ItemDrawer{T}, ReorderableListControl.DrawEmptyAbsolute, float, ReorderableListFlags)"/>
 public static void ListFieldAbsolute <T>(Rect position, IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListControl.DrawEmptyAbsolute drawEmpty, float itemHeight, ReorderableListFlags flags)
 {
     DoListFieldAbsolute <T>(position, list, drawItem, drawEmpty, itemHeight, flags);
 }
Exemplo n.º 11
0
 /// <inheritdoc cref="DoListField{T}(IList{T}, ReorderableListControl.ItemDrawer{T}, ReorderableListControl.DrawEmpty, float, ReorderableListFlags)"/>
 public static void ListField <T>(IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListControl.DrawEmpty drawEmpty, float itemHeight, ReorderableListFlags flags)
 {
     DoListField <T>(list, drawItem, drawEmpty, itemHeight, flags);
 }
Exemplo n.º 12
0
        /// <summary>
        /// Draw list field control with absolute positioning.
        /// </summary>
        /// <param name="position">Position of control.</param>
        /// <param name="list">The list which can be reordered.</param>
        /// <param name="drawItem">Callback to draw list item.</param>
        /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
        /// <param name="itemHeight">Height of a single list item.</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        /// <typeparam name="T">Type of list item.</typeparam>
        private static void DoListFieldAbsolute <T>(Rect position, IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListControl.DrawEmptyAbsolute drawEmpty, float itemHeight, ReorderableListFlags flags)
        {
            var adaptor = new GenericListAdaptor <T>(list, drawItem, itemHeight);

            ReorderableListControl.DrawControlFromState(position, adaptor, drawEmpty, flags);
        }
Exemplo n.º 13
0
        /// <summary>
        /// Calculate height of list field for absolute positioning.
        /// </summary>
        /// <param name="itemCount">Count of items in list.</param>
        /// <param name="itemHeight">Fixed height of list item.</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        /// <returns>
        /// Required list height in pixels.
        /// </returns>
        public static float CalculateListFieldHeight(int itemCount, float itemHeight, ReorderableListFlags flags)
        {
            // We need to push/pop flags so that nested controls are properly calculated.
            var restoreFlags = defaultListControl.flags;

            try
            {
                defaultListControl.flags = flags;
                return(defaultListControl.CalculateListHeight(itemCount, itemHeight));
            }
            finally
            {
                defaultListControl.flags = restoreFlags;
            }
        }
Exemplo n.º 14
0
        public virtual void DrawVariablesGUI()
        {
            serializedObject.Update();

            FungusScript t = target as FungusScript;

            if (t.variables.Count == 0)
            {
                t.variablesExpanded = true;
            }

            if (!t.variablesExpanded)
            {
                if (GUILayout.Button("Variables (" + t.variables.Count + ")", GUILayout.Height(24)))
                {
                    t.variablesExpanded = true;
                }
            }
            else
            {
                Rect listRect = new Rect();

                if (t.variables.Count > 0)
                {
                    ReorderableListGUI.Title("Variables");
                    VariableListAdaptor adaptor = new VariableListAdaptor(variablesProp, 0);

                    ReorderableListFlags flags = ReorderableListFlags.DisableContextMenu | ReorderableListFlags.HideAddButton;

                    ReorderableListControl.DrawControlFromState(adaptor, null, flags);
                    listRect = GUILayoutUtility.GetLastRect();
                }
                else
                {
                    GUILayoutUtility.GetRect(300, 24);
                    listRect    = GUILayoutUtility.GetLastRect();
                    listRect.y += 20;
                }

                float plusWidth  = 32;
                float plusHeight = 24;

                Rect  buttonRect   = listRect;
                float buttonHeight = 24;
                buttonRect.x      = 4;
                buttonRect.y     -= buttonHeight - 1;
                buttonRect.height = buttonHeight;
                if (!Application.isPlaying)
                {
                    buttonRect.width -= 30;
                }

                if (GUI.Button(buttonRect, "Variables"))
                {
                    t.variablesExpanded = false;
                }

                Rect plusRect = listRect;
                plusRect.x     += plusRect.width - plusWidth;
                plusRect.y     -= plusHeight - 1;
                plusRect.width  = plusWidth;
                plusRect.height = plusHeight;

                if (!Application.isPlaying &&
                    GUI.Button(plusRect, FungusEditorResources.texAddButton))
                {
                    GenericMenu menu = new GenericMenu();

                    List <System.Type> types = FindAllDerivedTypes <Variable>();

                    // Add variable types without a category
                    foreach (System.Type type in types)
                    {
                        VariableInfoAttribute variableInfo = VariableEditor.GetVariableInfo(type);
                        if (variableInfo == null ||
                            variableInfo.Category != "")
                        {
                            continue;
                        }

                        AddVariableInfo addVariableInfo = new AddVariableInfo();
                        addVariableInfo.fungusScript = t;
                        addVariableInfo.variableType = type;

                        GUIContent typeName = new GUIContent(variableInfo.VariableType);

                        menu.AddItem(typeName, false, AddVariable, addVariableInfo);
                    }

                    // Add types with a category
                    foreach (System.Type type in types)
                    {
                        VariableInfoAttribute variableInfo = VariableEditor.GetVariableInfo(type);
                        if (variableInfo == null ||
                            variableInfo.Category == "")
                        {
                            continue;
                        }

                        AddVariableInfo info = new AddVariableInfo();
                        info.fungusScript = t;
                        info.variableType = type;

                        GUIContent typeName = new GUIContent(variableInfo.Category + "/" + variableInfo.VariableType);

                        menu.AddItem(typeName, false, AddVariable, info);
                    }

                    menu.ShowAsContext();
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
Exemplo n.º 15
0
        private void DrawListField(
            string fieldName,
            Core.PropertyInfoType type,
            Type @enum,
            Type ptrType,
            IList list,
            Entity entity,
            bool isResizable)
        {
            ReorderableListGUI.Title(fieldName);

            ReorderableListFlags flags = ReorderableListFlags.ShowIndices;

            if (!isResizable)
            {
                flags = ReorderableListFlags.HideAddButton | ReorderableListFlags.HideRemoveButtons | ReorderableListFlags.ShowIndices;
            }

            switch (type)
            {
            case Core.PropertyInfoType.Int8:
                ReorderableListGUI.ListField(
                    list as IList <sbyte>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.UInt8:
                ReorderableListGUI.ListField(
                    list as IList <byte>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Int16:
                ReorderableListGUI.ListField(
                    list as IList <short>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.UInt16:
                ReorderableListGUI.ListField(
                    list as IList <ushort>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Int32:
                if (@enum != null)
                {
                    // I'm sorry
                    // I'll fix this later I swear
                    var castList = new List <int>(list.Count);
                    castList.AddRange(from object item in list select Convert.ToInt32(item));

                    ReorderableListGUI.ListField(
                        castList,
                        (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                        DrawEmpty,
                        flags);

                    list.Clear();
                    foreach (var item in castList)
                    {
                        list.Add(Enum.ToObject(@enum, item));
                    }
                    break;
                }

                ReorderableListGUI.ListField(
                    list as IList <int>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.UInt32:
                ReorderableListGUI.ListField(
                    list as IList <uint>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Int64:
                ReorderableListGUI.ListField(
                    list as IList <long>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.UInt64:
                ReorderableListGUI.ListField(
                    list as IList <ulong>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Float:
                ReorderableListGUI.ListField(
                    list as IList <float>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Double:
                ReorderableListGUI.ListField(
                    list as IList <double>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Bool:
                ReorderableListGUI.ListField(
                    list as IList <bool>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.String:
                ReorderableListGUI.ListField(
                    list as IList <string>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Path:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Object>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.EntityPtr:
                var genericAdapterType = typeof(EntityPtrListAdapter <>).MakeGenericType(ptrType);
                var adapter            = Activator.CreateInstance(genericAdapterType, list, ptrType, entity) as IReorderableListAdaptor;
                ReorderableListGUI.ListField(adapter);
                break;

            case Core.PropertyInfoType.Vector3:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Vector3>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Vector4:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Vector4>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Quat:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Quaternion>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Matrix3:
                break;

            case Core.PropertyInfoType.Matrix4:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Matrix4x4>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.Color:
                ReorderableListGUI.ListField(
                    list as IList <Color>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.FilePtr:
                ReorderableListGUI.ListField(
                    list as IList <UnityEngine.Object>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.EntityHandle:
                ReorderableListGUI.ListField(
                    list as IList <Entity>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.EntityLink:
                ReorderableListGUI.ListField(
                    list as IList <EntityLink>,
                    (position, itemValue) => DrawListItem(position, itemValue, type, @enum, ptrType),
                    DrawEmpty,
                    flags);
                break;

            case Core.PropertyInfoType.PropertyInfo:
                break;

            case Core.PropertyInfoType.WideVector3:
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }
        }
 /// <inheritdoc cref="DoListField(IReorderableListAdaptor, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(IReorderableListAdaptor adaptor, ReorderableListFlags flags)
 {
     DoListField(adaptor, null, flags);
 }
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, IReorderableListAdaptor, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, adaptor, null, flags);
 }
Exemplo n.º 18
0
 /// <inheritdoc cref="DoListFieldAbsolute{T}(Rect, IList{T}, ReorderableListControl.ItemDrawer{T}, ReorderableListControl.DrawEmptyAbsolute, float, ReorderableListFlags)"/>
 public static void ListFieldAbsolute <T>(Rect position, IList <T> list, ReorderableListControl.ItemDrawer <T> drawItem, ReorderableListFlags flags)
 {
     DoListFieldAbsolute <T>(position, list, drawItem, null, DefaultItemHeight, flags);
 }
 public DataItemAttribute()
 {
     _writableName = true;
     _listFlags = ReorderableListFlags.DisableReordering;
 }
Exemplo n.º 20
0
 /// <inheritdoc cref="CalculateListFieldHeight(int, float, ReorderableListFlags)"/>
 public static float CalculateListFieldHeight(int itemCount, ReorderableListFlags flags)
 {
     return(CalculateListFieldHeight(itemCount, DefaultItemHeight, flags));
 }
 private bool HasFlag(ReorderableListFlags flag)
 {
     return (Flags & flag) != 0;
 }
Exemplo n.º 22
0
        /// <summary>
        /// Draw list field control for serializable property array.
        /// </summary>
        /// <param name="position">Position of control.</param>
        /// <param name="arrayProperty">Serializable property.</param>
        /// <param name="fixedItemHeight">Use fixed height for items rather than <see cref="UnityEditor.EditorGUI.GetPropertyHeight(SerializedProperty)"/>.</param>
        /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        private static void DoListFieldAbsolute(Rect position, SerializedProperty arrayProperty, float fixedItemHeight, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags)
        {
            var adaptor = new SerializedPropertyAdaptor(arrayProperty, fixedItemHeight);

            ReorderableListControl.DrawControlFromState(position, adaptor, drawEmpty, flags);
        }
Exemplo n.º 23
0
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, IReorderableListAdaptor, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, adaptor, null, flags);
 }
Exemplo n.º 24
0
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, SerializedProperty, float, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, SerializedProperty arrayProperty, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, arrayProperty, 0, drawEmpty, flags);
 }
Exemplo n.º 25
0
        public virtual void DrawSequenceGUI(FungusScript fungusScript)
        {
            serializedObject.Update();

            Sequence sequence = target as Sequence;

            SerializedProperty descriptionProp = serializedObject.FindProperty("description");

            EditorGUILayout.PropertyField(descriptionProp);

            SerializedProperty runSlowInEditorProp = serializedObject.FindProperty("runSlowInEditor");

            EditorGUILayout.PropertyField(runSlowInEditorProp);

            DrawEventHandlerGUI(fungusScript);

            UpdateIndentLevels(sequence);

            SerializedProperty sequenceNameProperty = serializedObject.FindProperty("sequenceName");
            Rect sequenceLabelRect = new Rect(45, 5, 120, 16);

            EditorGUI.LabelField(sequenceLabelRect, new GUIContent("Sequence Name"));
            Rect sequenceNameRect = new Rect(45, 21, 180, 16);

            EditorGUI.PropertyField(sequenceNameRect, sequenceNameProperty, new GUIContent(""));

            // Ensure sequence name is unique for this Fungus Script
            string uniqueName = fungusScript.GetUniqueSequenceKey(sequenceNameProperty.stringValue, sequence);

            if (uniqueName != sequence.sequenceName)
            {
                sequenceNameProperty.stringValue = uniqueName;
            }

            // Make sure each command has a reference to its parent sequence
            foreach (Command command in sequence.commandList)
            {
                if (command == null)                 // Will be deleted from the list later on
                {
                    continue;
                }
                command.parentSequence = sequence;
            }

            SerializedProperty commandListProperty = serializedObject.FindProperty("commandList");

            ReorderableListGUI.Title("Commands");
            CommandListAdaptor adaptor = new CommandListAdaptor(commandListProperty, 0);

            adaptor.nodeRect = sequence.nodeRect;

            ReorderableListFlags flags = ReorderableListFlags.HideAddButton | ReorderableListFlags.HideRemoveButtons | ReorderableListFlags.DisableContextMenu;

            ReorderableListControl.DrawControlFromState(adaptor, null, flags);

            if (Event.current.type == EventType.ContextClick)
            {
                ShowContextMenu();
            }

            if (sequence == fungusScript.selectedSequence)
            {
                // Show add command button
                {
                    GUILayout.BeginHorizontal();

                    // Up Button
                    Texture2D upIcon = Resources.Load("Icons/up") as Texture2D;
                    if (GUILayout.Button(upIcon))
                    {
                        SelectPrevious();
                    }
                    // Down Button
                    Texture2D downIcon = Resources.Load("Icons/down") as Texture2D;
                    if (GUILayout.Button(downIcon))
                    {
                        SelectNext();
                    }

                    GUILayout.FlexibleSpace();

                    // Add Button
                    Texture2D addIcon = Resources.Load("Icons/add") as Texture2D;
                    if (GUILayout.Button(addIcon) || ((Event.current.type == EventType.KeyDown) && (Event.current.keyCode == KeyCode.A)))
                    {
                        ShowCommandMenu();
                    }

                    // Duplicate Button
                    Texture2D duplicateIcon = Resources.Load("Icons/duplicate") as Texture2D;
                    if (GUILayout.Button(duplicateIcon))
                    {
                        Copy();
                        Paste();
                    }

                    // Delete Button
                    Texture2D deleteIcon = Resources.Load("Icons/delete") as Texture2D;
                    if (GUILayout.Button(deleteIcon) || ((Event.current.type == EventType.KeyDown) && (Event.current.keyCode == KeyCode.Delete)))
                    {
                        Delete();
                    }

                    GUILayout.EndHorizontal();
                }
            }

            // Remove any null entries in the command list.
            // This can happen when a command class is deleted or renamed.
            for (int i = commandListProperty.arraySize - 1; i >= 0; --i)
            {
                SerializedProperty commandProperty = commandListProperty.GetArrayElementAtIndex(i);
                if (commandProperty.objectReferenceValue == null)
                {
                    commandListProperty.DeleteArrayElementAtIndex(i);
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
Exemplo n.º 26
0
 /// <inheritdoc cref="DoListField(SerializedProperty, float, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(SerializedProperty arrayProperty, ReorderableListFlags flags)
 {
     DoListField(arrayProperty, 0, null, flags);
 }
Exemplo n.º 27
0
        public virtual void DrawBlockGUI(Flowchart flowchart)
        {
            serializedObject.Update();

            // Execute any queued cut, copy, paste, etc. operations from the prevous GUI update
            // We need to defer applying these operations until the following update because
            // the ReorderableList control emits GUI errors if you clear the list in the same frame
            // as drawing the control (e.g. select all and then delete)
            if (Event.current.type == EventType.Layout)
            {
                foreach (Action action in actionList)
                {
                    if (action != null)
                    {
                        action();
                    }
                }
                actionList.Clear();
            }

            Block block = target as Block;

            SerializedProperty commandListProperty = serializedObject.FindProperty("commandList");

            if (block == flowchart.selectedBlock)
            {
                SerializedProperty descriptionProp = serializedObject.FindProperty("description");
                EditorGUILayout.PropertyField(descriptionProp);

                DrawEventHandlerGUI(flowchart);

                UpdateIndentLevels(block);

                // Make sure each command has a reference to its parent block
                foreach (Command command in block.commandList)
                {
                    if (command == null)                     // Will be deleted from the list later on
                    {
                        continue;
                    }
                    command.parentBlock = block;
                }

                ReorderableListGUI.Title("Commands");
                CommandListAdaptor adaptor = new CommandListAdaptor(commandListProperty, 0);
                adaptor.nodeRect = block.nodeRect;

                ReorderableListFlags flags = ReorderableListFlags.HideAddButton | ReorderableListFlags.HideRemoveButtons | ReorderableListFlags.DisableContextMenu;

                if (block.commandList.Count == 0)
                {
                    EditorGUILayout.HelpBox("Press the + button below to add a command to the list.", MessageType.Info);
                }
                else
                {
                    ReorderableListControl.DrawControlFromState(adaptor, null, flags);
                }

                // EventType.contextClick doesn't register since we moved the Block Editor to be inside
                // a GUI Area, no idea why. As a workaround we just check for right click instead.
                if (Event.current.type == EventType.mouseUp &&
                    Event.current.button == 1)
                {
                    ShowContextMenu();
                    Event.current.Use();
                }

                if (GUIUtility.keyboardControl == 0)                 //Only call keyboard shortcuts when not typing in a text field
                {
                    Event e = Event.current;

                    // Copy keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "Copy")
                    {
                        if (flowchart.selectedCommands.Count > 0)
                        {
                            e.Use();
                        }
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "Copy")
                    {
                        actionList.Add(Copy);
                        e.Use();
                    }

                    // Cut keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "Cut")
                    {
                        if (flowchart.selectedCommands.Count > 0)
                        {
                            e.Use();
                        }
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "Cut")
                    {
                        actionList.Add(Cut);
                        e.Use();
                    }

                    // Paste keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "Paste")
                    {
                        CommandCopyBuffer commandCopyBuffer = CommandCopyBuffer.GetInstance();
                        if (commandCopyBuffer.HasCommands())
                        {
                            e.Use();
                        }
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "Paste")
                    {
                        actionList.Add(Paste);
                        e.Use();
                    }

                    // Duplicate keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "Duplicate")
                    {
                        if (flowchart.selectedCommands.Count > 0)
                        {
                            e.Use();
                        }
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "Duplicate")
                    {
                        actionList.Add(Copy);
                        actionList.Add(Paste);
                        e.Use();
                    }

                    // Delete keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "Delete")
                    {
                        if (flowchart.selectedCommands.Count > 0)
                        {
                            e.Use();
                        }
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "Delete")
                    {
                        actionList.Add(Delete);
                        e.Use();
                    }

                    // SelectAll keyboard shortcut
                    if (e.type == EventType.ValidateCommand && e.commandName == "SelectAll")
                    {
                        e.Use();
                    }

                    if (e.type == EventType.ExecuteCommand && e.commandName == "SelectAll")
                    {
                        actionList.Add(SelectAll);
                        e.Use();
                    }
                }
            }

            // Remove any null entries in the command list.
            // This can happen when a command class is deleted or renamed.
            for (int i = commandListProperty.arraySize - 1; i >= 0; --i)
            {
                SerializedProperty commandProperty = commandListProperty.GetArrayElementAtIndex(i);
                if (commandProperty.objectReferenceValue == null)
                {
                    commandListProperty.DeleteArrayElementAtIndex(i);
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
Exemplo n.º 28
0
        /// <summary>
        /// Calculate height of list field for absolute positioning.
        /// </summary>
        /// <param name="arrayProperty">Serializable property.</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        /// <returns>
        /// Required list height in pixels.
        /// </returns>
        public static float CalculateListFieldHeight(SerializedProperty arrayProperty, ReorderableListFlags flags)
        {
            // We need to push/pop flags so that nested controls are properly calculated.
            var restoreFlags = DefaultListControl.Flags;

            try {
                DefaultListControl.Flags = flags;
                return(DefaultListControl.CalculateListHeight(new SerializedPropertyAdaptor(arrayProperty)));
            }
            finally {
                DefaultListControl.Flags = restoreFlags;
            }
        }
Exemplo n.º 29
0
 public static void DrawControlFromState(IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
 {
     int controlID = GUIUtility.GetControlID(FocusType.Passive);
     ReorderableListControl reorderableListControl = GUIUtility.GetStateObject(typeof(ReorderableListControl), controlID) as ReorderableListControl;
     reorderableListControl.flags = flags;
     reorderableListControl.Draw(controlID, adaptor, drawEmpty);
 }
Exemplo n.º 30
0
 /// <inheritdoc cref="DoListField(SerializedProperty, float, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(SerializedProperty arrayProperty, float fixedItemHeight, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
 {
     DoListField(arrayProperty, fixedItemHeight, drawEmpty, flags);
 }
 /// <inheritdoc cref="DoListField(IReorderableListAdaptor, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
 {
     DoListField(adaptor, drawEmpty, flags);
 }
Exemplo n.º 32
0
 /// <inheritdoc cref="DoListField(SerializedProperty, float, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(SerializedProperty arrayProperty, float fixedItemHeight, ReorderableListFlags flags)
 {
     DoListField(arrayProperty, fixedItemHeight, null, flags);
 }
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, IReorderableListAdaptor, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, adaptor, drawEmpty, flags);
 }
Exemplo n.º 34
0
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, SerializedProperty, float, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, SerializedProperty arrayProperty, float fixedItemHeight, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, arrayProperty, fixedItemHeight, null, flags);
 }
 /// <summary>
 /// Draw list field control for adapted collection.
 /// </summary>
 /// <param name="adaptor">Reorderable list adaptor.</param>
 /// <param name="drawEmpty">
 /// Callback to draw custom content for empty list (optional).
 /// </param>
 /// <param name="flags">Optional flags to pass into list field.</param>
 private static void DoListField(IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
 {
     ReorderableListControl.DrawControlFromState(adaptor, drawEmpty, flags);
 }
Exemplo n.º 36
0
 /// <summary>
 /// Draw list field control for adapted collection.
 /// </summary>
 /// <param name="adaptor">Reorderable list adaptor.</param>
 /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
 /// <param name="flags">Optional flags to pass into list field.</param>
 private static void DoListField(IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags = 0)
 {
     ReorderableListControl.DrawControlFromState(adaptor, drawEmpty, flags);
 }
Exemplo n.º 37
0
		/// <summary>
		/// Generate and draw control from state object.
		/// </summary>
		/// <param name="adaptor">Reorderable list adaptor.</param>
		/// <param name="drawEmpty">Delegate for drawing empty list.</param>
		/// <param name="flags">Optional flags to pass into list field.</param>
		public static void DrawControlFromState(IReorderableListAdaptor adaptor, DrawEmpty drawEmpty, ReorderableListFlags flags) {
			int controlID = GetReorderableListControlID();

			var control = GUIUtility.GetStateObject(typeof(ReorderableListControl), controlID) as ReorderableListControl;
			control.Flags = flags;
			control.Draw(controlID, adaptor, drawEmpty);
		}
Exemplo n.º 38
0
 /// <summary>
 /// Draw list field control for adapted collection.
 /// </summary>
 /// <param name="position">Position of control.</param>
 /// <param name="adaptor">Reorderable list adaptor.</param>
 /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
 /// <param name="flags">Optional flags to pass into list field.</param>
 private static void DoListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags = 0)
 {
     ReorderableListControl.DrawControlFromState(position, adaptor, drawEmpty, flags);
 }
Exemplo n.º 39
0
 /// <inheritdoc cref="DoListField(IReorderableListAdaptor, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
 {
     DoListField(adaptor, drawEmpty, flags);
 }
Exemplo n.º 40
0
 /// <inheritdoc cref="DoListFieldAbsolute(Rect, IReorderableListAdaptor, ReorderableListControl.DrawEmptyAbsolute, ReorderableListFlags)"/>
 public static void ListFieldAbsolute(Rect position, IReorderableListAdaptor adaptor, ReorderableListControl.DrawEmptyAbsolute drawEmpty, ReorderableListFlags flags)
 {
     DoListFieldAbsolute(position, adaptor, drawEmpty, flags);
 }
Exemplo n.º 41
0
		/// <summary>
		/// Initializes a new instance of <see cref="ReorderableListControl"/>.
		/// </summary>
		/// <param name="flags">Optional flags which affect behavior of control.</param>
		public ReorderableListControl(ReorderableListFlags flags)
			: this() {
			this.Flags = flags;
		}
Exemplo n.º 42
0
 /// <inheritdoc cref="DoListField(IReorderableListAdaptor, ReorderableListControl.DrawEmpty, ReorderableListFlags)"/>
 public static void ListField(IReorderableListAdaptor adaptor, ReorderableListFlags flags)
 {
     DoListField(adaptor, null, flags);
 }
 private void UpdateFlag(bool shouldSet, ReorderableListFlags flag)
 {
     if (shouldSet) Flags |= flag;
     else Flags &= ~flag;
 }
        /// <summary>
        /// Draw list field control for serializable property array.
        /// </summary>
        /// <param name="arrayProperty">Serializable property.</param>
        /// <param name="fixedItemHeight">Use fixed height for items rather than <see cref="UnityEditor.EditorGUI.GetPropertyHeight(SerializedProperty)"/>.</param>
        /// <param name="drawEmpty">Callback to draw custom content for empty list (optional).</param>
        /// <param name="flags">Optional flags to pass into list field.</param>
        static void DoListField(SerializedProperty arrayProperty, float fixedItemHeight, ReorderableListControl.DrawEmpty drawEmpty, ReorderableListFlags flags)
        {
            var adaptor = new SerializedPropertyAdaptor(arrayProperty, fixedItemHeight);

            ReorderableListControl.DrawControlFromState(adaptor, drawEmpty, flags);
        }