lyfz_repos/其他源码/LYFZ.ComponentLibrary/ComboBoxTreeViewEx.cs

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 System.Runtime.InteropServices;
using System.Collections;

namespace LYFZ.ComponentLibrary
{
    public partial class ComboBoxTreeViewEx : ComboBox
    {
        #region 只读
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern IntPtr GetWindow(IntPtr hWnd, int uCmd);
        int GW_CHILD = 5;

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        //wParam=1为只读;wParam=0为可写
        public static extern IntPtr SendMessage(IntPtr hWnd, int msg, int wParam, int lParam);
        public const int EM_SETREADONLY = 0xcf;

        private bool _readonly = false;
        /// <summary>
        /// 只读
        /// </summary>
        public bool ReadOnly
        {
            get { return _readonly; }
            set
            {
                _readonly = value;
                if (_readonly)
                {
                    IntPtr editHandle = GetWindow(this.Handle, GW_CHILD);
                    SendMessage(editHandle, EM_SETREADONLY, 1, 0);
                }
                else
                {
                    IntPtr editHandle = GetWindow(this.Handle, GW_CHILD);
                    SendMessage(editHandle, EM_SETREADONLY, 0, 0);
                }
            }
        }
        #endregion

        private const int WM_LBUTTONDOWN = 0x201, WM_LBUTTONDBLCLK = 0x203;
        ToolStripControlHost treeViewHost;
        ToolStripDropDown dropDown;
        public ComboBoxTreeViewEx()
        {
            TreeView treeView = new TreeView();
            treeView.AfterSelect += new TreeViewEventHandler(treeView_AfterSelect);
            treeView.BeforeExpand += new TreeViewCancelEventHandler(treeView_BeforeExpand);
            treeView.BorderStyle = BorderStyle.None;

            treeViewHost = new ToolStripControlHost(treeView);
            dropDown = new ToolStripDropDown();
            dropDown.Width = this.Width;
            dropDown.Items.Add(treeViewHost);
            this.DropDownHeight = 220;

            treeView.NodeMouseClick += treeView_NodeMouseClick;

        }

        bool isNodeMouseClick = false;
        /// <summary>
        /// 是否开启节点单击事件
        /// </summary>
        [Category("控件扩展事件"), Description("是否开启节点单击事件")]
        public bool IsNodeMouseClick
        {
            get { return isNodeMouseClick; }
            set { isNodeMouseClick = value; }
        }

        //定义delegate
        public delegate void ComboBoxTreeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e);
        //用event 关键字声明事件对象
        /// <summary>
        /// 
        /// </summary>
        [Category("控件扩展事件"), Description("文本框值修改时")]
        public event ComboBoxTreeView_NodeMouseClick ComboBoxTree_NodeMouseClick;
        void treeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if (!IsNodeMouseClick) { return; }
            if (!this.AfterSelectLevelFirstNode)
            {
                if (e.Node.Level == 0)
                { return; }
            }

            if (e.Node.Nodes.Count <= 0 || (this.isSelectParentNode && e.X > (e.Node.Level + 1) * 20))//判断选中节点是否有子节点
            {
                this.Text = "";
                this.StrGetName = e.Node.Name.ToString();
                this.Tag = e.Node.Tag;
                this.Text = e.Node.Text.ToString();
                dropDown.Close();

                if (this.ComboBoxTree_NodeMouseClick != null)
                { ComboBoxTree_NodeMouseClick(sender, e); }
            }
        }


        [Browsable(true), Description("获取TreeView的节点集合"), Category("TreeView"), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Editor(typeof(TreeNodeCollection), typeof(TreeNodeCollection))]
        public TreeNodeCollection Nodes
        {
            get
            { return this.TreeView.Nodes; }
        }

        [Browsable(true), Description("获取或设置TreeView的选定节点"), Category("TreeView")]
        public TreeNode SelectedNode
        {
            set
            { this.TreeView.SelectedNode = value; }
            get
            { return this.TreeView.SelectedNode; }
        }

        private object _strkey;
        /// <summary>
        ///
        /// </summary>
        public object StrKey
        {
            set { _strkey = value; }
            get { return _strkey; }
        }

        bool isSelectParentNode = false;
        /// <summary>
        /// 是否允许选择父节点
        /// </summary>
        [Category("控件扩展事件"), Description("是否允许选择父节点")]
        public bool IsSelectParentNode
        {
            get { return isSelectParentNode; }
            set { isSelectParentNode = value; }
        }

        public TreeView TreeView
        {
            get { return treeViewHost.Control as TreeView; }
        }
        private void ShowDropDown()
        {
            if (dropDown != null)
            {
                treeViewHost.Size = new Size(DropDownWidth - 2, DropDownHeight);
                dropDown.Show(this, 0, this.Height);
            }
        }
        protected override void WndProc(ref Message m)
        {

            if (m.Msg == WM_LBUTTONDBLCLK || m.Msg == WM_LBUTTONDOWN)
            {
                ShowDropDown();
                return;
            }
            base.WndProc(ref m);
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (dropDown != null)
                {
                    dropDown.Dispose();
                    dropDown = null;
                }
            }
            base.Dispose(disposing);
        }

        #region 定义文本框值更改后触发事件
        //定义delegate
        public delegate void ComboBoxTreeView_TextChanged(object sender, TreeViewEventArgs e);
        //用event 关键字声明事件对象
        /// <summary>
        /// 
        /// </summary>
        [Category("控件扩展事件"), Description("文本框值修改时")]
        public event ComboBoxTreeView_TextChanged ComboBoxTreeViewEx_TextChanged;

        private bool _dropdownshow = false;
        /// <summary>
        /// 控件下拉是展开还是隐藏
        /// </summary>
        public bool DropDownShow
        {
            get { return _dropdownshow; }
            set { _dropdownshow = value; }
        }
        private bool _afterselectlevelfirstnode;
        /// <summary>
        /// 是否可选择第一个节点，true：可以选择，false：不能选择
        /// </summary>
        [Category("控件扩展事件"), Description("是否可选择第一个节点，true：可以选择，false：不能选择")]
        public bool AfterSelectLevelFirstNode
        {
            get { return _afterselectlevelfirstnode; }
            set { _afterselectlevelfirstnode = value; }
        }
        /// <summary>
        /// 是否设置为空，未选择
        /// </summary>
        bool isSetValueNull = false;

        /// <summary>
        /// 清空当前控件所选择的值
        /// </summary>
        public void SetTextAndTag_ValueNull()
        {
            this.Text = "";
            this.Tag = null;
            this.StrGetName = "";
            this.isSetValueNull = true;
            this.NodeClearBackColor();
        }

        private string _StrGetName = "";
        /// <summary>
        /// 获取Tag同等的Name
        /// </summary>
        public string StrGetName
        {
            get { return _StrGetName; }
            set { _StrGetName = value; }
        }
        private string _StrGetTagName = "";
        /// <summary>
        /// 获取控件TagName同等的其他控件的Tag
        /// </summary>
        public string StrGetTagName
        {
            get { return _StrGetTagName; }
            set { _StrGetTagName = value; }
        }
        /// <summary>
        /// 节点选择事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void treeView_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (this.isSetValueNull) { this.isSetValueNull = false; TreeView.SelectedNode.ForeColor = Color.Red; return; }

            if (e.Node.Nodes.Count <= 0 || this.isSelectParentNode)//判断选中节点是否有子节点
            {
                NodeClearBackColor();
                if (AfterSelectLevelFirstNode)
                {
                    this.StrGetName = TreeView.SelectedNode.Name.ToString();
                    this.Tag = TreeView.SelectedNode.Tag;
                    this.Text = TreeView.SelectedNode.Text.ToString();
                    TreeView.SelectedNode.ForeColor = Color.Red;
                    dropDown.Close();
                }
                else
                {
                    if (DropDownShow && e.Node.Level == 0)
                    {
                        if (e.Node.Level == 0 && e.Node.Text == "")
                        {
                            this.Tag = null;
                            this.Text = "";
                            dropDown.Close();
                        }
                        else
                        {
                            this.StrGetName = "";
                            this.Text = "";
                            dropDown.Close();
                        }
                    }
                    else
                    {
                        if (TreeView.SelectedNode.Name.ToString().Trim() != "")
                        {
                            this.StrGetName = TreeView.SelectedNode.Name.ToString();
                            this.Tag = TreeView.SelectedNode.Tag;
                            this.Text = TreeView.SelectedNode.Text.ToString();
                            TreeView.SelectedNode.ForeColor = Color.Red;
                            dropDown.Close();
                        }
                        else
                        {
                            if (TreeView.SelectedNode.Text.ToString().Trim() == "")
                            {
                                this.StrGetName = TreeView.SelectedNode.Name.ToString();
                                this.Tag = TreeView.SelectedNode.Tag;
                                this.Text = TreeView.SelectedNode.Text.ToString();
                                TreeView.SelectedNode.ForeColor = Color.Red;
                                dropDown.Close();
                            }
                            else
                            {
                                return;
                            }
                        }
                    }
                }
            }
            if (this.ComboBoxTreeViewEx_TextChanged != null)
                ComboBoxTreeViewEx_TextChanged(sender, e);
            //选择后，关闭所有展开的节点
            /* foreach (TreeNode item in ((TreeView)sender).Nodes)
             {
                 if (e.Node != item)
                 {
                     item.Collapse();
                 }
             }*/
        }

        /// <summary>
        /// 点击一个节点展开，关闭其他展开的节点
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void treeView_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            foreach (TreeNode item in ((TreeView)sender).Nodes)
            {
                if (e.Node != item && !item.Nodes.Contains(e.Node))
                {
                    item.Collapse();
                }

            }
        }
        #endregion

        #region 根据Tag获取当前所指的Text
        /// <summary>
        ///  遍历树，根据Tag获取当前所指的Text
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void TagFindText(object ObjKey)
        {
            IsTagReturn = false;
            NodeClearBackColor();
            foreach (TreeNode node in this.TreeView.Nodes)
            {
                if (node.Tag != null)
                {
                    if (node.Tag.Equals(ObjKey))
                    {
                        this.Text = node.Text;
                        this.Tag = node.Tag;
                        this.StrGetName = node.Name;
                        //node.BackColor = System.Drawing.Color.FromArgb(224, 224, 224); //Color.LightPink;
                        this.TreeView.SelectedNode = node;
                        node.ForeColor = Color.Red;
                        IsTagReturn = true;
                    }
                    else
                    { TagForeachTreeNode(node, ObjKey); }
                }
                else
                { TagForeachTreeNode(node, ObjKey); }
                if (IsTagReturn)
                { return; }
            }
        }
        private bool IsTagReturn = false;
        /// <summary>
        /// 循环遍历子节点
        /// </summary>
        private void TagForeachTreeNode(TreeNode node, object Key)
        {
            foreach (TreeNode nde in node.Nodes)
            {
                if (nde.Tag.Equals(Key))
                {
                    this.Text = nde.Text;
                    this.Tag = nde.Tag;
                    this.StrGetName = nde.Name;
                    //nde.BackColor = System.Drawing.Color.FromArgb(224, 224, 224); //Color.Silver;
                    this.TreeView.SelectedNode = nde;
                    nde.ForeColor = Color.Red;
                    node.ExpandAll();
                    IsTagReturn = true;
                    return;
                }
                else
                {
                    if (nde.Nodes.Count > 0)
                    {
                        TagForeachTreeNode(nde, Key);
                    }
                }
            }
        }
        #endregion

        #region 根据Text获取当前所指的Tag
        /// <summary>
        /// 遍历树，根据Text获取当前所指的Tag
        /// </summary>
        /// <param name="ObjText"></param>
        public void TextFindTag(string ObjText)
        {
            IsTextReturn = false;
            NodeClearBackColor();
            foreach (TreeNode node in TreeView.Nodes)
            {
                if (node.Tag != null)
                {
                    if (node.Text.Equals(ObjText))
                    {
                        this.Text = node.Text;
                        this.Tag = node.Tag;
                        this.StrGetName = node.Name;
                        this.TreeView.SelectedNode = node;
                        node.ForeColor = Color.Red;
                        IsTextReturn = true;
                    }
                    else
                    { TextForeachTreeNode(node, ObjText); }
                }
                else
                { TextForeachTreeNode(node, ObjText); }
                if (IsTextReturn)
                { return; }
            }
            this.Text = ObjText.Trim();
        }
        private bool IsTextReturn = false;
        /// <summary>
        /// 循环遍历子节点
        /// </summary>
        private void TextForeachTreeNode(TreeNode node, string ObjText)
        {
            foreach (TreeNode nde in node.Nodes)
            {
                if (nde.Text.Equals(ObjText))
                {
                    this.Text = nde.Text;
                    this.Tag = nde.Tag;
                    this.StrGetName = nde.Name;
                    this.TreeView.SelectedNode = node;
                    nde.ForeColor = Color.Red;
                    node.Expand();
                    if (node.Level > 0)
                    { node.Parent.Expand(); }
                    IsTextReturn = true;
                    return;
                }
                else
                {
                    if (nde.Nodes.Count > 0)
                    { TextForeachTreeNode(nde, ObjText); }
                }
            }
        }

        /// <summary>
        /// 遍历树，根据Text获取当前所指的Tag
        /// </summary>
        /// <param name="ObjText"></param>
        public string TextFindParentText(string ObjText)
        {
            bool Isbl = false;
            string StrText = "";
            foreach (TreeNode node in TreeView.Nodes)
            {
                if (node.Tag != null)
                {
                    if (node.Text.Equals(ObjText))
                    {
                        StrText = node.Text; Isbl = true;
                    }
                    else
                    { StrText = TextForeachTreeNodeParentText(node, ObjText, ref Isbl); }
                }
                else
                { StrText = TextForeachTreeNodeParentText(node, ObjText, ref Isbl); }
                if (Isbl)
                { break; }
            }
            return StrText;
        }
        /// <summary>
        /// 循环遍历子节点
        /// </summary>
        private string TextForeachTreeNodeParentText(TreeNode node, string ObjText, ref bool Isbl)
        {
            string strText = "";
            foreach (TreeNode nde in node.Nodes)
            {
                if (nde.Text.Equals(ObjText))
                {
                    strText = nde.Parent.Text;
                    Isbl = true;
                }
                else
                {
                    if (nde.Nodes.Count > 0)
                    { strText = TextForeachTreeNodeParentText(nde, ObjText, ref Isbl); }
                }
                if (Isbl)
                { break; }
            }
            return strText;
        }
        #endregion

        #region 获取当前选择的最前的父节点
        /// <summary>
        /// 遍历树，根据Text获取当前所指的Tag
        /// </summary>
        /// <param name="ObjText"></param>
        public Hashtable TextFindParentIsParent(string ObjText)
        {
            bool Isbl = false;
            Hashtable htData = new Hashtable();
            if (ObjText != "")
            {
                foreach (TreeNode node in TreeView.Nodes)
                {
                    if (node.Tag != null)
                    {
                        if (node.Text.Equals(ObjText))
                        {
                            htData = GetNodeParent(node);
                            Isbl = true;
                        }
                        else
                        { htData = TextForeachTreeNodeParentIsParent(node, ObjText, ref Isbl); }
                    }
                    else
                    { htData = TextForeachTreeNodeParentIsParent(node, ObjText, ref Isbl); }
                    if (Isbl)
                    { break; }
                }
            }
            if (htData.Count <= 0)
            {
                htData["Text"] = "";
                htData["Tag"] = "";
                htData["Name"] = "";
            }
            return htData;
        }
        /// <summary>
        /// 循环遍历子节点
        /// </summary>
        private Hashtable TextForeachTreeNodeParentIsParent(TreeNode node, string ObjText, ref bool Isbl)
        {
            Hashtable htData = new Hashtable();
            foreach (TreeNode nde in node.Nodes)
            {
                if (nde.Text.Equals(ObjText))
                {
                    htData = GetNodeParent(node);
                    Isbl = true;
                }
                else
                {
                    if (nde.Nodes.Count > 0)
                    { htData = TextForeachTreeNodeParentIsParent(nde, ObjText, ref Isbl); }
                }
                if (Isbl)
                { break; }
            }
            return htData;
        }
        /// <summary>
        /// 获取当前选择的最前的父节点
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private Hashtable GetNodeParent(TreeNode node)
        {
            Hashtable htData = new Hashtable();
            if (node != null)
            {
                bool Isbl = true;
                while (Isbl)
                {
                    if (node.Parent != null)
                    {
                        node = node.Parent;
                    }
                    else
                    {
                        htData["Text"] = node.Text.Trim();
                        htData["Tag"] = node.Tag.ToString().Trim();
                        htData["Name"] = node.Name.Trim();
                        Isbl = false;
                    }
                }
            }
            return htData;
        }
        #endregion

        #region 获取当前选择的最前的父节点
        /// <summary>
        /// 遍历树，根据Text获取当前所指的Tag
        /// </summary>
        /// <param name="ObjText"></param>
        public Hashtable TagFindParentIsParent(string ObjTag)
        {
            bool Isbl = false;
            Hashtable htData = new Hashtable();
            if (ObjTag != "")
            {
                foreach (TreeNode node in TreeView.Nodes)
                {
                    if (node.Tag != null)
                    {
                        if (node.ToString().Trim().Equals(ObjTag))
                        {
                            htData = TagGetNodeParent(node);
                            Isbl = true;
                        }
                        else
                        { htData = TagForeachTreeNodeParentIsParent(node, ObjTag, ref Isbl); }
                    }
                    else
                    { htData = TagForeachTreeNodeParentIsParent(node, ObjTag, ref Isbl); }
                    if (Isbl)
                    { break; }
                }
            }
            if (htData.Count <= 0)
            {
                htData["Text"] = "";
                htData["Tag"] = "";
                htData["Name"] = "";
            }
            return htData;
        }
        /// <summary>
        /// 循环遍历子节点
        /// </summary>
        private Hashtable TagForeachTreeNodeParentIsParent(TreeNode node, string ObjTag, ref bool Isbl)
        {
            Hashtable htData = new Hashtable();
            foreach (TreeNode nde in node.Nodes)
            {
                if (nde.Tag.ToString().Trim().Equals(ObjTag))
                {
                    htData = TagGetNodeParent(node);
                    Isbl = true;
                }
                else
                {
                    if (nde.Nodes.Count > 0)
                    { htData = TagForeachTreeNodeParentIsParent(nde, ObjTag, ref Isbl); }
                }
                if (Isbl)
                { break; }
            }
            return htData;
        }
        /// <summary>
        /// 获取当前选择的最前的父节点
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private Hashtable TagGetNodeParent(TreeNode node)
        {
            Hashtable htData = new Hashtable();
            if (node != null)
            {
                bool Isbl = true;
                while (Isbl)
                {
                    if (node.Parent != null)
                    {
                        node = node.Parent;
                    }
                    else
                    {
                        htData["Text"] = node.Text.Trim();
                        htData["Tag"] = node.Tag.ToString().Trim();
                        htData["Name"] = node.Name.Trim();
                        Isbl = false;
                    }
                }
            }
            return htData;
        }
        #endregion

        /// <summary>
        /// 清除之前所选中的项的背景颜色
        /// </summary>
        /// <param name="node"></param>
        private void NodeClearBackColor()
        {
            foreach (TreeNode node in TreeView.Nodes)
            {
                //node.BackColor = Color.White;
                node.ForeColor = Color.Black;
                if (node.Nodes.Count > 0)
                { NodeClearBackColor(node); }
            }
        }
        /// <summary>
        /// 清除节点下的所有节点的背景颜色
        /// </summary>
        /// <param name="node"></param>
        private void NodeClearBackColor(TreeNode node)
        {
            foreach (TreeNode nde in node.Nodes)
            {
                //nde.BackColor = Color.White;
                nde.ForeColor = Color.Black;
                if (nde.Nodes.Count > 0)
                {
                    NodeClearBackColor(nde);
                    if (nde.Nodes.Count > 0)
                    { NodeClearBackColor(nde); }
                }
            }
        }

        int _Nodelevel = 0;
        /// <summary>
        /// 无效属性
        /// </summary>
        [Obsolete("此属性过期不建议使用")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]
        public int Nodelevel
        {
            get { return _Nodelevel; }
            set { _Nodelevel = value; }
        }

        public TreeNode GetNodeItem_TextToTag(string ObjText)
        {
            foreach (TreeNode node in TreeView.Nodes)
            {
                if (node.Tag != null)
                {
                    if (node.Text.Equals(ObjText))
                    {
                        return node;
                    }
                    else if (node.Nodes.Count > 0)
                    {
                        foreach (TreeNode node2 in node.Nodes)
                        {
                            if (node2.Tag != null)
                            {
                                if (node2.Text.Equals(ObjText))
                                { return node2; }
                                else if (node2.Nodes.Count > 0)
                                {
                                    foreach (TreeNode node3 in node2.Nodes)
                                    {
                                        if (node3.Tag != null)
                                        {
                                            if (node3.Text.Equals(ObjText))
                                            { return node3; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return null;
        }

        public TreeNode GetNodeItem_TagToText(string ObjTag)
        {
            foreach (TreeNode node in TreeView.Nodes)
            {
                if (node.Tag != null)
                {
                    if (node.Tag.Equals(ObjTag))
                    {
                        return node;
                    }
                    else if (node.Nodes.Count > 0)
                    {
                        foreach (TreeNode node2 in node.Nodes)
                        {
                            if (node2.Tag != null)
                            {
                                if (node2.Tag.Equals(ObjTag))
                                { return node2; }
                                else if (node2.Nodes.Count > 0)
                                {
                                    foreach (TreeNode node3 in node2.Nodes)
                                    {
                                        if (node3.Tag != null)
                                        {
                                            if (node3.Tag.Equals(ObjTag))
                                            { return node3; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return null;
        }
    }
}