WSHCommon/GameEditor/Scene/SceneEditor.cs

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 CommonAI.Zone;
using CommonAI.RTS;
using CommonLang.Vector;
using CommonAI.Zone.ZoneEditor.Plugin.EditorToScene;
using CommonAI.Zone.ZoneEditor.Plugin.SceneToEditor;
using CommonLang;
using CommonLang.Xml;
using System.Diagnostics;
using CommonAIEditor.Plugins.Win32;
using CommonFroms;
using CommonAI.ZoneEditor;
using GameEditorPlugin.Win32.Runtime;
using GameEditorPlugin.Win32;
using CommonFroms.G2D;
using CommonFroms.G2D.DataGrid;
using GameEditorPlugin.Tools;
using System.Xml;
using CommonFroms.Drawing;

namespace CommonAIEditor.Scene
{
    public partial class SceneEditor : Form
    {
        public delegate void SaveHandler(SceneEditor editor, G2DTreeNode<SceneData> node);

        public event SaveHandler OnSaved;

        public SceneData Data { get { return mData; } }

        private G2DTreeNode<SceneData> mNode;
        private SceneData mData;
        private ZoneInfo mZoneData;

        private ISceneEditorPlugin mPlugin;

        private G2DTreeNodeGroup treeRoot;

        private EditorMiniMap displayWorld;

        private RightMouseFilter rightFilter;

        private SceneEventEditor eventEditor;
        private SceneVarEditor varEditor;

        public SceneEditor(DataManagerPanel<SceneData> owner, G2DTreeNode<SceneData> node, ISceneEditorPlugin plugin)
        {
            SceneData data = node.Data;

            this.tree_setting_file = new FileInfo(owner.TreeRoot.SettingDir + "\\" + data.ID + ".tree");

            InitializeComponent();

            this.Text = "场景: " + data.ToString();
            this.DoubleBuffered = true;
            this.splitContainer1.Enabled = false;
            this.toolStrip1.Enabled = false;

            // tree and objects //
            {
                this.propertyGrid1.PropertyTabs.AddTabType(
                    typeof(System.Windows.Forms.Design.EventsTab),
                    PropertyTabScope.Global);
                this.treeView1.ImageList = Editor.Instance.Icons;
                this.treeRoot = new G2DTreeNodeGroup("所有单位");
                this.treeRoot.ImageKey = "icons_tool_bar2.png";
                this.treeRoot.SelectedImageKey = "icons_tool_bar2.png";
                this.treeRoot.ContextMenuStrip = groupMenuStrip;
                this.treeView1.Nodes.Add(treeRoot);
            }

            this.mNode = node;
            this.mData = data;
            this.mZoneData = data.ZoneData;
            this.displayWorld = new EditorMiniMap(treeRoot, mZoneData);

            // init plugin //
            {
                this.mPlugin = plugin;
                this.mPlugin.OnGetPluginMessage += new PluginMessageHandler(OnPluginMessageHandler);
                this.mPlugin.AsControl().Dock = DockStyle.Fill;
                this.mPlugin.CallAddObject += call_AddObject;
                this.mPlugin.CallResetObject += call_ResetObject;
                this.panel1.Controls.Add(mPlugin.AsControl());
            }
            // map define //
            {
                var brush = Editor.Instance.DefaultTerrainBrush;
                if (brush != null)
                {
                    toolStripButton_Color.BackColor = Color.FromArgb(brush.Value);
                    toolStripButton_Color.Text = brush.Name.Length > 0 ? brush.Name.Substring(0, 1) : "";
                }
                btn_BrushRect.Tag = MsgSetTerrainBrush.BrushType.Rectangle;
                btn_BrushRound.Tag = MsgSetTerrainBrush.BrushType.Round;
                btn_Brush.Tag = btn_BrushRound;
            }
            this.rightFilter = new RightMouseFilter(mPlugin.AsControl());
            if (!mPlugin.EnableRight)
            {
                Application.AddMessageFilter(rightFilter);
            }
        }

        class RightMouseFilter : IMessageFilter
        {
            const int WM_RBUTTONDBLCLK = 0x206;
            const int WM_RBUTTONDOWN = 0x204;
            const int WM_RBUTTONUP = 0x205;

            private Control component;

            public RightMouseFilter(Control component)
            {
                this.component = component;
            }

            public bool PreFilterMessage(ref System.Windows.Forms.Message m)
            {
                switch (m.Msg)
                {
                    case WM_RBUTTONDBLCLK:
                    case WM_RBUTTONDOWN:
                    case WM_RBUTTONUP:
                        {
                            Point pt = component.PointToClient(Control.MousePosition);
                            if (component.TopLevelControl.Focused)
                            {
                                if (component.Bounds.Contains(pt))
                                    return true;    //返回true则消息被裁取，系统不再处理 
                            }
                        }
                        break;
                    default:
                        return false; 　　　//返回false则消息未被裁取，系统会处理 
                }

                return false;
            }
        }


        private void SceneEditor_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (eventEditor != null)
            {
                eventEditor.Save();
                eventEditor.Close();
                eventEditor = null;
            }
            if (varEditor != null)
            {
                varEditor.Save();
                varEditor.Close();
                varEditor = null;
            }
            System.Windows.Forms.DialogResult result = MessageBox.Show(this,
                "关闭前保存场景？",
                "确认关闭？",
                MessageBoxButtons.YesNoCancel);
            if (result == System.Windows.Forms.DialogResult.Yes)
            {
                SaveToScene();
                Application.RemoveMessageFilter(rightFilter);
            }
            else if (result == System.Windows.Forms.DialogResult.No)
            {
                Application.RemoveMessageFilter(rightFilter);
            }
            else
            {
                e.Cancel = true;
            }
        }

        private void LaunchVarEdit()
        {
            if (varEditor == null)
            {
                varEditor = new SceneVarEditor(this);
                varEditor.FormClosed += new FormClosedEventHandler(
                    (object sender, FormClosedEventArgs e) =>
                    {
                        varEditor.Save();
                        varEditor = null;
                    }
                );
                varEditor.Show();
            }
            else
            {
                FormUtils.SwithToThisForm(varEditor, true);
            }
        }

        private void LaunchEventEdit()
        {
            if (eventEditor == null)
            {
                eventEditor = new SceneEventEditor(this);
                eventEditor.OnDataLoaded += (editor) =>
                {
                    LoadEventsTreeInfo(editor as SceneEventEditor);
                };
                eventEditor.OnDataSaved += (editor) =>
                {
                    SaveEventsTreeInfo(editor as SceneEventEditor);
                };
                eventEditor.Text = "事件列表";
                eventEditor.FormClosed += new FormClosedEventHandler(
                    (object sender, FormClosedEventArgs e) =>
                    {
                        eventEditor.Save();
                        eventEditor = null;
                    }
                );
                eventEditor.Show();
            }
            else
            {
                FormUtils.SwithToThisForm(eventEditor, true);
            }
        }

        //----------------------------------------------------------------------------
        #region SaveLoad


        private readonly FileInfo tree_setting_file;

        private void LoadScene()
        {
            this.numericCellW.Value = mData.Terrain.GridCellW;
            this.numericCellH.Value = mData.Terrain.GridCellH;
            this.numericXCount.Value = mData.Terrain.XCount;
            this.numericYCount.Value = mData.Terrain.YCount;

            post_MsgSetScene(mData);

            foreach (PointData tn in mData.Points)
            {
                LoadSceneObject(tn);
            }
            foreach (RegionData tn in mData.Regions)
            {
                LoadSceneObject(tn);
            }
            foreach (UnitData tn in mData.Units)
            {
                LoadSceneObject(tn);
            }
            foreach (DecorationData tn in mData.Decorations)
            {
                LoadSceneObject(tn);
            }
            foreach (ItemData tn in mData.Items)
            {
                LoadSceneObject(tn);
            }
            foreach (AreaData tn in mData.Areas)
            {
                LoadSceneObject(tn);
            }
            post_MsgShowTerrain();
            post_MsgSetEditorMode(MsgSetEditorMode.MODE_OBJECT);
            post_MsgSetTerrainBrush();
            post_MsgLocateCamera(
                displayWorld.Width / 2,
                displayWorld.Height / 2);

            LoadTreeInfo(tree_setting_file);
            treeRoot.Expand();

        }

        private void SaveToScene()
        {
            if (!bLoadScene) return;

            mData.SetTerrain(mZoneData);

            mData.Points = new List<PointData>();
            mData.Regions = new List<RegionData>();
            mData.Units = new List<UnitData>();
            mData.Decorations = new List<DecorationData>();
            mData.Items = new List<ItemData>();
            mData.Areas = new List<AreaData>();
            foreach (TreeNode tn in treeRoot.GetAllNodes())
            {
                if (tn is ObjectTreeNode)
                {
                    ObjectTreeNode otn = tn as ObjectTreeNode;
                    otn.Data.SavePath = treeRoot.GetSavePath(otn);
                    if (otn.Data is PointData)
                    {
                        mData.Points.Add(otn.Data as PointData);
                    }
                    else if (otn.Data is RegionData)
                    {
                        mData.Regions.Add(otn.Data as RegionData);
                    }
                    else if (otn.Data is DecorationData)
                    {
                        mData.Decorations.Add(otn.Data as DecorationData);
                    }
                    else if (otn.Data is UnitData)
                    {
                        mData.Units.Add(otn.Data as UnitData);
                    }
                    else if (otn.Data is ItemData)
                    {
                        mData.Items.Add(otn.Data as ItemData);
                    }
                    else if (otn.Data is AreaData)
                    {
                        mData.Areas.Add(otn.Data as AreaData);
                    }
                }
            }
            if (eventEditor != null)
            {
                eventEditor.Save();
            }
            if (varEditor != null)
            {
                varEditor.Save();
            }
            if (OnSaved != null)
            {
                OnSaved.Invoke(this, mNode);
            }

            SaveTreeInfo(tree_setting_file);

        }

        private XmlDocument tree_xml_status;
        private XmlElement events_xml_status;
        private XmlElement objects_xml_status;

        private void LoadTreeInfo(FileInfo file)
        {
            try
            {
                var xmltext = File.ReadAllText(file.FullName, CUtils.UTF8);
                tree_xml_status = XmlUtil.FromString(xmltext);
            }
            catch (Exception)
            {
                tree_xml_status = new XmlDocument();
                tree_xml_status.AppendChild(tree_xml_status.CreateElement("root"));
            }
            var eroot = tree_xml_status.DocumentElement;
            objects_xml_status = XmlUtil.FindChild(eroot, "objects") as XmlElement;
            if (objects_xml_status != null)
            {
                G2DTreeNodeGroup.SetTreeInfo(objects_xml_status as XmlElement, treeRoot);
            }
            else
            {
                objects_xml_status = tree_xml_status.CreateElement("objects");
                eroot.AppendChild(objects_xml_status);
            }
            events_xml_status = XmlUtil.FindChild(eroot, "events") as XmlElement;
            if (events_xml_status == null)
            {
                events_xml_status = tree_xml_status.CreateElement("events");
                eroot.AppendChild(events_xml_status);
            }
        }
        private void SaveTreeInfo(FileInfo file)
        {
            try
            {
                objects_xml_status.RemoveAll();
                G2DTreeNodeGroup.GetTreeInfo(objects_xml_status, treeRoot);

                var xmltext = XmlUtil.ToString(tree_xml_status);
                File.WriteAllText(file.FullName, xmltext, CUtils.UTF8);
            }
            catch (Exception) { }
        }
        private void LoadEventsTreeInfo(SceneEventEditor editor)
        {
            editor.LoadTreeInfo(events_xml_status);
        }
        private void SaveEventsTreeInfo(SceneEventEditor editor)
        {
            events_xml_status.RemoveAll();
            editor.SaveTreeInfo(events_xml_status);
        }
        #endregion

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

        private void ChangeSceneTerrain()
        {
            try
            {
                ZoneInfo old_info = mData.ZoneData;
                {
                    int cellW = (int)(numericCellW.Value);
                    int cellH = (int)(numericCellH.Value);
                    int xCount = (int)(numericXCount.Value);
                    int yCount = (int)(numericYCount.Value);
                    ZoneInfo new_info = new ZoneInfo(xCount, yCount, cellW, cellH);
                    for (int x = 0; x < xCount && x < old_info.XCount; x++)
                    {
                        for (int y = 0; y < yCount && y < old_info.YCount; y++)
                        {
                            new_info.TerrainMatrix[x, y] = old_info.TerrainMatrix[x, y];
                        }
                    }
                    mZoneData = new_info;
                    mData.SetTerrain(new_info);
                    this.displayWorld.ResetTerrain(mZoneData);
                }
                post_MsgSetScene(mData);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        //----------------------------------------------------------------------------
        #region Delegates
        //----------------------------------------------------------------------------

        private void tool_RunGameEmu_Click(object sender, EventArgs e)
        {
            SaveToScene();
            IGameEditorPlugin plugin = EditorPlugin.CurrentPlugin;
            plugin.RunLocalPlay(EditorPlugin.DefaultPlugin, new DirectoryInfo(Editor.DataDir), mData.ID, false);
        }

        private void tool_RunGamePlugin_Click(object sender, EventArgs e)
        {
            SaveToScene();
            try
            {
                IGameEditorPlugin plugin = EditorPlugin.CurrentPlugin;
                plugin.RunTest(EditorPlugin.DefaultPlugin, Editor.DataDir, mData.ID, Editor.GetTestActorTemplateID(mData, 0));
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        private void btn_TestAstar_Click(object sender, EventArgs e)
        {
            SaveToScene();
            new FormAstar(Editor.DataDir_scenes, Editor.Instance.TerrainDefinition, mData).Show();
        }
        private void btn_ScriptEditor_Click(object sender, EventArgs e)
        {
        }
        private void btn_Events_Click(object sender, EventArgs e)
        {
            LaunchEventEdit();
        }
        private void btn_EnvVars_Click(object sender, EventArgs e)
        {
            LaunchVarEdit();
        }

        //----------------------------------------------------------------------------
        private SceneObjectData call_AddObject(Type type, Action<SceneObjectData> callback)
        {
            return AddSceneObject(type, callback);
        }
        private SceneObjectData call_ResetObject(string name, Action<SceneObjectData> callback)
        {
            var data = this.GetSceneObjectData(name);
            if (data != null)
            {
                callback.Invoke(data);
                RefreshObject(data);
                return data;
            }
            return null;
        }

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

        private void addUnitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(UnitData));
        }
        private void addItem_MenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(ItemData));
        }
        private void addRegionToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(RegionData));
        }
        private void addPointToolStripMenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(PointData));
        }
        private void addDecoration_MenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(DecorationData));
        }
        private void addArea_MenuItem_Click(object sender, EventArgs e)
        {
            AddSceneObject(typeof(AreaData));
        }
        private void addGroup_MenuItem_Click(object sender, EventArgs e)
        {
            AddSceneGroup();
        }
        private void copyGroup_MenuItem_Click(object sender, EventArgs e)
        {
            CopySelected();
        }
        private void pasteGroup_MenuItem_Click(object sender, EventArgs e)
        {
            Paste();
        }
        private void cloneGroup_MenuItem_Click(object sender, EventArgs e)
        {
            DuplicateSelected();
        }
        private void renameGroup_MenuItem_Click(object sender, EventArgs e)
        {
            RenameSceneGroup();
        }
        //----------------------------------------------------------------------------

        private void btn_Brush_Click(object sender, EventArgs e)
        {
            btn_Brush.Tag = sender;
            btn_Brush.Image = (sender as ToolStripMenuItem).Image;
            post_MsgSetTerrainBrush();
        }
        //----------------------------------------------------------------------------------

        private void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
        {
            if (propertyGrid1.SelectedObject is G2DPropertyDescriptor)
            {
                G2DPropertyDescriptor prop = (G2DPropertyDescriptor)propertyGrid1.SelectedObject;
                if (prop.EditData is UnitData)
                {
                    post_MsgPutUnit(prop.EditData as UnitData);
                }
                else if (prop.EditData is ItemData)
                {
                    post_MsgPutItem(prop.EditData as ItemData);
                }
                else if (prop.EditData is RegionData)
                {
                    post_MsgPutRegion(prop.EditData as RegionData);
                }
                else if (prop.EditData is PointData)
                {
                    post_MsgPutPoint(prop.EditData as PointData);
                }
                else if (prop.EditData is DecorationData)
                {
                    post_MsgPutDecoration(prop.EditData as DecorationData);
                }
                else if (prop.EditData is AreaData)
                {
                    post_MsgPutArea(prop.EditData as AreaData);
                }
                ObjectTreeNode node = GetSelectedAsSceneObject();
                if (node != null)
                {
                    node.RefreshData();
                }
            }
        }

        private void propertyGrid1_Click(object sender, EventArgs e)
        {

        }
        private void propertyGrid1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(ObjectTreeNode)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void propertyGrid1_DragOver(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(ObjectTreeNode)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }


        private void propertyGrid1_DragDrop(object sender, DragEventArgs e)
        {
            ObjectTreeNode dragObjNode = (ObjectTreeNode)e.Data.GetData(typeof(ObjectTreeNode));
            if (propertyGrid1.SelectedObject != null && dragObjNode.Data is PointData)
            {
                PointData srcP = dragObjNode.Data as PointData;
                G2DPropertyDescriptor desc = propertyGrid1.SelectedObject as G2DPropertyDescriptor;
                if (desc.EditData is PointData)
                {
                    PointData dstP = desc.EditData as PointData;
                    if (!dstP.NextNames.Contains(srcP.Name))
                    {
                        dstP.NextNames.Add(srcP.Name);
                        post_MsgPutPoint(dstP);
                        propertyGrid1.Refresh();
                    }
                }
                else if (desc.EditData is UnitData)
                {
                    UnitData dstP = desc.EditData as UnitData;
                    dstP.StartPointName = srcP.Name;
                    propertyGrid1.Refresh();
                }
            }


        }

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

        private void treeView1_ItemDrag(object sender, ItemDragEventArgs e)
        {
            treeView1.DoDragDrop(e.Item, DragDropEffects.Move);
        }

        private void treeView1_DragDrop(object sender, DragEventArgs e)
        {
            Point pos = treeView1.PointToClient(new Point(e.X, e.Y));
            TreeNode dropNode = this.treeView1.GetNodeAt(pos);
            G2DTreeNodeBase child_node = (G2DTreeNodeBase)e.Data.GetData(typeof(ObjectTreeNode));
            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();
                    //treeView1.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();
                        //treeView1.SelectedNode = group_node;
                    }
                }
            }
            else if (dropNode is ObjectTreeNode && child_node is ObjectTreeNode)
            {
                ObjectTreeNode dragObjNode = child_node as ObjectTreeNode;
                ObjectTreeNode dropObjNode = dropNode as ObjectTreeNode;
                if (dragObjNode.Data is PointData &&
                    dropObjNode.Data is PointData)
                {
                    PointData srcP = dragObjNode.Data as PointData;
                    PointData dstP = dropObjNode.Data as PointData;
                    if (!dstP.NextNames.Contains(srcP.Name))
                    {
                        dstP.NextNames.Add(srcP.Name);
                        post_MsgPutPoint(dstP);
                        propertyGrid1.Refresh();
                        MessageBox.Show(dstP.Name + " -> " + srcP.Name + " 已连接");
                    }
                }
                if (dragObjNode.Data is PointData &&
                    dropObjNode.Data is UnitData)
                {
                    PointData srcP = dragObjNode.Data as PointData;
                    UnitData dstP = dropObjNode.Data as UnitData;
                    dstP.StartPointName = srcP.Name;
                    propertyGrid1.Refresh();
                    MessageBox.Show(dstP.Name + " -> " + srcP.Name + " 已设置路径");
                }
            }
        }

        private void treeView1_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(typeof(ObjectTreeNode)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else if (e.Data.GetDataPresent(typeof(G2DTreeNodeGroup)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void treeView1_DragOver(object sender, DragEventArgs e)
        {
            Point pos = treeView1.PointToClient(new Point(e.X, e.Y));
            TreeNode dropNode = this.treeView1.GetNodeAt(pos);
            if (dropNode is G2DTreeNodeBase)
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            treeView1.SelectedNode = e.Node;
        }

        private void treeView1_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if (e.Node is ObjectTreeNode)
            {
                ObjectTreeNode tn = e.Node as ObjectTreeNode;
                post_MsgLocateCamera(tn.Data.X, tn.Data.Y);
            }
        }
        private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (e.Node is ObjectTreeNode)
            {
                SelectSceneObject(e.Node as ObjectTreeNode);
            }
        }
        private void btn_TreeExpandAll_Click(object sender, EventArgs e)
        {
            treeRoot.ExpandAll();
        }

        private void btn_TreeCollapseAll_Click(object sender, EventArgs e)
        {
            foreach (TreeNode tn in treeRoot.Nodes)
            {
                tn.Collapse();
            }
        }
        //----------------------------------------------------------------------------

        private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (bLoadScene)
            {
                SaveToScene();
            }
        }
        private void buttonSetTerrain_Click(object sender, EventArgs e)
        {
            ChangeSceneTerrain();
        }
        private void toolStripButtonSave_Click(object sender, EventArgs e)
        {
            if (bLoadScene)
            {
                SaveToScene();
            }
        }

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

        private void btn_selectUnit_Click(object sender, EventArgs e)
        {
            btn_selectUnit.Checked = true;
            btn_setTerrain.Checked = !btn_selectUnit.Checked;
            post_MsgSetEditorMode(MsgSetEditorMode.MODE_OBJECT);
        }

        private void btn_setTerrain_Click(object sender, EventArgs e)
        {
            btn_setTerrain.Checked = true;
            btn_selectUnit.Checked = !btn_setTerrain.Checked;
            post_MsgSetEditorMode(MsgSetEditorMode.MODE_TERRAIN);
        }

        private void objBtn_Rename_Click(object sender, EventArgs e)
        {
            RenameSceneObject();
        }

        private void objBtn_Remove_Click(object sender, EventArgs e)
        {
            RemoveSelectedSceneObject();
        }

        private void objBtn_Duplicate_Click(object sender, EventArgs e)
        {
            DuplicateSelected();
        }
        private void objBtn_Copy_Click(object sender, EventArgs e)
        {
            CopySelected();
        }
        private void objBtn_Paste_Click(object sender, EventArgs e)
        {
            Paste();
        }
        private void objBtn_CopyNameText_Click(object sender, EventArgs e)
        {
            ObjectTreeNode node = GetSelectedAsSceneObject();
            if (node != null)
            {
                Clipboard.SetText(node.DataID);
            }
        }
        private void objBtn_Event_Click(object sender, EventArgs e)
        {
            ObjectTreeNode node = GetSelectedAsSceneObject();
            if (node != null)
            {

            }
        }
        private void objBtn_OnOff_Click(object sender, EventArgs e)
        {
            ObjectTreeNode node = GetSelectedAsSceneObject();
            if (node != null)
            {
                node.Data.Enable = !node.Data.Enable;
                node.RefreshData();
            }
        }

        //----------------------------------------------------------------------------
        private void btn_CopyToClipboard_Click(object sender, EventArgs e)
        {
            TreeNode node = treeView1.SelectedNode;
            if (node != null)
            {
                Clipboard.SetText(node.Text);
            }
        }
        private void btn_Copy_Click(object sender, EventArgs e)
        {
            TreeNode node = treeView1.SelectedNode;
            if (node != null)
            {
                Clipboard.SetText(node.Text);
            }
            CopySelected();
        }

        private void btn_Paste_Click(object sender, EventArgs e)
        {
            Paste();
        }
        private void btn_Delete_Click(object sender, EventArgs e)
        {
            RemoveSelectedSceneObject();
        }

        //----------------------------------------------------------------------------
        private void panel1_MouseDown(object sender, MouseEventArgs e)
        {
        }
        private void panel1_MouseMove(object sender, MouseEventArgs e)
        {
        }
        private void panel1_MouseUp(object sender, MouseEventArgs e)
        {
        }
        private void toolStripButtonColor_Click(object sender, EventArgs e)
        {
            var cd = Editor.Instance.ShowTerrainDefinitionDialog(this, toolStripButton_Color.BackColor.ToArgb());
            var brush = cd.SelectedBrush;
            if (brush != null)
            {
                toolStripButton_Color.BackColor = Color.FromArgb(brush.Value);
                toolStripButton_Color.Text = brush.Name.Length > 0 ? brush.Name.Substring(0, 1) : "";
                toolStripButton_Color.ToolTipText = brush.Desc;
                post_MsgSetTerrainBrush();
            }
        }
        private void toolStripButtonShowTerrain_Click(object sender, EventArgs e)
        {
            post_MsgShowTerrain();
        }

        private void combo_BrushSize_TextChanged(object sender, EventArgs e)
        {
            post_MsgSetTerrainBrush();
        }

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

        private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {
            int wx = (int)displayWorld.screenToWorldX(e.X);
            int wy = (int)displayWorld.screenToWorldY(e.Y);
            if (e.Button == MouseButtons.Left)
            {
                post_MsgLocateCamera(wx, wy);
                pictureBox1.Refresh();
            }
        }
        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            int wx = (int)displayWorld.screenToWorldX(e.X);
            int wy = (int)displayWorld.screenToWorldY(e.Y);
            if (e.Button == MouseButtons.Left)
            {
                post_MsgLocateCamera(wx, wy);
                pictureBox1.Refresh();
            }
        }
        private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
        {

        }

        private Pen camera_pen = new Pen(Color.White);

        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            float scaleX = pictureBox1.Width / (float)mZoneData.TotalWidth;
            float scaleY = pictureBox1.Height / (float)mZoneData.TotalHeight;
            float scaleD = Math.Min(scaleX, scaleY);
            displayWorld.setWindow(
                new RectangleF(0, 0,
                pictureBox1.Width,
                pictureBox1.Height));
            displayWorld.setCameraScale(scaleD, scaleD);
            displayWorld.setCamera(
                mZoneData.TotalWidth / 2f,
                mZoneData.TotalHeight / 2f);
            displayWorld.render(e.Graphics);
            if (bLastCamera != null)
            {
                e.Graphics.DrawRectangle(camera_pen,
                    displayWorld.worldToScreenX(bLastCamera.X - bLastCamera.W / 2),
                    displayWorld.worldToScreenY(bLastCamera.Y - bLastCamera.H / 2),
                    displayWorld.worldToScreenSizeX(bLastCamera.W),
                    displayWorld.worldToScreenSizeY(bLastCamera.H)
                    );
            }
        }

        private void pictureBox1_ClientSizeChanged(object sender, EventArgs e)
        {
            this.pictureBox1.Refresh();
        }

        private void SceneEditor_KeyDown(object sender, KeyEventArgs e)
        {

        }
        #endregion

        //---------------------------------------------------------------------------------
        #region Post To Scene
        //---------------------------------------------------------------------------------

        private void post_MsgSetScene(SceneData zonedata)
        {
            MsgSetScene ss = new MsgSetScene();
            ss.ProjectName = TemplateManager.Factory.GetType().Name;
            ss.Data = zonedata.ZoneData;
            ss.FileName = zonedata.FileName;
            ss.ResourceDir = Editor.EditorRootDir;
            ss.ResourceProperty = zonedata.ResourceProperty;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutUnit(UnitData data)
        {
            MsgPutUnit ss = new MsgPutUnit();
            ss.Data = data;
            ss.UnitData = Editor.Instance.GetTemplateByType<UnitInfo>(data.UnitTemplateID);
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutItem(ItemData data)
        {
            MsgPutItem ss = new MsgPutItem();
            ss.Data = data;
            ss.Item = Editor.Instance.GetTemplateByType<ItemTemplate>(data.ItemTemplateID);
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutPoint(PointData data)
        {
            MsgPutPoint ss = new MsgPutPoint();
            ss.Data = data;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutRegion(RegionData data)
        {
            MsgPutRegion ss = new MsgPutRegion();
            ss.Data = data;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutDecoration(DecorationData data)
        {
            MsgPutDecoration ss = new MsgPutDecoration();
            ss.Data = data;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgPutArea(AreaData data)
        {
            MsgPutArea ss = new MsgPutArea();
            ss.Data = data;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgRemoveObject(string name)
        {
            MsgRemoveObject ss = new MsgRemoveObject();
            ss.Name = name;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgRenameObject(string src, string dst)
        {
            MsgRenameObject ss = new MsgRenameObject();
            ss.SrcName = src;
            ss.DstName = dst;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgSelectObject(string name)
        {
            MsgSelectObject ss = new MsgSelectObject();
            ss.Name = name;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgShowTerrain()
        {
            MsgShowTerrain ss = new MsgShowTerrain();
            ss.Show = toolStripButton_ShowTerrain.Checked;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgLocateCamera(float x, float y)
        {
            MsgLocateCamera ss = new MsgLocateCamera();
            ss.X = x;
            ss.Y = y;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgSetEditorMode(int mode)
        {
            MsgSetEditorMode ss = new MsgSetEditorMode();
            ss.Mode = mode;
            mPlugin.SendMessage(ss);
        }
        private void post_MsgSetTerrainBrush()
        {
            try
            {
                int color = toolStripButton_Color.BackColor.ToArgb();
                int size = int.Parse(combo_BrushSize.Text);
                MsgSetTerrainBrush ss = new MsgSetTerrainBrush();
                ss.ARGB = color;
                ss.Size = size;
                ss.Size = Math.Max(1, ss.Size);
                ss.Brush = (MsgSetTerrainBrush.BrushType)((btn_Brush.Tag as ToolStripMenuItem).Tag);
                mPlugin.SendMessage(ss);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }
        #endregion

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

        #region Recived From Scene

        private bool bLoadScene = false;

        private RspCameraChanged bLastCamera = null;

        private void rsp(RspZoneFlagBathChanged dt)
        {
            foreach (RspZoneFlagChanged dd in dt.Flags)
            {
                try
                {
                    mZoneData.TerrainMatrix[dd.SceneX, dd.SceneY] = dd.Flag;
                }
                catch (Exception ) { }
            }
            pictureBox1.Refresh();
        }


        private void rsp(RspTerrainBrushChanged data)
        {
            combo_BrushSize.Text = data.Size.ToString();
        }

        private void rsp(RspZoneFlagChanged dt)
        {
            try
            {
                mZoneData.TerrainMatrix[dt.SceneX, dt.SceneY] = dt.Flag;
                pictureBox1.Refresh();
            }
            catch (Exception err) { }
        }

        private void rsp(RspOnObjectSelected dt)
        {
            ObjectTreeNode tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.Name, true);
            if (tn != null)
            {
                if (dt.Selected)
                {
                    treeView1.SelectedNode = tn;
                    propertyGrid1.SelectedObject = new G2DPropertyDescriptor(tn.Data, new SceneDataAdapters(this));
                }
                else
                {
                    if (tn.IsSelected && treeView1.SelectedNode == tn)
                    {
                        treeView1.SelectedNode = tn.Parent;
                        propertyGrid1.SelectedObject = null;
                    }
                }
            }
        }
        private void rsp(RspObjectPositionChanged dt)
        {
            ObjectTreeNode tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.Name, true);
            if (tn != null)
            {
                tn.Data.X = dt.x;
                tn.Data.Y = dt.y;
                propertyGrid1.Refresh();
            }
        }
        private void rsp(RspObjectDirectionChanged dt)
        {
            ObjectTreeNode tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.Name, true);
            if (tn != null)
            {
                if (tn.Data is UnitData)
                {
                    UnitData ud = tn.Data as UnitData;
                    ud.Direction = dt.dir;
                }
                else if (tn.Data is ItemData)
                {
                    ItemData ud = tn.Data as ItemData;
                    ud.Direction = dt.dir;
                }
                propertyGrid1.Refresh();
            }
        }
        private void rsp(RspObjectSizeChanged dt)
        {
            ObjectTreeNode tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.Name, true);
            if (tn != null && tn.Data is RegionData)
            {
                RegionData rg = tn.Data as RegionData;
                rg.W = dt.x;
                rg.H = dt.y;
                propertyGrid1.Refresh();
            }
        }
        private void rsp(RspPointLinkChanged dt)
        {
            ObjectTreeNode src_tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.SrcPointName, true);
            ObjectTreeNode dst_tn = G2DTreeNodeGroup.FindNodeByText<ObjectTreeNode>(treeRoot, dt.DstPointName, true);
            if (src_tn != null &&
                dst_tn != null &&
                src_tn.Data is PointData &&
                dst_tn.Data is PointData)
            {
                PointData sp = src_tn.Data as PointData;
                PointData dp = dst_tn.Data as PointData;
                sp.NextNames.Add(dp.Name);
            }
        }

        private void rsp(RspEditorState dt)
        {
            if (!bLoadScene)
            {
                if (dt.State == RspEditorState.STATE_SUCCEED)
                {
                    LoadScene();
                    this.bLoadScene = true;
                    this.splitContainer1.Enabled = true;
                    this.toolStrip1.Enabled = true;
                }
            }
        }

        private void rsp(RspCameraChanged dt)
        {
            bLastCamera = dt;
            pictureBox1.Refresh();
        }

        private void OnPluginMessageHandler(object data)
        {
            try
            {
                if (data is RspEditorState)
                {
                    rsp(data as RspEditorState);
                }
                else if (data is RspTerrainBrushChanged)
                {
                    rsp(data as RspTerrainBrushChanged);
                }

                else if (data is RspZoneFlagChanged)
                {
                    rsp(data as RspZoneFlagChanged);
                }
                else if (data is RspZoneFlagBathChanged)
                {
                    rsp(data as RspZoneFlagBathChanged);
                }

                else if (data is RspOnObjectSelected)
                {
                    rsp(data as RspOnObjectSelected);
                }

                else if (data is RspObjectPositionChanged)
                {
                    rsp(data as RspObjectPositionChanged);
                }
                else if (data is RspObjectDirectionChanged)
                {
                    rsp(data as RspObjectDirectionChanged);
                }

                else if (data is RspObjectSizeChanged)
                {
                    rsp(data as RspObjectSizeChanged);
                }

                else if (data is RspPointLinkChanged)
                {
                    rsp(data as RspPointLinkChanged);
                }

                else if (data is RspCameraChanged)
                {
                    rsp(data as RspCameraChanged);
                }
            }
            catch (Exception err)
            {
                MessageBox.Show("OnPluginMessageHandler\n" + err.Message);
            }
        }
        #endregion



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


        #region Tree_Node_And_Units


        public class ObjectTreeNode : G2DTreeNode<SceneObjectData>
        {

            public ObjectTreeNode(SceneObjectData data) : base(data) { }
            public ObjectTreeNode(Stream input) : base(input) { }

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

        private G2DTreeNodeGroup GetSelectedSceneGroup()
        {
            if (treeView1.SelectedNode is G2DTreeNodeGroup)
            {
                return treeView1.SelectedNode as G2DTreeNodeGroup;
            }
            if (treeView1.SelectedNode is ObjectTreeNode)
            {
                return (treeView1.SelectedNode as ObjectTreeNode).Parent as G2DTreeNodeGroup;
            }
            return null;
        }
        private ObjectTreeNode GetSelectedAsSceneObject()
        {
            if (treeView1.SelectedNode is ObjectTreeNode)
            {
                return treeView1.SelectedNode as ObjectTreeNode;
            }
            return null;
        }

        private void SelectSceneObject(ObjectTreeNode node)
        {
            node.RefreshData();
            if (propertyGrid1.SelectedObject != null)
            {
                G2DPropertyDescriptor desc = propertyGrid1.SelectedObject as G2DPropertyDescriptor;
                if (desc.EditData.Equals(node.Data))
                {
                    return;
                }
            }
            propertyGrid1.SelectedObject = new G2DPropertyDescriptor(node.Data, new SceneDataAdapters(this));
            toolStripTextBox1.Text = node.DataID;
            post_MsgSelectObject(node.DataID);
        }

        public SceneObjectData ShowSelectSceneObject(Type type, string srcName)
        {
            TreeNode droot = G2DListSelectEditor<SceneObjectData>.TreeNodeDuplicate(treeRoot);
            foreach (TreeNode tn in G2DTreeNodeBase.GetAllNodes(droot))
            {
                if (!type.IsInstanceOfType(tn.Tag) && tn.Nodes.Count == 0)
                {
                    tn.Remove();
                }
            }
            SceneObjectData src = GetSceneObjectData(srcName);
            G2DListSelectEditor<SceneObjectData> dialog = new G2DListSelectEditor<SceneObjectData>(droot, treeView1.ImageList, src);
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                return dialog.SelectedObject;
            }
            return null;
        }


        public CommonAI.Zone.ZoneEditor.ZoneEvent ShowSelectSceneEvent(string srcName)
        {
            CommonAI.Zone.ZoneEditor.ZoneEvent src = GetSceneEventData(srcName);
            G2DListSelectEditor<CommonAI.Zone.ZoneEditor.ZoneEvent> dialog = new G2DListSelectEditor<CommonAI.Zone.ZoneEditor.ZoneEvent>(
                new List<CommonAI.Zone.ZoneEditor.ZoneEvent>(mData.Events), src);
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                return dialog.SelectedObject;
            }
            return null;
        }

        public ZoneVar ShowSelectSceneVar(string srcKey, Type valueType)
        {
            ZoneVar src = GetSceneVarData(srcKey);
            G2DListSelectEditor<ZoneVar> dialog = new G2DListSelectEditor<ZoneVar>(
                GetSceneVarsAsType(valueType), src);
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                return dialog.SelectedObject;
            }
            return null;
        }

        private static List<SceneObjectData> copying_objects = new List<SceneObjectData>();

        private void DuplicateSelected()
        {
            var selected = GetSelectedAsSceneObject();
            if (selected != null)
            {
                G2DTreeNodeGroup parent = selected.Parent as G2DTreeNodeGroup;
                SceneObjectData copy = XmlUtil.CloneObject(selected.Data);
                ObjectTreeNode copy_node = new ObjectTreeNode(copy);
                copy_node.ImageKey = selected.ImageKey;
                copy_node.SelectedImageKey = selected.SelectedImageKey;
                copy_node.ContextMenuStrip = selected.ContextMenuStrip;
                copy.Name = selected.Data.Name + "_Copy";
                copy.SavePath = "";
                TryAddSceneNode(copy_node, parent, parent.Nodes.IndexOf(selected) + 1);
                return;
            }
            var group = GetSelectedSceneGroup();
            if (group != null)
            {
                G2DTreeNodeGroup parent = group.Parent as G2DTreeNodeGroup;
                foreach (var sub in group.GetAllNodes())
                {
                    if (sub is ObjectTreeNode)
                    {
                        var otn = sub as ObjectTreeNode;
                        SceneObjectData copy = XmlUtil.CloneObject(otn.Data);
                        ObjectTreeNode copy_node = new ObjectTreeNode(copy);
                        copy_node.ImageKey = sub.ImageKey;
                        copy_node.SelectedImageKey = sub.SelectedImageKey;
                        copy_node.ContextMenuStrip = sub.ContextMenuStrip;
                        copy.Name = otn.Data.Name + "_Copy";
                        copy.SavePath = group.GetSavePath(otn, true);
                        TryAddSceneNode(copy_node, parent, parent.Nodes.IndexOf(group) + 1);
                    }
                }
                return;
            }
        }
        private void CopySelected()
        {
            copying_objects.Clear();
            var node = GetSelectedAsSceneObject();
            if (node != null)
            {
                var parent = node.Parent as G2DTreeNodeGroup;
                var copying = XmlUtil.CloneObject(node.Data);
                copying.SavePath = parent.GetSavePath(node);
                copying_objects.Add(copying);
                return;
            }
            var group = GetSelectedSceneGroup();
            if (group != null)
            {
                foreach (var sub in group.GetAllNodes())
                {
                    if (sub is ObjectTreeNode)
                    {
                        var otn = sub as ObjectTreeNode;
                        var copying = XmlUtil.CloneObject(otn.Data);
                        copying.SavePath = group.GetSavePath(otn, true);
                        copying_objects.Add(copying);
                    }
                }
                return;
            }
        }
        private string BestNewName(string name)
        {
            if (ContainsSceneObject(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 + treeRoot.GetAllNodes().Count;
        }
        private void Paste()
        {
            G2DTreeNodeGroup parent = treeRoot;
            int index = parent.Nodes.Count;
            do
            {
                var selected = GetSelectedAsSceneObject();
                if (selected != null)
                {
                    parent = selected.Parent as G2DTreeNodeGroup;
                    index = parent.Nodes.IndexOf(selected) + 1;
                    break;
                }
                var group = GetSelectedSceneGroup();
                if (group != null)
                {
                    parent = group;
                    index = parent.Nodes.Count;
                    break;
                }
                break;
            }
            while (true);
            foreach (var copying_object in copying_objects)
            {
                SceneObjectData copy = XmlUtil.CloneObject(copying_object);
                ObjectTreeNode copy_node = CreateSceneObjectNode(copy);
                TryAddSceneNode(copy_node, parent, index);
            }
        }
        private bool TryAddSceneNode(ObjectTreeNode copy_node, G2DTreeNodeGroup parent, int index)
        {
            string src_name = copy_node.Name;
            SceneObjectData copy = copy_node.Data;
            while (!string.IsNullOrEmpty(copy.Name))
            {
                if (ContainsSceneObject(copy.Name))
                {
                    copy.Name = BestNewName(copy.Name);
                    copy.Name = G2DTextDialog.Show(copy.Name, "复制: " + src_name);
                }
                else
                {
                    copy_node.SetDataID(copy.Name);
                    var group = parent.GetOrCreateGroup(copy.SavePath);
                    if (group != parent)
                    {
                        group.Nodes.Add(copy_node);
                        parent.Expand();
                        group.Expand();
                    }
                    else
                    {
                        parent.Nodes.Insert(index, copy_node);
                        parent.Expand();
                    }
                    copy_node.RefreshData();
                    RefreshObject(copy);
                    treeView1.SelectedNode = copy_node;
                    SelectSceneObject(copy_node);
                    return true;
                }
            }
            return false;
        }

        private void RemoveSelectedSceneObject()
        {
            ObjectTreeNode node = GetSelectedAsSceneObject();
            if (node != null)
            {
                if (MessageBox.Show(
                    "确定要删除: " + node.DataID,
                    "确认",
                    MessageBoxButtons.OKCancel) == DialogResult.OK)
                {
                    node.Parent.Nodes.Remove(node);
                    post_MsgRemoveObject(node.DataID);
                }
            }
        }
        private void RenameSceneObject()
        {
            ObjectTreeNode node = GetSelectedAsSceneObject();
            if (node != null)
            {
                string name = node.DataID;
                while (!string.IsNullOrEmpty(name))
                {
                    name = G2DTextDialog.Show(name, "重命名: " + name);
                    if (name != null)
                    {
                        if (ContainsSceneObject(name))
                        {
                            MessageBox.Show("\"" + name + "\" 已存在!");
                        }
                        else
                        {
                            string src_name = node.DataID;
                            node.SetDataID(name);
                            post_MsgRenameObject(src_name, name);
                            return;
                        }
                    }
                }
            }
        }

        private bool ContainsSceneObject(string name)
        {
            TreeNode tn = G2DTreeNodeBase.FindNodeByText<ObjectTreeNode>(treeRoot, name, true);
            return tn != null;
        }

        private SceneObjectData GetSceneObjectData(string name)
        {
            if (name != null)
            {
                TreeNode tn = G2DTreeNodeBase.FindNodeByText<ObjectTreeNode>(treeRoot, name, true);
                if (tn is ObjectTreeNode)
                {
                    return (tn as ObjectTreeNode).Data;
                }
            }
            return null;
        }

        private CommonAI.Zone.ZoneEditor.ZoneEvent GetSceneEventData(string name)
        {
            if (name != null)
            {
                foreach (CommonAI.Zone.ZoneEditor.ZoneEvent evt in mData.Events)
                {
                    if (evt.Name.Equals(name))
                    {
                        return evt;
                    }
                }
            }
            return null;
        }

        private ZoneVar GetSceneVarData(string name)
        {
            if (name != null)
            {
                foreach (ZoneVar var in mData.EnvironmentVars)
                {
                    if (var.Key.Equals(name))
                    {
                        return var;
                    }
                }
            }
            return null;
        }
        private List<ZoneVar> GetSceneVarsAsType(Type valueType)
        {
            if (valueType == null)
            {
                return new List<ZoneVar>(mData.EnvironmentVars);
            }
            else
            {
                List<ZoneVar> ret = new List<ZoneVar>();
                foreach (ZoneVar var in mData.EnvironmentVars)
                {
                    if (valueType.IsInstanceOfType(var.Value))
                    {
                        ret.Add(var);
                    }
                }
                return ret;
            }
        }

        private void AddSceneGroup()
        {
            G2DTreeNodeGroup parent = GetSelectedSceneGroup();
            if (parent != null)
            {
                string name = G2DTextDialog.Show("分组", "添加过滤器");
                if (name != null)
                {
                    G2DTreeNodeGroup group = parent.AddG2DGroup(name);
                    parent.Expand();
                    treeView1.SelectedNode = group;
                }
            }
        }

        private void RenameSceneGroup()
        {
            G2DTreeNodeGroup parent = GetSelectedSceneGroup();
            if (parent != null)
            {
                string name = G2DTextDialog.Show(parent.Text, "添加过滤器");
                if (name != null)
                {
                    parent.Text = name;
                }
            }
        }

        private ObjectTreeNode CreateSceneObjectNode(SceneObjectData data)
        {
            string imageKey = "icon_res_1.png";
            if (data is PointData)
            {
                imageKey = "icon_trigger.png";
            }
            else if (data is RegionData)
            {
                imageKey = "icon_layer.png";
            }
            else if (data is UnitData)
            {
                imageKey = "icon_res_2.png";
            }
            else if (data is ItemData)
            {
                imageKey = "icon_res_4.png";
            }
            else if (data is DecorationData)
            {
                imageKey = "icon_res_1.png";
            }
            else if (data is AreaData)
            {
                imageKey = "icon_res_6.png";
            }
            ObjectTreeNode node = new ObjectTreeNode(data);
            node.ImageKey = imageKey;
            node.SelectedImageKey = imageKey;
            node.ContextMenuStrip = objectMenuStrip;
            node.RefreshData();
            return node;
        }

        private SceneObjectData AddSceneObject(Type dataType, Action<SceneObjectData> callback = null)
        {
            G2DTreeNodeGroup parent = GetSelectedSceneGroup();
            if (parent == null)
            {
                parent = treeRoot;
            }
            if (parent != null)
            {
                string name = dataType.Name + treeRoot.GetAllNodes().Count;
                while (!string.IsNullOrEmpty(name))
                {
                    name = G2DTextDialog.Show(name, "添加: " + name);
                    if (name != null)
                    {
                        if (ContainsSceneObject(name))
                        {
                            MessageBox.Show("\"" + name + "\" 已存在!");
                        }
                        else
                        {
                            SceneObjectData data = (SceneObjectData)Activator.CreateInstance(dataType);
                            data.Name = name;
                            if (bLastCamera != null)
                            {
                                data.X = bLastCamera.X;
                                data.Y = bLastCamera.Y;
                            }
                            ObjectTreeNode node = CreateSceneObjectNode(data);
                            parent.Nodes.Add(node);
                            parent.Expand();
                            if (callback != null)
                            {
                                callback.Invoke(data);
                            }
                            RefreshObject(data);
                            treeView1.SelectedNode = node;
                            SelectSceneObject(node);
                            return data;
                        }
                    }
                }
            }
            return null;
        }

        private bool LoadSceneObject(SceneObjectData data)
        {
            if (ContainsSceneObject(data.Name))
            {
                MessageBox.Show("\"" + data.Name + "\" 已存在!");
                return false;
            }
            else
            {
                ObjectTreeNode node = CreateSceneObjectNode(data);
                G2DTreeNodeGroup parent = treeRoot.GetOrCreateGroup(data.SavePath);
                parent.Nodes.Add(node);
                RefreshObject(data);
                return true;
            }
        }

        private void RefreshObject(SceneObjectData data)
        {
            if (data is UnitData)
            {
                post_MsgPutUnit(data as UnitData);
            }
            else if (data is ItemData)
            {
                post_MsgPutItem(data as ItemData);
            }
            else if (data is PointData)
            {
                post_MsgPutPoint(data as PointData);
            }
            else if (data is RegionData)
            {
                post_MsgPutRegion(data as RegionData);
            }
            else if (data is DecorationData)
            {
                post_MsgPutDecoration(data as DecorationData);
            }
            else if (data is AreaData)
            {
                post_MsgPutArea(data as AreaData);
            }
        }


        #endregion


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

        class EditorMiniMap : DisplayTerrain
        {
            private G2DTreeNodeGroup treeRoot;

            public EditorMiniMap(G2DTreeNodeGroup treeRoot, ZoneInfo terrain)
            {
                this.treeRoot = treeRoot;
                base.InitTerrain(terrain);
            }

            public override void Dispose()
            {

            }

            public void ResetTerrain(ZoneInfo terrain)
            {
                base.InitTerrain(terrain);
            }

            protected override void renderObjects(Graphics g, RectangleF worldBounds)
            {
                foreach (TreeNode tn in treeRoot.GetAllNodes())
                {
                    if (tn is ObjectTreeNode)
                    {
                        SceneObjectData sd = (tn as ObjectTreeNode).Data;
                        System.Drawing.Drawing2D.GraphicsState state = g.Save();
                        g.TranslateTransform(sd.X, sd.Y);
                        renderNode(g, sd);
                        g.Restore(state);
                    }
                }
            }

            protected override void renderScreen(Graphics g, RectangleF worldBounds)
            {

            }

            private Pen pen = new Pen(Color.White);
            private SolidBrush brush = new SolidBrush(Color.White);

            private void renderNode(Graphics g, SceneObjectData data)
            {
                pen.Color = brush.Color = Color.FromArgb(data.Color);

                if (data is PointData)
                {
                    g.FillEllipse(brush, -1, -1, 2, 2);
                }
                else if (data is RegionData)
                {
                    RegionData rd = data as RegionData;
                    if (rd.RegionType == RegionData.Shape.RECTANGLE)
                    {
                        g.FillRectangle(brush, -rd.W / 2, -rd.H / 2, rd.W, rd.H);
                    }  
                    else if (rd.RegionType == RegionData.Shape.STRIP)
                    {
                        float line_r = rd.W / 2;
                        Line2 line = new Line2(0, 0, 0, 0);
                        MathVector.movePolar(line.p, rd.StripDirection, -rd.H / 2);
                        MathVector.movePolar(line.q, rd.StripDirection, +rd.H / 2);
                        DrawingUtils.FillLineRect(g, brush, line.p.X, line.p.Y, line.q.X, line.q.Y, line_r);
                    }
					else
					{
						g.FillEllipse(brush, -rd.W / 2, -rd.H / 2, rd.W, rd.H);
					}
				}
                else if (data is UnitData)
                {
                    UnitData rd = data as UnitData;
                    UnitInfo ut = Editor.Instance.GetTemplateByType<UnitInfo>(rd.UnitTemplateID);
                    if (ut != null)
                    {
                        g.FillEllipse(brush, -ut.BodySize, -ut.BodySize, ut.BodySize * 2, ut.BodySize * 2);
                    }
                    else
                    {
                        g.FillEllipse(brush, -1, -1, 2, 2);
                    }
                }
                else if (data is ItemData)
                {
                    ItemData rd = data as ItemData;
                    ItemTemplate ut = Editor.Instance.GetTemplateByType<ItemTemplate>(rd.ItemTemplateID);
                    if (ut != null)
                    {
                        g.FillEllipse(brush, -ut.BodySize, -ut.BodySize, ut.BodySize * 2, ut.BodySize * 2);
                    }
                    else
                    {
                        g.FillEllipse(brush, -1, -1, 2, 2);
                    }
                }
                else if (data is DecorationData)
                {
                    DecorationData rd = data as DecorationData;
                    if (rd.RegionType == DecorationData.Shape.RECTANGLE)
                    {
                        g.FillRectangle(brush, -rd.W / 2, -rd.H / 2, rd.W, rd.H);
                    }
                    else
                    {
                        g.FillEllipse(brush, -rd.W / 2, -rd.H / 2, rd.W, rd.H);
                    }
                }
                else if (data is AreaData)
                {
                    AreaData rd = data as AreaData;
                    g.FillEllipse(brush, -1, -1, 2, 2);
                }
            }

        }

    }
}