CS_GIS/Search/SearchUI.Win/FormIdentifyBySpatial.cs

//======================================================================
//
//
//
//        CLR 版本: 4.0.30319.1
//        命名空间: Tofly.SearchUI.Win
//        类  名: FormIdentifyBySpatial
//        创 建 人: 汤云伟
//        创建时间: 2016/11/08 9:32:00
//        修 改 人: 
//        修改时间: 
//
//======================================================================

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using Tofly.Core.Stereotype;
using Tofly.Core.ServiceLocator;
using Tofly.CoreUI.Control;
using Tofly.CoreUI.Message;
using Tofly.CoreUI.Plot;
using Tofly.Data.General;
using Tofly.GIS;
using Tofly.GIS.Carto;
using Tofly.GIS.Geometry;
using Tofly.GIS.Util;
using Tofly.GIS.SpatialDatabase;
using Tofly.GISUI.Controls;
using Tofly.GISUI.Utils;
using Tofly.GIS.Display;
using Tofly.Core.Context.Support;

namespace Tofly.SearchUI.Win
{
    /// <summary>
    /// 以空间查询实现图形识别类（查询图形的属性数据）
    /// </summary>
    [Component(IsSingleton = "false", Name = "Tofly.SearchUI.Win.FormIdentifyBySpatial")]
    public partial class FormIdentifyBySpatial : Tofly.CoreUI.Win.Form.Forms.FormClass, Tofly.SearchUI.Query.IFormIdentifyBySpatial
    {
        #region ----- 模块级变量 -----
        private const string TopMostLayer = "<最顶图层>";
        private const string SelectableLayers = "<可选图层>";
        private const string VisibleLayers = "<可见图层>";
        private const string AllLayers = "<所有图层>";

        /// <summary>
        /// 系统主接口
        /// </summary>
        private IPluginContent _mainContent;
        /// <summary>
        /// 
        /// </summary>
        private IMap _cmap;
        /// <summary>
        /// 识别范围“图层”集合
        /// </summary>
        private List<CustomMapLayer> _lstIdentifyRange = new List<CustomMapLayer>();
        /// <summary>
        /// 参与识别工具的图层
        /// </summary>
        private List<IFeatureLayer> _lstIdentifyLayer = new List<IFeatureLayer>();
        /// <summary>
        /// 用于保存空间查询结果的字典
        /// </summary>
        private Dictionary<IFeatureLayer, List<IFeature>> _dicIdentifyResults = new Dictionary<IFeatureLayer, List<IFeature>>();
        /// <summary>
        /// 当前选择要素的数据对象
        /// </summary>
        private IFeatureLayer _layerSelected;
        /// <summary>
        /// 当前选择的要素
        /// </summary>
        private IFeature _ftrSelected;
        /// <summary>
        /// 是否正在查询附件
        /// </summary>
        private bool _bQueryingAttachments = false;
        #endregion


        #region ----- IFormIdentifyBySpatial 接口实现 -----
        /// <summary>
        /// 执行识别操作
        /// </summary>
        /// <param name="geomIdentify">进行失败操作的图形</param>
        public Dictionary<IFeatureLayer, List<IFeature>> DoIdentify(IGeometry geomIdentify)
        {
            //try
            //{
            if (this.IsDisposed)        //确保窗口有效
            {
                return null;
            }
            this._layerSelected = null;
            this._ftrSelected = null;
            this.tvIdentifyResult.Nodes.Clear();
            this._dicIdentifyResults.Clear();
            this.ShowClickedNodeInfo(null, false);                //清除表格数据
            Application.DoEvents();

            List<IFeatureLayer> __lstIdentifyLayers = this._lstIdentifyLayer;//this.GetIdentifyLayers();             //获取查询图层
            if (geomIdentify == null || __lstIdentifyLayers.Count == 0)             //没有图层时不进行任何操作返回
            {
                return null;
            }
            this.lblFeatureCount.Text = "正在查询...";
            Application.DoEvents();

            Dictionary<IFeatureLayer, List<IFeature>> __dicIdentifyResult = this.ExecuteIdentify(__lstIdentifyLayers, geomIdentify);         //对需查询的图层执行查询操作
            #region ----- 显示识别结果 -----
            if (this.identifyRange.IfTopLayers)           //在识别结果中分析顶层图层
            {
                if (this._dicIdentifyResults.Count > 0)         //通过图层树分析顶图层
                {
                    List<ILayer> __lstIdentifiedLayers = this._dicIdentifyResults.Keys.Select(flyrItem => flyrItem as ILayer).ToList();
                    ILayer __lyrTopLayer = this.GetTopMostLayer(__lstIdentifiedLayers);
                    this._dicIdentifyResults = this._dicIdentifyResults.Where(kvItem => kvItem.Key == __lyrTopLayer).ToDictionary(kvItem => kvItem.Key, kvItem => kvItem.Value);
                }
            }
            int __iCount = this._dicIdentifyResults.Sum(kvLayerFeature => kvLayerFeature.Value.Count);
            if (__iCount > 1000)
            {
                throw new System.Exception("查看范围过大,结果超过1000个,请缩小查看范围。");
            }

            this.tvIdentifyResult.Nodes.Clear();          //快速连续点击时，可能出现并发处理的必要已有结果清除
            #region 选择要素的符号缩略图集合
            IBaseSymbolHelper __symolHelper = ContextRegistry.GetContext().GetObject("Tofly.GIS.ArcGIS.Util.BaseSymbolHelper") as IBaseSymbolHelper;
            ImageList __imgList = __symolHelper.GetSelectedFeaturesSymbol(this._dicIdentifyResults);

            //移除非设计时加载的图片（动态生成的要素符号缩略图）
            while (this.imgListTV.Images.Count > 6)
            {
                this.imgListTV.Images.RemoveAt(6);
            }
            for (int __iKey = 0; __iKey < __imgList.Images.Keys.Count; __iKey++)
            {
                this.imgListTV.Images.Add(__imgList.Images.Keys[__iKey], __imgList.Images[__imgList.Images.Keys[__iKey]]);
            }
            #endregion

            foreach (var __identifyResultItem in this._dicIdentifyResults)
            {
                TreeNode __tnLayer = this.tvIdentifyResult.Nodes.Add(__identifyResultItem.Key.Name);       //图层节点
                string __strClassPrefix = __identifyResultItem.Key.FeatureClass.ObjectClassID.ToString();

                foreach (var __identifyObj in __identifyResultItem.Value)
                {
                    //__tnLayer.Nodes.Add(__identifyObj.OID.ToString());          //要素节点
                    __tnLayer.Nodes.Add(new TreeNode()
                    {
                        Text = __identifyObj.OID.ToString(),
                        ImageKey = string.Format("{0}_{1}", __strClassPrefix, __identifyObj.OID)
                    });          //要素节点
                }
            }
            this.tvIdentifyResult.ExpandAll();         //展开所有节点

            if (this.tvIdentifyResult.Nodes.Count > 0)
            {
                this.tvIdentifyResult.TopNode = tvIdentifyResult.Nodes[0];                  //显示第一节点
                this.tvIdentifyResult.SelectedNode = tvIdentifyResult.Nodes[0];             //默认选中首节点
            }
            #endregion

            return __dicIdentifyResult;
            //}
            //catch (System.Exception ex)
            //{
            //    if ((ex is System.NullReferenceException) == false)
            //    {
            //        MessageManager.Show(ex.Message, "执行查询");
            //    }
            //}
            //return null;
        }
        /// <summary>
        /// 显示鼠标当前位置
        /// </summary>
        /// <param name="mapX"></param>
        /// <param name="mapY"></param>
        public void DisplayCoordinates(double mapX, double mapY)
        {
            if (this.IsDisposed)
            {
                return;
            }

            //鼠标在按下移动时显示当时坐标
            this.txtCoordinate.Text = string.Format("{0}, {1}", mapX.ToString("########.########"), mapY.ToString("########.########")) + " " + this.MapUnitChinese(this._cmap.MapUnits);
        }
        #endregion

        /// <summary>
        /// 
        /// </summary>
        private FormIdentifyBySpatial()
        {
            InitializeComponent();
            tsbtnAttachFile.Visible = false;//隐藏“查看附件”

            this.identifyRange.DropHeight = this.Height * 2 / 3;
            this.identifyRange.LayerSelectedChanged += this.IdentifyRange_LayerSelectedChanged;
            this.ucsFeatureViewer.IsViewer = true;      //设置属性控件模式
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="content">系统主接口</param>
        public FormIdentifyBySpatial(IPluginContent content)
            : this()
        {
            this._mainContent = content;
        }

        #region ----- 实现Singleton模式(单例) -----
        /// <summary>
        /// 获取唯一的识别结果窗口对象
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        public static FormIdentifyBySpatial GetInstance(IPluginContent content) 
        {
            return Nested.GetIdentifyForm(content);
        }
        /// <summary>
        /// 内嵌类,提供惟一的识别结果窗口对象
        /// </summary>
        private class Nested
        {
            private static FormIdentifyBySpatial _frmIndentify;

            /// <summary>
            /// 获取识别结果窗口对象实例
            /// </summary>
            /// <param name="content"></param>
            /// <returns></returns>
            internal static FormIdentifyBySpatial GetIdentifyForm(IPluginContent content)
            {
                if (Nested._frmIndentify == null || Nested._frmIndentify.IsDisposed)
                {
                    Nested._frmIndentify = new FormIdentifyBySpatial(content);
                }

                return Nested._frmIndentify;
            }
        }
        #endregion

        /// <summary>
        /// 窗体初始化时加载图层过滤器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormIdentifyBySpatial_Load(object sender, EventArgs e)
        {
            try
            {
                IMapControl __cmapControl = ServiceLocatorFactory.ServiceLocator.GetInstance<IControl>(ServiceLocatorKeys.MapControl) as IMapControl;
                this._cmap = __cmapControl.Map;
                this._mainContent.ServiceLocator.ServiceValueChange += ServiceLocator_ServiceValueChange;

                this.pbarIdentify.Visible = false;          //隐藏进度条
                this.identifyRange.InitLayer();             //初始化图层树
                this.IdentifyRange_LayerSelectedChanged(null);     //初始化识别图层集合

                this.ucsFeatureViewer.CMap = this._cmap;    //设置属性浏览控件的地图引起
            }
            catch { }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormIdentifyBySpatial_Deactivate(object sender, EventArgs e)
        {
            //this.tvIdentifyRange_Leave(null, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormIdentifyBySpatial_FormClosed(object sender, FormClosedEventArgs e)
        {
            //清空列表
            this._lstIdentifyRange.Clear();
            this._dicIdentifyResults.Clear();

            this.identifyRange.LayerSelectedChanged -= this.IdentifyRange_LayerSelectedChanged;
        }

        private void tvIdentifyResult_AfterSelect(object sender, TreeViewEventArgs e)
        {
            try
            {
                if (e != null)
                {
                    this.ShowClickedNodeInfo(e.Node, true);          //显示选中要素的数据
                }
            }
            catch (System.Exception ex)
            {
                MessageManager.Show(ex.Message, "查看台帐");
            }
        }

        private void tvIdentifyRange_Leave(object sender, EventArgs e)
        {
            //this.tvIdentifyRange.Visible = false;
        }

        private void tvIdentifyRange_AfterSelect(object sender, TreeViewEventArgs e)
        {
            //try
            //{
            //    if (e != null)
            //    {
            //        this.cmbIdentifyType.Items.Clear();
            //        this.cmbIdentifyType.Items.Add(e.Node.Text);
            //        this.cmbIdentifyType.SelectedIndex = 0;
            //        this.cmbIdentifyType.Focus();
            //    }
            //}
            //catch(System.Exception ex)
            //{
            //    MessageManager.Show("设置识别范围失败：" + ex.Message);
            //}
        }

        private void cmbLayerFilter_Click(object sender, EventArgs e)
        {
            //if (this.tvIdentifyRange.Nodes.Count > 0)
            //{
            //    if (!this.tvIdentifyRange.Visible)
            //    {
            //        if (this.tvIdentifyRange.SelectedNode == null)
            //        {
            //            string __strIdentifyRange = this.cmbIdentifyType.Text;
            //            TreeNode[] __arrNodeMatched = this.tvIdentifyRange.Nodes.Find(__strIdentifyRange, true);
            //            if (__arrNodeMatched.Length > 0)
            //            {
            //                this.tvIdentifyRange.SelectedNode = __arrNodeMatched[0];
            //            }
            //            this.tvIdentifyRange.TopNode = this.tvIdentifyRange.Nodes[0];
            //        }

            //        this.tvIdentifyRange.Width = this.cmbIdentifyType.Width;
            //        this.tvIdentifyRange.Height = 200;
            //        this.tvIdentifyRange.Left = this.cmbIdentifyType.Left;
            //        this.tvIdentifyRange.Top = this.cmbIdentifyType.Top + this.cmbIdentifyType.Height;
            //        this.tvIdentifyRange.Visible = true;
            //        this.tvIdentifyRange.Focus();
            //    }
            //    else
            //    {
            //        this.tvIdentifyRange.Visible = false;
            //    }
            //}
        }
        /// <summary>
        /// 查看设备要素附件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tsbtnAttachFile_Click(object sender, EventArgs e)
        {
            try
            {
                if (this._ftrSelected == null || this._bQueryingAttachments)
                {
                    return;
                }
                #region ------------ 查询/查看附件 ------------
                Tofly.CoreUI.Control.IForm pForm = Tofly.Core.Context.Support.ContextRegistry.GetContext().GetObject("FormFTPManager", new object[] { this._ftrSelected,false }) as Tofly.CoreUI.Control.IForm;
                pForm.ShowDialog();
                #endregion
            }
            catch (System.Exception ex)
            {
                MessageManager.Show(string.Format("获取失败:{0}", ex.Message), "查看要素附件");
            } 
        }

        private void tsbtnCreateSelectionset_Click(object sender, EventArgs e)
        {
            try
            {
                this._cmap.ClearSelection();
                this._cmap.ActiveView.PartialRefresh(ViewDrawPhase.ViewGeoSelection, null, this._cmap.Extent);

                List<int> __lstFeatureOIDs = new List<int>();
                foreach (var __identifyResult in this._dicIdentifyResults)
                {
                    __lstFeatureOIDs.Clear();
                    __lstFeatureOIDs.AddRange(__identifyResult.Value.Select(feat => feat.OID));
                    __identifyResult.Key.AddSelectFeatureList(__lstFeatureOIDs);        //图层选择集更新
                }
                this._cmap.PartialRefresh(ViewDrawPhase.ViewGeoSelection, null, this._cmap.Extent);
                MessageManager.Show(string.Format("生成选择集成功."));
            }
            catch(System.Exception ex)
            {
                MessageManager.Show(string.Format("生成失败:{0}", ex.Message), "生成选择集");
            }
        }

        private void tsbtnFlashSelected_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.tvIdentifyResult.SelectedNode != null)
                {
                    IGeometry[] __arrShineGeoms = new IGeometry[0];

                    if (this.tvIdentifyResult.SelectedNode.Nodes.Count == 0)        //选择要素节点
                    {
                        __arrShineGeoms = new IGeometry[] { this._ftrSelected.ShapeCopy };
                    }
                    else   //图层节点
                    {
                        var __kvSelectedFeatureByLayer = this._dicIdentifyResults.First(kvItem => kvItem.Key.Name == this.tvIdentifyResult.SelectedNode.Text);
                        __arrShineGeoms = __kvSelectedFeatureByLayer.Value.Select(feat => feat.ShapeCopy as IGeometry).ToArray();
                    }
                    this._cmap.FlashGeometry(this._cmap.ActiveView, __arrShineGeoms, 1, 200);       //闪烁选择要素
                }
            }
            catch { }
        }

        private void FormIdentifyBySpatial_MouseEnter(object sender, EventArgs e)
        {
            if (!this.Focused)
            {
                this.Focus();
            }
        }

        private void tvIdentifyResult_MouseUp(object sender,System.Windows.Forms.MouseEventArgs e)
        {
            try
            {
                var __nodeMouseDown = this.tvIdentifyResult.GetNodeAt(e.Location);
                if (e.Button == System.Windows.Forms.MouseButtons.Right)
                {
                    //var __nodeMouseDown = this.tvIdentifyResult.GetNodeAt(e.Location);
                    if (__nodeMouseDown != null)
                    {
                        if (__nodeMouseDown != this.tvIdentifyResult.SelectedNode)
                        {
                            this.tvIdentifyResult.SelectedNode = __nodeMouseDown;         //更新选中的节点
                        }
                        this.contextMenuTree.Show(this.tvIdentifyResult, e.Location);
                    }
                }
                else if (e.Button == System.Windows.Forms.MouseButtons.Left)
                {
                    if (this.tvIdentifyResult.SelectedNode != null && __nodeMouseDown == this.tvIdentifyResult.SelectedNode)   //只在当前节点重复点击时，触发
                    {
                        this.tsbtnFlashSelected.PerformClick();         //触发要素闪烁
                    }
                }
            }
            catch { }
        }
        /// <summary>
        /// 弹出菜单点击事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void contextMenuTree_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            try
            {
                if (e == null)
                {
                    return;
                }
                List<IFeature> __lstFeatureSelected = new List<IFeature>();
                KeyValuePair<IFeatureLayer, List<IFeature>> __kvSelectedFeatureByLayer = new KeyValuePair<IFeatureLayer, List<IFeature>>();
                if (this.tvIdentifyResult.SelectedNode.Nodes.Count == 0)          //要素节点
                {
                    __kvSelectedFeatureByLayer = this._dicIdentifyResults.First(kvItem => kvItem.Key.Name == this.tvIdentifyResult.SelectedNode.Parent.Text);
                    __lstFeatureSelected.Add(__kvSelectedFeatureByLayer.Value.Find(ftrItem => ftrItem.OID == Convert.ToInt32(this.tvIdentifyResult.SelectedNode.Text)));
                }
                else       //图层节点
                {
                    __kvSelectedFeatureByLayer = this._dicIdentifyResults.First(kvItem => kvItem.Key.Name == this.tvIdentifyResult.SelectedNode.Text);
                    __lstFeatureSelected.AddRange(__kvSelectedFeatureByLayer.Value);
                }

                if (e.ClickedItem == this.miFlashFeature)
                {
                    List<IGeometry> __lstFeatureGeoms = new List<IGeometry>();

                    foreach (var __ftrSel in __lstFeatureSelected)
                    {
                        __lstFeatureGeoms.Add(__ftrSel.ShapeCopy);
                    }
                    this._cmap.FlashGeometry(this._cmap.ActiveView, __lstFeatureGeoms.ToArray(), 1, 200);       //闪烁选择要素
                }
                else if (e.ClickedItem == this.miZoomTo)
                {
                    IEnvelope __gEnv = MapSelectionHelper.GetFeaturesEnvelope(__lstFeatureSelected);
                    this._cmap.ActiveView.Extent = __gEnv;
                    this._cmap.PartialRefresh(ViewDrawPhase.ViewGeography | ViewDrawPhase.ViewGeoSelection, null, null);
                }
                else if (e.ClickedItem == this.miPanTo)
                {
                    IEnvelope __gEnvNew = MapSelectionHelper.GetFeaturesEnvelope(__lstFeatureSelected);
                    IEnvelope __gEnvCurrent = this._cmap.Extent;

                    __gEnvCurrent.CenterAt(__gEnvNew.GetCentroid());
                    this._cmap.ActiveView.Extent = __gEnvCurrent;
                    this._cmap.PartialRefresh(ViewDrawPhase.ViewGeography | ViewDrawPhase.ViewGeoSelection, null, null);
                }
                Application.DoEvents();
            }
            catch(System.Exception ex)
            {
                MessageManager.Show(ex.Message, "要素识别");
            }
        }

        #region ----- 事件处理 -----
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        private void IdentifyRange_LayerSelectedChanged(object sender)
        {
            List<ILayer> __lstSelectLayer = this.identifyRange.SelectNodeLayers();

            this._lstIdentifyLayer.Clear();
            foreach (var __layer in __lstSelectLayer)
            {
                if (__layer is IFeatureLayer)
                {
                    this._lstIdentifyLayer.Add(__layer as IFeatureLayer);
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        private void ServiceLocator_ServiceValueChange(string key, object value)
        {
            try
            {
                if (key.Equals(ServiceLocatorKeys.MapDocument))
                {
                    this.DoIdentify(null);                      //执行空识别
                }
            }
            catch { }
        }
        ///// <summary>
        ///// 地图切换（更改）事件
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        //private void Map_OnMapReplaced(object sender, IMapControlEvents2_OnMapReplacedEvent e)
        //{
        //    this.OnIdentifyRangeChanged(null);          //加载过滤器列表
        //    this.DoIdentify(null);                      //执行空识别
        //}
        /// <summary>
        /// 识别范围改变事件处理
        /// </summary>
        private void OnIdentifyRangeChanged(object item)
        {
            this._lstIdentifyRange.Clear();

            #region ----- 装载逻辑图层 -----
            CustomMapLayer topMostLayerProperty = new CustomMapLayer()         //最顶图层
            {
                Category = TopMostLayer,
                FeatureType = tfLayerFeatureType.LayerFeatureLogic,
                LayerAliasName = TopMostLayer,
                SourceLayer = null,
                Valid = true
            };
            CustomMapLayer visibleLayerProperty = new CustomMapLayer()          //可见图层
            {
                Category = VisibleLayers,
                FeatureType = tfLayerFeatureType.LayerFeatureLogic,
                LayerAliasName = VisibleLayers,
                SourceLayer = null,
                Valid = true
            };
            CustomMapLayer selectableLayerProperty = new CustomMapLayer()       //可选图层
            {
                Category = SelectableLayers,
                FeatureType = tfLayerFeatureType.LayerFeatureLogic,
                LayerAliasName = SelectableLayers,
                SourceLayer = null,
                Valid = true
            };
            CustomMapLayer allLayerProperty = new CustomMapLayer()              //所有图层
            {
                Category = AllLayers,
                FeatureType = tfLayerFeatureType.LayerFeatureLogic,
                LayerAliasName = AllLayers,
                SourceLayer = null,
                Valid = true
            };

            this._lstIdentifyRange.Add(topMostLayerProperty);
            this._lstIdentifyRange.Add(visibleLayerProperty);
            this._lstIdentifyRange.Add(selectableLayerProperty);
            this._lstIdentifyRange.Add(allLayerProperty);
            #endregion

            //List<CustomMapLayer> __lstTreeLayer = FeatureLayerHelper.GetTreeCustomLayer(this._arcHelper.FocusMap);  //获取地图中树状图层集合
            //this._lstIdentifyRange.AddRange(__lstTreeLayer);

            #region ------- 呈现识别范围 -------
            //List<tfLayerFeatureType> __lstExceptedLayerType = new List<tfLayerFeatureType>()       //排除识别的图层类型
            //{
            //    tfLayerFeatureType.LayerFeatureUnknown, 
            //    tfLayerFeatureType.LayerFeatureRaster,
            //};

            //this.cmbIdentifyType.Items.Add(FormIdentifyBySpatial.SelectableLayers);
            //this.cmbIdentifyType.SelectedIndex = 0;
            //foreach (CustomMapLayer __custMapLayerItem in _lstIdentifyRange)
            //{
            //    if (__custMapLayerItem.Valid && !__lstExceptedLayerType.Contains(__custMapLayerItem.FeatureType))
            //    {
            //        TreeNode __tnRootItem = new TreeNode(__custMapLayerItem.LayerAliasName)
            //        {
            //            Name = __custMapLayerItem.LayerAliasName,
            //            Tag = __custMapLayerItem
            //        };
            //        switch (__custMapLayerItem.FeatureType)
            //        {
            //            case tfLayerFeatureType.LayerFeatureGroupLayer:
            //                __tnRootItem.ImageKey = "LayerGroup";
            //                __tnRootItem.SelectedImageKey = "LayerGroup";
            //                break;
            //            case tfLayerFeatureType.LayerFeatureLogic:
            //                __tnRootItem.ImageKey = "LayerLogic";
            //                __tnRootItem.SelectedImageKey = "LayerLogic";
            //                break;
            //            case tfLayerFeatureType.LayerFeaturePoint:
            //                __tnRootItem.ImageKey = "LayerPoint";
            //                __tnRootItem.SelectedImageKey = "LayerPoint";
            //                break;
            //            case tfLayerFeatureType.LayerFeaturePolyline:
            //                __tnRootItem.ImageKey = "LayerLine";
            //                __tnRootItem.SelectedImageKey = "LayerLine";
            //                break;
            //            case tfLayerFeatureType.LayerFeaturePolygon:
            //                __tnRootItem.ImageKey = "LayerPolygon";
            //                __tnRootItem.SelectedImageKey = "LayerPolygon";
            //                break;
            //        }
            //        if (__custMapLayerItem.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
            //        {
            //            List<TreeNode> __lstSubLayerNodes = this.GetSubLayerNodes(__custMapLayerItem);
            //            __tnRootItem.Nodes.AddRange(__lstSubLayerNodes.ToArray());
            //        }
            //        this.tvIdentifyRange.Nodes.Add(__tnRootItem);
            //    }
            //}
            //this.tvIdentifyRange.ExpandAll();
            #endregion
        }
        #endregion

        #region ----- < 指定图层过滤器的获取方法 > -----
        /// <summary>
        /// 获取所有图层
        /// </summary>
        private List<ILayer> getAllLayers
        {
            get
            {
                List<ILayer> __lstSourceLayer = new List<ILayer>();

                List<tfLayerFeatureType> __lstExceptedLayerType = new List<tfLayerFeatureType>()       //排除识别的图层类型
                {
                    tfLayerFeatureType.LayerFeatureLogic,
                    tfLayerFeatureType.LayerFeatureUnknown,
                    tfLayerFeatureType.LayerFeatureRaster
                };
                foreach (CustomMapLayer __custMapLayerItem in this._lstIdentifyRange)
                {
                    if (__custMapLayerItem.Valid && !__lstExceptedLayerType.Contains(__custMapLayerItem.FeatureType))
                    {
                        if (__custMapLayerItem.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
                        {
                            List<ILayer> __lstSubLayerSource = this.GetSubLayerSource(__custMapLayerItem);
                            __lstSourceLayer.AddRange(__lstSubLayerSource);
                        }
                        else
                        {
                            __lstSourceLayer.Add(__custMapLayerItem.SourceLayer);
                        }
                    }

                }
                return __lstSourceLayer;
            }
        }
        /// <summary>
        /// 获取所有可选图层
        /// </summary>
        private List<ILayer> getSelectableLayers
        {
            get
            {
                List<ILayer> __lstSourceLayers = this.getAllLayers;
                __lstSourceLayers.RemoveAll(layerItem => !((IFeatureLayer)layerItem).Selectable);
                __lstSourceLayers.RemoveAll(layerItem => !layerItem.Visible);

                return __lstSourceLayers;
            }
        }
        /// <summary>
        /// 获取所有可见图层
        /// </summary>
        private List<ILayer> getVisibleLayers
        {
            get
            {
                //List<ILayer> __lstSourceLayers = this.getAllLayers;
                //__lstSourceLayers.RemoveAll(layerItem => !layerItem.Visible);

                List<ILayer> __lstSourceLayers = new List<ILayer>();
                List<tfLayerFeatureType> __lstExceptedLayerType = new List<tfLayerFeatureType>()       //排除识别的图层类型
                {
                    tfLayerFeatureType.LayerFeatureLogic,
                    tfLayerFeatureType.LayerFeatureUnknown,
                    tfLayerFeatureType.LayerFeatureRaster
                };
                foreach (CustomMapLayer __custMapLayerItem in this._lstIdentifyRange)
                {
                    if (__custMapLayerItem.Valid && !__lstExceptedLayerType.Contains(__custMapLayerItem.FeatureType) && __custMapLayerItem.SourceLayer.Visible)
                    {
                        if (__custMapLayerItem.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
                        {
                            List<ILayer> __lstSubLayerSource = this.GetSubLayerSource(__custMapLayerItem);
                            __lstSourceLayers.AddRange(__lstSubLayerSource);
                        }
                        else
                        {
                            __lstSourceLayers.Add(__custMapLayerItem.SourceLayer);
                        }
                    }
                }
                __lstSourceLayers.RemoveAll(lyrItem => !lyrItem.Visible);       //排除可能的图层组中的不可见子图层

                return __lstSourceLayers;
            }
        }

        ///// <summary>
        /////  获取图层过滤器中的图层
        ///// </summary>
        //private CustomMapLayer getTargetLayer
        //{
        //    get
        //    {
        //        int selectedIndex = cmbIdentifyType.SelectedIndex;
        //        return _lstIdentifyRange[selectedIndex];
        //    }
        //}
        /// <summary>
        /// 获取最顶图层
        /// </summary>
        private CustomMapLayer getTopmostLayer
        {
            //必须保证index为0的图层不是GroupLayer或CompositeLayer
            get
            {
                CustomMapLayer layer = null;
                int layerCount = _lstIdentifyRange.Count;
                for (int i = 4; i < layerCount; i++)
                {
                    CustomMapLayer layerProp = _lstIdentifyRange[i];
                    ILayer esriLayer = layerProp.SourceLayer;
                    if (!(esriLayer is IGroupLayer) &&
                        !(esriLayer is ICompositeLayer))
                    {
                        layer = layerProp;
                        break;
                    }
                }
                return layer;
            }
        }
        #endregion

        #region ----- 其他私有方法 -----
        /// <summary>
        /// 显示中文地图单位
        /// </summary>
        /// <param name="mapUnit"></param>
        /// <returns></returns>
        private string MapUnitChinese(Units mapUnit)
        {
            string mapUnitChinese = "未知单位";
            switch (mapUnit)
            {
                case Units.Centimeters:
                    mapUnitChinese = "厘米";
                    break;
                case Units.DecimalDegrees:
                    mapUnitChinese = "分米";
                    break;
                case Units.Decimeters:
                    mapUnitChinese = "";
                    break;
                //case Units.Feet:
                //    mapUnitChinese = "";
                //    break;
                //case Units.Inches:
                //    mapUnitChinese = "";
                //    break;
                case Units.Kilometers:
                    mapUnitChinese = "千米";
                    break;
                case Units.Meters:
                    mapUnitChinese = "米";
                    break;
                case Units.Miles:
                    mapUnitChinese = "英里";
                    break;
                case Units.Millimeters:
                    mapUnitChinese = "毫米";
                    break;
                //case Units.Yards:
                //    mapUnitChinese = "";
                //    break;
            }
            return mapUnitChinese;
        }
        /// <summary>
        /// 获取组图层中子图层集合的树节点集合
        /// </summary>
        /// <param name="groupLayer"></param>
        /// <returns></returns>
        private List<TreeNode> GetSubLayerNodes(CustomMapLayer groupLayer)
        {
            List<TreeNode> __lstLayerNodes = new List<TreeNode>();

            List<tfLayerFeatureType> __lstExceptedLayerType = new List<tfLayerFeatureType>()       //排除识别的图层类型
            {
                tfLayerFeatureType.LayerFeatureLogic,
                tfLayerFeatureType.LayerFeatureUnknown, 
                tfLayerFeatureType.LayerFeatureRaster
            };
            foreach (CustomMapLayer __custMapLayerItem in groupLayer.SubLayers)
            {
                if (__custMapLayerItem.Valid && !__lstExceptedLayerType.Contains(__custMapLayerItem.FeatureType))
                {
                    TreeNode __tnRootItem = new TreeNode(__custMapLayerItem.LayerAliasName)
                    {
                        Name = __custMapLayerItem.LayerAliasName,
                        Tag = __custMapLayerItem
                    };
                    switch (__custMapLayerItem.FeatureType)
                    {
                        case tfLayerFeatureType.LayerFeatureGroupLayer:
                            __tnRootItem.ImageKey = "LayerGroup";
                            __tnRootItem.SelectedImageKey = "LayerGroup";
                            break;
                        case tfLayerFeatureType.LayerFeatureLogic:
                            __tnRootItem.ImageKey = "LayerLogic";
                            __tnRootItem.SelectedImageKey = "LayerLogic";
                            break;
                        case tfLayerFeatureType.LayerFeaturePoint:
                            __tnRootItem.ImageKey = "LayerPoint";
                            __tnRootItem.SelectedImageKey = "LayerPoint";
                            break;
                        case tfLayerFeatureType.LayerFeaturePolyline:
                            __tnRootItem.ImageKey = "LayerLine";
                            __tnRootItem.SelectedImageKey = "LayerLine";
                            break;
                        case tfLayerFeatureType.LayerFeaturePolygon:
                            __tnRootItem.ImageKey = "LayerPolygon";
                            __tnRootItem.SelectedImageKey = "LayerPolygon";
                            break;
                    }
                    if (__custMapLayerItem.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
                    {
                        List<TreeNode> __lstSubLayerNodes = this.GetSubLayerNodes(__custMapLayerItem);
                        __tnRootItem.Nodes.AddRange(__lstSubLayerNodes.ToArray());
                    }

                    __lstLayerNodes.Add(__tnRootItem);
                }
            }

            return __lstLayerNodes;
        }
        /// <summary>
        /// 获取组图层中子图层的源图层对象集合
        /// </summary>
        /// <param name="groupLayer"></param>
        /// <returns></returns>
        private List<ILayer> GetSubLayerSource(CustomMapLayer groupLayer)
        {
            List<ILayer> __lstSourceLayer = new List<ILayer>();

            List<tfLayerFeatureType> __lstExceptedLayerType = new List<tfLayerFeatureType>()       //排除识别的图层类型
            {
                tfLayerFeatureType.LayerFeatureLogic,
                tfLayerFeatureType.LayerFeatureUnknown, 
                tfLayerFeatureType.LayerFeatureRaster
            };
            foreach (CustomMapLayer __custMapLayerItem in groupLayer.SubLayers)
            {
                if (__custMapLayerItem.Valid && !__lstExceptedLayerType.Contains(__custMapLayerItem.FeatureType))
                {
                    if (__custMapLayerItem.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
                    {
                        List<ILayer> __lstSubLayerSource = this.GetSubLayerSource(__custMapLayerItem);
                        __lstSourceLayer.AddRange(__lstSubLayerSource);
                    }
                    else
                    {
                        __lstSourceLayer.Add(__custMapLayerItem.SourceLayer);
                    }
                }
            }

            return __lstSourceLayer;
        }
        /// <summary>
        /// 获取需要进识别的图层集合
        /// </summary>
        /// <returns></returns>
        private List<ILayer> GetIdentifyLayers()
        {
            List<ILayer> __lstIdentifyLayers = new List<ILayer>();

            //string __identifyType = this.cmbIdentifyType.Text.Trim();     //获取过滤文本

            //switch (__identifyType)
            //{
            //    case AllLayers:
            //        __lstIdentifyLayers = this.getAllLayers;
            //        break;
            //    case SelectableLayers:
            //        __lstIdentifyLayers = this.getSelectableLayers;
            //        break;
            //    case VisibleLayers:
            //        __lstIdentifyLayers = this.getVisibleLayers;
            //        break;
            //    case TopMostLayer:
            //        __lstIdentifyLayers = this.getSelectableLayers;          //模拟先对所有可选图层进行识别
            //        break;
            //    default:
            //        TreeNode[] __arrNodeSelected = this.tvIdentifyRange.Nodes.Find(__identifyType, true);
            //        CustomMapLayer __custLayerSelected = __arrNodeSelected[0].Tag as CustomMapLayer;

            //        if (__custLayerSelected.FeatureType == tfLayerFeatureType.LayerFeatureGroupLayer)
            //        {
            //            __lstIdentifyLayers.AddRange(this.GetSubLayerSource(__custLayerSelected));
            //        }
            //        else
            //        {
            //            __lstIdentifyLayers.Add(__custLayerSelected.SourceLayer);
            //        }
            //        break;
            //}

            return __lstIdentifyLayers;
        }
        /// <summary>
        /// 执行识别查询
        /// </summary>
        /// <param name="identifyLayers">进行识别的图层集合</param>
        /// <param name="geomIdentify">识别范围图形</param>
        private Dictionary<IFeatureLayer, List<IFeature>> ExecuteIdentify(List<IFeatureLayer> identifyLayers, IGeometry geomIdentify)
        {
            //Dictionary<IFeatureLayer, List<IFeature>> __dicSelectedFeatureByLayer = new Dictionary<IFeatureLayer, List<IFeature>>();

            #region  ----- 显示处理进度 -----
            this.pbarIdentify.Visible = true;
            this.pbarIdentify.Maximum = 10;
            this.pbarIdentify.Minimum = 0;
            this.pbarIdentify.Value = 0;
            #endregion

            Dictionary<object, List<object>> __dicFeaturesByLayer = new Dictionary<object, List<object>>();
            List<ILayer> __lstIdenLayer = identifyLayers.Select(flayer => flayer as ILayer).ToList();
            Dictionary<object, List<object>> __dicTempLayerRow = this._cmap.GetSelectedFeaturesByGeometry(__lstIdenLayer, geomIdentify);

            if (this.identifyRange.IfTopLayers)
            {
                if (__dicTempLayerRow != null && __dicTempLayerRow.Count != 0)
                {
                    foreach (KeyValuePair<object, List<object>> __kvLayerRow in __dicTempLayerRow)
                    {
                        __dicFeaturesByLayer.Add(__kvLayerRow.Key, __kvLayerRow.Value);
                        break;
                    }
                }
            }
            else
            {
                __dicFeaturesByLayer = __dicTempLayerRow;
            }

            this.pbarIdentify.Maximum = __dicFeaturesByLayer.Count;      //更新进度条最大值
            IFeatureLayer __flayer = null;
            foreach (var __kvFeatureByLayer in __dicFeaturesByLayer)
            {
                __flayer = __kvFeatureByLayer.Key as IFeatureLayer;
                if (this._dicIdentifyResults.ContainsKey(__flayer) == false)
                {
                    this._dicIdentifyResults.Add(__kvFeatureByLayer.Key as IFeatureLayer, __kvFeatureByLayer.Value.Select(objSel => objSel as IFeature).ToList());          //追加识别结果
                }
                else
                { 
                
                }

                #region  ----- 显示处理进度 -----
                if ((this.pbarIdentify.Value + 1) > this.pbarIdentify.Maximum)
                {
                    this.pbarIdentify.Value = 0;
                }
                this.pbarIdentify.Value += 1;
                Application.DoEvents();
                #endregion
            }
            this.pbarIdentify.Value = this.pbarIdentify.Maximum;

            int __identifiedObjCount = 0;              //查询得到的要素的数量
            if (this._dicIdentifyResults.Count > 0)
            {
                __identifiedObjCount = this._dicIdentifyResults.Sum(kvSelFeaturesByLayer => kvSelFeaturesByLayer.Value.Count);
            }
            this.pbarIdentify.Visible = false;         //隐藏进度条
            this.lblFeatureCount.Text = "查询到 " + __identifiedObjCount + " 条记录";       //显示查询到的要素数量

            return this._dicIdentifyResults;
        }
        /// <summary>
        /// 显示选择节点的信息
        /// </summary>
        /// <param name="nodeClicked">被点击节点</param>
        /// <param name="doFlash">是否闪烁</param>
        private void ShowClickedNodeInfo(TreeNode nodeClicked, bool doFlash)
        {
            try
            {
                if (nodeClicked == null)
                {
                    this.ShowFeatureAttributes(null, null);         //清空显示表格数据
                }
                else
                {
                    KeyValuePair<IFeatureLayer, List<IFeature>> __kvSelectedFeatureByLayer = new KeyValuePair<IFeatureLayer, List<IFeature>>();
                    int __iFeatureIndex = -1;
                    if (nodeClicked.Nodes.Count == 0)    //要素节点
                    {
                        __iFeatureIndex = nodeClicked.Index;
                        __kvSelectedFeatureByLayer = this._dicIdentifyResults.First(kvItem => kvItem.Key.Name == nodeClicked.Parent.Text);
                    }
                    else        //图层节点
                    {
                        __kvSelectedFeatureByLayer = this._dicIdentifyResults.First(kvItem => kvItem.Key.Name == nodeClicked.Text);
                    }

                    this._layerSelected = __kvSelectedFeatureByLayer.Key;        //设置当前选择图层
                    if (__iFeatureIndex > -1)          //点击了图层下的要素
                    {
                        this._ftrSelected = __kvSelectedFeatureByLayer.Value.Find(ftrItem => ftrItem.OID == Convert.ToInt32(nodeClicked.Text));
                        this.ShowFeatureAttributes(__kvSelectedFeatureByLayer.Key, this._ftrSelected);

                        //判断是否闪烁要素
                        if (doFlash)
                        {
                            IGeometry[] __arrGeoms = new IGeometry[] { this._ftrSelected.ShapeCopy };
                            this._cmap.FlashGeometry(this._cmap.ActiveView, __arrGeoms, 1, 200);                  //图层选择要素闪烁
                            //DisplayHelper.FlashGeometry(this._arcHelper.ActiveView, new IGeometry[1] { __featureSelected.ShapeCopy }, 1, 300);     //存在延迟，切换过快后，立即关闭窗口，出现资源访问错误
                            //if (this._hookAction == null)
                            //{
                            //    this._hookAction = new HookHelperClass() { Hook = this._arcHelper.Application };
                            //}
                            //this._hookAction.DoAction(__featureSelected.ShapeCopy, esriHookActions.esriHookActionsFlash);
                            //Application.DoEvents();           //快速操作时，不能立即提交消息,否则可能
                        }
                    }
                    else    //点击了图层，同时闪烁图层下的所有要素图形
                    {
                        if (nodeClicked.Nodes.Count > 0 && this.ucsFeatureViewer.ProcessingFeature == null)   //识别（空间）查询后的首要素数据显示
                        {
                            int __iFeatOID = Convert.ToInt32(nodeClicked.Nodes[0].Text);
                            this._ftrSelected = __kvSelectedFeatureByLayer.Value.Find(ftrItem => ftrItem.OID == __iFeatOID);
                            this.ShowClickedNodeInfo(nodeClicked.Nodes[0], false);
                        }
                        Application.DoEvents();

                        IGeometry[] __arrGeoms = __kvSelectedFeatureByLayer.Value.Select(feat => feat.ShapeCopy as IGeometry).ToArray();
                        this._cmap.FlashGeometry(this._cmap.ActiveView, __arrGeoms, 1, 200);                  //图层选择要素闪烁
                    }
                    //this.tsbtnAttachFile.Enabled = false;             //设置附件按钮初始值
                    //this.tsbtnAttachFile_Click(null, null);           //判断是否有附件数据
                }
            }
            catch (System.Exception ex)
            {
                MessageManager.Show("显示失败:" + ex.Message, "显示选择设备信息");
            }
        }
        /// <summary>
        /// 显示指定要素的属性
        /// </summary>
        /// <param name="fLayerSelected">源要素图层</param>
        /// <param name="identifiedFeature">查看要素</param>
        private void ShowFeatureAttributes(IFeatureLayer fLayerSelected, IFeature identifiedFeature)
        {
            this.ucsFeatureViewer.ResetUserControlState(null);      //重置控件
            if (identifiedFeature == null)
            {
                return;
            }
            this.ucsFeatureViewer.SetFeatureView(fLayerSelected, identifiedFeature);        //设置浏览要素
        }
        /// <summary>
        /// 分析图层集合中的顶图层
        /// </summary>
        /// <param name="layers"></param>
        /// <returns></returns>
        private ILayer GetTopMostLayer(List<ILayer> layers)
        {
            ILayer __lyrTopLayer = null;

            List<ILayer> __lstLayersAnalysting = new List<ILayer>(layers);
            TreeNode __tnTopNode = null;            //分析到的顶层图层节点

            //while (__lstLayersAnalysting.Count > 1)
            //{
            //    Dictionary<ILayer, int> __dicLayerIndex = new Dictionary<ILayer, int>();
            //    TreeNode __tnTopNodeNew = null;
            //    int __iMinIndex = -1;

            //    foreach (ILayer __lyrItem in __lstLayersAnalysting)
            //    {
            //        TreeNode __tnLayer = this.tvIdentifyRange.Nodes.Find(__lyrItem.Name, true)[0];
            //        while (__tnLayer.Parent != null && __tnLayer.Parent != __tnTopNode)
            //        {
            //            __tnLayer = __tnLayer.Parent;
            //        }

            //        __dicLayerIndex.Add(__lyrItem, __tnLayer.Index);
            //        if ((__iMinIndex == -1) || (__iMinIndex > __tnLayer.Index))
            //        {
            //            __iMinIndex = __tnLayer.Index;
            //            __tnTopNodeNew = __tnLayer;
            //        }
            //    }

            //    __lstLayersAnalysting.Clear();
            //    foreach (KeyValuePair<ILayer, int> __kvItem in __dicLayerIndex)
            //    {
            //        if (__kvItem.Value == __iMinIndex)
            //        {
            //            __lstLayersAnalysting.Add(__kvItem.Key);
            //        }
            //    }
            //    __tnTopNode = __tnTopNodeNew;                //更新顶层节点
            //}
            //if (__lstLayersAnalysting.Count > 0)
            //{
            __lyrTopLayer = __lstLayersAnalysting[0];
            //}

            return __lyrTopLayer;
        }
        /// <summary>
        /// 处理附件结果
        /// </summary>
        /// <param name="showForm"></param>
        private void ProcessAttachmentsResult(bool showForm)
        {
            //this.tsbtnAttachFile.Enabled = (this._feEquipmentSelected.Attachments.Count > 0);
            //if (showForm)
            //{
            //    string __strMapRegion = ToflyGIS.BaseUtility.AppConfig.g_CurrentMapName;
            //    List<FeatureAttachment> __lstAttachment = new List<FeatureAttachment>();
            //    __lstAttachment.AddRange(this._feEquipmentSelected.Attachments);
            //    SDE_DAL.UI.FormAttachmentManage __frmAttachment = new SDE_DAL.UI.FormAttachmentManage(__strMapRegion, this._feEquipmentSelected.LayerCLSShortName, this._feEquipmentSelected.OID, __lstAttachment)
            //    {
            //        Owner = this,
            //        StartPosition = FormStartPosition.CenterParent
            //    };
            //    __frmAttachment.ShowDialog();
            //    __frmAttachment.Dispose();
            //    __frmAttachment = null;
            //}
        }

        #endregion

    }
}