using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using DevComponents.DotNetBar;
using GeoScene.Data;
using GeoScene.Engine;
using GeoScene.Globe;

namespace Cyberpipe
{
    public partial class FrmLayerControl : Office2007Form
    {
        TreeView treeView1;
        GSOGlobeControl globeControl1;
        GSOGlobeControl globeControl2;
        TreeNode terrainManagerNode;
        TreeNode layerManagerNode;
        TreeNode terrainManagerNode1;
        TreeNode layerManagerNode1;
        
        public FrmLayerControl(TreeView t,GSOGlobeControl ctl1,GSOGlobeControl ctl2)
        {
            InitializeComponent();
            globeControl1 = ctl1;
            globeControl2 = ctl2;
        }

        List<string> listGroupName = new List<string>();
        /// <summary>
        /// 窗体初始化事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmLayerControl_Load(object sender, EventArgs e)
        {
            //加载layertree1
            layerTree1.Nodes.Clear();
            layerTree2.Nodes.Clear();

            //加载layertree2
            layerManagerNode1 = new TreeNode();
            layerManagerNode1.ImageIndex = 0;
            layerManagerNode1.SelectedImageIndex = 0;
            layerManagerNode1.Checked = false;
            layerManagerNode1.Text = "图层管理";
            layerTree1.Nodes.Add(layerManagerNode1);
            layerManagerNode = new TreeNode();
            layerManagerNode.ImageIndex = 0;
            layerManagerNode.SelectedImageIndex = 0;
            layerManagerNode.Checked = false;
            layerManagerNode.Text = "图层管理";
            layerTree2.Nodes.Add(layerManagerNode);

            terrainManagerNode1 = new TreeNode();
            terrainManagerNode1.ImageIndex = 0;
            terrainManagerNode1.SelectedImageIndex = 0;
            terrainManagerNode1.Checked = false;
            terrainManagerNode1.Text = "地形管理";
            layerTree1.Nodes.Add(terrainManagerNode1);
            terrainManagerNode = new TreeNode();
            terrainManagerNode.ImageIndex = 0;
            terrainManagerNode.SelectedImageIndex = 0;
            terrainManagerNode.Checked = false;
            terrainManagerNode.Text = "地形管理";
            layerTree2.Nodes.Add(terrainManagerNode);
            
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(Application.StartupPath + "\\双屏设置.xml");
                XmlNodeList Params1 = doc.SelectNodes("/Params/layers");

                foreach (XmlNode paramsNode in Params1) //layers
                {
                    foreach (XmlNode layerNode in paramsNode) //layer
                    {
                        TreeNode nodeGroup1 = new TreeNode();
                        string nodeGroupName1 = layerNode.Attributes["label"].Value;

                       
                        if (nodeGroupName1 == "电力")
                        {
                            nodeGroup1.Text = "供电";
                        }          
                        else {
                            nodeGroup1.Text = nodeGroupName1;
                        }
                        
                        //nodeGroup1.Text = nodeGroupName1;

                        layerTree1.Nodes[0].Nodes.Add(nodeGroup1);

                        TreeNode nodeGroup = new TreeNode();
                        string nodeGroupName = layerNode.Attributes["label"].Value;
                        nodeGroup.Text = nodeGroupName;
                        layerTree2.Nodes[0].Nodes.Add(nodeGroup);
                    }
                }
                TreeNode nodeGroupElse1 = new TreeNode();
                string nodeGroupNameElse1 = "基础数据";
                nodeGroupElse1.Text = nodeGroupNameElse1;
                layerTree1.Nodes[0].Nodes.Add(nodeGroupElse1); 
                TreeNode nodeGroupElse = new TreeNode();
                string nodeGroupNameElse = "基础数据";
                nodeGroupElse.Text = nodeGroupNameElse;
                layerTree2.Nodes[0].Nodes.Add(nodeGroupElse);

                nodeGroupElse1 = new TreeNode();
                nodeGroupNameElse1 = "其它";
                nodeGroupElse1.Text = nodeGroupNameElse1;
                layerTree1.Nodes[0].Nodes.Add(nodeGroupElse1);
                nodeGroupElse = new TreeNode();
                nodeGroupNameElse = "其它";
                nodeGroupElse.Text = nodeGroupNameElse;
                layerTree2.Nodes[0].Nodes.Add(nodeGroupElse);
            }
            catch (Exception ex)
            {
                LogError.PublishError(ex);
            }

            RefreshLayerAndTerrainTree();
        }
        /// <summary>
        /// 刷新节点树
        /// </summary>
        private void RefreshLayerAndTerrainTree()
        {
            ////layertree1
            int nLayerCount1 = globeControl1.Globe.Layers.Count;
            int nTerrainCount1 = globeControl1.Globe.Terrains.Count;

            int i = 0;
            for (i = 0; i < nLayerCount1; i++)
            {
                GSOLayer layer = globeControl1.Globe.Layers[i];
                if (layer != null)
                {
                    string layerName = layer.Name;
                    TreeNode node = new TreeNode();
                    node.Tag = layer;
                    node.Text = layer.Caption;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Checked = layer.Visible;

                    bool isContains = false;
                    for (int j = 0; j < layerTree1.Nodes[0].Nodes.Count; j++)
                    {
                        if (layerName.Contains("fttp:"))
                        {
                            layerTree1.Nodes[0].Nodes[layerTree1.Nodes[0].Nodes.Count - 2].Nodes.Add(node);
                            isContains = true;
                            break;
                        }
                        if (layerName.Contains(layerTree1.Nodes[0].Nodes[j].Text.Trim())&&!layerName.Contains("施工")&&!layerName.Contains("规划"))
                        {
                            layerTree1.Nodes[0].Nodes[j].Nodes.Add(node);
                            isContains = true;
                            break;
                        }
                    }
                    if (layerName.Contains("tempLgdData") || layerName.Contains("城市") || layerName.Contains("标注"))
                    {
                        continue;
                    }
                    if (isContains == false&&!layerName.Contains("施工")&&!layerName.Contains("规划")&&!layerName.Contains("景观")&&!layerName.Contains("红线"))
                    {
                        layerTree1.Nodes[0].Nodes[layerTree1.Nodes[0].Nodes.Count - 1].Nodes.Add(node);
                    }
                }
            }

            //节点选中状态控制
            foreach (TreeNode node in layerTree1.Nodes[0].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null && layer.Visible)
                    {
                        node.Checked = true;
                        break;
                    }
                }
            }
            foreach (TreeNode node in layerTree1.Nodes[0].Nodes)
            {
                if (node.Checked)
                {
                    layerTree1.Nodes[0].Checked = true;
                    break;
                }
            }

            for (i = 0; i < nTerrainCount1; i++)
            {
                GSOTerrain terrain = globeControl1.Globe.Terrains[i];
                if (terrain != null)
                {

                    TreeNode node = new TreeNode();
                    node.Tag = terrain;
                    node.Text = terrain.Caption;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Checked = terrain.Visible;
                    terrainManagerNode1.Nodes.Add(node);
                }
            }

            foreach (TreeNode node in layerTree1.Nodes[1].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOTerrain layer = childNode.Tag as GSOTerrain;
                    if (layer != null && layer.Visible)
                    {
                        node.Checked = true;
                        break;
                    }
                }
            }
            ///layertree2
            int nLayerCount = globeControl2.Globe.Layers.Count;
            int nTerrainCount = globeControl2.Globe.Terrains.Count;
            //int i = 0;
            for (i = 0; i < nLayerCount; i++)
            {
                GSOLayer layer = globeControl2.Globe.Layers[i];
                if (layer != null)
                {
                    string layerName = layer.Name;
                    TreeNode node = new TreeNode();
                    node.Tag = layer;
                    node.Text = layer.Caption;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Checked = layer.Visible;

                    bool isContains = false;
                    for (int j = 0; j < layerTree2.Nodes[0].Nodes.Count; j++)
                    {
                        if (layerName.Contains("fttp:"))
                        {
                            layerTree2.Nodes[0].Nodes[layerTree2.Nodes[0].Nodes.Count - 2].Nodes.Add(node);
                            isContains = true;
                            break;
                        }
                        if (layerName.Contains(layerTree2.Nodes[0].Nodes[j].Text.Trim()))
                        {
                            layerTree2.Nodes[0].Nodes[j].Nodes.Add(node);
                            isContains = true;
                            break;
                        }

                    }

                    if (layerName.Contains("tempLgdData2"))
                    {
                        continue;
                    }
                    if (isContains == false)
                    {
                        layerTree2.Nodes[0].Nodes[layerTree2.Nodes[0].Nodes.Count - 1].Nodes.Add(node);
                    }
                }
            }

            foreach (TreeNode node in layerTree2.Nodes[0].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null && layer.Visible)
                    {
                        node.Checked = true;
                        break;
                    }
                }
            }
            foreach (TreeNode node in layerTree2.Nodes[0].Nodes)
            {
                if (node.Checked)
                {
                    layerTree2.Nodes[0].Checked = true;
                    break;
                }
            }

            for (i = 0; i < nTerrainCount; i++)
            {
                GSOTerrain terrain = globeControl2.Globe.Terrains[i];
                if (terrain != null)
                {
                    
                    TreeNode node = new TreeNode();
                    node.Tag = terrain;
                    node.Text = terrain.Caption;
                    node.ImageIndex = 0;
                    node.SelectedImageIndex = 0;
                    node.Checked = terrain.Visible;
                    terrainManagerNode.Nodes.Add(node);
                }
            }
            foreach (TreeNode node in layerTree2.Nodes[1].Nodes)
            {
                foreach (TreeNode childNode in node.Nodes)
                {
                    GSOTerrain layer = childNode.Tag as GSOTerrain;
                    if (layer != null && layer.Visible)
                    {
                        node.Checked = true;
                        break;
                    }
                }
            }
            // 展开
            layerManagerNode1.Expand();
            terrainManagerNode1.Expand();
            layerManagerNode.Expand();
            terrainManagerNode.Expand();
        }
        /// <summary>
        /// 刷新节点树
        /// </summary>
        private void RefreshDataTree()
        {
            layerTree2.Nodes[0].Nodes.Clear();
            Int32 nCount = globeControl2.Globe.Layers.Count;
            Int32 i = 0;
            for (i = 0; i < nCount; i++)
            {
                GSODataset dataSpace = globeControl2.Globe.Layers[i].Dataset;
                TreeNode node = new TreeNode();
                node.Text = dataSpace.Name;
                node.ImageIndex = 0;
                node.SelectedImageIndex = 0;
                node.Checked = true;
                node.Tag = dataSpace;               
                layerTree2.Nodes[0].Nodes.Add(node);
            }
        }
        /// <summary>
        /// 目标图层按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FeatureAddLayerMenuItem_Click(object sender, EventArgs e)
        {
            if (!FeatureAddLayerMenuItem.Checked)
            {
                TreeNode node = layerNodeContexMenu.Tag as TreeNode;
                FeatureAddLayerMenuItem.Checked = true;
                GSOLayer layer = globeControl1.Globe.Layers.GetLayerByCaption(node.Tag.ToString().Split('|')[1]);
                //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
                globeControl1.Globe.DestLayerFeatureAdd = layer;
            }
        }
        /// <summary>
        /// 可选择按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void LayerSelectableMenuItem_Click(object sender, EventArgs e)
        {
            TreeNode node = layerNodeContexMenu.Tag as TreeNode;
            Int32 nIndex = node.Index;
            GSOLayer layer = globeControl1.Globe.Layers[nIndex];
            LayerSelectableMenuItem.Checked = !LayerSelectableMenuItem.Checked;
            layer.Selectable = LayerSelectableMenuItem.Checked;
        }
        /// <summary>
        /// 可编辑按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void LayerEditableMenuItem_Click(object sender, EventArgs e)
        {
            TreeNode node = layerNodeContexMenu.Tag as TreeNode;
            //GSOLayer layer = node.Tag as GSOLayer;
            //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
            GSOLayer layer = globeControl1.Globe.Layers.GetLayerByCaption(node.Tag.ToString().Split('|')[1]);
            LayerEditableMenuItem.Checked = !LayerEditableMenuItem.Checked;
            layer.Editable = LayerEditableMenuItem.Checked;
        }
        /// <summary>
        /// 保存图层按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SaveLayerMenuItem_Click(object sender, EventArgs e)
        {
            TreeNode node = layerNodeContexMenu.Tag as TreeNode;

            Int32 nIndex = node.Index;
            string layerCaption = node.Tag.ToString().Split('|')[1];
            //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
            GSOLayer layer = globeControl1.Globe.Layers.GetLayerByCaption(layerCaption);
            //globeControl1.Globe.Layers[nIndex].Save();
            layer.Dataset.Save();
        }
        /// <summary>
        /// 节点树复选框选中状态改变事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void layerTree2_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                if (e.Node.Tag != null)
                {
                    if (e.Node.Tag is GSOLayer)
                    {
                        GSOLayer layer = e.Node.Tag as GSOLayer;
                        if (layer != null)
                        {
                            layer.Visible = e.Node.Checked;
                            globeControl2.Globe.Refresh();
                        }
                    }
                    if (e.Node.Tag is GSOTerrain)
                    {

                        GSOTerrain feat = e.Node.Tag as GSOTerrain;
                        feat.Visible = e.Node.Checked;
                        globeControl2.Globe.Refresh();

                    }
                }

                CheckParentNode(e.Node);
                if (e.Node.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree2(e.Node, e.Node.Checked);
                }

                //setLayerTree1(e.Node);
            }                     
        }

        private void setLayerTree1(TreeNode node)
        {
            if (node.Tag != null)
            {
                if (node.Tag is GSOLayer)
                {
                    GSOLayer layer = globeControl1.Globe.Layers.GetLayerByCaption(node.Text);
                    if (layer != null)
                    {
                        layer.Visible = node.Checked;
                        globeControl1.Globe.Refresh();
                    }
                }
                if (node.Tag is GSOTerrain)
                {

                    GSOTerrain feat = globeControl1.Globe.Terrains.GetTerrainByCaption(node.Text);
                    feat.Visible = node.Checked;
                    globeControl1.Globe.Refresh();
                }
            }
            TreeNode n = queryNodeFromTree(node.Text, layerTree1);
            if (n != null)
            {
                n.Checked = node.Checked;
                CheckParentNode(n);
                if (n.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree1(n, node.Checked);
                }
            }
        }
        /// <summary>
        /// 改变指定节点的子节点的选中状态
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="isChecked"></param>
        private void checkChildrenNodeLayertree1(TreeNode parentNode, bool isChecked)
        {
            foreach (TreeNode childNode in parentNode.Nodes)
            {
                childNode.Checked = isChecked;
                if (childNode.Tag is GSOLayer)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null)
                    {
                        layer.Visible = isChecked;
                        globeControl1.Globe.Refresh();
                    }
                }
                if (childNode.Tag is GSOTerrain)
                {
                    GSOTerrain feat = childNode.Tag as GSOTerrain;
                    feat.Visible = isChecked;
                    globeControl1.Globe.Refresh();
                }
                if (childNode.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree1(childNode, isChecked);
                }
            }
        }
        private TreeNode queryNode(TreeNode node,string txt)
        {
            foreach (TreeNode n in node.Nodes)
            {
                if (txt.Equals(n.Text))
                {
                    return n;
                }
                return queryNode(n, txt);
            }
            return null;
            
        }
        /// <summary>
        /// 改变指定节点的子节点的选中状态
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="isChecked"></param>
        private void checkChildrenNodeLayertree2(TreeNode parentNode,bool isChecked)
        {
            foreach (TreeNode childNode in parentNode.Nodes)
            {
                childNode.Checked = isChecked;
                if (childNode.Tag is GSOLayer)
                {
                    GSOLayer layer = childNode.Tag as GSOLayer;
                    if (layer != null)
                    {
                        layer.Visible = isChecked;
                        globeControl2.Globe.Refresh();
                    }
                }
                if (childNode.Tag is GSOTerrain)
                {
                    GSOTerrain feat = childNode.Tag as GSOTerrain;
                    feat.Visible = isChecked;
                    globeControl2.Globe.Refresh();
                }
                if (childNode.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree2(childNode, isChecked);
                }
            }
        }

        /// <summary>
        /// 改变指定节点的选中状态
        /// </summary>
        /// <param name="node"></param>
        /// <param name="bChecked"></param>
        private void CheckTreeNode(TreeNode node, Boolean bChecked)
        {
            CheckChildTreeNode(node, bChecked);

            // 对于kml图层，如果当前处理的节点是true，那么要把所有的祖宗节点置为true
            // 只有所有节点都未false，那么这个节点才为false
            // CheckFatherTreeNode(node, bChecked);
            globeControl1.Globe.Refresh();
            globeControl2.Globe.Refresh();

        }
        private void CheckChildTreeNode(TreeNode node, Boolean bChecked)
        {
            if (node == null)
            {
                return;
            }
            if (node.Tag != null)
            {
                if (node.Tag.GetType() == typeof(GSOFeatureFolder) ||
                    node.Tag.GetType() == typeof(GSOFeature))
                {

                    //((GSOFeature)node.Tag).Visible = bChecked;

                    // 注意不可调用上面的那个方法，因为上面的那个本身也是递归的
                    // CheckChildTreeNode 是个递归的过程，所以只需要设置调用SetVisibleDirectly
                    // 直接设置Feature自己的可见性即可
                    ((GSOFeature)node.Tag).SetVisibleDirectly(bChecked);
                }
                else
                {
                    GSOLayer curLayer = node.Tag as GSOLayer;
                    GSOTerrain curTerrain = node.Tag as GSOTerrain;
                    if (curLayer != null)
                    {
                        curLayer.Visible = bChecked;
                    }
                    else if (curTerrain != null)
                    {
                        curTerrain.Visible = bChecked;

                    }
                }
            }
            // 递归处理子节点
            for (int i = 0; i < node.Nodes.Count; i++)
            {
                node.Nodes[i].Checked = bChecked;
                CheckChildTreeNode(node.Nodes[i], bChecked);
            }
        }
        /// <summary>
        /// 目标图层按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem1_Click(object sender, EventArgs e)
        {
            if (!toolStripMenuItem1.Checked)
            {
                TreeNode node = contextMenuStrip1.Tag as TreeNode;
                toolStripMenuItem1.Checked = true;
                GSOLayer layer = globeControl2.Globe.Layers.GetLayerByCaption(node.Text);
                //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
                globeControl2.Globe.DestLayerFeatureAdd = layer;
            }
        }
        /// <summary>
        /// 可选择按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem2_Click(object sender, EventArgs e)
        {
            TreeNode node = contextMenuStrip1.Tag as TreeNode;
            Int32 nIndex = node.Index;
            GSOLayer layer = globeControl2.Globe.Layers[nIndex];
            toolStripMenuItem2.Checked = !toolStripMenuItem2.Checked;
            layer.Selectable = toolStripMenuItem2.Checked;
        }
        /// <summary>
        /// 可编辑按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem3_Click(object sender, EventArgs e)
        {
            TreeNode node = contextMenuStrip1.Tag as TreeNode;
            //GSOLayer layer = node.Tag as GSOLayer;
            //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
            GSOLayer layer = globeControl2.Globe.Layers.GetLayerByCaption(node.Text);
            toolStripMenuItem3.Checked = !toolStripMenuItem3.Checked;
            layer.Editable = toolStripMenuItem3.Checked;
        }
        /// <summary>
        /// 保存按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void toolStripMenuItem4_Click(object sender, EventArgs e)
        {
            TreeNode node = contextMenuStrip1.Tag as TreeNode;

            Int32 nIndex = node.Index;
            string layerCaption = node.Text;
            //GSOLayer layer = globeControl1.Globe.Layers.GetLayerByID((int)node.Tag);
            GSOLayer layer = globeControl2.Globe.Layers.GetLayerByCaption(layerCaption);
            //globeControl1.Globe.Layers[nIndex].Save();
            layer.Dataset.Save();
        }
        /// <summary>
        /// 移除图层按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void 移除图层ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TreeNode node = contextMenuStrip1.Tag as TreeNode;
            TreeNode parentNode = node.Parent;
            Int32 nIndex = node.Index;

            if (parentNode == layerManagerNode)
            {
                string layername = globeControl2.Globe.Layers[nIndex].Name;
                globeControl2.Globe.Layers.Remove(nIndex);

                globeControl2.Globe.DataManager.DeleteDataSourceByName(layername); // 1， 多次添加同一个图层， lrp不行， kml可以。 2， datamanager removeby 3.remove delete difference
            }
            else
            {
                globeControl2.Globe.Terrains.Remove(nIndex);
            }
            node.Remove();
            globeControl2.Globe.Refresh();
        }
        /// <summary>
        /// 节点树选中状态改变事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void layerTree1_AfterCheck(object sender, TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                if (e.Node.Tag != null)
                {
                    if (e.Node.Tag is GSOLayer)
                    {
                        GSOLayer layer = e.Node.Tag as GSOLayer;
                        if (layer != null)
                        {
                            layer.Visible = e.Node.Checked;
                            globeControl1.Globe.Refresh();
                        }
                    }
                    if (e.Node.Tag is GSOTerrain)
                    {

                        GSOTerrain feat = e.Node.Tag as GSOTerrain;
                        feat.Visible = e.Node.Checked;
                        globeControl1.Globe.Refresh();

                    }
                }

                CheckParentNode(e.Node);
                if (e.Node.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree1(e.Node, e.Node.Checked);
                }

                //setLayerTree2(e.Node);
            }
        }

        private void setLayerTree2(TreeNode node)
        {
            if (node.Tag != null)
            {
                if (node.Tag is GSOLayer)
                {
                    GSOLayer layer = globeControl2.Globe.Layers.GetLayerByCaption(node.Text);
                    if (layer != null)
                    {
                        layer.Visible = node.Checked;
                        globeControl2.Globe.Refresh();
                    }
                }
                if (node.Tag is GSOTerrain)
                {

                    GSOTerrain feat = globeControl2.Globe.Terrains.GetTerrainByCaption(node.Text);
                    feat.Visible = node.Checked;
                    globeControl2.Globe.Refresh();
                }
            }
            TreeNode n= queryNodeFromTree(node.Text, layerTree2);
            if (n != null)
            {
                n.Checked = node.Checked;
                CheckParentNode(n);
                if (n.Nodes.Count > 0)
                {
                    checkChildrenNodeLayertree2(n, node.Checked);
                }
            }  
        }

        private TreeNode queryNodeFromTree(string txt , TreeView tree)
        {
            TreeNode node = null;
            foreach (TreeNode n in tree.Nodes)
            {
                if (n.Text.Equals(txt))
                {
                    return n;
                }
                node = queryChildNode(txt, n);
                if (null != node)
                {
                    return node;
                }
            }
            return null;
        }

        private TreeNode queryChildNode(String txt, TreeNode parent)
        {
            TreeNode child = null;
            foreach (TreeNode node in parent.Nodes)
            {
                if (txt.Equals(node.Text))
                {
                    return node;
                }
                child = queryChildNode(txt, node);
                if (null != child)
                {
                    return child;
                }
            }
            return null;
        }

        
        /// <summary>
        /// 树节点选中方法
        /// </summary>
        /// <param name="e"></param>
        private void CheckControl(TreeViewEventArgs e)
        {
            if (e.Action != TreeViewAction.Unknown)
            {
                if (e.Node != null && !Convert.IsDBNull(e.Node))
                {
                    CheckParentNode(e.Node);
                    if (e.Node.Nodes.Count > 0)
                    {
                        CheckAllChildNodes(e.Node, e.Node.Checked);
                    }
                }
            }
        }
        /// <summary>
        /// 改变所有子节点的状态
        /// </summary>
        /// <param name="pn"></param>
        /// <param name="IsChecked"></param>
        private void CheckAllChildNodes(TreeNode pn, bool IsChecked)
        {
            foreach (TreeNode tn in pn.Nodes)
            {
                tn.Checked = IsChecked;
                if (tn.Tag.ToString().Contains("|"))
                {
                    string nodeTag = tn.Tag.ToString().Split('|')[1];
                    GSOLayer layer = globeControl1.Globe.Layers.GetLayerByCaption(nodeTag);
                    if (layer != null)
                    {
                        layer.Visible = IsChecked;
                        globeControl1.Globe.Refresh();
                    }
                }
                if (tn.Tag is GSOFeature)
                {
                    if (tn.Nodes.Count == 0)
                    {
                        GSOFeature feat = tn.Tag as GSOFeature;
                        feat.Visible = IsChecked;
                        globeControl1.Globe.Refresh();
                    }
                }
                if (tn.Nodes.Count > 0)
                {
                    CheckAllChildNodes(tn, IsChecked);
                }
            }
        }
        /// <summary>
        /// 改变父节点的选中状态，此处为所有子节点不选中时才取消父节点选中，可以根据需要修改
        /// </summary>
        /// <param name="curNode"></param>
        private void CheckParentNode(TreeNode curNode)
        {
            bool bChecked = false;

            if (curNode.Parent != null)
            {
                foreach (TreeNode node in curNode.Parent.Nodes)
                {
                    if (node.Checked)
                    {
                        bChecked = true;
                        break;
                    }
                }

                if (bChecked)
                {
                    curNode.Parent.Checked = true;
                    CheckParentNode(curNode.Parent);
                }
                else
                {
                    curNode.Parent.Checked = false;
                    CheckParentNode(curNode.Parent);
                }
            }
        }
    }
}