using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;

using System.Text;
using System.Windows.Forms;
using CommonAI.Zone.ZoneEditor;
using CommonFroms.Utils;
using System.IO;
using CommonLang.Property;
using SyntaxHighlighter;
using CommonLang.Xml;
using CommonFroms.DescAttributeEdit;
using CommonAI.Zone.ZoneEditor.EventTrigger;
using CommonAI.Zone.EventTrigger;
using CommonFroms.G2D;
using CommonFroms.G2D.DataGrid;
using System.Xml;

namespace CommonAIEditor.EventEditor
{
    public abstract partial class EventEditor : Form
    {
        private G2DTreeNodeGroup rootEvents;
        private TreeNode rootTrigger;
        private TreeNode rootCondition;
        private TreeNode rootAction;
        private TreeNode rootLocalVar;

        private EventTreeNode editEventNode;

        private static IEventDataNode copyEventNode;
        private static object copyEventAward;

        //----------------------------------------------------------------------------------------

        public EventEditor()
        {
            InitializeComponent();

            this.rootEvents = new G2DTreeNodeGroup(this.Text);
            this.rootEvents.ImageKey = "icons_tool_bar2.png";
            this.rootEvents.SelectedImageKey = "icons_tool_bar2.png";
            this.rootEvents.ContextMenuStrip = groupMenuStrip;
            this.treeViewEvents.Nodes.Add(rootEvents);

            this.rootLocalVar = treeView2.Nodes["RootLocalVar"];
            this.rootTrigger = treeView2.Nodes["RootTrigger"];
            this.rootCondition = treeView2.Nodes["RootCondition"];
            this.rootAction = treeView2.Nodes["RootAction"];
            this.treeView2.DrawMode = TreeViewDrawMode.OwnerDrawText;
            this.treeView2.DrawNode += TreeView2_DrawNode;
        }
        //----------------------------------------------------------------------------------------

        public event Action<EventEditor> OnDataSaved;
        public event Action<EventEditor> OnDataLoaded;

        //----------------------------------------------------------------------------------------
        #region ABSTRACT

        public abstract List<IEventDataNode> LoadEventDataNodes();

        public abstract void OnSave(List<IEventDataNode> events);

        public abstract IEventDataNode CreateEventDataNode();

        public abstract IG2DPropertyAdapter[] CreatePropertyAdapters();

        #endregion
        //----------------------------------------------------------------------------------------
        private void EventEditor_Load(object sender, EventArgs e)
        {
            LoadData();
            this.rootEvents.Text = "事件列表";
            //             this.treeViewEvents.ExpandAll();
            //             this.treeView2.ExpandAll();
            this.rootEvents.Expand();
        }

        private void EventEditor_Validating(object sender, CancelEventArgs e)
        {
        }

        private void LoadData()
        {
            foreach (IEventDataNode evt in LoadEventDataNodes())
            {
                LoadZoneEvent(evt);
            }
            if (OnDataLoaded != null)
                OnDataLoaded.Invoke(this);
        }
        public void Save()
        {
            OnSelectEventObject(editEventNode);
            List<IEventDataNode> events = new List<IEventDataNode>();
            foreach (TreeNode tn in rootEvents.GetAllNodes())
            {
                if (tn is EventTreeNode)
                {
                    EventTreeNode otn = tn as EventTreeNode;
                    otn.Data.EventTreePath = rootEvents.GetSavePath(otn);
                    events.Add(otn.Data);
                }
            }
            OnSave(events);
            if (OnDataSaved != null)
                OnDataSaved.Invoke(this);
        }
        
        public void LoadTreeInfo(XmlElement events)
        {
            if (events != null)
            {
                G2DTreeNodeGroup.SetTreeInfo(events, rootEvents);
            }
        }
        public void SaveTreeInfo(XmlElement events)
        {
            G2DTreeNodeGroup.GetTreeInfo(events, rootEvents);
        }

        //----------------------------------------------------------------------------------------

        public class EventTreeNode : G2DTreeNode<IEventDataNode>
        {
            public EventTreeNode(IEventDataNode data, EventEditor editor)
                : base(data)
            {
                this.ImageKey = "icon_quest.png";
                this.SelectedImageKey = "icon_quest.png";
                this.ContextMenuStrip = editor.groupMenuStrip;
                RefreshData();
            }

            public void RefreshData()
            {
                if (!Data.EventIsActive)
                {
                    this.ForeColor = Color.LightGray;
                }
                else
                {
                    this.ForeColor = Color.Black;
                }
            }
        }

        //----------------------------------------------------------------------------------------

        private void AddGroup()
        {
            G2DTreeNodeGroup parent = GetSelectedGroup();
            if (parent != null)
            {
                string name = G2DTextDialog.Show("分组", "添加过滤器");
                if (name != null)
                {
                    G2DTreeNodeGroup group = parent.AddG2DGroup(name);
                    parent.Expand();
                    treeViewEvents.SelectedNode = group;
                }
            }
        }
        private void LoadZoneEvent(IEventDataNode data)
        {
            if (ContainsEvent(data.EventName))
            {
                MessageBox.Show("\"" + data.EventName + "\" 已存在!");
            }
            else
            {
                EventTreeNode node = new EventTreeNode(data, this);
                G2DTreeNodeGroup parent = rootEvents.GetOrCreateGroup(data.EventTreePath);
                parent.Nodes.Add(node);
            }
        }
        private void AddZoneEvent()
        {
            G2DTreeNodeGroup parent = GetSelectedGroup();
            if (parent != null)
            {
                string name = "未命名事件" + rootEvents.GetAllNodes().Count;
                while (!string.IsNullOrEmpty(name))
                {
                    name = G2DTextDialog.Show(name, "新建事件");
                    if (name != null)
                    {
                        if (ContainsEvent(name))
                        {
                            MessageBox.Show("\"" + name + "\" 已存在!");
                        }
                        else
                        {
                            IEventDataNode data = CreateEventDataNode();
                            data.EventName = name;
                            EventTreeNode node = new EventTreeNode(data, this);
                            parent.Nodes.Add(node);
                            parent.Expand();
                            treeViewEvents.SelectedNode = node;
                            return;
                        }
                    }
                }
            }
        }
        private string BestNewName(string name)
        {
            if (ContainsEvent(name))
            {
                int i = name.Length - 1;
                for (; i >= 0; --i)
                {
                    char ch = name[i];
                    if (ch >= '0' && ch <= '9')
                    {
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
                name = name.Substring(0, i + 1);
            }
            return name + rootEvents.GetAllNodes().Count;
        }
        private void CloneZoneEvent(IEventDataNode data)
        {
            G2DTreeNodeGroup parent = GetSelectedGroup();
            int index = parent.Nodes.Count;
            TreeNode selected = GetSelectedEvent();
            if (selected != null)
            {
                index = parent.Nodes.IndexOf(selected) + 1;
            }
            if (data != null && parent != null)
            {
                data = XmlUtil.CloneObject<IEventDataNode>(data);
                string name = data.EventName;
                if (ContainsEvent(name))
                {
                    name = BestNewName(name);
                }
                while (!string.IsNullOrEmpty(name))
                {
                    name = G2DTextDialog.Show(name, "复制 " + data.EventName);
                    if (name != null)
                    {
                        if (ContainsEvent(name))
                        {
                            MessageBox.Show("\"" + name + "\" 已存在!");
                        }
                        else
                        {
                            data.EventName = name;
                            EventTreeNode node = new EventTreeNode(data, this);
                            parent.Nodes.Insert(index, node);
                            parent.Expand();
                            treeViewEvents.SelectedNode = node;
                            return;
                        }
                    }
                }
            }
        }
        private void RenameZoneEvent()
        {
            EventTreeNode node = GetSelectedEvent();
            if (node != null)
            {
                string name = node.DataID;
                while (!string.IsNullOrEmpty(name))
                {
                    name = G2DTextDialog.Show(name, "重命名 " + name);
                    if (name != null)
                    {
                        if (ContainsEvent(name))
                        {
                            MessageBox.Show("\"" + name + "\" 已存在!");
                        }
                        else
                        {
                            node.SetDataID(name);
                            return;
                        }
                    }
                }
            }
        }
        private void RemoveZoneEvent()
        {
            EventTreeNode node = GetSelectedEvent();
            if (node != null)
            {
                node.RemoveFromParent();
            }
        }

        private G2DTreeNodeGroup GetSelectedGroup()
        {
            if (treeViewEvents.SelectedNode is G2DTreeNodeGroup)
            {
                return treeViewEvents.SelectedNode as G2DTreeNodeGroup;
            }
            if (treeViewEvents.SelectedNode is EventTreeNode)
            {
                return (treeViewEvents.SelectedNode as EventTreeNode).Parent as G2DTreeNodeGroup;
            }
            return rootEvents;
        }
        private EventTreeNode GetSelectedEvent()
        {
            if (treeViewEvents.SelectedNode is EventTreeNode)
            {
                return treeViewEvents.SelectedNode as EventTreeNode;
            }
            return null;
        }
        private bool ContainsEvent(string name)
        {
            TreeNode tn = G2DTreeNodeBase.FindNodeByText<EventTreeNode>(rootEvents, name, true);
            return tn != null;
        }

        //--------------------------------------------------------------------------------------

        private void treeView_Enter(object sender, EventArgs e)
        {
            //             if (treeViewEvents.Focused)
            //             {
            //                 tool_Edit.Enabled = true;
            //             }
            //             else if (treeView2.Focused)
            //             {
            //                 tool_Edit.Enabled = true;
            //             }
            //             else
            //             {
            //                 tool_Edit.Enabled = false;
            //             }
        }
        private void treeView_Leave(object sender, EventArgs e)
        {
            //             if (treeViewEvents.Focused)
            //             {
            //                 tool_Edit.Enabled = true;
            //             }
            //             else if (treeView2.Focused)
            //             {
            //                 tool_Edit.Enabled = true;
            //             }
            //             else
            //             {
            //                 tool_Edit.Enabled = false;
            //             }
        }

        private void btn_CopyToClipboard_Click(object sender, EventArgs e)
        {
            if (treeViewEvents.Focused)
            {
                TreeNode node = treeViewEvents.SelectedNode;
                if (node != null)
                {
                    Clipboard.SetText(node.Text);
                }
            }
            else if (treeView2.Focused)
            {
                TreeNode node = treeView2.SelectedNode;
                if (node != null)
                {
                    Clipboard.SetText(node.Text);
                }
            }
        }

        private void btn_Copy_Click(object sender, EventArgs e)
        {
            if (treeViewEvents.Focused)
            {
                TreeNode node = treeViewEvents.SelectedNode;
                if (node != null)
                {
                    Clipboard.SetText(node.Text);
                }
                EventTreeNode tn = GetSelectedEvent();
                if (tn != null)
                {
                    copyEventNode = XmlUtil.CloneObject<IEventDataNode>(tn.Data);
                }
            }
            else if (treeView2.Focused)
            {
                TreeNode node = treeView2.SelectedNode;
                if (node != null)
                {
                    Clipboard.SetText(node.Text);
                }
                EventAwardNode obj = GetSelectedEventAwardNode();
                if (obj != null)
                {
                    copyEventAward = XmlUtil.CloneObject<object>(obj.Data);
                }
            }
            else if (txt_EventComment.Focused)
            {
            }
        }
        private void btn_Paste_Click(object sender, EventArgs e)
        {
            if (treeViewEvents.Focused)
            {
                CloneZoneEvent(copyEventNode);
            }
            else if (treeView2.Focused)
            {
                if (copyEventAward != null)
                {
                    AddEvetAwardNode(copyEventAward);
                }
            }
            else if (txt_EventComment.Focused)
            {
            }
        }
        private void btn_Delete_Click(object sender, EventArgs e)
        {
            if (treeViewEvents.Focused)
            {
                if (MessageBox.Show(
                "确认删除事件: " + GetSelectedEvent(),
                "确认删除",
                MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.OK)
                {
                    RemoveZoneEvent();
                }
            }
            else if (treeView2.Focused)
            {
                EventAwardNode obj = GetSelectedEventAwardNode();
                if (obj != null)
                {
                    if (MessageBox.Show(
                      "确认删除: " + obj,
                      "确认删除",
                      MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.OK)
                    {
                        RemoveAward(obj);
                    }
                }
            }
            else if (txt_EventComment.Focused)
            {
            }
        }

        //--------------------------------------------------------------------------------------
        #region groupMenu

        private void menu_AddZoneEvent_Click(object sender, EventArgs e)
        {
            AddZoneEvent();
        }
        private void menu_RenameZoneEvent_Click(object sender, EventArgs e)
        {
            RenameZoneEvent();
        }
        private void menu_AddGroupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AddGroup();
        }
        private void menu_CopyZoneEvent_Click(object sender, EventArgs e)
        {
            EventTreeNode node = GetSelectedEvent();
            if (node != null)
            {
                copyEventNode = XmlUtil.CloneObject<IEventDataNode>(node.Data);
            }
        }
        private void menu_ParseZoneEvent_Click(object sender, EventArgs e)
        {
            CloneZoneEvent(copyEventNode);
        }
        private void menu_DeleteZoneEvent_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show(
                "确认删除事件: " + GetSelectedEvent(),
                "确认删除",
                MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.OK)
            {
                RemoveZoneEvent();
            }
        }

        private void groupMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            bool single = (treeViewEvents.SelectedNode is EventTreeNode);
            bool group = !single;

            menu_AddGroup.Enabled = group;
            menu_AddZoneEvent.Enabled = group;

            menu_CopyZoneEvent.Enabled = single;
            menu_DeleteZoneEvent.Enabled = single;
            menu_RenameZoneEvent.Enabled = single;

            menu_ParseZoneEvent.Enabled = true;
        }

        #endregion

        //----------------------------------------------------------------------------------------------

        #region TreeView_Events

        private void treeViewEvents_ItemDrag(object sender, ItemDragEventArgs e)
        {
            treeViewEvents.DoDragDrop(e.Item, DragDropEffects.Move);
        }
        private void treeViewEvents_DragDrop(object sender, DragEventArgs e)
        {
            Point pos = treeViewEvents.PointToClient(new Point(e.X, e.Y));
            TreeNode dropNode = this.treeViewEvents.GetNodeAt(pos);
            G2DTreeNodeBase child_node = (G2DTreeNodeBase)e.Data.GetData(typeof(EventTreeNode));
            G2DTreeNodeBase group_node = (G2DTreeNodeBase)e.Data.GetData(typeof(G2DTreeNodeGroup));
            if (dropNode is G2DTreeNodeGroup)
            {
                if (child_node == null && group_node == null)
                {
                    MessageBox.Show("error");
                }
                else if (child_node != null)
                {
                    child_node.RemoveFromParent();
                    dropNode.Nodes.Add(child_node);
                    dropNode.Expand();
                    //treeViewEvents.SelectedNode = child_node;
                }
                else if (group_node != dropNode)
                {
                    if (!G2DTreeNodeBase.ContainsChild(group_node, dropNode, true))
                    {
                        group_node.RemoveFromParent();
                        dropNode.Nodes.Add(group_node);
                        dropNode.Expand();
                        //treeViewEvents.SelectedNode = group_node;
                    }
                }
            }
        }
        private void treeViewEvents_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(EventTreeNode)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else if (e.Data.GetDataPresent(typeof(G2DTreeNodeGroup)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }
        private void treeViewEvents_DragOver(object sender, DragEventArgs e)
        {
            Point pos = treeViewEvents.PointToClient(new Point(e.X, e.Y));
            TreeNode dropNode = this.treeViewEvents.GetNodeAt(pos);
            if (dropNode is G2DTreeNodeBase)
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }
        private void treeViewEvents_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            treeViewEvents.SelectedNode = e.Node;
        }
        private void treeViewEvents_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            treeViewEvents.SelectedNode = e.Node;
        }
        private void treeViewEvents_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (e.Node is EventTreeNode)
            {
                splitContainerEventData.Enabled = true;
                OnSelectEventObject(e.Node as EventTreeNode);
            }
            else
            {
                splitContainerEventData.Enabled = false;
                OnSelectEventObject(null);
            }
        }

        private void treeViewEvents_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                if (MessageBox.Show("确认删除事件 " + GetSelectedEvent(), "确认删除", MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.OK)
                {
                    RemoveZoneEvent();
                }
            }
        }
        private void treeViewEvents_KeyPress(object sender, KeyPressEventArgs e)
        {
        }

        #endregion

        //-------------------------------------------------------------------------------------------------------

        class EventAwardNode : TreeNode
        {
            public object Data { get; private set; }
            public Type BaseDataType { get; private set; }
            public TypeDescAttribute Desc { get; private set; }

            public EventAwardNode(object data)
            {
                if (data is LocalVar)
                {
                    this.BaseDataType = typeof(LocalVar);
                }
                else if (data is AbstractTrigger)
                {
                    this.BaseDataType = typeof(AbstractTrigger);
                }
                else if (data is AbstractCondition)
                {
                    this.BaseDataType = typeof(AbstractCondition);
                }
                else if (data is AbstractAction)
                {
                    this.BaseDataType = typeof(AbstractAction);
                }
                else
                {
                    throw new Exception("对象必须为，临时变量，事件，条件，动作。");
                }

                this.Data = data;
                this.Text = data.ToString();
                this.Desc = new TypeDescAttribute(BaseDataType);

            }

            public void SetData(object data)
            {
                this.Data = data;
                this.Text = data.ToString();
            }

            public void Refresh()
            {
                this.Text = Data.ToString();
            }

            public void Draw(DrawTreeNodeEventArgs e)
            {
                // Draw the background and node text for a selected node.
                if ((e.State & TreeNodeStates.Selected) != 0)
                {
                    // Draw the background of the selected node. The NodeBounds
                    // method makes the highlight rectangle large enough to
                    // include the text of a node tag, if one is present.
                    e.Graphics.FillRectangle(Brushes.Green, NodeBounds(e.Node));

                    // Retrieve the node font. If the node font has not been set,
                    // use the TreeView font.
                    Font nodeFont = e.Node.NodeFont;
                    if (nodeFont == null) nodeFont = TreeView.Font;

                    // Draw the node text.
                    e.Graphics.DrawString(e.Node.Text, nodeFont, Brushes.White,
                        Rectangle.Inflate(e.Bounds, 2, 0));
                }

                // Use the default background and node text.
                else
                {
                    e.DrawDefault = true;
                }

                // If a node tag is present, draw its string representation 
                // to the right of the label text.
                if (e.Node.Tag != null)
                {
                    e.Graphics.DrawString(e.Node.Tag.ToString(), TreeView.Font,
                        Brushes.Yellow, e.Bounds.Right + 2, e.Bounds.Top);
                }

                // If the node has focus, draw the focus rectangle large, making
                // it large enough to include the text of the node tag, if present.
                if ((e.State & TreeNodeStates.Focused) != 0)
                {
                    using (Pen focusPen = new Pen(Color.Black))
                    {
                        focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
                        Rectangle focusBounds = NodeBounds(e.Node);
                        focusBounds.Size = new Size(focusBounds.Width - 1,
                        focusBounds.Height - 1);
                        e.Graphics.DrawRectangle(focusPen, focusBounds);
                    }
                }
            }
            // Returns the bounds of the specified node, including the region 
            // occupied by the node label and any node tag displayed.
            private Rectangle NodeBounds(TreeNode node)
            {
                // Set the return value to the normal node bounds.
                Rectangle bounds = node.Bounds;
                if (node.Tag != null)
                {
                    // Retrieve a Graphics object from the TreeView handle
                    // and use it to calculate the display width of the tag.
                    Graphics g = TreeView.CreateGraphics();
                    int tagWidth = (int)g.MeasureString(node.Tag.ToString(), TreeView.Font).Width + 6;

                    // Adjust the node bounds using the calculated value.
                    bounds.Offset(tagWidth / 2, 0);
                    bounds = Rectangle.Inflate(bounds, tagWidth / 2, 0);
                    bounds.Height += 100;
                    g.Dispose();
                }

                return bounds;

            }

        }
        private void TreeView2_DrawNode(object sender, DrawTreeNodeEventArgs e)
        {
            if (e.Node is EventAwardNode)
            {
                //(e.Node as EventAwardNode).Draw(e);
                e.DrawDefault = true;
            }
            else
            {
                e.DrawDefault = true;
            }
        }


        private EventAwardNode GetSelectedEventAwardNode()
        {
            if (editEventNode != null && treeView2.SelectedNode != null)
            {
                return treeView2.SelectedNode as EventAwardNode;
            }
            return null;
        }
        private EventAwardNode SetSelectedEventAwardNode(object data)
        {
            foreach (TreeNode tn in G2DTreeNodeBase.GetAllNodes(treeView2.Nodes))
            {
                if (tn is EventAwardNode)
                {
                    EventAwardNode ean = tn as EventAwardNode;
                    if (ean.Data == data)
                    {
                        treeView2.SelectedNode = ean;
                        return ean;
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 事件节点选择
        /// 会将右边的数据保存，并初始化新的右边编辑栏
        /// </summary>
        /// <param name="node"></param>
        private void OnSelectEventObject(EventTreeNode node)
        {
            if (editEventNode != null)
            {
                editEventNode.Data.EventIsActive = chk_EnableEvent.Checked;
                editEventNode.Data.EventComment = txt_EventComment.Text;
                editEventNode.Data.EventDelayTimeMS = (int)numericDelayTimeMS.Value;
                editEventNode.Data.EventLocalVars.Clear();
                editEventNode.Data.EventTriggers.Clear();
                editEventNode.Data.EventConditions.Clear();
                editEventNode.Data.EventActions.Clear();
                foreach (TreeNode tn in G2DTreeNodeBase.GetAllNodes(treeView2.Nodes))
                {
                    if (tn is EventAwardNode)
                    {
                        EventAwardNode ean = tn as EventAwardNode;
                        if (ean.Data is LocalVar)
                        {
                            editEventNode.Data.EventLocalVars.Add(ean.Data as LocalVar);
                        }
                        else if (ean.Data is AbstractTrigger)
                        {
                            editEventNode.Data.EventTriggers.Add(ean.Data as AbstractTrigger);
                        }
                        else if (ean.Data is AbstractCondition)
                        {
                            editEventNode.Data.EventConditions.Add(ean.Data as AbstractCondition);
                        }
                        else if (ean.Data is AbstractAction)
                        {
                            editEventNode.Data.EventActions.Add(ean.Data as AbstractAction);
                        }
                    }
                }
            }
            editEventNode = node;
            if (node != null)
            {
                chk_EnableEvent.Checked = node.Data.EventIsActive;
                txt_EventComment.Text = node.Data.EventComment;
                txt_EventFunction.Text = node.Data.FunctionText();
                numericDelayTimeMS.Value = node.Data.EventDelayTimeMS;
                rootLocalVar.Nodes.Clear();
                rootTrigger.Nodes.Clear();
                rootCondition.Nodes.Clear();
                rootAction.Nodes.Clear();

                foreach (LocalVar data in node.Data.EventLocalVars)
                {
                    AddEvetAwardNode(data);
                }
                foreach (AbstractTrigger data in node.Data.EventTriggers)
                {
                    AddEvetAwardNode(data);
                }
                foreach (AbstractCondition data in node.Data.EventConditions)
                {
                    AddEvetAwardNode(data);
                }
                foreach (AbstractAction data in node.Data.EventActions)
                {
                    AddEvetAwardNode(data);
                }
            }
            this.treeView2.ExpandAll();
        }
        private void AddEvetAwardNode(object data)
        {
            if (data != null)
            {
                EventAwardNode node = new EventAwardNode(data);
                if (data is LocalVar)
                {
                    node.ImageKey = node.SelectedImageKey = "icon_var.png";
                    node.ContextMenuStrip = rootTrigger.ContextMenuStrip;
                    rootLocalVar.Nodes.Add(node);
                }
                else if (data is AbstractTrigger)
                {
                    node.ImageKey = node.SelectedImageKey = "icon_quest_event.png";
                    node.ContextMenuStrip = rootTrigger.ContextMenuStrip;
                    rootTrigger.Nodes.Add(node);
                }
                else if (data is AbstractCondition)
                {
                    node.ImageKey = node.SelectedImageKey = "icon_quest_condition.png";
                    node.ContextMenuStrip = rootCondition.ContextMenuStrip;
                    rootCondition.Nodes.Add(node);
                }
                else if (data is AbstractAction)
                {
                    node.ImageKey = node.SelectedImageKey = "icon_quest_result.png";
                    node.ContextMenuStrip = rootAction.ContextMenuStrip;
                    rootAction.Nodes.Add(node);
                }
            }
        }
        private void AddEventLocalVar()
        {
            if (editEventNode != null)
            {
                LocalVar result = ValueTypeDialog.ShowAddDialog<LocalVar>(
                    this, "设置: 临时变量", CreatePropertyAdapters());
                if (result != null)
                {
                    AddEvetAwardNode(result);
                    OnSelectEventObject(editEventNode);
                }
            }
        }
        private void AddEventTrigger()
        {
            if (editEventNode != null)
            {
                AbstractTrigger result = ValueTypeDialog.ShowAddDialog<AbstractTrigger>(this, "设置: 触发器", CreatePropertyAdapters());
                if (result != null)
                {
                    AddEvetAwardNode(result);
                    OnSelectEventObject(editEventNode);
                }
            }
        }
        private void AddEventCondition()
        {
            if (editEventNode != null)
            {
                AbstractCondition result = ValueTypeDialog.ShowAddDialog<AbstractCondition>(this, "设置: 条件", CreatePropertyAdapters());
                if (result != null)
                {
                    AddEvetAwardNode(result);
                    OnSelectEventObject(editEventNode);
                }
            }
        }
        private void AddEventAction()
        {
            if (editEventNode != null)
            {
                AbstractAction result = ValueTypeDialog.ShowAddDialog<AbstractAction>(this, "设置: 动作", CreatePropertyAdapters());
                if (result != null)
                {
                    AddEvetAwardNode(result);
                    OnSelectEventObject(editEventNode);
                }
            }
        }
        private void OpenEventAwardNode(EventAwardNode node)
        {
            if (editEventNode != null)
            {
                object result = ValueTypeDialog.ShowEditDialog(this, "设置: " + node.Data, node.BaseDataType, node.Data, CreatePropertyAdapters());
                if (result != null)
                {
                    node.SetData(result);
                    OnSelectEventObject(editEventNode);
                }
            }
        }
        private void RemoveAward(EventAwardNode obj)
        {
            obj.Remove();
            treeView2.Refresh();
            if (editEventNode != null)
            {
                OnSelectEventObject(editEventNode);
            }
        }

        private void MoveAward(EventAwardNode obj, int d)
        {
            try
            {
                TreeNode parent = obj.Parent;
                if (d < 0)
                {
                    TreeNode prev = obj.PrevNode;
                    if (prev != null)
                    {
                        obj.Remove();
                        parent.Nodes.Insert(parent.Nodes.IndexOf(prev), obj);
                    }
                }
                else if (d > 0)
                {
                    TreeNode next = obj.NextNode;
                    if (next != null)
                    {
                        obj.Remove();
                        parent.Nodes.Insert(parent.Nodes.IndexOf(next) + 1, obj);
                    }
                }
                OnSelectEventObject(editEventNode);
                SetSelectedEventAwardNode(obj.Data);
                treeView2.Select();
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        //----------------------------------------------------------------------------------------

        public LocalVar GetSelectedEventLocalVar(string key)
        {
            if (editEventNode != null)
            {
                foreach (LocalVar lcv in editEventNode.Data.EventLocalVars)
                {
                    if (string.Equals(key, lcv.Key))
                    {
                        return lcv;
                    }
                }
            }
            return null;
        }

        public LocalVar ShowSelectLocalVar(string srcKey, Type valueType)
        {
            if (editEventNode != null)
            {
                List<LocalVar> vars = new List<LocalVar>();
                foreach (LocalVar lcv in editEventNode.Data.EventLocalVars)
                {
                    if (valueType == null || valueType.IsInstanceOfType(lcv.GetAbstractValue()))
                    {
                        vars.Add(lcv);
                    }
                }
                LocalVar src = GetSelectedEventLocalVar(srcKey);
                G2DListSelectEditor<LocalVar> dialog = new G2DListSelectEditor<LocalVar>(vars, src);
                if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    return dialog.SelectedObject;
                }
            }
            return null;
        }



        #region TreeView_EventData



        private void chk_EnableEvent_CheckedChanged(object sender, EventArgs e)
        {
            EventTreeNode evt = GetSelectedEvent();
            if (evt != null)
            {
                evt.Data.EventIsActive = chk_EnableEvent.Checked;
                evt.RefreshData();
            }
        }
        private void txt_EventComment_TextChanged(object sender, EventArgs e) { }


        // tree view 2

        private void treeView2_AfterSelect(object sender, TreeViewEventArgs e)
        {

        }
        private void treeView2_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            treeView2.SelectedNode = e.Node;
        }
        private void treeView2_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                OpenEventAwardNode(obj);
            }
        }

        private void treeView2_KeyPress(object sender, KeyPressEventArgs e)
        {

        }

        private void treeView2_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                EventAwardNode obj = GetSelectedEventAwardNode();
                if (obj != null)
                {
                    RemoveAward(obj);
                }
            }
        }

        // tree view 2 menu

        private void dataMenu_AddLocalVar_Click(object sender, EventArgs e)
        {
            if (editEventNode != null)
            {
                AddEventLocalVar();
            }
        }

        private void dataMenu_AddTrigger_Click(object sender, EventArgs e)
        {
            if (editEventNode != null)
            {
                AddEventTrigger();
            }
        }
        private void dataMenu_AddCondition_Click(object sender, EventArgs e)
        {
            if (editEventNode != null)
            {
                AddEventCondition();
            }
        }
        private void dataMenu_AddAction_Click(object sender, EventArgs e)
        {
            if (editEventNode != null)
            {
                AddEventAction();
            }
        }
        private void dataMenu_Copy_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                copyEventAward = XmlUtil.CloneObject<object>(obj.Data);
            }
        }
        private void dataMenu_Paste_Click(object sender, EventArgs e)
        {
            if (copyEventAward != null)
            {
                AddEvetAwardNode(copyEventAward);
            }
        }
        private void dataMenu_Delete_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                RemoveAward(obj);
            }
        }

        private void btn_moveAwardUP_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                MoveAward(obj, -1);
            }
        }

        private void btn_moveAwardDown_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                MoveAward(obj, 1);
            }
        }

        private void dataMenu_UP_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                MoveAward(obj, -1);
            }
        }

        private void dataMenu_Down_Click(object sender, EventArgs e)
        {
            EventAwardNode obj = GetSelectedEventAwardNode();
            if (obj != null)
            {
                MoveAward(obj, 1);
            }
        }

        private void eventMenuStrip_Opening(object sender, CancelEventArgs e)
        {
            bool single = treeView2.SelectedNode is EventAwardNode;
            bool group = !single;

            dataMenu_AddLocalVar.Enabled = group;
            dataMenu_AddAction.Enabled = group;
            dataMenu_AddCondition.Enabled = group;
            dataMenu_AddTrigger.Enabled = group;

            dataMenu_UP.Enabled = single;
            dataMenu_Down.Enabled = single;
            dataMenu_Copy.Enabled = single;
            dataMenu_Delete.Enabled = single;

            dataMenu_Paste.Enabled = true;
        }


        #endregion



        //------------------------------------------------------------------------------------------------------------

        //----------------------------------------------------------------------------------------


    }
}