/******************************
* 说明：自定义TreeView
* 创建人：龚宇超
* 创建日期：2017-09-04
* 修改人：
* 修改日期：
* 修改备注：
* 版本：1.0.0.0
******************************/
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 Lskj.Business.Impl;
using Lskj.Business;

namespace Lskj.Control
{
    /// <summary>
    /// 自定义TreeView
    /// </summary>
    public partial class TreeViewEx : UserControl
    {
        private string checkValues;
        private DragTreeNodeEventHandler dragEvent;
        public delegate void DragTreeNodeEventHandler(TreeNode ParentNode);
        #region public property
        /// <summary>
        /// The tree node key field
        /// </summary>
        public string TreeNodeKeyField;
        /// <summary>
        /// The tree node text field
        /// </summary>
        public string TreeNodeTextField;
        /// 弹出框回车事件
        /// </summary>
        public event KeyEventHandler OnGridViewEnter;
        /// <summary>
        ///单击节点事件
        /// </summary>
        public event TreeNodeMouseClickEventHandler OnTreeNodeMouseClick;
        /// <summary>
        ///双击节点事件
        /// </summary>
        public event TreeNodeMouseClickEventHandler OnTreeNodeMouseDoubleClick;
        /// <summary>
        /// 数据源
        /// </summary>
        /// <value>The data source.</value>
        public DataTable DataSource { private set; get; }
        /// <summary>
        /// 选中树节点后
        /// </summary>
        public event TreeViewEventHandler TreeNodeSelectAfter;
        /// <summary>
        /// Gets the TreeView.
        /// </summary>
        /// <value>The TreeView.</value>
        public TreeView TreeView { get { return tvMain; } }
        public int SpecNoLen = 2;
        //树节点长度限制
        public string TreeNodeLength;
        //树节点禁止默认排序
        public bool TreeInhibitSort;
        //树节点选中模式，0默认，1不自动选中子节点
        public string TreeCheckModel = "0";

        #endregion

        public TreeViewEx()
        {
            InitializeComponent();
            this.btnSearch.Click += BtnSearch_Click;
            this.txt_Key.KeyDown += txt_Key_KeyDown;
            this.tvMain.AfterCheck += new System.Windows.Forms.TreeViewEventHandler(this.tvMain_AfterCheck);
            this.tvMain.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.tvMain_AfterSelect);
            this.tvMain.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.OnTreeMouseClick);
            this.tvMain.NodeMouseDoubleClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.OnTreeMouseDoubleClick);
            this.tvMain.KeyUp += new System.Windows.Forms.KeyEventHandler(this.OntvMainKeyUp);
        }

        #region public method
        /// <summary>
        /// <para>说明：绑定树结构</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="treeTable">The tree table.</param>
        public void BindTreeView(DataTable treeTable)
        {
            this.DataSource = treeTable;
            this.tvMain.Nodes.Clear();
            this.tvMain.BeginUpdate();
            if (treeTable != null && treeTable.Rows.Count > 0)
            {
                if (!TreeInhibitSort)
                {
                    treeTable = treeTable.Rows.Cast<DataRow>().Where(y => !string.IsNullOrEmpty(y[TreeNodeKeyField] + "")).OrderBy(x => x[TreeNodeKeyField]).CopyToDataTable();
                }
                int TreeDigit = treeTable.Rows[0][TreeNodeKeyField].ToString().Length;
                if (string.IsNullOrEmpty(treeTable.Rows[0][TreeNodeTextField] + ""))
                {
                    treeTable.Rows.RemoveAt(0);
                }
                this.Tag = treeTable.Rows[0];
                DataColumnCollection dcc = treeTable.Columns;

                DataTable treeTableNew = treeTable.Copy();
                int lengthLimitation = 0;
                string sort = "remark";
                if (!string.IsNullOrWhiteSpace(TreeNodeLength))
                {
                    lengthLimitation = int.Parse(TreeNodeLength);
                    treeTable = treeTable.Rows.Cast<DataRow>().Where(y => !string.IsNullOrEmpty(y[TreeNodeKeyField] + "") && (y[TreeNodeKeyField] + "").Length <= lengthLimitation).OrderBy(x => x[TreeNodeKeyField]).CopyToDataTable();
                }
                Dictionary<string, List<TreeNode>> nodesDic = new Dictionary<string, List<TreeNode>>();
                for (int i = 0; i < treeTable.Rows.Count; i++)
                {
                    DataRow dr = treeTable.Rows[i];
                    string tnKey = dr[TreeNodeKeyField] + "";
                    string tnStr = dr[TreeNodeTextField] + "";

                    if (SystemInfo.Instance.TreeSpecialBinding && treeTable.Columns.Contains("pid"))
                    {
                        string pKey = dr["pid"] + "";
                        //pKey = pKey.Substring(0, pKey.Length - 1);
                        TreeNode[] nodes = tvMain.Nodes.Find(pKey, true);
                        if (nodes.Count() > 0)
                        {
                            TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                            if (nodesDic.ContainsKey(tnKey))
                            {
                                List<TreeNode> childNodesList = nodesDic[tnKey];
                                childNodesList.Add(tNode);
                            }
                            else
                            {
                                List<TreeNode> childNodesList = new List<TreeNode>();
                                childNodesList.Add(tNode);
                                nodesDic.Add(tnKey, childNodesList);
                            }
                            tNode.Tag = tnKey;
                        }
                        else
                        {
                            TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                            if (nodesDic.ContainsKey(tnKey))
                            {
                                List<TreeNode> childNodesList = nodesDic[tnKey];
                                childNodesList.Add(tNode);
                            }
                            else
                            {
                                List<TreeNode> childNodesList = new List<TreeNode>();
                                childNodesList.Add(tNode);
                                nodesDic.Add(tnKey, childNodesList);
                            }
                            tNode.Tag = tnKey;
                        }
                    }
                    else
                    {
                        if (tnKey.Length >= TreeDigit * 2)
                        {
                            string pKey = tnKey.Substring(0, tnKey.Length - TreeDigit);
                            //List<TreeNode> nodes = nodesDic.ContainsKey(pKey) ? nodesDic[pKey] : new List<TreeNode>();
                            TreeNode[] nodes = tvMain.Nodes.Find(pKey, true);
                            if (nodes.Count() > 0)
                            {
                                TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                                if (nodesDic.ContainsKey(tnKey))
                                {
                                    List<TreeNode> childNodesList = nodesDic[tnKey];
                                    childNodesList.Add(tNode);
                                }
                                else
                                {
                                    List<TreeNode> childNodesList = new List<TreeNode>();
                                    childNodesList.Add(tNode);
                                    nodesDic.Add(tnKey, childNodesList);
                                }
                                tNode.Tag = tnKey;
                            }
                            else
                            {
                                TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                                if (nodesDic.ContainsKey(tnKey))
                                {
                                    List<TreeNode> childNodesList = nodesDic[tnKey];
                                    childNodesList.Add(tNode);
                                }
                                else
                                {
                                    List<TreeNode> childNodesList = new List<TreeNode>();
                                    childNodesList.Add(tNode);
                                    nodesDic.Add(tnKey, childNodesList);
                                }
                                tNode.Tag = tnKey;
                            }
                        }
                        else
                        {
                            TreeNode node = tvMain.Nodes.Add(tnKey, tnStr);
                            if (nodesDic.ContainsKey(tnKey))
                            {
                                List<TreeNode> childNodesList = nodesDic[tnKey];
                                childNodesList.Add(node);
                            }
                            else
                            {
                                List<TreeNode> childNodesList = new List<TreeNode>();
                                childNodesList.Add(node);
                                nodesDic.Add(tnKey, childNodesList);
                            }
                            node.Tag = tnKey;
                        }
                    }
                }
                if (!string.IsNullOrWhiteSpace(TreeNodeLength))
                {
                    treeTable = treeTableNew.Copy();
                    treeTable = treeTable.Rows.Cast<DataRow>().Where(y => !string.IsNullOrEmpty(y[TreeNodeKeyField] + "") && (y[TreeNodeKeyField] + "").Length > lengthLimitation).OrderBy(x => x[sort]).CopyToDataTable();
                    for (int i = 0; i < treeTable.Rows.Count; i++)
                    {
                        DataRow dr = treeTable.Rows[i];
                        string tnKey = dr[TreeNodeKeyField] + "";
                        string tnStr = dr[TreeNodeTextField] + "";
                        string tnKeyNew = tnKey.Substring(0, lengthLimitation);
                        string sortValue = dr[sort] + "";
                        if (!sortValue.Contains("-"))
                        {
                            //没有包含 - ，直接加入指定位数的节点中
                            TreeNode[] nodes = tvMain.Nodes.Find(tnKeyNew, true);
                            if (nodes.Count() > 0)
                            {
                                TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                                if (nodesDic.ContainsKey(tnKey))
                                {
                                    List<TreeNode> childNodesList = nodesDic[tnKey];
                                    childNodesList.Add(tNode);
                                }
                                else
                                {
                                    List<TreeNode> childNodesList = new List<TreeNode>();
                                    childNodesList.Add(tNode);
                                    nodesDic.Add(tnKey, childNodesList);
                                }
                                tNode.Tag = tnKey;
                            }
                            else
                            {
                                TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                                if (nodesDic.ContainsKey(tnKey))
                                {
                                    List<TreeNode> childNodesList = nodesDic[tnKey];
                                    childNodesList.Add(tNode);
                                }
                                else
                                {
                                    List<TreeNode> childNodesList = new List<TreeNode>();
                                    childNodesList.Add(tNode);
                                    nodesDic.Add(tnKey, childNodesList);
                                }
                                tNode.Tag = tnKey;
                            }
                        }
                        else
                        {
                            //包含 - ，寻找对应特殊排序字段的父节点
                            //找到特殊排序字段中对应的父级
                            string parentNodeSortValue = sortValue.Remove(sortValue.LastIndexOf("-"), sortValue.Length - sortValue.LastIndexOf("-"));
                            //根据指定位数的编号和特殊排序字段找到指定父级
                            DataTable dataTable = treeTable.Rows.Cast<DataRow>().Where(y => (y[TreeNodeKeyField] + "").Substring(0, lengthLimitation).Equals(tnKeyNew) && (y[sort] + "").Equals(parentNodeSortValue)).OrderBy(x => x[sort]).CopyToDataTable();
                            if (dataTable != null)
                            {
                                TreeNode[] nodes = tvMain.Nodes.Find(dataTable.Rows[0][TreeNodeKeyField] + "", true);
                                if (nodes.Count() > 0)
                                {
                                    TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                                    if (nodesDic.ContainsKey(tnKey))
                                    {
                                        List<TreeNode> childNodesList = nodesDic[tnKey];
                                        childNodesList.Add(tNode);
                                    }
                                    else
                                    {
                                        List<TreeNode> childNodesList = new List<TreeNode>();
                                        childNodesList.Add(tNode);
                                        nodesDic.Add(tnKey, childNodesList);
                                    }
                                    tNode.Tag = tnKey;
                                }
                                else
                                {
                                    TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                                    if (nodesDic.ContainsKey(tnKey))
                                    {
                                        List<TreeNode> childNodesList = nodesDic[tnKey];
                                        childNodesList.Add(tNode);
                                    }
                                    else
                                    {
                                        List<TreeNode> childNodesList = new List<TreeNode>();
                                        childNodesList.Add(tNode);
                                        nodesDic.Add(tnKey, childNodesList);
                                    }
                                    tNode.Tag = tnKey;
                                }
                            }
                        }
                        //TreeNode[] nodes = tvMain.Nodes.Find(tnKeyNew, true);
                    }
                }
            }
            this.tvMain.EndUpdate();
            // 默认展开第一个节点
            if (this.tvMain.Nodes.Count > 0)
                this.tvMain.Nodes[0].Expand();
        }
        /// <summary>
        /// <para>说明：绑定树结构</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="treeTable">The tree table.</param>
        public void BindTreeView(DataTable treeTable, string specialId)
        {
            string keyField = "pid";
            this.DataSource = treeTable;
            TreeNodeKeyField = specialId;
            this.tvMain.Nodes.Clear();
            this.tvMain.BeginUpdate();
            if (treeTable != null && treeTable.Rows.Count > 0)
            {
                if (!TreeInhibitSort)
                {
                    treeTable = treeTable.Rows.Cast<DataRow>().OrderBy(x => x["orderid"] + "").CopyToDataTable();
                }

                DataColumnCollection dcc = treeTable.Columns;
                for (int i = 0; i < treeTable.Rows.Count; i++)
                {
                    DataRow dr = treeTable.Rows[i];
                    string tnparentKey = dr[keyField] + "";
                    string tnKey = dr[TreeNodeKeyField] + "";
                    string tnStr = dr[TreeNodeTextField] + "";
                    if (tnparentKey == "0")
                    {
                        TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                        tNode.Tag = tnKey;
                        DataRow[] rowItems = treeTable.Rows.Cast<DataRow>().Where(x => tnKey.Equals(x[keyField] + "")).ToArray();

                        if (rowItems != null && rowItems.Count() > 0)
                        {
                            AddChildNode(tNode, keyField, treeTable, rowItems.OrderBy(x => Convert.ToInt32(x["orderid"] + "")).CopyToDataTable());
                        }
                    }
                }
            }
            this.tvMain.EndUpdate();

            // 默认展开第一个节点
            if (this.tvMain.Nodes.Count > 0)
                this.tvMain.Nodes[0].Expand();
        }
        /// <summary>
        /// <para>说明：绑定树结构</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="treeTable">The tree table.</param>
        public void BindTreeView(DataTable treeTable, string TreeNodeKeyField, string TreeNodeTextField, string tagStrField)
        {
            this.DataSource = treeTable;
            this.tvMain.Nodes.Clear();
            this.tvMain.BeginUpdate();
            if (treeTable != null && treeTable.Rows.Count > 0)
            {
                treeTable = treeTable.Rows.Cast<DataRow>().Where(y => !string.IsNullOrEmpty(y[TreeNodeKeyField] + "")).OrderBy(x => x[TreeNodeKeyField]).CopyToDataTable();
                int TreeDigit = treeTable.Rows[0][TreeNodeKeyField].ToString().Length;
                if (string.IsNullOrEmpty(treeTable.Rows[0][TreeNodeTextField] + ""))
                {
                    treeTable.Rows.RemoveAt(0);
                }
                this.Tag = treeTable.Rows[0];
                DataColumnCollection dcc = treeTable.Columns;
                for (int i = 0; i < treeTable.Rows.Count; i++)
                {
                    DataRow dr = treeTable.Rows[i];
                    string tnKey = dr[TreeNodeKeyField] + "";
                    string tnStr = dr[TreeNodeTextField] + "";
                    string tagStr = dr[tagStrField] + "";
                    if (tnKey.Length >= TreeDigit * 2)
                    {
                        string pKey = tnKey.Substring(0, tnKey.Length - TreeDigit);
                        TreeNode[] nodes = tvMain.Nodes.Find(pKey, true);
                        if (nodes.Count() > 0)
                        {
                            TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                            tNode.Tag = tagStr;
                        }
                        else
                        {
                            TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                            tNode.Tag = tagStr;
                        }
                    }
                    else
                    {
                        TreeNode node = tvMain.Nodes.Add(tnKey, tnStr);
                        node.Tag = tagStr;
                    }
                }
            }
            this.tvMain.EndUpdate();

            // 默认展开第一个节点
            if (this.tvMain.Nodes.Count > 0)
                this.tvMain.Nodes[0].Expand();
        }
        /// <summary>
        /// <para>说明：添加子节点</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2020-12-20 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="treeNode">The tree node.</param>
        /// <param name="childs">The childs.</param>
        public void AddChildNode(TreeNode treeNode, string keyField, DataTable treeTable, DataTable childs)
        {
            foreach (DataRow item in childs.Rows)
            {
                string tnparentKey = item[keyField] + "";
                string tnKey = item[TreeNodeKeyField] + "";
                string tnStr = item[TreeNodeTextField] + "";

                TreeNode tNode = treeNode.Nodes.Add(tnKey, tnStr);
                tNode.Tag = tnKey;

                DataRow[] rowItems = treeTable.Rows.Cast<DataRow>().Where(x => tnKey.Equals(x[keyField] + "")).ToArray();

                if (rowItems != null && rowItems.Count() > 0)
                {
                    AddChildNode(tNode, keyField, treeTable, rowItems.OrderBy(x => Convert.ToInt32(x["orderid"] + "")).CopyToDataTable());
                }
            }
        }
        /// <summary>
        /// <para>说明：开启树结构拖拽</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2020-12-20 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="dragCall">The drag call.</param>
        public void EnableTreeNodeDrag(DragTreeNodeEventHandler dragEvent)
        {
            this.dragEvent = dragEvent;
            this.tvMain.AllowDrop = true;
            this.tvMain.ItemDrag += new ItemDragEventHandler(OnMainItemDrag);
            this.tvMain.DragEnter += new DragEventHandler(tvMain_DragEnter);
            this.tvMain.DragOver += new DragEventHandler(tvMain_DragOver);
            this.tvMain.DragDrop += new DragEventHandler(tvMain_DragDrop);
            this.tvMain.KeyDown += new KeyEventHandler(tvMain_KeyDown);
        }
        /// <summary>
        /// <para>说明：绑定特殊树结构</para>
        /// <para>创建人：王一帆</para>
        /// <para>创建日期：2019-09-05 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="treeTable">The tree table.</param>
        public void BindSpecialTreeView(DataTable treeTable)
        {
            this.DataSource = treeTable;

            this.tvMain.Nodes.Clear();
            this.tvMain.BeginUpdate();
            if (treeTable != null && treeTable.Rows.Count > 0)
            {
                treeTable = treeTable.Rows.Cast<DataRow>().Where(y => !string.IsNullOrEmpty(y[TreeNodeKeyField] + "")).OrderBy(x => x[TreeNodeKeyField]).CopyToDataTable();
                this.Tag = treeTable.Rows[0];
                SpecNoLen = treeTable.Rows[0]["SpeciesNo"].ToString().Length;

                for (int i = 0; i < treeTable.Rows.Count; i++)
                {
                    DataRow dr = treeTable.Rows[i];
                    string tnKey = dr[TreeNodeKeyField] + "";
                    string tnStr = dr[TreeNodeTextField] + "";

                    if (SystemInfo.Instance.TreeSpecialBinding && treeTable.Columns.Contains("pid"))
                    {
                        string pKey = dr["pid"] + "";
                        TreeNode[] nodes = tvMain.Nodes.Find(pKey, true);
                        if (nodes.Count() > 0)
                        {
                            TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                            tNode.Tag = tnKey;
                        }
                        else
                        {
                            TreeNode tNode = this.TreeView.Nodes.Add(tnKey, tnStr);
                            tNode.Tag = tnKey;
                        }
                    }
                    else
                    {
                        if (tnKey.Length > SpecNoLen)
                        {
                            String pKey = tnKey.Substring(0, tnKey.Length - SpecNoLen);
                            TreeNode[] nodes = tvMain.Nodes.Find(pKey, true);
                            if (nodes.Length > 0)
                            {
                                TreeNode tNode = nodes[0].Nodes.Add(tnKey, tnStr);
                                tNode.Tag = tnKey;
                            }
                        }
                        else
                        {
                            TreeNode node = tvMain.Nodes.Add(tnKey, tnStr);
                            node.Tag = tnKey;
                        }
                    }

                }
            }
            this.tvMain.EndUpdate();
        }
        /// <summary>
        /// <para>说明：获取控件选择值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <returns>System.String.</returns>
        public string GetCheckValues(bool isRootNode)
        {
            checkValues = string.Empty;
            foreach (TreeNode tn in tvMain.Nodes)
                GetCheckedState(tn, isRootNode);
            return checkValues.Trim(',');
        }

        public string GetCheckValues()
        {
            checkValues = string.Empty;
            foreach (TreeNode tn in tvMain.Nodes)
                GetCheckedState(tn, true);
            return checkValues.Trim(',');
        }


        /// <summary>
        /// <para>说明：获取复选框选中值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <returns>System.String.</returns>
        public string GetSelectValue()
        {
            checkValues = string.Empty;
            TreeNode currNode = tvMain.SelectedNode;
            if (currNode != null)
            {
                checkValues = currNode.Name;
            }
            return checkValues;
        }
        /// <summary>
        /// <para>说明：获取选中节点值</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2018-01-02 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <returns>System.String.</returns>
        public string GetSelectNodeValue()
        {
            string parentValue = string.Empty;
            if (this.TreeView.SelectedNode != null)
            {
                parentValue = this.TreeView.SelectedNode.Tag + "";
            }
            return parentValue;
        }
        /// <summary>
        /// <para>说明：</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期： </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        public void DeleteTreeNode(TreeNode treeNode, TreeNode deleteNode)
        {
            var nodes = treeNode == null ? this.tvMain.Nodes : treeNode.Nodes;

            foreach (TreeNode item in nodes)
            {
                if (item.Tag == deleteNode.Tag)
                {
                    this.tvMain.Nodes.Remove(item);
                    break;
                }
                if (item.Nodes != null && item.Nodes.Count > 0)
                {
                    this.DeleteTreeNode(item, deleteNode);
                }
            }
        }
        /// <summary>
        /// 取消勾选所有节点
        /// </summary>
        public void UnCheckAllNodes()
        {
            try
            {
                foreach (TreeNode treeNode in this.TreeView.Nodes)
                {
                    UnCheckNode(treeNode);
                }
            }
            catch (Exception)
            {
            }
        }
        /// <summary>
        /// 取消勾选节点及子节点
        /// </summary>
        private void UnCheckNode(TreeNode treeNode)
        {
            if (treeNode.Nodes != null && treeNode.Nodes.Count > 0)
            {
                foreach (TreeNode item in treeNode.Nodes)
                {
                    item.Checked = false;
                    UnCheckNode(item);
                }
            }
        }
        #endregion

        #region private method
        /// <summary>
        /// <para>说明：选择后</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="TreeViewEventArgs"/> instance containing the event data.</param>
        private void tvMain_AfterSelect(object sender, TreeViewEventArgs e)
        {
            try
            {

                if (e.Action == TreeViewAction.ByMouse && this.TreeNodeSelectAfter != null)
                {
                    this.TreeNodeSelectAfter(sender, e);
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        /// <summary>
        /// <para>说明：选中后</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="TreeViewEventArgs"/> instance containing the event data.</param>
        public void tvMain_AfterCheck(object sender, TreeViewEventArgs e)
        {
            try
            {
                if (e.Action == TreeViewAction.ByMouse)
                {
                    if (!TreeCheckModel.Equals("1"))//不等于1选中子节点
                    {
                        SetChildNodeCheckedState(e.Node, e.Node.Checked);
                    }
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        /// <summary>
        /// <para>说明：选中节点之后，选中节点的所有子节点</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        private void GetCheckedState(TreeNode currNode, bool isRootNode = false)
        {
            bool isContain = currNode.Nodes.Count > 0 && !isRootNode;
            if (currNode.Checked && !isContain)
                checkValues += "'" + currNode.Name + "',";
            TreeNodeCollection nodes = currNode.Nodes;
            foreach (TreeNode tn in nodes)
            {
                GetCheckedState(tn, isRootNode);
            }
        }
        /// <summary>
        /// <para>说明：选中节点之后，选中节点的所有子节点</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-09-04 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        private void GetCheckedStateAll(TreeNode currNode, bool isRootNode = false)
        {

            if (currNode.Checked)
                checkValues += "'" + currNode.Name + "',";
            TreeNodeCollection nodes = currNode.Nodes;
            foreach (TreeNode tn in nodes)
            {
                GetCheckedStateAll(tn, isRootNode);
            }
        }
        /// <summary>
        /// <para>说明：选中当权节点下所有子节点</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2017-11-02 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        /// <param name="state">if set to <c>true</c> [state].</param>
        private void SetChildNodeCheckedState(TreeNode currNode, bool state)
        {
            TreeNodeCollection nodes = currNode.Nodes;
            if (nodes.Count > 0)
                foreach (TreeNode tn in nodes)
                {
                    tn.Checked = state;
                    SetChildNodeCheckedState(tn, state);
                }
        }
        #endregion

        #region 树结构拖拽
        /// <summary>
        /// <para>说明：</para>
        /// <para>创建人：龚宇超</para>
        /// <para>创建日期：2020-12-20 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="ItemDragEventArgs"/> instance containing the event data.</param>
        void OnMainItemDrag(object sender, ItemDragEventArgs e)
        {
            try
            {
                if (e.Button == MouseButtons.Left)
                {
                    DoDragDrop(e.Item, DragDropEffects.Move);
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        void tvMain_DragEnter(object sender, DragEventArgs e)
        {
            //e.Effect = DragDropEffects.Move;
        }
        void tvMain_DragOver(object sender, DragEventArgs e)
        {
            try
            {
                if (e.Data.GetDataPresent(typeof(TreeNode)))
                {
                    TreeView tv = sender as TreeView;
                    //获得拖放中的节点
                    TreeNode moveNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
                    tv.SelectedNode = tv.GetNodeAt(tv.PointToClient(new Point(e.X, e.Y)));
                    if (tv.SelectedNode != null) tv.SelectedNode.Expand();
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        void tvMain_DragDrop(object sender, DragEventArgs e)
        {
            try
            {
                if (e.Data.GetDataPresent(typeof(TreeNode)))
                {
                    TreeView tv = sender as TreeView;
                    //获得拖放中的节点
                    TreeNode moveNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
                    //根据鼠标坐标确定要移动到的目标节点
                    Point pt = ((TreeView)sender).PointToClient(new Point(e.X, e.Y));
                    TreeNode targetNode = tv.GetNodeAt(pt);
                    //如果目标节点为分组则添加到下级节点的未端,如果目标节点为素材文件则添加为同级节点
                    TreeNode NewMoveNode = (TreeNode)moveNode.Clone();
                    if (moveNode.Parent != targetNode.Parent)
                    {
                        return;

                    }
                    if (moveNode.NextNode == targetNode)
                    {
                        targetNode.Parent.Nodes.Insert(targetNode.Index + 1, NewMoveNode);
                    }
                    else
                    {
                        targetNode.Parent.Nodes.Insert(targetNode.Index, NewMoveNode);
                    }

                    //移除拖放的节点
                    moveNode.Remove();
                    //更新当前拖动的节点选择
                    tv.SelectedNode = NewMoveNode;

                    if (dragEvent != null) this.dragEvent(tv.SelectedNode.Parent);
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        /// <summary>
        /// 绑定键盘事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void tvMain_KeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                TreeView tv = sender as TreeView;
                //获得拖放中的节点
                TreeNode node = tv.SelectedNode;     //获得选中节点的值
                if (e.Modifiers.CompareTo(Keys.Control) == 0 && e.KeyCode == Keys.Down)
                {

                    if (node.NextNode == null)      //下一个节点为Null时返回  
                    {
                        return;
                    }
                    TreeNode dowNode = node.NextNode;
                    TreeNode newNode = (TreeNode)node.Clone();       //克隆下一个节点及其所有的子节点  
                    node.Parent.Nodes.Insert(dowNode.Index + 1, newNode);
                    //node.Parent.Nodes.Insert(node.Index, newNode);
                    node.Remove();           //删除掉选中节点的下一个节点  
                    tv.SelectedNode = newNode;  //重新选中  
                    if (dragEvent != null) this.dragEvent(tv.SelectedNode.Parent);
                }
                if (e.Modifiers.CompareTo(Keys.Control) == 0 && e.KeyCode == Keys.Up)
                {
                    if (node.PrevNode == null)      //下一个节点为Null时返回  
                    {
                        return;
                    }
                    TreeNode upNode = node.PrevNode;            //获得选中节点的上一个节点  
                    TreeNode newNode = (TreeNode)node.Clone();      //克隆选中的节点  
                    node.Parent.Nodes.Insert(upNode.Index, newNode);
                    node.Remove();
                    tv.SelectedNode = newNode;
                    if (dragEvent != null) this.dragEvent(tv.SelectedNode.Parent);
                }
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }


        }
        #endregion
        #region 注册回调函数
        /// <summary>
        /// <para>说明：树结构回车回调函数</para>
        /// <para>创建人：王一帆</para>
        /// <para>创建日期：2021-03-29 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        /// <param name="state">if set to <c>true</c> [state].</param>
        private void OntvMainKeyUp(object sender, KeyEventArgs e)
        {
            try
            {
                TreeNode node = this.TreeView.SelectedNode;
                if (this.OnGridViewEnter != null)
                    this.OnGridViewEnter(sender, e);
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        /// <summary>
        /// <para>说明：单击树结构回调函数</para>
        /// <para>创建人：王一帆</para>
        /// <para>创建日期：2021-03-29 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        /// <param name="state">if set to <c>true</c> [state].</param>
        private void OnTreeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            try
            {
                if (this.OnTreeNodeMouseClick != null)
                    this.OnTreeNodeMouseClick(sender, e);
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }

        /// <summary>
        /// <para>说明：双击树结构回调函数</para>
        /// <para>创建人：曹屹峰</para>
        /// <para>创建日期：2023-09-22 </para>
        /// <para>修改人：</para>
        /// <para>修改日期：</para>
        /// <para>修改备注：</para>
        /// <para>版本：1.0</para>
        /// </summary>
        /// <param name="currNode">The curr node.</param>
        /// <param name="state">if set to <c>true</c> [state].</param>
        private void OnTreeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            try
            {
                if (this.OnTreeNodeMouseDoubleClick != null)
                    this.OnTreeNodeMouseDoubleClick(sender, e);
            }
            catch (Exception ex)
            {
                string Message = ErrorMessage.PromptErrorMessage(ex);
                MessageUtil.Show(Message, ex.Message);
            }

        }
        #endregion

        //查询出来的节点集合
        public List<TreeNode> searchtreeNodes = new List<TreeNode>();


        private void BtnSearch_Click(object sender, EventArgs e)
        {
            //把上一次搜索的还原
            if (searchtreeNodes.Count > 0)
            {
                for (int i = 0; i < searchtreeNodes.Count; i++)
                {
                    TreeNode temp = searchtreeNodes[i];
                    //展开对应的节点
                    ExpandNode(temp);
                    if (i == 0 && temp.Parent != null)
                    {
                        tvMain.SelectedNode = temp.Parent;
                    }
                    temp.BackColor = Color.White;
                    //temp.ForeColor = Color.Blue;
                }

            }
            string name = txt_Key.Text + "";
            if (string.IsNullOrWhiteSpace(name)) return;
            //收起全部节点
            if (this.tvMain.Nodes.Count > 0)
            {
                //tvMain.SelectedNode.Expand();
                tvMain.SelectedNode = tvMain.Nodes[0];
                tvMain.SelectedNode.Collapse();
            }
            //清除数据
            searchtreeNodes = new List<TreeNode>();
            //获取全部节点中符合条件的节点
            foreach (TreeNode node in tvMain.Nodes)
            {
                SearchLayernew(node, name);
            }

            for (int i = 0; i < searchtreeNodes.Count; i++)
            {
                TreeNode temp = searchtreeNodes[i];
                //展开对应的节点
                ExpandNode(temp);
                if (i == 0 && temp.Parent != null)
                {
                    tvMain.SelectedNode = temp.Parent;
                }
                temp.BackColor = Color.Yellow;
            }
        }


        //展开对应的节点和它的父节点
        private void ExpandNode(TreeNode node)
        {
            if (node.Parent != null)
            {
                node.Expand();
                ExpandNode(node.Parent);
            }
        }



        //获得符合条件的节点
        private void SearchLayernew(TreeNode node, string name)
        {
            //node.BackColor = Color.White;
            //node.ForeColor = Color.Black;
            if (string.Equals(node.Text, name) || node.Text.Contains(name))
            {
                searchtreeNodes.Add(node);
            }
            if (node.Nodes.Count != 0)
            {
                for (int i = 0; i < node.Nodes.Count; i++)
                {
                    SearchLayernew(node.Nodes[i], name);
                }
            }
        }

        /// <summary>
        /// 搜索框回车事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txt_Key_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                BtnSearch_Click(null, null);
            }
        }
    }
}