dev treelist 常用用法小结

要求如下：

1：选择父节点后，子节点全部打钩；
2：选择子节点而不选择父节点，则从当前节点的父节点一直到根节点check框都是半选状态。
3：当子节点均未勾选时，设置父节点状态为：未选中状态
具体实现如下：
一、OptionView—ShowCheckBoxes属性为true,则每个节点前面自动增加一个check框。
二、设置OptionBehavior—AllIndeterminateCheckState属性为true,则check框可以出现半选状态。

具体代码显示如下：

 

1. #region 树形 点击节点前  
2.        /// <summary>    
3.        /// 点击节点前    
4.        /// </summary>    
5.        /// <param name="sender"></param>    
6.        /// <param name="e"></param>    
7.        private void treeList_BeforeCheckNode(object sender, CheckNodeEventArgs e)  
8.        {  
9.            if (!this.ifMultipleChoice)  
10.            {  
11.                //选择前取消前面已经选择的，实现单选功能  
12.                List<DevExpress.XtraTreeList.Nodes.TreeListNode> treeListNodes = treeList.GetAllCheckedNodes();  
13.                foreach (DevExpress.XtraTreeList.Nodes.TreeListNode node in treeListNodes)  
14.                {  
15.                    node.Checked = false;  
16.                }  
17.            }  
18.            e.State = (e.PrevState == CheckState.Checked ? CheckState.Unchecked : CheckState.Checked);  
19.        }  
20.        #endregion  
21.  
22.        #region 树形 点击节点后  
23.        /// <summary>    
24.        /// 点击节点后    
25.        /// </summary>    
26.        /// <param name="sender"></param>    
27.        /// <param name="e"></param>    
28.        private void treeList_AfterCheckNode(object sender, NodeEventArgs e)  
29.        {  
30.            if (!this.ifMultipleChoice)  
31.            {  
32.                return;  
33.            }  
34.            if (e.Node == null)  
35.            {  
36.                return;  
37.            }  
38.            if (e.Node.CheckState == CheckState.Indeterminate)  
39.            {  
40.                e.Node.CheckState = CheckState.Checked;  
41.            }  
42.            if (e.Node.CheckState == CheckState.Checked)  
43.            {  
44.                if (e.Node.HasChildren)  
45.                {  
46.                    this.CheckNode(e.Node);  
47.                }  
48.                this.ValidParentIsChecked(e.Node);  
49.            }  
50.            else if (e.Node.CheckState == CheckState.Unchecked)  
51.            {  
52.                if (e.Node.HasChildren)  
53.                {  
54.                    this.SetCheckedChildNodes(e.Node, CheckState.Unchecked);  
55.                }  
56.                //从根节点往下 查询 是否有打钩的子节点，如果有那么 父节点的 半选状态不变 否则变为 不选择状态    
57.                //this.ValidParentNodeIsCanleSel(e.Node);  
58.                SetCheckedParentNodes(e.Node, e.Node.CheckState);  
59.   
60.            }  
61.        }  
62.        #endregion  
63.  
64.        #region 树形 节点操作集合  
65.        /// <summary>    
66.        /// 选择某个节点及其子节点    
67.        /// </summary>    
68.        /// <param name="node"></param>    
69.        private void CheckNode(DevExpress.XtraTreeList.Nodes.TreeListNode node)  
70.        {  
71.            foreach (DevExpress.XtraTreeList.Nodes.TreeListNode cnode in node.Nodes)  
72.            {  
73.                if (cnode != null)  
74.                {  
75.                    cnode.CheckState = CheckState.Checked;  
76.                }  
77.                if (cnode.HasChildren)  
78.                {  
79.                    CheckNode(cnode);  
80.                }  
81.            }  
82.        }  
83.   
84.        /// <summary>    
85.        /// 勾选子节点后，修改父节点的状态    
86.        /// </summary>    
87.        /// <param name="node"></param>    
88.        private void ValidParentIsChecked(DevExpress.XtraTreeList.Nodes.TreeListNode node)  
89.        {  
90.            if (node.ParentNode != null)  
91.            {  
92.                //父节点未被选中    
93.                if (node.ParentNode.CheckState == CheckState.Unchecked)  
94.                {  
95.                    //该节点有子节点 并且  该节点与子节点均被选中    
96.                    if (node.HasChildren && ValidIsCheckAllChildNode(node.ParentNode))  
97.                    {  
98.                        node.ParentNode.CheckState = CheckState.Checked;  
99.                    }  
100.                    //该节点没有子节点 并且 其父节点下的子节点均被选中    
101.                    else if ((!node.HasChildren) && ValidIsCheckAllChildNode(node.ParentNode))  
102.                    {  
103.                        node.ParentNode.CheckState = CheckState.Checked;  
104.                    }  
105.                    else  
106.                    {  
107.                        node.ParentNode.CheckState = CheckState.Indeterminate;  
108.                    }  
109.                }  
110.                else if (node.ParentNode.CheckState == CheckState.Indeterminate)  
111.                {  
112.                    //该节点有子节点并且 子节点均未被选中时，修改其状态     
113.                    if (node.HasChildren && (!this.ValidIsHasCheckChildNode(node)))  
114.                    {  
115.                        node.ParentNode.CheckState = CheckState.Unchecked;  
116.                    }  
117.                    // 该节点的父节点下所有节点均被选中 ValidIsCheckAllChildNode    
118.                    else if (ValidIsCheckAllChildNode(node.ParentNode))  
119.                    {  
120.                        node.ParentNode.CheckState = CheckState.Checked;  
121.                    }  
122.                }  
123.                this.ValidParentIsChecked(node.ParentNode);  
124.            }  
125.        }  
126.   
127.        /// <summary>    
128.        /// 从该节点往下 查询 是否有打钩的子节点，如果有那么 父节点的 半选、选中状态不变否则变为 不选择状态    
129.        /// </summary>    
130.        /// <param name="node"></param>    
131.        private void ValidParentNodeIsCanleSel(DevExpress.XtraTreeList.Nodes.TreeListNode node)  
132.        {  
133.            bool isSel = false;  
134.            if (node.ParentNode != null)  
135.            {  
136.                if (node.ParentNode.CheckState == CheckState.Indeterminate)  
137.                {  
138.                    //如果父节点的 状态为 半选 状态 这 根据父节点 判断子节点是否打钩    
139.                    isSel = ValidIsHasCheckChildNode(node.ParentNode);  
140.                    if (isSel == false)  
141.                    {  
142.                        //如果所有的 子节点 都没有 “选中”那么 父节点的状态 变为 非选中状态    
143.                        node.ParentNode.CheckState = CheckState.Unchecked;  
144.                    }  
145.                }  
146.                this.ValidParentNodeIsCanleSel(node.ParentNode);  
147.            }  
148.        }  
149.   
150.        /// <summary>    
151.        /// 判断该节点下是否有节点被选中，如果有返回true    
152.        /// </summary>    
153.        /// <param name="node"></param>    
154.        /// <returns></returns>    
155.        private bool ValidIsHasCheckChildNode(DevExpress.XtraTreeList.Nodes.TreeListNode node)  
156.        {  
157.            bool isCheck = false;  
158.            foreach (DevExpress.XtraTreeList.Nodes.TreeListNode cnode in node.Nodes)  
159.            {  
160.                if (cnode != null)  
161.                {  
162.                    if (cnode.CheckState == CheckState.Checked)  
163.                    {  
164.                        isCheck = true;  
165.                        return isCheck;  
166.                    }  
167.                }  
168.                if (cnode.HasChildren)  
169.                {  
170.                    isCheck = this.ValidIsHasCheckChildNode(cnode);  
171.                    if (isCheck == true)  
172.                    {  
173.                        return isCheck;  
174.                    }  
175.                }  
176.            }  
177.            return isCheck;  
178.        }  
179.        /// <summary>    
180.        /// 节点全选    
181.        /// </summary>    
182.        /// <param name="node"></param>    
183.        /// <returns></returns>    
184.        private bool ValidIsCheckAllChildNode(DevExpress.XtraTreeList.Nodes.TreeListNode node)  
185.        {  
186.            bool isCheck = true;  
187.            foreach (DevExpress.XtraTreeList.Nodes.TreeListNode cnode in node.Nodes)  
188.            {  
189.                if (cnode != null)  
190.                {  
191.                    if (cnode.CheckState == CheckState.Unchecked)  
192.                    {  
193.                        isCheck = false;  
194.                        return isCheck;  
195.                    }  
196.                }  
197.                if (cnode.HasChildren)  
198.                {  
199.                    isCheck = this.ValidIsCheckAllChildNode(cnode);  
200.                    if (isCheck == false)  
201.                    {  
202.                        return isCheck;  
203.                    }  
204.                }  
205.            }  
206.            return isCheck;  
207.        }  
208.  
209.  
210.        #endregion  
211.  
212.        #region  树形 获取全部子节点  
213.        private void GetChildNodes(TreeListNode parentNode, List<TreeListNode> list)  
214.        {  
215.            if (parentNode == null)  
216.            {  
217.                return;  
218.            }  
219.            if (parentNode.Nodes.Count > 0)  
220.            {  
221.                foreach (TreeListNode node in parentNode.Nodes)  
222.                {  
223.                    list.Add(node);  
224.                    if (node.Nodes.Count > 0)  
225.                    {  
226.                        GetChildNodes(node, list);  
227.                    }  
228.                }  
229.            }  
230.        }  
231.        #endregion  
232.  
233.        #region 树形 选择子节点时触发  
234.        /// <summary>    
235.        /// 选择子节点时触发    
236.        /// </summary>    
237.        /// <param name="node"></param>    
238.        /// <param name="check"></param>    
239.        private void SetCheckedChildNodes(TreeListNode node, CheckState check)  
240.        {  
241.            foreach (TreeListNode tn in node.Nodes)  
242.            {  
243.                tn.CheckState = check;  
244.                if (tn.HasChildren)  
245.                {  
246.                    SetCheckedChildNodes(tn, check);  
247.                }  
248.            }  
249.        }  
250.        #endregion  
251.  
252.        #region  树形 选择父节点时触发  
253.        /// <summary>    
254.        /// 选择父节点时触发    
255.        /// </summary>    
256.        /// <param name="node"></param>    
257.        /// <param name="check"></param>    
258.        private void SetCheckedParentNodes(TreeListNode node, CheckState check)  
259.        {  
260.            if (node.ParentNode != null)  
261.            {  
262.                bool b = false;  
263.                CheckState state;  
264.                foreach (TreeListNode tln in node.ParentNode.Nodes)  
265.                {  
266.                    state = (CheckState)tln.CheckState;  
267.                    if (!check.Equals(state))  
268.                    {  
269.                        b = !b;  
270.                        break;  
271.                    }  
272.                }  
273.                node.ParentNode.CheckState = b ? CheckState.Indeterminate : check;  
274.                SetCheckedParentNodes(node.ParentNode, check);  
275.            }  
276.        }  
277.        #endregion  
278.  
279.        #region 树形 判断此节点下的所有孩子节点是否选中  
280.        /// <summary>    
281.        /// 判断此节点下的所有孩子节点是否选中    
282.        /// </summary>    
283.        /// <param name="node"></param>    
284.        /// <returns></returns>    
285.        private Boolean IsChildsChecked(TreeListNode node)  
286.        {  
287.            foreach (TreeListNode tln in node.ParentNode.Nodes)  
288.            {  
289.                if (tln.CheckState == CheckState.Unchecked)  
290.                {  
291.                    return false;  
292.                }  
293.                if (tln.HasChildren)  
294.                {  
295.                    IsChildsChecked(tln);  
296.                }  
297.            }  
298.            return true;  
299.        }  
300.        #endregion  
301.