private void RemoveTreeNode(TreeNode node)
        {
            if (node == null)
            {
                return;
            }

            if (selectedTreeNode == treeNodeRootConditions)
            {
                RemoveAllConditions();
            }
            else if (selectedTreeNode == treeNodeRootActions)
            {
                RemoveAllActions();
            }
            else if (selectedTreeNode == treeNodeRootFlags)
            {
                RemoveAllFlags();
            }
            else
            {
                NodeCondition condition = node.Tag as NodeCondition;
                NodeAction    action    = node.Tag as NodeAction;
                NodeFlag      flag      = node.Tag as NodeFlag;

                var parent = node.Parent;
                node.Remove();

                if (condition != null)
                {
                    if (parent.Tag is NodeConditionGroup)
                    {
                        ((NodeConditionGroup)parent.Tag).Conditions.Remove(condition);
                    }
                    else
                    {
                        dialogueNode.Conditions.Remove(condition);
                    }
                }
                else if (action != null)
                {
                    dialogueNode.Actions.Remove(action);
                }
                else if (flag != null)
                {
                    dialogueNode.Flags.Remove(flag);
                }
            }

            document.RefreshTreeNode(treeNode);
            document.SetDirty();
        }
        private void AddNodeCondition(NodeCondition condition)
        {
            if (condition != null)
            {
                if (selectedTreeNode == treeNodeRootConditions)
                {
                    dialogueNode.Conditions.Add(condition);
                }
                else if (selectedTreeNode.Tag is NodeConditionGroup)
                {
                    ((NodeConditionGroup)selectedTreeNode.Tag).Conditions.Add(condition);
                }

                AddTreeNodeCondition(condition, selectedTreeNode);

                document.RefreshTreeNode(treeNode);
                document.SetDirty();
            }
        }
        private void OnPropertyGridAttributesChanged(object s, PropertyValueChangedEventArgs e)
        {
            NodeCondition condition = selectedTreeNode.Tag as NodeCondition;
            NodeAction    action    = selectedTreeNode.Tag as NodeAction;
            NodeFlag      flag      = selectedTreeNode.Tag as NodeFlag;

            //Refresh node text
            if (condition != null)
            {
                selectedTreeNode.Text = condition.GetTreeText();
            }
            if (action != null)
            {
                selectedTreeNode.Text = action.GetTreeText();
            }
            if (flag != null)
            {
                selectedTreeNode.Text = flag.GetTreeText();
            }

            document.RefreshTreeNode(treeNode);
            document.SetDirty();
        }
        private void AddTreeNodeCondition(NodeCondition condition, TreeNode parent)
        {
            TreeNode treeNodeAttribute = parent.Nodes.Add(condition.GetTreeText());

            treeNodeAttribute.ContextMenuStrip = menuAttributes;
            treeNodeAttribute.Tag = condition;

            if (condition is NodeConditionGroup)
            {
                EditorHelper.SetNodeIcon(treeNodeAttribute, ENodeIcon.ListItemConditionGroup);

                foreach (NodeCondition subCondition in ((NodeConditionGroup)condition).Conditions)
                {
                    AddTreeNodeCondition(subCondition, treeNodeAttribute);
                }
            }
            else
            {
                EditorHelper.SetNodeIcon(treeNodeAttribute, ENodeIcon.ListItemCondition);
            }

            parent.ExpandAll();
        }