易语言超级列表框排序源码

易语言超级列表框排序源码

.版本 2
.支持库 iext

.程序集 窗口程序集1
.程序集变量 集_中文, 文本型, , "0"
.程序集变量 集_中文排序, 整数型, , "0"
.程序集变量 集_大写字母, 文本型, , "0"
.程序集变量 集_大写字母排序, 整数型, , "0"
.程序集变量 集_小写字母, 文本型, , "0"
.程序集变量 集_小写字母排序, 整数型, , "0"
.程序集变量 集_数字, 文本型, , "0"
.程序集变量 集_数字排序, 整数型, , "0"
.程序集变量 集_其他, 文本型, , "0"
.程序集变量 集_函数地址, 整数型

.子程序 __启动窗口_创建完毕

集_函数地址 ＝ SetWindowLong (超级列表框1.取窗口句柄 (), #GWL_WNDPROC, 到整数 (&消息返回))  ' 改变指定窗口的属性

.子程序 消息返回, , , 新地址子程序
.参数 句柄, 整数型
.参数 消息值, 整数型
.参数 参数1, 整数型
.参数 参数2, 整数型
.局部变量 A, 字节集
.局部变量 B, 整数型
.局部变量 C, 整数型
.局部变量 D, 整数型

.如果真 (消息值 ＝ 528 且 参数1 ＝ 513)  ' 如果头被点击
    A ＝ 到字节集 (参数2)
    B ＝ 取字节集数据 (取字节集左边 (A, 2), 3, )  ' 取点击位置宽度
    .计次循环首 (超级列表框1.取列数 (), C)
        D ＝ D ＋ 超级列表框1.取列宽 (C － 1)  ' 逐次增加判断宽度D
        .如果真 (D ＞ B)  ' 判断宽度D是否大过点击的宽度B
            排序_ (C － 1)  ' 取得列索引 C - 1
            跳出循环 ()
        .如果真结束

    .计次循环尾 ()
.如果真结束
CallWindowProc (集_函数地址, 句柄, 消息值, 参数1, 参数2)  ' 传递窗口消息

.子程序 排序_, , , 首字，大写，小写，其他，插入的先后顺序可以随便调。
.参数 列索引, 整数型
.局部变量 局_分割的文本A, 文本型, , "0"
.局部变量 局_分割的文本B, 文本型, , "0"
.局部变量 局_循环变量A, 整数型
.局部变量 局_循环变量B, 整数型
.局部变量 局_插入位置, 整数型

数据保存 (列索引)  ' 保存超级列表框数据
超级列表框1.全部删除 ()
' ----------------首字插入----------------
.循环判断首 ()
    .计次循环首 (取数组成员数 (集_中文), 局_循环变量A)
        局_分割的文本A ＝ 分割文本 (集_中文 [局_循环变量A], “|分割线|”, )  ' 把合并的超级列表框数据分成数组
        逐字分割 (局_分割的文本A [列索引 ＋ 2], 局_分割的文本B)  ' 列索引+2的意思是取他点的那列的数据作为比较的变量(列索引为0)
        .如果真 (取数组成员数 (集_中文排序) ＝ 0)  ' 防止错误
            到循环尾 ()
        .如果真结束
        .如果真 (取文本左边 (取拼音 (局_分割的文本B [1], 1), 1) ＝ 字符 (集_中文排序 [取数组成员数 (集_中文排序)]))  ' 对比字母
            删除成员 (集_中文排序, 取数组成员数 (集_中文排序), 1)  ' 删除对比成功的成员
            局_插入位置 ＝ 超级列表框1.插入表项 (-1, , , , , )
            .如果真 (局_分割的文本A [1] ＝ “√”)  ' 判断检查框
                超级列表框1.置状态图片 (局_插入位置, 1)
            .如果真结束
            .计次循环首 (取数组成员数 (局_分割的文本A) － 1, 局_循环变量B)
                超级列表框1.置标题 (局_插入位置, 局_循环变量B － 1, 局_分割的文本A [局_循环变量B ＋ 1])  ' 插入数据
            .计次循环尾 ()
        .如果真结束

    .计次循环尾 ()
.循环判断尾 (取数组成员数 (集_中文排序) ≠ 0)  ' 判断是否还有未排列的记录
' ----------------大写插入----------------
.循环判断首 ()
    .计次循环首 (取数组成员数 (集_大写字母), 局_循环变量A)
        局_分割的文本A ＝ 分割文本 (集_大写字母 [局_循环变量A], “|分割线|”, )
        逐字分割 (局_分割的文本A [列索引 ＋ 2], 局_分割的文本B)
        .如果真 (取数组成员数 (集_大写字母排序) ＝ 0)
            到循环尾 ()
        .如果真结束
        .如果真 (局_分割的文本B [1] ＝ 字符 (集_大写字母排序 [取数组成员数 (集_大写字母排序)]))
            删除成员 (集_大写字母排序, 取数组成员数 (集_大写字母排序), 1)
            局_插入位置 ＝ 超级列表框1.插入表项 (-1, , , , , )
            .如果真 (局_分割的文本A [1] ＝ “√”)
                超级列表框1.置状态图片 (局_插入位置, 1)
            .如果真结束
            .计次循环首 (取数组成员数 (局_分割的文本A) － 1, 局_循环变量B)
                超级列表框1.置标题 (局_插入位置, 局_循环变量B － 1, 局_分割的文本A [局_循环变量B ＋ 1])
            .计次循环尾 ()
        .如果真结束

    .计次循环尾 ()
.循环判断尾 (取数组成员数 (集_大写字母排序) ≠ 0)
' ----------------小写插入----------------
.循环判断首 ()
    .计次循环首 (取数组成员数 (集_小写字母), 局_循环变量A)
        局_分割的文本A ＝ 分割文本 (集_小写字母 [局_循环变量A], “|分割线|”, )
        逐字分割 (局_分割的文本A [列索引 ＋ 2], 局_分割的文本B)
        .如果真 (取数组成员数 (集_小写字母排序) ＝ 0)
            到循环尾 ()
        .如果真结束
        .如果真 (局_分割的文本B [1] ＝ 字符 (集_小写字母排序 [取数组成员数 (集_小写字母排序)]))
            删除成员 (集_小写字母排序, 取数组成员数 (集_小写字母排序), 1)
            局_插入位置 ＝ 超级列表框1.插入表项 (-1, , , , , )
            .如果真 (局_分割的文本A [1] ＝ “√”)
                超级列表框1.置状态图片 (局_插入位置, 1)
            .如果真结束
            .计次循环首 (取数组成员数 (局_分割的文本A) － 1, 局_循环变量B)
                超级列表框1.置标题 (局_插入位置, 局_循环变量B － 1, 局_分割的文本A [局_循环变量B ＋ 1])
            .计次循环尾 ()
        .如果真结束

    .计次循环尾 ()
.循环判断尾 (取数组成员数 (集_小写字母排序) ≠ 0)
' ----------------数字插入----------------
.循环判断首 ()
    .计次循环首 (取数组成员数 (集_数字), 局_循环变量A)
        局_分割的文本A ＝ 分割文本 (集_数字 [局_循环变量A], “|分割线|”, )
        逐字分割 (局_分割的文本A [列索引 ＋ 2], 局_分割的文本B)
        .如果真 (取数组成员数 (集_数字排序) ＝ 0)
            到循环尾 ()
        .如果真结束
        .如果真 (到整数 (局_分割的文本B [1]) ＝ 集_数字排序 [取数组成员数 (集_数字排序)])
            删除成员 (集_数字排序, 取数组成员数 (集_数字排序), 1)
            局_插入位置 ＝ 超级列表框1.插入表项 (-1, , , , , )
            .如果真 (局_分割的文本A [1] ＝ “√”)
                超级列表框1.置状态图片 (局_插入位置, 1)
            .如果真结束
            .计次循环首 (取数组成员数 (局_分割的文本A) － 1, 局_循环变量B)
                超级列表框1.置标题 (局_插入位置, 局_循环变量B － 1, 局_分割的文本A [局_循环变量B ＋ 1])
            .计次循环尾 ()
        .如果真结束

    .计次循环尾 ()
.循环判断尾 (取数组成员数 (集_数字排序) ≠ 0)
' ----------------其他插入----------------
.计次循环首 (取数组成员数 (集_其他), 局_循环变量A)
    局_分割的文本A ＝ 分割文本 (集_其他 [局_循环变量A], “|分割线|”, )
    局_插入位置 ＝ 超级列表框1.插入表项 (-1, , , , , )
    .如果真 (局_分割的文本A [1] ＝ “√”)
        超级列表框1.置状态图片 (局_插入位置, 1)
    .如果真结束
    .计次循环首 (取数组成员数 (局_分割的文本A) － 1, 局_循环变量B)
        超级列表框1.置标题 (局_插入位置, 局_循环变量B － 1, 局_分割的文本A [局_循环变量B ＋ 1])
    .计次循环尾 ()
.计次循环尾 ()

.子程序 数据保存, , , 按顺序保存文本
.参数 列索引, 整数型
.局部变量 局_逐字分割文本, 文本型, , "0"
.局部变量 局_数组成员数, 整数型
.局部变量 局_循环变量A, 整数型
.局部变量 局_循环变量B, 整数型

清除数组 (集_中文)  ' 初始化
清除数组 (集_大写字母)
清除数组 (集_小写字母)
清除数组 (集_数字)
清除数组 (集_其他)
.计次循环首 (超级列表框1.取表项数 (), 局_循环变量A)  ' 行数
    逐字分割 (超级列表框1.取标题 (局_循环变量A － 1, 列索引), 局_逐字分割文本)  ' 取点击的那列的标题，然后每个字分割成数组
    .如果 (取数组成员数 (局_逐字分割文本) ＞ 0)  ' 以防有空(拼音会出错)
        .判断开始 (取拼音 (局_逐字分割文本 [1], 1) ≠ “”)  ' 判断文字
            加入成员 (集_中文排序, 反字符 (取文本左边 (取拼音 (局_逐字分割文本 [1], 1), 1)))  ' 把首字母变回ASCII码放进数值数组，等下排序
            .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)  ' 检查框是否选中并加入数组成员
                加入成员 (集_中文, “√”)
            .否则
                加入成员 (集_中文, “×”)
            .如果结束
            .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)  ' 保存数据
                局_数组成员数 ＝ 取数组成员数 (集_中文)
                集_中文 [局_数组成员数] ＝ 集_中文 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
            .计次循环尾 ()
        .判断 (大写判断 (局_逐字分割文本 [1]))  ' 判断大写
            加入成员 (集_大写字母排序, 反字符 (局_逐字分割文本 [1]))
            .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)
                加入成员 (集_大写字母, “√”)
            .否则
                加入成员 (集_大写字母, “×”)
            .如果结束
            .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)
                局_数组成员数 ＝ 取数组成员数 (集_大写字母)

                集_大写字母 [局_数组成员数] ＝ 集_大写字母 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
            .计次循环尾 ()
        .判断 (小写判断 (局_逐字分割文本 [1]))  ' 判断小写
            加入成员 (集_小写字母排序, 反字符 (局_逐字分割文本 [1]))
            .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)
                加入成员 (集_小写字母, “√”)
            .否则
                加入成员 (集_小写字母, “×”)
            .如果结束
            .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)
                局_数组成员数 ＝ 取数组成员数 (集_小写字母)
                集_小写字母 [局_数组成员数] ＝ 集_小写字母 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
            .计次循环尾 ()
        .判断 (数字判断 (局_逐字分割文本 [1]))  ' 判断数字
            加入成员 (集_数字排序, 到整数 (局_逐字分割文本 [1]))
            .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)
                加入成员 (集_数字, “√”)
            .否则
                加入成员 (集_数字, “×”)
            .如果结束
            .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)
                局_数组成员数 ＝ 取数组成员数 (集_数字)
                集_数字 [局_数组成员数] ＝ 集_数字 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
            .计次循环尾 ()
        .默认
            .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)  ' 判断其他
                加入成员 (集_其他, “√”)
            .否则
                加入成员 (集_其他, “×”)
            .如果结束
            .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)
                局_数组成员数 ＝ 取数组成员数 (集_其他)
                集_其他 [局_数组成员数] ＝ 集_其他 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
            .计次循环尾 ()
        .判断结束

    .否则
        .如果 (超级列表框1.取当前状态图片 (局_循环变量A － 1) ＝ 1)  ' 判断为空，加入其他
            加入成员 (集_其他, “√”)
        .否则
            加入成员 (集_其他, “×”)
        .如果结束
        .计次循环首 (超级列表框1.取列数 (), 局_循环变量B)
            局_数组成员数 ＝ 取数组成员数 (集_其他)
            集_其他 [局_数组成员数] ＝ 集_其他 [局_数组成员数] ＋ “|分割线|” ＋ 超级列表框1.取标题 (局_循环变量A － 1, 局_循环变量B － 1)
        .计次循环尾 ()
    .如果结束
    清除数组 (局_逐字分割文本)  ' 初始化文本数组
.计次循环尾 ()
数组排序 (集_中文排序, 假)  ' 开始排序
数组排序 (集_大写字母排序, 假)
数组排序 (集_小写字母排序, 假)
数组排序 (集_数字排序, 假)

.子程序 反字符, 整数型
.参数 字母, 文本型
.局部变量 循环变量, 整数型

.计次循环首 (26, 循环变量)
    .如果真 (字符 (64 ＋ 循环变量) ＝ 字母)
        返回 (64 ＋ 循环变量)
    .如果真结束

.计次循环尾 ()
.计次循环首 (26, 循环变量)
    .如果真 (字符 (96 ＋ 循环变量) ＝ 字母)
        返回 (96 ＋ 循环变量)
    .如果真结束

.计次循环尾 ()
返回 (0)

.子程序 大写判断, 逻辑型
.参数 文本, 文本型
.局部变量 局_循环变量, 整数型

.计次循环首 (26, 局_循环变量)
    .如果真 (字符 (64 ＋ 局_循环变量) ＝ 文本)
        返回 (真)
    .如果真结束

.计次循环尾 ()
返回 (假)

.子程序 小写判断, 逻辑型
.参数 文本, 文本型
.局部变量 局_循环变量, 整数型

.计次循环首 (26, 局_循环变量)
    .如果真 (字符 (96 ＋ 局_循环变量) ＝ 文本)
        返回 (真)
    .如果真结束

.计次循环尾 ()
返回 (假)

.子程序 数字判断, 逻辑型
.参数 文本, 文本型
.局部变量 局_循环变量, 整数型

.计次循环首 (10, 局_循环变量)
    .如果真 (字符 (47 ＋ 局_循环变量) ＝ 文本)
        返回 (真)
    .如果真结束

.计次循环尾 ()
返回 (假)

.子程序 逐字分割, 整数型, , 将一段文本按字符分割后生成一个文本数组
.参数 被转换文本, 文本型, , 待分割的文本
.参数 文本数组, 文本型, 参考 数组, 返回分割后生成的文本数组变量
.局部变量 计次, 整数型
.局部变量 移动步长, 整数型

清除数组 (文本数组)
计次 ＝ 1
.判断循环首 (计次 ≤ 取文本长度 (被转换文本))
    移动步长 ＝ 选择 (取代码 (被转换文本, 计次) ＜ 0 或 取代码 (被转换文本, 计次) ＞ 255, 2, 1)
    加入成员 (文本数组, 取文本中间 (被转换文本, 计次, 移动步长))
    计次 ＝ 计次 ＋ 移动步长
.判断循环尾 ()
返回 (取数组成员数 (文本数组))

@易语言代码编写例子