Example #1
0
        public void OnClauseGUI()
        {
            if (target == null || serializedObject == null)
            {
                return;
            }
            serializedObject.Update();

            EditorGUILayout.PropertyField(this.spDescription);

            GUIContent gcIf   = ClausesUtilities.Get(ClausesUtilities.Icon.If);
            Rect       rectIf = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.boldLabel);

            EditorGUI.LabelField(rectIf, gcIf, EditorStyles.boldLabel);

            this.conditionsListEditor.OnInspectorGUI();
            EditorGUILayout.Space();

            GUIContent gcThen   = ClausesUtilities.Get(ClausesUtilities.Icon.Then);
            Rect       rectThen = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.boldLabel);

            EditorGUI.LabelField(rectThen, gcThen, EditorStyles.boldLabel);

            ActionsEditor.Return returnActions = ActionsEditor.PaintActionsGUI(
                this.parentConditions.gameObject,
                this.spActions,
                this.actionsEditor
                );

            if (returnActions != null)
            {
                this.spActions     = returnActions.spParentActions;
                this.actionsEditor = returnActions.parentActionsEditor;

                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            serializedObject.ApplyModifiedPropertiesWithoutUndo();
        }
Example #2
0
        // INSPECTOR: -----------------------------------------------------------------------------

        public override void OnInspectorGUI()
        {
            if (target == null || serializedObject == null)
            {
                return;
            }
            serializedObject.Update();
            this.UpdateSubEditors(this.instance.conditions);

            int  removConditionIndex     = -1;
            int  duplicateConditionIndex = -1;
            int  copyConditionIndex      = -1;
            bool forceRepaint            = false;
            bool conditionsCollapsed     = true;

            int spConditionsSize = this.spConditions.arraySize;

            for (int i = 0; i < spConditionsSize; ++i)
            {
                bool forceSortRepaint = this.editorSortableList.CaptureSortEvents(this.handleRect[i], i);
                forceRepaint = forceSortRepaint || forceRepaint;

                GUILayout.BeginVertical();
                ItemReturnOperation returnOperation = this.PaintConditionsHeader(i);
                if (returnOperation.removeIndex)
                {
                    removConditionIndex = i;
                }
                if (returnOperation.duplicateIndex)
                {
                    duplicateConditionIndex = i;
                }
                if (returnOperation.copyIndex)
                {
                    copyConditionIndex = i;
                }

                conditionsCollapsed &= this.isExpanded[i].target;
                using (var group = new EditorGUILayout.FadeGroupScope(this.isExpanded[i].faded))
                {
                    if (group.visible)
                    {
                        EditorGUILayout.BeginVertical(CoreGUIStyles.GetBoxExpanded());
                        if (this.subEditors[i] != null)
                        {
                            this.subEditors[i].OnInspectorGUI();
                        }
                        else
                        {
                            EditorGUILayout.HelpBox(MSG_UNDEF_CONDITION_1, MessageType.Warning);
                            EditorGUILayout.HelpBox(MSG_UNDEF_CONDITION_2, MessageType.None);
                        }
                        EditorGUILayout.EndVertical();
                    }
                }

                GUILayout.EndVertical();

                if (UnityEngine.Event.current.type == EventType.Repaint)
                {
                    this.objectRect[i] = GUILayoutUtility.GetLastRect();
                }

                this.editorSortableList.PaintDropPoints(this.objectRect[i], i, spConditionsSize);
            }

            Rect rectControls      = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
            Rect rectAddConditions = new Rect(
                rectControls.x,
                rectControls.y,
                SelectTypePanel.WINDOW_WIDTH,
                rectControls.height
                );

            Rect rectPaste = new Rect(
                rectAddConditions.x + rectAddConditions.width,
                rectControls.y,
                25f,
                rectControls.height
                );

            Rect rectPlay = new Rect(
                rectControls.x + rectControls.width - 25f,
                rectControls.y,
                25f,
                rectControls.height
                );

            Rect rectCollapse = new Rect(
                rectPlay.x - 25f,
                rectPlay.y,
                25f,
                rectPlay.height
                );

            Rect rectUnused = new Rect(
                rectPaste.x + rectPaste.width,
                rectControls.y,
                rectControls.width - ((rectPaste.x + rectPaste.width) - rectControls.x) - rectPlay.width - rectCollapse.width,
                rectControls.height
                );

            if (GUI.Button(rectAddConditions, "Add Condition", CoreGUIStyles.GetToggleButtonLeftAdd()))
            {
                SelectTypePanel selectTypePanel = new SelectTypePanel(this.AddNewCondition, "Conditions", typeof(ICondition));
                PopupWindow.Show(this.addConditionsButtonRect, selectTypePanel);
            }

            if (UnityEngine.Event.current.type == EventType.Repaint)
            {
                this.addConditionsButtonRect = rectAddConditions;
            }

            GUIContent gcPaste = ClausesUtilities.Get(ClausesUtilities.Icon.Paste);

            EditorGUI.BeginDisabledGroup(CLIPBOARD_ICONDITION == null);
            if (GUI.Button(rectPaste, gcPaste, CoreGUIStyles.GetButtonMid()))
            {
                ICondition conditionCreated = (ICondition)this.instance.gameObject.AddComponent(CLIPBOARD_ICONDITION.GetType());
                EditorUtility.CopySerialized(CLIPBOARD_ICONDITION, conditionCreated);

                this.spConditions.AddToObjectArray(conditionCreated);
                this.AddSubEditorElement(conditionCreated, -1, true);

                DestroyImmediate(CLIPBOARD_ICONDITION.gameObject, true);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                CLIPBOARD_ICONDITION = null;
            }
            EditorGUI.EndDisabledGroup();

            GUI.Label(rectUnused, "", CoreGUIStyles.GetToggleButtonMidOn());

            GUIContent gcToggle = (conditionsCollapsed
               ? ClausesUtilities.Get(ClausesUtilities.Icon.Collapse)
               : ClausesUtilities.Get(ClausesUtilities.Icon.Expand)
                                   );

            EditorGUI.BeginDisabledGroup(this.instance.conditions.Length == 0);
            if (GUI.Button(rectCollapse, gcToggle, CoreGUIStyles.GetButtonMid()))
            {
                for (int i = 0; i < this.subEditors.Length; ++i)
                {
                    this.SetExpand(i, !conditionsCollapsed);
                }
            }
            EditorGUI.EndDisabledGroup();

            GUIContent gcPlay = ClausesUtilities.Get(ClausesUtilities.Icon.Play);

            EditorGUI.BeginDisabledGroup(!EditorApplication.isPlaying);
            if (GUI.Button(rectPlay, gcPlay, CoreGUIStyles.GetButtonRight()))
            {
                Debug.LogFormat("<b>Conditions Evaluation:</b> {0}", this.instance.Check(null));
            }
            EditorGUI.EndDisabledGroup();

            if (removConditionIndex >= 0)
            {
                ICondition source = (ICondition)this.spConditions.GetArrayElementAtIndex(removConditionIndex).objectReferenceValue;

                this.spConditions.RemoveFromObjectArrayAt(removConditionIndex);
                this.RemoveSubEditorsElement(removConditionIndex);
                DestroyImmediate(source, true);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
            }

            if (duplicateConditionIndex >= 0)
            {
                int srcIndex = duplicateConditionIndex;
                int dstIndex = duplicateConditionIndex + 1;

                ICondition source = (ICondition)this.subEditors[srcIndex].target;
                ICondition copy   = (ICondition)this.instance.gameObject.AddComponent(source.GetType());

                this.spConditions.InsertArrayElementAtIndex(dstIndex);
                this.spConditions.GetArrayElementAtIndex(dstIndex).objectReferenceValue = copy;

                EditorUtility.CopySerialized(source, copy);
                this.AddSubEditorElement(copy, dstIndex, true);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
            }

            if (copyConditionIndex >= 0)
            {
                ICondition source = (ICondition)this.subEditors[copyConditionIndex].target;

                GameObject conditionInstance = new GameObject();
                conditionInstance.hideFlags = HideFlags.HideAndDontSave;

                CLIPBOARD_ICONDITION = (ICondition)conditionInstance.AddComponent(source.GetType());
                EditorUtility.CopySerialized(source, CLIPBOARD_ICONDITION);
            }

            EditorSortableList.SwapIndexes swapIndexes = this.editorSortableList.GetSortIndexes();
            if (swapIndexes != null)
            {
                this.spConditions.MoveArrayElement(swapIndexes.src, swapIndexes.dst);
                this.MoveSubEditorsElement(swapIndexes.src, swapIndexes.dst);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
            }

            if (EditorApplication.isPlaying)
            {
                forceRepaint = true;
            }
            if (forceRepaint)
            {
                this.Repaint();
            }
            serializedObject.ApplyModifiedProperties();
        }
Example #3
0
        private ItemReturnOperation PaintConditionsHeader(int i)
        {
            ItemReturnOperation returnOperation = new ItemReturnOperation();

            Rect rectHeader = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());

            this.PaintDragHandle(i, rectHeader);

            Texture2D conditionIcon = (i < this.subEditors.Length && this.subEditors[i] != null ?
                                       this.subEditors[i].GetIcon()
                : null
                                       );

            string conditionName = (this.isExpanded[i].target ? " ▾ " : " ▸ ");

            conditionName += (this.instance.conditions[i] != null
                     ? this.instance.conditions[i].GetNodeTitle()
                                : "<i>Undefined Condition</i>"
                              );

            GUIStyle style = (this.isExpanded[i].target
                                ? CoreGUIStyles.GetToggleButtonMidOn()
                                : CoreGUIStyles.GetToggleButtonMidOff()
                              );

            Rect rectDelete = new Rect(
                rectHeader.x + rectHeader.width - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectDuplicate = new Rect(
                rectDelete.x - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectCopy = new Rect(
                rectDuplicate.x - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectMain = new Rect(
                rectHeader.x + 25f,
                rectHeader.y,
                rectHeader.width - (25f * 4f),
                rectHeader.height
                );

            if (GUI.Button(rectMain, new GUIContent(conditionName, conditionIcon), style))
            {
                this.ToggleExpand(i);
            }

            GUIContent gcCopy      = ClausesUtilities.Get(ClausesUtilities.Icon.Copy);
            GUIContent gcDuplicate = ClausesUtilities.Get(ClausesUtilities.Icon.Duplicate);
            GUIContent gcDelete    = ClausesUtilities.Get(ClausesUtilities.Icon.Delete);

            if (this.instance.conditions[i] != null && GUI.Button(rectCopy, gcCopy, CoreGUIStyles.GetButtonMid()))
            {
                returnOperation.copyIndex = true;
            }

            if (this.instance.conditions[i] != null && GUI.Button(rectDuplicate, gcDuplicate, CoreGUIStyles.GetButtonMid()))
            {
                returnOperation.duplicateIndex = true;
            }

            if (GUI.Button(rectDelete, gcDelete, CoreGUIStyles.GetButtonRight()))
            {
                returnOperation.removeIndex = true;
            }

            return(returnOperation);
        }
        private ItemReturnOperation PaintActionHeader(int i)
        {
            ItemReturnOperation returnOperation = new ItemReturnOperation();

            Color defaultBackgroundColor = GUI.backgroundColor;

            if (this.spExecutingIndex.intValue == i)
            {
                GUI.backgroundColor = COLOR_EXECUTING_ACTION;
            }

            Rect rectHeader = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());

            this.PaintDragHandle(i, rectHeader);

            Texture2D icon = (i < this.subEditors.Length && this.subEditors[i] != null ?
                              this.subEditors[i].GetIcon()
                : null
                              );

            string name = (this.isExpanded[i].target ? " ▾ " : " ▸ ");

            name += (this.instance.actions[i] != null
                ? this.instance.actions[i].GetNodeTitle()
                : "<i>Undefined Action</i>"
                     );

            GUIStyle style = (this.isExpanded[i].target
                ? CoreGUIStyles.GetToggleButtonMidOn()
                : CoreGUIStyles.GetToggleButtonMidOff()
                              );

            float opacity = 1.0f;

            if (this.subEditors[i] != null && this.subEditors[i].action != null)
            {
                opacity = this.subEditors[i].action.GetOpacity();
            }

            Color tempColor = style.normal.textColor;

            style.normal.textColor = new Color(
                style.normal.textColor.r,
                style.normal.textColor.g,
                style.normal.textColor.b,
                opacity
                );

            Rect rectDelete = new Rect(
                rectHeader.x + rectHeader.width - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectDuplicate = new Rect(
                rectDelete.x - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectCopy = new Rect(
                rectDuplicate.x - 25f,
                rectHeader.y,
                25f,
                rectHeader.height
                );

            Rect rectMain = new Rect(
                rectHeader.x + 25f,
                rectHeader.y,
                rectHeader.width - (25f * 4f),
                rectHeader.height
                );

            if (GUI.Button(rectMain, new GUIContent(name, icon), style))
            {
                this.ToggleExpand(i);
            }

            style.normal.textColor = tempColor;

            GUIContent gcCopy      = ClausesUtilities.Get(ClausesUtilities.Icon.Copy);
            GUIContent gcDuplicate = ClausesUtilities.Get(ClausesUtilities.Icon.Duplicate);
            GUIContent gcDelete    = ClausesUtilities.Get(ClausesUtilities.Icon.Delete);

            if (this.instance.actions[i] != null && GUI.Button(rectCopy, gcCopy, CoreGUIStyles.GetButtonMid()))
            {
                returnOperation.copyIndex = true;
            }

            if (this.instance.actions[i] != null && GUI.Button(rectDuplicate, gcDuplicate, CoreGUIStyles.GetButtonMid()))
            {
                returnOperation.duplicateIndex = true;
            }

            if (GUI.Button(rectDelete, gcDelete, CoreGUIStyles.GetButtonRight()))
            {
                returnOperation.removeIndex = true;
            }

            GUI.backgroundColor = defaultBackgroundColor;

            return(returnOperation);
        }
Example #5
0
        private void PaintConditions()
        {
            if (this.spClauses != null && this.spClauses.arraySize > 0)
            {
                this.PaintClauses();
            }
            else
            {
                EditorGUILayout.HelpBox(MSG_EMTPY_CONDITIONS, MessageType.None);
            }

            float widthAddClause = 100f;
            Rect  rectControls   = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
            Rect  rectAddClause  = new Rect(
                rectControls.x + (rectControls.width / 2.0f) - (widthAddClause + 25f) / 2.0f,
                rectControls.y,
                widthAddClause,
                rectControls.height
                );

            Rect rectPaste = new Rect(
                rectAddClause.x + rectAddClause.width,
                rectControls.y,
                25f,
                rectControls.height
                );

            if (GUI.Button(rectAddClause, "Add Clause", CoreGUIStyles.GetButtonLeft()))
            {
                Clause clauseCreated = this.instance.gameObject.AddComponent <Clause>();

                int clauseCreatedIndex = this.spClauses.arraySize;
                this.spClauses.InsertArrayElementAtIndex(clauseCreatedIndex);
                this.spClauses.GetArrayElementAtIndex(clauseCreatedIndex).objectReferenceValue = clauseCreated;

                this.AddSubEditorElement(clauseCreated, -1, true);

                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            GUIContent gcPaste = ClausesUtilities.Get(ClausesUtilities.Icon.Paste);

            EditorGUI.BeginDisabledGroup(CLIPBOARD_CLAUSE == null);
            if (GUI.Button(rectPaste, gcPaste, CoreGUIStyles.GetButtonRight()))
            {
                Clause copy = this.instance.gameObject.AddComponent <Clause>();
                EditorUtility.CopySerialized(CLIPBOARD_CLAUSE, copy);

                if (copy.conditionsList != null)
                {
                    IConditionsList conditionsListSource = copy.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    ConditionsEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(copy);
                    soCopy.FindProperty(ClauseEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedPropertiesWithoutUndo();
                    soCopy.Update();
                }

                int clauseIndex = this.spClauses.arraySize;
                this.spClauses.InsertArrayElementAtIndex(clauseIndex);
                this.spClauses.GetArrayElementAtIndex(clauseIndex).objectReferenceValue = copy;

                this.AddSubEditorElement(copy, -1, true);

                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();

                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
                DestroyImmediate(CLIPBOARD_CLAUSE.gameObject, true);
                CLIPBOARD_CLAUSE = null;
            }
            EditorGUI.EndDisabledGroup();

            GUIContent gcElse   = ClausesUtilities.Get(ClausesUtilities.Icon.Else);
            Rect       rectElse = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.boldLabel);

            EditorGUI.LabelField(rectElse, gcElse, EditorStyles.boldLabel);

            ActionsEditor.Return returnActions = ActionsEditor.PaintActionsGUI(
                this.instance.gameObject,
                this.spDefaultActions,
                this.actionsEditor
                );

            if (returnActions != null)
            {
                this.spDefaultActions = returnActions.spParentActions;
                this.actionsEditor    = returnActions.parentActionsEditor;

                serializedObject.ApplyModifiedPropertiesWithoutUndo();
                serializedObject.Update();
            }

            EditorGUILayout.Space();
        }
Example #6
0
        private void PaintClauses()
        {
            int removeClauseIndex    = -1;
            int duplicateClauseIndex = -1;
            int copyClauseIndex      = -1;

            bool forceRepaint = false;
            int  clauseSize   = this.spClauses.arraySize;

            for (int i = 0; i < clauseSize; ++i)
            {
                if (this.subEditors == null || i >= this.subEditors.Length || this.subEditors[i] == null)
                {
                    continue;
                }

                bool repaint = this.editorSortableList.CaptureSortEvents(this.subEditors[i].handleDragRect, i);
                forceRepaint = repaint || forceRepaint;

                EditorGUILayout.BeginVertical();
                Rect rectHeader = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOn());
                this.PaintDragHandle(i, rectHeader);

                EditorGUIUtility.AddCursorRect(this.subEditors[i].handleDragRect, MouseCursor.Pan);
                string   name  = (this.isExpanded[i].target ? "▾ " : "▸ ") + this.instance.clauses[i].description;
                GUIStyle style = (this.isExpanded[i].target
                                        ? CoreGUIStyles.GetToggleButtonMidOn()
                                        : CoreGUIStyles.GetToggleButtonMidOff()
                                  );

                Rect rectDelete = new Rect(
                    rectHeader.x + rectHeader.width - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectDuplicate = new Rect(
                    rectDelete.x - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectCopy = new Rect(
                    rectDuplicate.x - 25f,
                    rectHeader.y,
                    25f,
                    rectHeader.height
                    );

                Rect rectMain = new Rect(
                    rectHeader.x + 25f,
                    rectHeader.y,
                    rectHeader.width - (25f * 4f),
                    rectHeader.height
                    );

                if (GUI.Button(rectMain, name, style))
                {
                    this.ToggleExpand(i);
                }

                GUIContent gcCopy      = ClausesUtilities.Get(ClausesUtilities.Icon.Copy);
                GUIContent gcDuplicate = ClausesUtilities.Get(ClausesUtilities.Icon.Duplicate);
                GUIContent gcDelete    = ClausesUtilities.Get(ClausesUtilities.Icon.Delete);

                if (GUI.Button(rectCopy, gcCopy, CoreGUIStyles.GetButtonMid()))
                {
                    copyClauseIndex = i;
                }

                if (GUI.Button(rectDuplicate, gcDuplicate, CoreGUIStyles.GetButtonMid()))
                {
                    duplicateClauseIndex = i;
                }

                if (GUI.Button(rectDelete, gcDelete, CoreGUIStyles.GetButtonRight()))
                {
                    if (EditorUtility.DisplayDialog(MSG_REMOVE_TITLE, MSG_REMOVE_DESCR, "Yes", "Cancel"))
                    {
                        removeClauseIndex = i;
                    }
                }

                using (var group = new EditorGUILayout.FadeGroupScope(this.isExpanded[i].faded))
                {
                    if (group.visible)
                    {
                        EditorGUILayout.BeginVertical(CoreGUIStyles.GetBoxExpanded());
                        this.subEditors[i].OnClauseGUI();
                        EditorGUILayout.EndVertical();
                    }
                }

                EditorGUILayout.EndVertical();
                if (UnityEngine.Event.current.type == EventType.Repaint)
                {
                    this.subEditors[i].clauseRect = GUILayoutUtility.GetLastRect();
                }

                this.editorSortableList.PaintDropPoints(this.subEditors[i].clauseRect, i, clauseSize);
            }

            if (copyClauseIndex >= 0)
            {
                Clause     source       = (Clause)this.subEditors[copyClauseIndex].target;
                GameObject copyInstance = EditorUtility.CreateGameObjectWithHideFlags(
                    "Clause (Copy)",
                    HideFlags.HideAndDontSave
                    );

                CLIPBOARD_CLAUSE = (Clause)copyInstance.AddComponent(source.GetType());
                EditorUtility.CopySerialized(source, CLIPBOARD_CLAUSE);

                if (CLIPBOARD_CLAUSE.conditionsList != null)
                {
                    IConditionsList conditionsListSource = CLIPBOARD_CLAUSE.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    ConditionsEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(CLIPBOARD_CLAUSE);
                    soCopy.FindProperty(ClauseEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;
                    soCopy.ApplyModifiedPropertiesWithoutUndo();
                    soCopy.Update();
                }
            }

            if (duplicateClauseIndex >= 0)
            {
                int srcIndex = duplicateClauseIndex;
                int dstIndex = duplicateClauseIndex + 1;

                Clause source = (Clause)this.subEditors[srcIndex].target;
                Clause copy   = (Clause)this.instance.gameObject.AddComponent(source.GetType());
                EditorUtility.CopySerialized(source, copy);

                if (copy.conditionsList != null)
                {
                    IConditionsList conditionsListSource = copy.conditionsList;
                    IConditionsList conditionsListCopy   = this.instance.gameObject.AddComponent <IConditionsList>();

                    EditorUtility.CopySerialized(conditionsListSource, conditionsListCopy);
                    ConditionsEditor.DuplicateIConditionList(conditionsListSource, conditionsListCopy);

                    SerializedObject soCopy = new SerializedObject(copy);
                    soCopy.FindProperty(ClauseEditor.PROP_CONDITIONSLIST).objectReferenceValue = conditionsListCopy;

                    if (!Application.isPlaying)
                    {
                        EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                    }
                    soCopy.ApplyModifiedPropertiesWithoutUndo();
                    soCopy.Update();
                }

                this.spClauses.InsertArrayElementAtIndex(dstIndex);
                this.spClauses.GetArrayElementAtIndex(dstIndex).objectReferenceValue = copy;

                this.spClauses.serializedObject.ApplyModifiedPropertiesWithoutUndo();
                this.spClauses.serializedObject.Update();

                this.AddSubEditorElement(copy, dstIndex, true);
            }

            if (removeClauseIndex >= 0)
            {
                this.subEditors[removeClauseIndex].OnDestroyClause();
                Clause rmClause = (Clause)this.spClauses
                                  .GetArrayElementAtIndex(removeClauseIndex).objectReferenceValue;

                this.spClauses.DeleteArrayElementAtIndex(removeClauseIndex);
                this.spClauses.RemoveFromObjectArrayAt(removeClauseIndex);

                DestroyImmediate(rmClause, true);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
            }

            EditorSortableList.SwapIndexes swapIndexes = this.editorSortableList.GetSortIndexes();
            if (swapIndexes != null)
            {
                this.spClauses.MoveArrayElement(swapIndexes.src, swapIndexes.dst);
                this.MoveSubEditorsElement(swapIndexes.src, swapIndexes.dst);
                if (!Application.isPlaying)
                {
                    EditorSceneManager.MarkSceneDirty(this.instance.gameObject.scene);
                }
            }

            if (forceRepaint)
            {
                this.Repaint();
            }
        }
Example #7
0
        private void PaintItems()
        {
            int  itemsCount   = this.spItems.arraySize;
            int  removeIndex  = -1;
            bool forceRepaint = false;

            GUIContent gcDelete = ClausesUtilities.Get(ClausesUtilities.Icon.Delete);

            for (int i = 0; i < itemsCount; ++i)
            {
                SerializedProperty spItem        = this.spItems.GetArrayElementAtIndex(i);
                SerializedProperty spIOption     = spItem.FindPropertyRelative(PROP_OPTION);
                SerializedProperty spIActions    = spItem.FindPropertyRelative(PROP_ACTIONS);
                SerializedProperty spIConditions = spItem.FindPropertyRelative(PROP_CONDITIONS);

                Rect rectItem = GUILayoutUtility.GetRect(GUIContent.none, CoreGUIStyles.GetToggleButtonNormalOff());

                Rect rectHandle = new Rect(
                    rectItem.x,
                    rectItem.y,
                    25f,
                    rectItem.height
                    );

                Rect rectToggle = new Rect(
                    rectHandle.x + rectHandle.width,
                    rectHandle.y,
                    25f,
                    rectHandle.height
                    );

                Rect rectDelete = new Rect(
                    rectItem.x + (rectItem.width - 25f),
                    rectToggle.y,
                    25f,
                    rectToggle.height
                    );

                Rect rectCont = new Rect(
                    rectToggle.x + rectToggle.width,
                    rectToggle.y,
                    rectItem.width - (rectHandle.width + rectToggle.width + rectDelete.width),
                    rectToggle.height
                    );

                GUI.Label(rectHandle, "=", CoreGUIStyles.GetButtonLeft());
                bool forceSortRepaint = this.sortableList.CaptureSortEvents(rectHandle, i);
                forceRepaint = forceSortRepaint || forceRepaint;

                EditorGUIUtility.AddCursorRect(rectHandle, MouseCursor.Pan);

                GUIContent gcToggle = null;
                if (spIOption.intValue == (int)Trigger.ItemOpts.Actions)
                {
                    gcToggle = GC_ACTIONS;
                }
                if (spIOption.intValue == (int)Trigger.ItemOpts.Conditions)
                {
                    gcToggle = GC_CONDITIONS;
                }

                if (GUI.Button(rectToggle, gcToggle, CoreGUIStyles.GetButtonMid()))
                {
                    switch (spIOption.intValue)
                    {
                    case (int)Trigger.ItemOpts.Actions:
                        spIOption.intValue = (int)Trigger.ItemOpts.Conditions;
                        break;

                    case (int)Trigger.ItemOpts.Conditions:
                        spIOption.intValue = (int)Trigger.ItemOpts.Actions;
                        break;
                    }
                }

                GUI.Label(rectCont, string.Empty, CoreGUIStyles.GetButtonMid());
                Rect rectField = new Rect(
                    rectCont.x + 2f,
                    rectCont.y + (rectCont.height / 2f - EditorGUIUtility.singleLineHeight / 2f),
                    rectCont.width - 7f,
                    EditorGUIUtility.singleLineHeight
                    );

                switch (spIOption.intValue)
                {
                case (int)Trigger.ItemOpts.Actions:
                    EditorGUI.PropertyField(rectField, spIActions, GUIContent.none, true);
                    break;

                case (int)Trigger.ItemOpts.Conditions:
                    EditorGUI.PropertyField(rectField, spIConditions, GUIContent.none, true);
                    break;
                }


                if (GUI.Button(rectDelete, gcDelete, CoreGUIStyles.GetButtonRight()))
                {
                    removeIndex = i;
                }

                this.sortableList.PaintDropPoints(rectItem, i, itemsCount);
            }

            if (removeIndex != -1 && removeIndex < this.spItems.arraySize)
            {
                SerializedProperty spItem        = this.spItems.GetArrayElementAtIndex(removeIndex);
                SerializedProperty spIOption     = spItem.FindPropertyRelative(PROP_OPTION);
                SerializedProperty spIActions    = spItem.FindPropertyRelative(PROP_ACTIONS);
                SerializedProperty spIConditions = spItem.FindPropertyRelative(PROP_CONDITIONS);
                UnityEngine.Object @object       = null;
                switch (spIOption.intValue)
                {
                case (int)Trigger.ItemOpts.Actions: @object = spIActions.objectReferenceValue; break;

                case (int)Trigger.ItemOpts.Conditions: @object = spIConditions.objectReferenceValue; break;
                }

                this.spItems.DeleteArrayElementAtIndex(removeIndex);
            }

            EditorSortableList.SwapIndexes swapIndexes = this.sortableList.GetSortIndexes();
            if (swapIndexes != null)
            {
                this.spItems.MoveArrayElement(swapIndexes.src, swapIndexes.dst);
            }

            if (forceRepaint)
            {
                this.Repaint();
            }
        }