1
yhj
2024-07-24 5e5d945e91568b973faa27d8ab0bcef99fc4a6c5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
#region
 
using System;
using System.Data;
using System.Windows.Forms;
using CSFrameworkV5.Common;
using CSFrameworkV5.Core;
using DevExpress.XtraTreeList;
using DevExpress.XtraTreeList.Nodes;
 
#endregion
 
namespace CSFrameworkV5.Library.CommonClass
{
    /// <summary>
    ///     TreeList样式的表格
    /// </summary>
    public class DevTreeListView : ISummaryView
    {
        private TreeList _TreeList;
 
        /// <summary>
        ///     DevTreeListView的构造器
        /// </summary>
        /// <param name="treeList"></param>
        public DevTreeListView(TreeList treeList)
        {
            _TreeList = treeList;
        }
 
        /// <summary>
        ///     DevTreeListView的构造器
        /// </summary>
        /// <param name="treeList">TreeList组件</param>
        /// <param name="boundContextMenu">绑定弹出菜单,展开和收缩</param>
        public DevTreeListView(TreeList treeList, bool boundContextMenu)
        {
            _TreeList = treeList;
            if (boundContextMenu) _TreeList.ContextMenu = CreateContextMenu();
        }
 
        /// <summary>
        ///     勾选或取消勾选当前结点的所有父结点
        /// </summary>
        /// <param name="currentNode">当前结点</param>
        public static void CheckParent(TreeListNode currentNode, bool isCheck)
        {
            var tmp = currentNode;
 
            currentNode = tmp.ParentNode;
            while (currentNode != null)
            {
                currentNode.Checked = isCheck;
                currentNode = currentNode.ParentNode;
            }
 
            //设置所有父节点的状态,当父结点的所有子结点没有勾选的情况下,父结点不勾选
            currentNode = tmp.ParentNode;
            while (currentNode != null)
            {
                if (HasChildChecked(currentNode) == false)
                    currentNode.Checked = false;
 
                currentNode = currentNode.ParentNode;
            }
        }
 
        private ContextMenu CreateContextMenu()
        {
            var menu = new ContextMenu();
            menu.MenuItems.Add("展开树结点", OnExpandAll);
            menu.MenuItems.Add("收缩全部", OnCollapseAll);
            return menu;
        }
 
        /// <summary>
        ///     检查当前结点是否有子节点是勾选状态
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public static bool HasChildChecked(TreeListNode node)
        {
            if (node.HasChildren)
                foreach (TreeListNode N in node.Nodes)
                    if (N.Checked)
                        return true;
 
            return false;
        }
 
        private void OnCollapseAll(object sender, EventArgs e)
        {
            _TreeList.CollapseAll();
        }
 
        private void OnExpandAll(object sender, EventArgs e)
        {
            _TreeList.ExpandAll();
        }
 
        /// <summary>
        ///     设置TreeList显示的图标
        /// </summary>
        /// <param name="tl">TreeList组件</param>
        /// <param name="node">当前结点,从根结构递归时此值必须=null</param>
        /// <param name="nodeIndex">根结点图标(无子结点)</param>
        /// <param name="parentIndex">有子结点的图标</param>
        public static void SetImageIndex(TreeList tl, TreeListNode node,
            int nodeIndex, int parentIndex)
        {
            if (node == null)
            {
                foreach (TreeListNode N in tl.Nodes)
                    SetImageIndex(tl, N, nodeIndex, parentIndex);
            }
            else
            {
                if (node.HasChildren || node.ParentNode == null)
                {
                    //node.SelectImageIndex = parentIndex;
                    node.StateImageIndex = parentIndex;
                    node.ImageIndex = parentIndex;
                }
                else
                {
                    //node.SelectImageIndex = nodeIndex;
                    node.StateImageIndex = nodeIndex;
                    node.ImageIndex = nodeIndex;
                }
 
                foreach (TreeListNode N in node.Nodes)
                    SetImageIndex(tl, N, nodeIndex, parentIndex);
            }
        }
 
        #region ISummaryView 成员
 
        public void ExportData(string format, string file)
        {
            Msg.Warning("未实现ExportData方法!");
        }
 
        public int RowCount => (_TreeList.DataSource as DataTable).Rows.Count;
 
        public int FocusedRowHandle
        {
            get => _TreeList.FocusedNode.Id;
            set
            {
                var node = FindNode(value);
                _TreeList.SetFocusedNode(node);
            }
        }
 
        private TreeListNode FindNode(int rowIndex)
        {
            TreeListNode result = null;
 
            foreach (TreeListNode n in _TreeList.Nodes)
            {
                if (n.Id == rowIndex) return n;
 
                if (n.Nodes.Count > 0) FindChildNode(n, rowIndex, ref result);
            }
 
            return result;
        }
 
        private void FindChildNode(TreeListNode root, int rowIndex,
            ref TreeListNode result)
        {
            foreach (TreeListNode n in root.Nodes)
            {
                if (n.Id == rowIndex) result = n;
 
                if (n.Nodes.Count > 0) FindChildNode(n, rowIndex, ref result);
            }
        }
 
        public object DataSource
        {
            get => _TreeList.DataSource;
            set => _TreeList.DataSource = value;
        }
 
        public object View => _TreeList;
 
        public DataRow GetDataRow(int rowHandle)
        {
            var source = _TreeList.DataSource as DataTable;
            return source.Rows[rowHandle];
        }
 
        public void RefreshDataSource()
        {
            var o = _TreeList.DataSource;
            _TreeList.DataSource = null;
            _TreeList.DataSource = o;
            _TreeList.RefreshDataSource();
            _TreeList.Invalidate();
        }
 
        public void BindingDoubleClick(EventHandler eventHandler)
        {
            _TreeList.DoubleClick += eventHandler;
        }
 
        public void SetFocus()
        {
            _TreeList.Focus();
        }
 
        public void MoveFirst()
        {
            _TreeList.MoveFirst();
        }
 
        public void MovePrior()
        {
            _TreeList.MovePrev();
        }
 
        public void MoveNext()
        {
            _TreeList.MoveNext();
        }
 
        public void MoveLast()
        {
            _TreeList.MoveLast();
        }
 
        public bool IsValidRowHandle(int rowHandle)
        {
            return rowHandle >= 0 && rowHandle <=
                (_TreeList.DataSource as DataTable).Rows.Count;
        }
 
        public void RefreshRow(int rowHandle)
        {
            _TreeList.Invalidate();
        }
 
        public void RemoveRow(int rowHandle)
        {
            var N = _TreeList.GetNodeByVisibleIndex(rowHandle);
            _TreeList.DeleteNode(N);
        }
 
        #endregion
    }
}