[分享源码] 常用超级列表框操作子程序

vcdemon

1. .版本 2
   
2. .支持库 iext
   
3. 
   
4. .子程序 超列去重, 整数型, , 返回共删了多少个重复项  -  bbs.125.la (呵呵仙)
   
5. .参数 超级列表框, 超级列表框
   
6. .参数 指定列作重复此较, 整数型, , 0为第1列,1为第2列----------
   
7. .参数 要相加合并的列_数组, 整数型, 可空 数组, 0为第1列,1为第2列------支持多列,格式如:{0,3}就是第1列,第4列的值都相加合并
   
8. .参数 只去重复项_不相加合并列, 整数型, 可空, 为0为空,值不相加;   大于0,值相加
   
9. .参数 置表项数值_标记重复项用, 整数型, 可空, 默认是-888888888作标记
   
10. .局部变量 n, 整数型
    
11. .局部变量 要比较标题, 文本型
    
12. .局部变量 m, 整数型
    
13. .局部变量 合并列数c, 整数型, , "0"
    
14. .局部变量 表项数, 整数型
    
15. .局部变量 x, 整数型
    
16. .局部变量 a, 整数型
    
17. .局部变量 b, 整数型
    
18. .局部变量 c, 整数型
    
19. .局部变量 指定列, 整数型
    
20. .局部变量 不合并, 整数型
    
21. .局部变量 k, 整数型
    
22. .局部变量 置标记, 整数型
    
23. 
    
24. 指定列 ＝ 指定列作重复此较
    
25. 置标记 ＝ 置表项数值_标记重复项用
    
26. 
    
27. .如果 (是否为空 (置表项数值_标记重复项用))
    
28.     置标记 ＝ -888888888
    
29. .否则
    
30.     置标记 ＝ 置表项数值_标记重复项用
    
31. .如果结束
    
32. 
    
33. 不合并 ＝ 只去重复项_不相加合并列
    
34. 合并列数c ＝ 要相加合并的列_数组
    
35. 表项数 ＝ 超级列表框.取表项数 ()
    
36. .计次循环首 (表项数, n)
    
37.     a ＝ n － 1
    
38.     要比较标题 ＝ 超级列表框.取标题 (a, 指定列)
    
39.     .如果 (超级列表框.取表项数值 (a) ≠ 0)
    
40.         到循环尾 ()
    
41. 
    
42.     .否则
    
43.         .计次循环首 (表项数 － n, m)
    
44.             b ＝ n ＋ m － 1
    
45.             .如果 (超级列表框.取表项数值 (b) ≠ 0)
    
46.                 到循环尾 ()
    
47.             .否则
    
48.                 .如果真 (超级列表框.取标题 (b, 指定列) ＝ 要比较标题)
    
49.                     超级列表框.置表项数值 (b, 置标记)
    
50.                     .如果真 (不合并 ＞ 0)
    
51.                         .计次循环首 (取数组成员数 (合并列数c), x)
    
52.                             超级列表框.置标题 (a, 合并列数c [x], 到文本 (到数值 (超级列表框.取标题 (a, 合并列数c [x])) ＋ 到数值 (超级列表框.取标题 (b, 合并列数c [x]))))
    
53.                         .计次循环尾 ()
    
54. 
    
55.                     .如果真结束
    
56. 
    
57. 
    
58.                 .如果真结束
    
59. 
    
60.             .如果结束
    
61. 
    
62.         .计次循环尾 ()
    
63.     .如果结束
    
64. 
    
65. .计次循环尾 ()
    
66. .计次循环首 (表项数, n)
    
67.     c ＝ 表项数 － n
    
68.     .如果真 (超级列表框.取表项数值 (c) ＝ 置标记)
    
69.         超级列表框.删除表项 (c)
    
70. 
    
71.     .如果真结束
    
72. 
    
73. .计次循环尾 ()
    
74. 返回 (超级列表框.取表项数 () － 表项数)
    
75. 
    
76. .子程序 超列保存, , , 动态保存任意炒鸡列表框  -  bbs.125.la (Joker4tb)
    
77. .参数 超列, 超级列表框
    
78. .参数 保存路径, 文本型, 可空, 保存到指定路径
    
79. .参数 行分割, 文本型, 可空
    
80. .参数 列分割, 文本型, 可空
    
81. .参数 输出表列头, 逻辑型, 可空
    
82. .局部变量 S, 文本型
    
83. .局部变量 C, 文本型
    
84. .局部变量 Lstr, 文本型, , , 列标题
    
85. .局部变量 I, 整数型
    
86. .局部变量 X, 整数型
    
87. .局部变量 文件号, 整数型
    
88. 
    
89. .如果真 (保存路径 ＝ “”)
    
90.     保存路径 ＝ 取运行目录 () ＋ “\炒鸡列表框.txt”
    
91. .如果真结束
    
92. .如果真 (行分割 ＝ “”)
    
93.     行分割 ＝ 到文本 (#换行符)
    
94. .如果真结束
    
95. .如果真 (列分割 ＝ “”)
    
96.     列分割 ＝ “,”
    
97. .如果真结束
    
98. .如果真 (输出表列头 ＝ 真)
    
99.     .计次循环首 (超列.取列数 (), I)
    
100.         Lstr ＝ Lstr ＋ 超列.取列标题 (I － 1) ＋ 列分割
     
101.     .计次循环尾 ()
     
102.     Lstr ＝ 取文本中间 (Lstr, 1, 取文本长度 (Lstr) － 取文本长度 (列分割)) ＋ 行分割  ' 取得列标题
     
103. .如果真结束
     
104. 
     
105. .计次循环首 (超列.取表项数 (), I)
     
106.     .计次循环首 (超列.取列数 (), X)
     
107.         S ＝ S ＋ 超列.取标题 (I － 1, X － 1) ＋ 列分割
     
108.     .计次循环尾 ()
     
109.     S ＝ 取文本中间 (S, 1, 取文本长度 (S) － 取文本长度 (列分割))
     
110.     C ＝ C ＋ S ＋ 行分割
     
111.     S ＝ “”
     
112. .计次循环尾 ()
     
113. 
     
114. 文件号 ＝ 打开文件 (保存路径, 4, )
     
115. .如果真 (文件号 ＞ 0)
     
116.     写出文本 (文件号, Lstr ＋ C)
     
117. .如果真结束
     
118. 关闭文件 (文件号)
     
119. 
     
120. .子程序 超列读取, , , 读取文本到任意炒鸡列表框  -  bbs.125.la (Joker4tb)
     
121. .参数 超列, 超级列表框
     
122. .参数 读取文件, 文本型, 可空, 文件路径
     
123. .参数 行分割, 文本型, 可空
     
124. .参数 列分割, 文本型, 可空
     
125. .参数 存在表列头, 逻辑型, 可空
     
126. .局部变量 S, 文本型, , "0"
     
127. .局部变量 C, 文本型, , "0"
     
128. .局部变量 Code, 文本型
     
129. .局部变量 L, 整数型, , , 列标题
     
130. .局部变量 I, 整数型
     
131. .局部变量 X, 整数型
     
132. .局部变量 文件号, 整数型
     
133. 
     
134. .如果真 (读取文件 ＝ “”)
     
135.     读取文件 ＝ 取运行目录 () ＋ “\炒鸡列表框.txt”
     
136. .如果真结束
     
137. .如果真 (行分割 ＝ “”)
     
138.     行分割 ＝ 到文本 (#换行符)
     
139. .如果真结束
     
140. .如果真 (列分割 ＝ “”)
     
141.     列分割 ＝ “,”
     
142. .如果真结束
     
143. 
     
144. 文件号 ＝ 打开文件 (读取文件, 1, )
     
145. Code ＝ 读入文本 (文件号, )
     
146. .如果真 (寻找文本 (Code, 列分割, , 假) ＜ 0)
     
147.     返回 ()
     
148. .如果真结束
     
149. 
     
150. S ＝ 分割文本 (Code, 行分割, )
     
151. .如果真 (存在表列头 ＝ 真 且 取数组成员数 (S) ＞ 0)
     
152.     删除成员 (S, 1, )  ' 直接删除表列头，不做读取操作
     
153. .如果真结束
     
154. 
     
155. .计次循环首 (取数组成员数 (S), I)
     
156.     .如果真 (寻找文本 (S [I], 列分割, , 假) ＞ 0)
     
157. 
     
158.         C ＝ 分割文本 (S [I], 列分割, )
     
159.         .如果真 (取数组成员数 (C) ＞ 0)
     
160.             L ＝ 超列.取表项数 ()
     
161.             超列.插入表项 (, C [1], , , , )
     
162.             .计次循环首 (取数组成员数 (C) － 1, X)
     
163.                 超列.置标题 (L, X, C [X ＋ 1])
     
164.             .计次循环尾 ()
     
165.         .如果真结束
     
166. 
     
167.     .如果真结束
     
168. 
     
169. .计次循环尾 ()
     
170. 
     
171. .子程序 超列全选, , ,  bbs.125.la (Joker4tb)
     
172. .参数 超列, 超级列表框
     
173. .参数 检查框判断, 逻辑型, 可空
     
174. .局部变量 I, 整数型
     
175. 
     
176. .如果 (检查框判断 ＝ 假)
     
177.     .计次循环首 (超列.取表项数 (), I)
     
178.         超列.选择表项 (I － 1)
     
179.     .计次循环尾 ()
     
180. .否则
     
181.     .计次循环首 (超列.取表项数 (), I)
     
182.         超列.置状态图片 (I － 1, 1)
     
183.     .计次循环尾 ()
     
184. .如果结束
     
185. 超列.进入编辑 (1)
     
186. 
     
187. .子程序 超列全不选, , ,  bbs.125.la (Joker4tb)
     
188. .参数 超列, 超级列表框
     
189. .参数 检查框判断, 逻辑型, 可空
     
190. .局部变量 I, 整数型
     
191. 
     
192. .如果 (检查框判断 ＝ 假)
     
193.     .计次循环首 (超列.取表项数 (), I)
     
194.         超列.取消表项选择 (I － 1)
     
195.     .计次循环尾 ()
     
196. .否则
     
197.     .计次循环首 (超列.取表项数 (), I)
     
198.         超列.置状态图片 (I － 1, 0)
     
199.     .计次循环尾 ()
     
200. .如果结束
     
201. 超列.进入编辑 (1)
     
202. 
     
203. .子程序 超列反选, , ,  bbs.125.la (Joker4tb)
     
204. .参数 超列, 超级列表框
     
205. .参数 检查框判断, 逻辑型, 可空
     
206. .局部变量 I, 整数型
     
207. 
     
208. .计次循环首 (超列.取表项数 (), I)
     
209.     .如果 (检查框判断 ＝ 假)
     
210.         .如果 (超列.是否被选择 (I － 1) ＝ 真)
     
211.             超列.取消表项选择 (I － 1)
     
212.         .否则
     
213.             超列.选择表项 (I － 1)
     
214.         .如果结束
     
215. 
     
216.     .否则
     
217.         .如果 (超列.取当前状态图片 (I － 1) ＝ 1)
     
218.             超列.置状态图片 (I － 1, 0)
     
219.         .否则
     
220.             超列.置状态图片 (I － 1, 1)
     
221.         .如果结束
     
222. 
     
223.     .如果结束
     
224. 
     
225. .计次循环尾 ()
     
226. 超列.进入编辑 (1)
     
227. 
     
228. .子程序 超列复制选中, , ,  bbs.125.la (Joker4tb)
     
229. .参数 超列, 超级列表框
     
230. .参数 指定列, 文本型, 可空, 多列用逗号隔开,0为复制整行(默认)
     
231. .参数 行分割, 文本型, 可空, 默认为#换行符
     
232. .参数 列分割, 文本型, 可空, 默认为 #Tab 键
     
233. .参数 检查框判断, 逻辑型, 可空, 根据检查框状态执行复制选中操作
     
234. .局部变量 C, 文本型, , "0"
     
235. .局部变量 I, 整数型
     
236. .局部变量 X, 整数型
     
237. .局部变量 S, 文本型
     
238. .局部变量 G, 文本型
     
239. 
     
240. .如果真 (行分割 ＝ “”)
     
241.     行分割 ＝ 到文本 (#换行符)
     
242. .如果真结束
     
243. 
     
244. .如果真 (列分割 ＝ “”)
     
245.     列分割 ＝ 字符 (9)
     
246. .如果真结束
     
247. 
     
248. .如果 (指定列 ＝ “”)
     
249.     .计次循环首 (超列.取表项数 (), I)
     
250.         .如果 (检查框判断 ＝ 假)
     
251.             .如果真 (超列.是否被选择 (I － 1) ＝ 真)
     
252.                 .计次循环首 (超列.取列数 (), X)
     
253.                     S ＝ S ＋ 超列.取标题 (I － 1, X) ＋ 列分割
     
254.                 .计次循环尾 ()
     
255.                 S ＝ 取文本中间 (S, 1, 取文本长度 (S) － 取文本长度 (列分割))
     
256.                 G ＝ G ＋ S ＋ 行分割
     
257.                 S ＝ “”
     
258.             .如果真结束
     
259. 
     
260.         .否则
     
261.             .如果真 (超列.取当前状态图片 (I － 1) ＝ 1)  ' 检查框被勾选
     
262.                 .计次循环首 (超列.取列数 (), X)
     
263.                     S ＝ S ＋ 超列.取标题 (I － 1, X) ＋ 列分割
     
264.                 .计次循环尾 ()
     
265.                 S ＝ 取文本中间 (S, 1, 取文本长度 (S) － 取文本长度 (列分割))
     
266.                 G ＝ G ＋ S ＋ 行分割
     
267.                 S ＝ “”
     
268.             .如果真结束
     
269. 
     
270. 
     
271.         .如果结束
     
272. 
     
273.     .计次循环尾 ()
     
274. 
     
275. .否则
     
276.     指定列 ＝ “,” ＋ 指定列 ＋ “,”
     
277.     .计次循环首 (超列.取表项数 (), I)
     
278.         .如果 (检查框判断 ＝ 假)
     
279.             .如果真 (超列.是否被选择 (I － 1) ＝ 真)
     
280.                 .计次循环首 (超列.取列数 (), X)
     
281.                     .如果真 (寻找文本 (指定列, “,” ＋ 到文本 (X) ＋ “,”, , 假) ＞ 0)
     
282.                         S ＝ S ＋ 超列.取标题 (I － 1, X) ＋ 列分割
     
283.                     .如果真结束
     
284. 
     
285.                 .计次循环尾 ()
     
286.                 S ＝ 取文本中间 (S, 1, 取文本长度 (S) － 取文本长度 (列分割))
     
287.                 G ＝ G ＋ S ＋ 行分割
     
288.                 S ＝ “”
     
289.             .如果真结束
     
290. 
     
291.         .否则
     
292.             .如果真 (超列.取当前状态图片 (I － 1) ＝ 1)  ' 检查框被勾选
     
293.                 .计次循环首 (超列.取列数 (), X)
     
294.                     .如果真 (寻找文本 (指定列, “,” ＋ 到文本 (X) ＋ “,”, , 假) ＞ 0)
     
295.                         S ＝ S ＋ 超列.取标题 (I － 1, X) ＋ 列分割
     
296.                     .如果真结束
     
297. 
     
298.                 .计次循环尾 ()
     
299.                 S ＝ 取文本中间 (S, 1, 取文本长度 (S) － 取文本长度 (列分割))
     
300.                 G ＝ G ＋ S ＋ 行分割
     
301.                 S ＝ “”
     
302.             .如果真结束
     
303. 
     
304.         .如果结束
     
305. 
     
306.     .计次循环尾 ()
     
307. 
     
308. .如果结束
     
309. 置剪辑板文本 (G)
     
310. 
     
311. .子程序 超列删除选中, , ,  bbs.125.la (Joker4tb)
     
312. .参数 超列, 超级列表框
     
313. .参数 检查框判断, 逻辑型, 可空, 根据检查框状态执行删除操作
     
314. .局部变量 I, 整数型
     
315. 
     
316. .如果 (检查框判断 ＝ 假)
     
317.     .变量循环首 (超列.取表项数 () － 1, 0, -1, I)
     
318.         .如果 (超列.是否被选择 (I) ＝ 真)
     
319.             超列.删除表项 (I)
     
320.         .否则
     
321. 
     
322.         .如果结束
     
323. 
     
324.     .变量循环尾 ()
     
325. 
     
326. .否则
     
327.     .变量循环首 (超列.取表项数 () － 1, 0, -1, I)
     
328.         .如果 (超列.取当前状态图片 (I － 1) ＝ 1)  ' 检查框被勾选
     
329.             超列.删除表项 (I)
     
330.         .否则
     
331. 
     
332.         .如果结束
     
333. 
     
334.     .变量循环尾 ()
     
335. .如果结束
     
336. 
     
337. 
     
338. .子程序 超列查找, , ,  bbs.125.la (Joker4tb)
     
339. .参数 超列, 超级列表框
     
340. .参数 欲查找内容, 文本型
     
341. .参数 指定列, 文本型, 可空, 用逗号隔开
     
342. .参数 返回索引, 整数型, 可空 数组, 传入一个整数型数组变量
     
343. .参数 起始行, 整数型, 可空
     
344. .参数 结束行, 整数型, 可空
     
345. .参数 全字匹配, 逻辑型, 可空
     
346. .参数 区分大小写, 逻辑型, 可空
     
347. .局部变量 C, 文本型, , "0"
     
348. .局部变量 I, 整数型
     
349. .局部变量 X, 整数型
     
350. .局部变量 S, 文本型
     
351. .局部变量 G, 文本型
     
352. .局部变量 Idx, 整数型, , "0"
     
353. 
     
354. .如果真 (起始行 ＞ 结束行)
     
355.     返回 ()
     
356. .如果真结束
     
357. .如果真 (结束行 ＝ 0)
     
358.     结束行 ＝ 超列.取表项数 ()
     
359. .如果真结束
     
360. .如果真 (起始行 ＞ 超列.取表项数 () 或 结束行 ＞ 超列.取表项数 ())
     
361.     返回 ()
     
362. .如果真结束
     
363. .如果真 (起始行 ＝ 0)
     
364.     起始行 ＝ 1
     
365. .如果真结束
     
366. 
     
367. .如果 (指定列 ＝ “”)
     
368.     .变量循环首 (起始行, 结束行, 1, I)
     
369.         .计次循环首 (超列.取列数 (), X)
     
370.             .如果 (全字匹配 ＝ 假)
     
371.                 .如果真 (寻找文本 (超列.取标题 (I － 1, X), 欲查找内容, , 区分大小写) ＞ 0)
     
372.                     超列.选择表项 (I － 1)
     
373.                     加入成员 (Idx, I － 1)
     
374.                     跳出循环 ()
     
375.                 .如果真结束
     
376. 
     
377.             .否则
     
378.                 .如果真 (超列.取标题 (I － 1, X) ＝ 欲查找内容)
     
379.                     超列.选择表项 (I － 1)
     
380.                     加入成员 (Idx, I － 1)
     
381.                     跳出循环 ()
     
382.                 .如果真结束
     
383. 
     
384.             .如果结束
     
385. 
     
386.         .计次循环尾 ()
     
387.     .变量循环尾 ()
     
388. 
     
389. .否则
     
390.     指定列 ＝ “,” ＋ 指定列 ＋ “,”
     
391.     .变量循环首 (起始行, 结束行, 1, I)
     
392.         .计次循环首 (超列.取列数 (), X)
     
393.             .如果真 (寻找文本 (指定列, “,” ＋ 到文本 (X) ＋ “,”, , 假) ＞ 0)
     
394.                 .如果 (全字匹配 ＝ 假)
     
395.                     .如果真 (寻找文本 (超列.取标题 (I － 1, X), 欲查找内容, , 区分大小写) ＞ 0)
     
396.                         超列.选择表项 (I － 1)
     
397.                         加入成员 (Idx, I － 1)
     
398.                         跳出循环 ()
     
399.                     .如果真结束
     
400. 
     
401.                 .否则
     
402.                     .如果真 (超列.取标题 (I － 1, X) ＝ 欲查找内容)
     
403.                         超列.选择表项 (I － 1)
     
404.                         加入成员 (Idx, I － 1)
     
405.                         跳出循环 ()
     
406.                     .如果真结束
     
407. 
     
408.                 .如果结束
     
409. 
     
410.             .如果真结束
     
411. 
     
412.         .计次循环尾 ()
     
413.     .变量循环尾 ()
     
414. 
     
415. .如果结束
     
416. 返回索引 ＝ Idx
     
417. 超列.进入编辑 (1)
     
418. 
     
419. .子程序 超列排除, , , bbs.125.la (Joker4tb)
     
420. .参数 超列, 超级列表框
     
421. .参数 排除内容, 文本型
     
422. .参数 指定列数, 整数型
     
423. .参数 全字匹配, 逻辑型, 可空
     
424. .参数 区分大小写, 逻辑型, 可空
     
425. .参数 起始行, 整数型, 可空
     
426. .参数 结束行, 整数型, 可空
     
427. .局部变量 I
     
428. .局部变量 X
     
429. 
     
430. .如果真 (结束行 ＝ 0)
     
431.     结束行 ＝ 超列.取表项数 ()
     
432. .如果真结束
     
433. .如果真 (起始行 ＞ 结束行)
     
434.     返回 ()
     
435. .如果真结束
     
436. 
     
437. .变量循环首 (起始行, 结束行, 1, I)
     
438.     .如果 (全字匹配 ＝ 真)
     
439.         .如果 (超列.取标题 (I, 指定列数) ＝ 排除内容)
     
440.             超列.选择表项 (I)
     
441.         .否则
     
442.             超列.取消表项选择 (I)
     
443.         .如果结束

复制代码

联系我时，请说是在 挂海论坛 上看到的，谢谢！