易语言高级表格鼠标左键扩展模块源码

易语言高级表格鼠标左键扩展模块源码

.版本 2
.支持库 eGrid
.支持库 EdirectX

.程序集 类_鼠标左键扩展, , 公开, 增强鼠标左键在高级表格中功能的扩展【官方论坛ID：小修 联系QQ：464678768 编写日期：2008年8月】
.程序集变量 私_表格, 高级表格, , , 欲增强功能的高级表格
.程序集变量 私_信息, 标签, , , 用于增强功能的信息显示
.程序集变量 私_数据, 自_扩展数据, , , 此类相关的数据集合
.程序集变量 私_状态, 整数型, , , 记录功能的执行状态。可选状态见常量：#常_状态_**
.程序集变量 私_功能, 整数型, , , 记录当前功能的类型。可选状态见常量：#常_功能_**
.程序集变量 私_区域位置, 矩形, , , 已选区域在表格中的绝对位置。-1为无效的位置

.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用

私_数据.距离邻近 ＝ 3

私_数据.距离水平 ＝ 25  ' 显示信息位置初始化，默认为鼠标指针的右下方
私_数据.距离垂直 ＝ 25

私_数据.颜色文本 ＝ #黑色  ' 显示信息颜色初始化
私_数据.颜色背景 ＝ #黄色

私_数据.显示方式 ＝ #常_方式_永久显示

私_数据.边距水平 ＝ 5  ' 表头边距初始化
私_数据.边距垂直 ＝ 2

更新填充序列 (#常_信息_序列)  ' 初始化填充序列

.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用



.子程序 更新填充序列, 整数型, , 添加、更新自定义填充序列
.参数 参_序列信息, 文本型, 可空, 欲添加的序列数据。如果为空则仅接收填充序列信息
.参数 参_填充序列, 文本型, 可空 数组, 用于接收填充序列信息
.局部变量 局_填充序列, 文本型, 静态, , 序列数据备份
.局部变量 局_序列指针, 整数型, , "0"
.局部变量 局_序列位置, 整数型
.局部变量 局_计次, 整数型

.如果真 (是否为空 (参_序列信息))
    参_填充序列 ＝ 分割文本 (局_填充序列, #换行符, )
    返回 (取数组成员数 (参_填充序列))
.如果真结束
局_填充序列 ＝ 局_填充序列 ＋ #换行符 ＋ 参_序列信息  ' 在原始基础上添加
参_填充序列 ＝ 分割文本 (局_填充序列, #换行符, )
' 删除空白序列
.计次循环首 (取数组成员数 (参_填充序列), 局_计次)
    .如果真 (删全部空 (参_填充序列 [局_计次]) ＝ “”)
        加入成员 (局_序列指针, 局_计次)
    .如果真结束

.计次循环尾 ()
数组排序 (局_序列指针, 假)
.计次循环首 (取数组成员数 (局_序列指针), 局_计次)
    删除成员 (参_填充序列, 局_序列指针 [局_计次], )
.计次循环尾 ()
' 删除重复序列
清除数组 (局_序列指针)
.计次循环首 (取数组成员数 (参_填充序列) － 1, 局_计次)
    .变量循环首 (局_计次 ＋ 1, 取数组成员数 (参_填充序列), 1, 局_序列位置)
        .如果真 (文本比较 (参_填充序列 [局_计次], 参_填充序列 [局_序列位置], 真) ＝ 0)
            加入成员 (局_序列指针, 局_序列位置)
        .如果真结束

    .变量循环尾 ()
.计次循环尾 ()
数组排序 (局_序列指针, 假)
.计次循环首 (取数组成员数 (局_序列指针), 局_计次)
    删除成员 (参_填充序列, 局_序列指针 [局_计次], )
.计次循环尾 ()
' 更新备份序列
局_填充序列 ＝ “”
.计次循环首 (取数组成员数 (参_填充序列), 局_计次)
    局_填充序列 ＝ 局_填充序列 ＋ 参_填充序列 [局_计次] ＋ #换行符
.计次循环尾 ()
' 调试输出 (参_填充序列)
返回 (取数组成员数 (参_填充序列))

.子程序 取当前功能名, 文本型, , 根据当前执行的功能返回功能名称。失败返回空文本

.如果真 (私_功能 ＜ #常_功能_累加 或 私_功能 ＞ #常_功能_移动)  ' 检查范围
    返回 (“”)
.如果真结束
返回 (多项选择 (私_功能, “累加”, “复制”, “填充”, “移动”))

.子程序 获取指定数据, 逻辑型, 公开, 根据指定的类型获取相关数据。成功返回真，失败返回假。！此方法为获取内部数据的接口！
.参数 参_数据名称, 整数型, , 可选类型：1、#常_距离_邻近 2、#常_距离_水平 3、#常_距离_垂直 4、#常_颜色_文本 5、#常_颜色_背景 6、常_显示_方式 7、#常_边距_水平 8、#常_边距_垂直 9、#常_填充_序列
.参数 参_获取结果, 文本型, , 用于接收获取的数据
.局部变量 局_填充序列, 文本型, , "0"
.局部变量 局_计次, 整数型

.判断开始 (参_数据名称 ＝ #常_数据_距离邻近)
    参_获取结果 ＝ 到文本 (私_数据.距离邻近)
.判断 (参_数据名称 ＝ #常_数据_距离水平)
    参_获取结果 ＝ 到文本 (私_数据.距离水平)
.判断 (参_数据名称 ＝ #常_数据_距离垂直)
    参_获取结果 ＝ 到文本 (私_数据.距离垂直)
.判断 (参_数据名称 ＝ #常_数据_颜色文本)
    参_获取结果 ＝ 到文本 (私_数据.颜色文本)
.判断 (参_数据名称 ＝ #常_数据_颜色背景)
    参_获取结果 ＝ 到文本 (私_数据.颜色背景)
.判断 (参_数据名称 ＝ #常_数据_显示方式)
    参_获取结果 ＝ 到文本 (私_数据.显示方式)
.判断 (参_数据名称 ＝ #常_数据_边距水平)
    参_获取结果 ＝ 到文本 (私_数据.边距水平)
.判断 (参_数据名称 ＝ #常_数据_边距垂直)
    参_获取结果 ＝ 到文本 (私_数据.边距垂直)
.判断 (参_数据名称 ＝ #常_数据_填充序列)
    更新填充序列 (, 局_填充序列)
    .计次循环首 (取数组成员数 (局_填充序列), 局_计次)
        参_获取结果 ＝ 参_获取结果 ＋ 局_填充序列 [局_计次] ＋ #换行符
    .计次循环尾 ()
.默认
    返回 (假)
.判断结束
返回 (真)

.子程序 设置指定数据, 逻辑型, 公开, 根据指定的类型设置相关数据。成功返回真，失败返回假。！此方法为外部设置的接口！
.参数 参_数据名称, 整数型, , 可选类型：1、#常_距离_邻近 2、#常_距离_水平 3、#常_距离_垂直 4、#常_颜色_文本 5、#常_颜色_背景 6、常_显示_方式 7、#常_边距_水平 8、#常_边距_垂直 9、#常_填充_序列
.参数 参_置入数据, 文本型, , 根据类型提供适当的数据
.局部变量 局_置入数据, 整数型

.如果真 (参_数据名称 ≠ #常_数据_填充序列)  ' 对于非填充序列数据进行检查
    .如果真 (检查指定数据 (参_置入数据, #常_检查_数字) ＝ 假)
        返回 (假)  ' 检查失败直接返回
    .如果真结束
    局_置入数据 ＝ 到整数 (参_置入数据)
.如果真结束
.判断开始 (参_数据名称 ＝ #常_数据_距离邻近)
    私_数据.距离邻近 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_距离水平)
    私_数据.距离水平 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_距离垂直)
    私_数据.距离垂直 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_颜色文本)
    .如果真 (置入提示标签 () ＝ 假)
        返回 (假)
    .如果真结束
    私_数据.颜色文本 ＝ 局_置入数据
    私_信息.文本颜色 ＝ 私_数据.颜色文本
.判断 (参_数据名称 ＝ #常_数据_颜色背景)
    .如果真 (置入提示标签 () ＝ 假)
        返回 (假)
    .如果真结束
    私_数据.颜色背景 ＝ 局_置入数据
    私_信息.背景颜色 ＝ 私_数据.颜色背景
.判断 (参_数据名称 ＝ #常_数据_显示方式)
    私_数据.显示方式 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_边距水平)
    私_数据.边距水平 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_边距垂直)
    私_数据.边距垂直 ＝ 局_置入数据
.判断 (参_数据名称 ＝ #常_数据_填充序列)
    更新填充序列 (参_置入数据)
.默认
    返回 (假)
.判断结束
返回 (真)

.子程序 显示提示信息, 逻辑型, , 将欲显示的信息显示到指定的位置。失败返回假，说明未成功调用【置入提示标签】方法
.参数 参_信息内容, 文本型, 可空, 信息内容，多行信息请使用#换行符分割。不提供此参数或者参数值为空则隐藏不显示
.参数 参_显示坐标, 自_坐标, 可空, 鼠标指针在表格中的绝对位置。为空则为上次提供的位置
.局部变量 局_显示信息, 文本型, 静态, , 备份显示的内容
.局部变量 局_文本数组, 文本型, , "0"
.局部变量 局_已选区域, 矩形
.局部变量 局_单元坐标, 自_坐标
.局部变量 局_计次, 整数型

.如果真 (置入提示标签 ())
    私_信息.可视 ＝ 假  ' 我有话说：某些组件在可视状态下直接更新显示内容容易导致显示闪烁，那就先隐藏，更新完毕后再显示，很多时候可以解决问题^_^
    .如果真 (参_信息内容 ＝ “” 且 是否为空 (参_显示坐标))
        返回 (真)
    .如果真结束
    .如果真 (参_信息内容 ≠ “”)
        局_显示信息 ＝ 参_信息内容 ＋ #换行符  ' 更新显示信息
    .如果真结束
    .如果真 (是否为空 (参_显示坐标))  ' 未提供显示坐标
        参_显示坐标.水平 ＝ 私_信息.左边 － 私_表格.左边 － 私_数据.距离水平  ' 计算鼠标指针的坐标，用于计算单元格的坐标
        参_显示坐标.垂直 ＝ 私_信息.顶边 － 私_表格.顶边 － 私_数据.距离垂直
    .如果真结束
    私_信息.左边 ＝ 私_表格.左边 ＋ 参_显示坐标.水平 ＋ 私_数据.距离水平  ' 本次显示绝对位置
    私_信息.顶边 ＝ 私_表格.顶边 ＋ 参_显示坐标.垂直 ＋ 私_数据.距离垂直
    .如果 (计算单元位置 (参_显示坐标, 局_单元坐标))  ' 单元提示信息
        参_信息内容 ＝ 局_显示信息 ＋ “指针单元：行号：” ＋ 到文本 (局_单元坐标.垂直) ＋ “ 列号：” ＋ 到文本 (局_单元坐标.水平) ＋ #换行符
    .否则
        参_信息内容 ＝ 局_显示信息 ＋ “指针单元：当前指针下没有单元格，相关操作被忽略” ＋ #换行符
    .如果结束
    .如果真 (取已选择区域 (局_已选区域))  ' 区域提示信息
        参_信息内容 ＝ 参_信息内容 ＋ “区域尺寸：宽度_” ＋ 到文本 (局_已选区域.右边 － 局_已选区域.左边 ＋ 1) ＋ “ 高度_” ＋ 到文本 (局_已选区域.底边 － 局_已选区域.顶边 ＋ 1) ＋ #换行符
        参_信息内容 ＝ 参_信息内容 ＋ “区域位置：左_” ＋ 到文本 (局_已选区域.左边) ＋ “ 右_” ＋ 到文本 (局_已选区域.右边) ＋ “ 顶_” ＋ 到文本 (局_已选区域.顶边) ＋ “ 底_” ＋ 到文本 (局_已选区域.底边) ＋ #换行符
    .如果真结束
    私_信息.标题 ＝ 参_信息内容  ' 置显示信息
    ' 计算显示信息的宽度和高度
    私_信息.宽度 ＝ 0
    局_文本数组 ＝ 分割文本 (私_信息.标题, #换行符, )
    .计次循环首 (取数组成员数 (局_文本数组), 局_计次)
        .如果真 (取文本长度 (局_文本数组 [局_计次]) ＞ 私_信息.宽度)
            私_信息.宽度 ＝ 取文本长度 (局_文本数组 [局_计次])  ' 取最长的字符行来计算信息显示的宽度
        .如果真结束

    .计次循环尾 ()
    私_信息.宽度 ＝ 私_信息.宽度 × 6 ＋ 2  ' 字符宽度为6，+2为修正值
    私_信息.高度 ＝ 取数组成员数 (局_文本数组) × 12 ＋ 2  ' 字符高度为12
    ' 显示
    私_信息.可视 ＝ 真
    私_信息.刷新显示 ()
    私_表格.刷新显示 ()  ' 刷新显示可以清除信息移动时留下的痕迹
    返回 (真)
.如果真结束
返回 (假)

.子程序 置入提示标签, 逻辑型, 公开, 置入一个已创建的标签。成功返回真，失败返回假。！使用此类之前必先确保已成功调用此方法，否则提示信息功能不能实现！
.参数 参_欲置入标签, 标签, 可空, 指定一个标签用于增强功能的信息显示。为空则仅检查已置入成功的标签是否已创建

.如果真 (是否为空 (参_欲置入标签) ＝ 假)
    私_信息 ＝ 参_欲置入标签
    显示提示信息 (#常_信息_开发)  ' 显示此代码开发的相关信息
    私_信息.左边 ＝ (取屏幕宽度 () － 私_信息.宽度) ＼ 2  ' 将信息显示在屏幕中间
    私_信息.顶边 ＝ (取屏幕高度 () － 私_信息.高度) ＼ 2
    设置指定数据 (#常_数据_颜色文本, 到文本 (私_数据.颜色文本))  ' 将颜色数据应用到当前置入的标签
    设置指定数据 (#常_数据_颜色背景, 到文本 (私_数据.颜色背景))
    ' 可以在下面做更多的初始化操作
    私_信息.边框 ＝ 5  ' 单线边框式
    私_信息.是否自动折行 ＝ 真
.如果真结束
返回 (是否已创建 (私_信息))

.子程序 置入高级表格, 逻辑型, 公开, 置入一个已创建的高级表格。成功返回真，失败返回假。！使用此类之前必先确保已成功调用此方法，否则不能确保其它方法能成功调用！
.参数 参_欲置入表格, 高级表格, 可空, 指定一个欲增强鼠标功能的表格。为空则仅检查已置入成功的表格是否已创建

.如果真 (是否为空 (参_欲置入表格) ＝ 假)
    私_表格 ＝ 参_欲置入表格
    ' 可以在下面做更多的初始化操作
    私_表格.选择区背景 ＝ #银白
.如果真结束
返回 (是否已创建 (私_表格))

.子程序 检查指定数据, 逻辑型, , 根据检查方式检查数据。真-表示检查通过
.参数 参_检查数据, 文本型, , 被检查的数据
.参数 参_检查方式, 整数型, , 可选值：1、#常_检查_空白 2、#常_检查_数字 3、#常_检查_包含
.参数 参_包含数据, 文本型, 可空, 如果是【常_检查_包含】则必须提供此参数
.局部变量 局_数据, 字节集
.局部变量 局_字节, 字节型
.局部变量 局_计次, 整数型

.判断开始 (参_检查方式 ＝ #常_检查_空白)
    局_数据 ＝ 子字节集替换 (到字节集 (参_检查数据), 到字节集 (到字节 (#Tab键)), , , )  ' 删除#Tab键
    局_数据 ＝ 子字节集替换 (局_数据, 到字节集 (到字节 (#空格键)), , , )  ' 删除#空格键
    局_数据 ＝ 子字节集替换 (局_数据, 到字节集 (到字节 (10)), , , )  ' 删除换行
    .如果真 (取字节集长度 (局_数据) ≠ 0)
        返回 (真)
    .如果真结束

.判断 (参_检查方式 ＝ #常_检查_数字)
    局_数据 ＝ 到字节集 (参_检查数据)
    .计次循环首 (取字节集长度 (局_数据), 局_计次)
        .如果真 (局_数据 [局_计次] ＜ 取代码 (“0”, ) 或 局_数据 [局_计次] ＞ 取代码 (“9”, ))  ' 0-9
            .如果真 (局_数据 [局_计次] ≠ 取代码 (“.”, ))  ' 小数点
                .如果真 (局_数据 [局_计次] ≠ 取代码 (“-”, ))  ' 负号
                    返回 (假)
                .如果真结束

            .如果真结束

        .如果真结束

    .计次循环尾 ()
    返回 (真)
.判断 (参_检查方式 ＝ #常_检查_包含)
    .如果真 (寻找文本 (参_包含数据, 参_检查数据, , 假) ≠ -1)
        返回 (真)
    .如果真结束

.默认

.判断结束
返回 (假)

.子程序 累加指定区域, 逻辑型, , 对指定区域内的数值进行累加，如果区域内数据全部为数值则返回真，包含非数值数据将返回假
.参数 参_累加区域, 矩形, , 指定一个欲被累加的单元格区域。注意：目前仅支持【数值型】、【货币型】、【文本型】，必须在外部自行确认，否则可能导致运行错误
.参数 参_累加结果, 双精度小数型, 参考, 用于接收区域累加结果
.局部变量 局_数值数据, 逻辑型
.局部变量 局_单元数据, 文本型
.局部变量 局_行号, 整数型
.局部变量 局_列号, 整数型

局_数值数据 ＝ 真
.变量循环首 (参_累加区域.左边, 参_累加区域.右边, 1, 局_列号)
    .变量循环首 (参_累加区域.顶边, 参_累加区域.底边, 1, 局_行号)
        局_单元数据 ＝ 私_表格.取数据 (局_行号, 局_列号)
        .如果 (检查指定数据 (局_单元数据, #常_检查_数字))  ' 检查数据
            参_累加结果 ＝ 参_累加结果 ＋ 到数值 (局_单元数据)  ' 累加数值
        .否则
            局_数值数据 ＝ 假
        .如果结束

    .变量循环尾 ()
.变量循环尾 ()
返回 (局_数值数据)

.子程序 取已选择区域, 逻辑型, , 如果有单元格被选择则返回真，否则返回假
.参数 参_选择区域, 矩形, , 用于接收被选择区域的相关位置信息。此参数值仅在调用返回真才有效

.如果真 (置入高级表格 () ＝ 假)
    返回 (假)
.如果真结束
参_选择区域.顶边 ＝ 私_表格.取选择起始行 ()
参_选择区域.底边 ＝ 私_表格.取选择终止行 ()
参_选择区域.左边 ＝ 私_表格.取选择起始列 ()
参_选择区域.右边 ＝ 私_表格.取选择终止列 ()
.如果真 (参_选择区域.顶边 ＝ -1 或 参_选择区域.底边 ＝ -1 或 参_选择区域.左边 ＝ -1 或 参_选择区域.右边 ＝ -1)
    返回 (假)
.如果真结束
返回 (真)

.子程序 更新起始行列, 逻辑型, , 更新可视区域内左上角单元格的坐标。！注：可视单元区域改变后必须调用此方法！
.参数 参_按下坐标, 自_坐标, 可空, 鼠标左键在表格中按下的位置。不为空则更新坐标信息
.参数 参_放开坐标, 自_坐标, 可空, 鼠标左键在表格中放开的位置。不为空则更新起始行列
.参数 参_起始单元, 自_坐标, 可空, 用于接收起始行列信息
.局部变量 局_起始单元, 自_坐标, 静态, , 备份左上角单元格的坐标(垂直：行号 水平：列号)
.局部变量 局_按下坐标, 自_坐标, 静态, , 备份鼠标左键按下的位置
.局部变量 局_放开坐标, 自_坐标
.局部变量 局_表头尺寸, 自_尺寸
.局部变量 局_已选区域, 矩形

' 实现原理与步骤：根据鼠标左键按下的坐标和放开的坐标来计算起始单元的坐标
' 1、首先在鼠标左键按下时备份按下的坐标
' 2、左键放开时可能是选择了一个区域，必须选择放开时指针下的单元格来计算
' 3、根据表头尺寸、单元格坐标和指针坐标这几个信息计算出起始单元坐标
' 注：单元格尺寸差异过大时结果可能会有误差，期待表格直接提供起始单元信息
.如果真 (是否为空 (参_按下坐标) ＝ 假)  ' 备份按下坐标
    局_按下坐标.水平 ＝ 参_按下坐标.水平
    局_按下坐标.垂直 ＝ 参_按下坐标.垂直
.如果真结束
.如果真 (是否为空 (参_放开坐标) ＝ 假)  ' 计算起始单元
    局_放开坐标.水平 ＝ 参_放开坐标.水平
    局_放开坐标.垂直 ＝ 参_放开坐标.垂直
    .如果真 (取已选择区域 (局_已选区域))
        .如果 (局_按下坐标.水平 ＞ 局_放开坐标.水平)  ' 取放开时指针下的单元格
            局_起始单元.水平 ＝ 局_已选区域.左边
        .否则
            局_起始单元.水平 ＝ 局_已选区域.右边
        .如果结束
        .如果 (局_按下坐标.垂直 ＞ 局_放开坐标.垂直)
            局_起始单元.垂直 ＝ 局_已选区域.顶边
        .否则
            局_起始单元.垂直 ＝ 局_已选区域.底边
        .如果结束
        计算表头尺寸 (局_表头尺寸)
        ' 计算起始单元列号到备份
        局_放开坐标.水平 ＝ 局_放开坐标.水平 － 局_表头尺寸.宽度
        .判断循环首 (真)
            .如果真 (局_起始单元.水平 ＜ 私_表格.表头列数)
                返回 (假)
            .如果真结束
            局_放开坐标.水平 ＝ 局_放开坐标.水平 － 私_表格.取列宽 (局_起始单元.水平)
            .如果真 (局_放开坐标.水平 ＜ 0)
                跳出循环 ()
            .如果真结束
            局_起始单元.水平 ＝ 局_起始单元.水平 － 1
        .判断循环尾 ()
        ' 计算起始单元行号到备份
        局_放开坐标.垂直 ＝ 局_放开坐标.垂直 － 局_表头尺寸.高度
        .判断循环首 (真)
            .如果真 (局_起始单元.垂直 ＜ 私_表格.表头行数)
                返回 (假)
            .如果真结束
            局_放开坐标.垂直 ＝ 局_放开坐标.垂直 － 私_表格.取行高 (局_起始单元.垂直)
            .如果真 (局_放开坐标.垂直 ＜ 0)
                跳出循环 ()
            .如果真结束
            局_起始单元.垂直 ＝ 局_起始单元.垂直 － 1
        .判断循环尾 ()
        返回 (真)
    .如果真结束

.如果真结束
.如果真 (是否为空 (参_起始单元) ＝ 假)  ' 提取起始单元
    参_起始单元.水平 ＝ 局_起始单元.水平
    参_起始单元.垂直 ＝ 局_起始单元.垂直
    返回 (真)
.如果真结束
返回 (假)

.子程序 计算表头尺寸, 逻辑型, , 计算整个表头区域的尺寸
.参数 参_表头尺寸, 自_尺寸, , 用于接收计算结果。如果表格没有行列表头则对应尺寸为0，比如【表头行数】＝0，则【表头尺寸.高度】＝0
.局部变量 局_计次, 整数型

.如果真 (置入高级表格 () ＝ 假)
    返回 (假)
.如果真结束
参_表头尺寸.高度 ＝ 0
.计次循环首 (私_表格.表头行数, 局_计次)
    参_表头尺寸.高度 ＝ 参_表头尺寸.高度 ＋ 私_表格.取行高 (局_计次 － 1)  ' 行高累加
.计次循环尾 ()
参_表头尺寸.宽度 ＝ 0
.计次循环首 (私_表格.表头列数, 局_计次)
    参_表头尺寸.宽度 ＝ 参_表头尺寸.宽度 ＋ 私_表格.取列宽 (局_计次 － 1)  ' 列宽累加
.计次循环尾 ()
返回 (真)

.子程序 计算行列尺寸, 整数型, , 计算指定“行”总高度或者“列”总宽度。失败返回-1
.参数 参_起始序号, 整数型, , 起始行、列单元格序号。
.参数 参_结束序号, 整数型, , 结束行、列单元格序号。
.参数 参_统计行高, 逻辑型, , 真－统计行高度，假－统计列宽度。注意与前面的参数匹配
.局部变量 局_单元尺寸, 整数型
.局部变量 局_区域尺寸, 整数型
.局部变量 局_统计次序, 整数型
.局部变量 局_计次, 整数型

局_统计次序 ＝ 1  ' 正向统计
.如果真 (参_起始序号 ＞ 参_结束序号)
    局_统计次序 ＝ -1  ' 反向统计
.如果真结束
.变量循环首 (参_起始序号, 参_结束序号, 局_统计次序, 局_计次)
    .如果 (参_统计行高)  ' 我有话说：在大量循环时需将此判断放到循环外部，可提高运行效率
        局_单元尺寸 ＝ 私_表格.取行高 (局_计次)
    .否则
        局_单元尺寸 ＝ 私_表格.取列宽 (局_计次)
    .如果结束
    .如果真 (局_单元尺寸 ＝ -1)
        返回 (局_单元尺寸)  ' 取单元尺寸失败
    .如果真结束
    局_区域尺寸 ＝ 局_区域尺寸 ＋ 局_单元尺寸
.变量循环尾 ()
返回 (局_区域尺寸)

.子程序 计算区域尺寸, 逻辑型, , 计算指定区域单元格的尺寸
.参数 参_目标区域, 矩形, , 欲计算的单元格区域
.参数 参_区域尺寸, 自_尺寸, , 用于接收计算结果

参_区域尺寸.宽度 ＝ 计算行列尺寸 (参_目标区域.左边, 参_目标区域.右边, 假)
参_区域尺寸.高度 ＝ 计算行列尺寸 (参_目标区域.顶边, 参_目标区域.底边, 真)
.如果真 (参_区域尺寸.宽度 ＝ -1 或 参_区域尺寸.高度 ＝ -1)
    返回 (假)
.如果真结束
返回 (真)

.子程序 计算区域位置, 逻辑型, , 计算目标单元格区域在表格中的绝对位置
.参数 参_目标区域, 矩形, , 欲计算的单元格区域
.参数 参_区域位置, 矩形, , 目标区域的绝对位置。用于接收计算结果。
.局部变量 局_起始单元, 自_坐标
.局部变量 局_表头尺寸, 自_尺寸
.局部变量 局_区域尺寸, 自_尺寸
.局部变量 局_统计次序, 整数型
.局部变量 局_计次, 整数型

参_区域位置.顶边 ＝ -1  ' 先置为无效的位置
参_区域位置.底边 ＝ -1
参_区域位置.左边 ＝ -1
参_区域位置.右边 ＝ -1
计算表头尺寸 (局_表头尺寸)
.如果真 (计算区域尺寸 (参_目标区域, 局_区域尺寸) ＝ 假)
    返回 (假)
.如果真结束
更新起始行列 (, , 局_起始单元)  ' 取起始行列坐标
' 下面计算区域的具体位置
.如果 (局_起始单元.垂直 ＝ 参_目标区域.顶边)
    参_区域位置.顶边 ＝ 局_表头尺寸.高度
.否则
    参_区域位置.顶边 ＝ 局_表头尺寸.高度 ＋ 计算行列尺寸 (局_起始单元.垂直, 参_目标区域.顶边 － 1, 真)
.如果结束
参_区域位置.底边 ＝ 参_区域位置.顶边 ＋ 局_区域尺寸.高度
.如果 (局_起始单元.水平 ＝ 参_目标区域.左边)
    参_区域位置.左边 ＝ 局_表头尺寸.宽度
.否则
    参_区域位置.左边 ＝ 局_表头尺寸.宽度 ＋ 计算行列尺寸 (局_起始单元.水平, 参_目标区域.左边 － 1, 假)
.如果结束
参_区域位置.右边 ＝ 参_区域位置.左边 ＋ 局_区域尺寸.宽度
返回 (真)

.子程序 计算单元序号, 整数型, , 根据指定的位置获取指定的序号。成功返回有效的序号，失败返回-1
.参数 参_绝对位置, 整数型, , 必须是表格内部任何有效位置，否则将导致失败
.参数 参_获取行号, 逻辑型, , 真-取行号 假-取列号。注意与前面的参数匹配
.局部变量 局_起始单元, 自_坐标
.局部变量 局_尺寸, 整数型
.局部变量 局_计次, 整数型

更新起始行列 (, , 局_起始单元)  ' 取起始行列坐标
.如果 (参_获取行号)
    .变量循环首 (0, 私_表格.表头行数 － 1, 1, 局_计次)  ' 表头区域单元判断
        局_尺寸 ＝ 局_尺寸 ＋ 私_表格.取行高 (局_计次)
        .如果真 (局_尺寸 ＞ 参_绝对位置)
            返回 (局_计次)
        .如果真结束

    .变量循环尾 ()
    .变量循环首 (局_起始单元.垂直, 私_表格.行数 － 1, 1, 局_计次)  ' 表格区域单元判断
        局_尺寸 ＝ 局_尺寸 ＋ 私_表格.取行高 (局_计次)
        .如果真 (局_尺寸 ＞ 参_绝对位置)
            返回 (局_计次)
        .如果真结束

    .变量循环尾 ()
.否则
    .变量循环首 (0, 私_表格.表头列数 － 1, 1, 局_计次)  ' 表头区域单元判断
        局_尺寸 ＝ 局_尺寸 ＋ 私_表格.取列宽 (局_计次)
        .如果真 (局_尺寸 ＞ 参_绝对位置)
            返回 (局_计次)
        .如果真结束

    .变量循环尾 ()
    .变量循环首 (局_起始单元.水平, 私_表格.列数 － 1, 1, 局_计次)  ' 表格区域单元判断
        局_尺寸 ＝ 局_尺寸 ＋ 私_表格.取列宽 (局_计次)
        .如果真 (局_尺寸 ＞ 参_绝对位置)
            返回 (局_计次)
        .如果真结束

    .变量循环尾 ()
.如果结束
返回 (-1)

.子程序 计算单元位置, 逻辑型, , 计算鼠标指针处单元格的行列位置(既行号和列号)。成功返回真，否则说明指针处没有单元格或者未曾成功调用【置入高级表格】方法
.参数 参_指针坐标, 自_坐标, , 鼠标指针在表格中的绝对坐标
.参数 参_单元坐标, 自_坐标, , 用于接收单元格所在表格的行列号。如果返回假时此参数内容为不确定值！

.如果真 (置入高级表格 () ＝ 假)
    返回 (假)
.如果真结束
参_单元坐标.水平 ＝ 计算单元序号 (参_指针坐标.水平, 假)  ' 计算水平位置
.如果真 (参_单元坐标.水平 ＝ -1)
    返回 (假)
.如果真结束
参_单元坐标.垂直 ＝ 计算单元序号 (参_指针坐标.垂直, 真)  ' 计算垂直位置
.如果真 (参_单元坐标.垂直 ＝ -1)
    返回 (假)
.如果真结束
返回 (真)

.子程序 计算位置关系, 整数型, , 计算鼠标指针与指定的表格区域信息之间的位置关系。位置关系常量值(相邻时可能为和值)：-1、#常_指针_邻外 0、#常_指针_邻内 1、#常_指针_邻顶 2、#常_指针_邻底 4、#常_指针_邻左 8、#常_指针_邻右
.参数 参_指针坐标, 自_坐标, , 鼠标指针在表格中的绝对坐标
.参数 参_区域位置, 矩形, , 区域的位置信息
.局部变量 局_已选区域, 矩形, , , 表格中被选择单元格的行列信息
.局部变量 局_指针位置, 整数型, , , 记录鼠标指针与被选择区域的相对位置

' 考虑到程序可读性对不同的类型分别进行判断
.判断开始 (参_区域位置.顶边 ＝ -1 或 参_区域位置.底边 ＝ -1 或 参_区域位置.左边 ＝ -1 或 参_区域位置.右边 ＝ -1)  ' 无效的区域位置
    返回 (#常_指针_邻外)
.判断 (参_指针坐标.水平 ≤ 参_区域位置.左边 或 参_指针坐标.水平 ≥ 参_区域位置.右边)  ' 鼠标指针在选择区域的水平范围之外
    返回 (#常_指针_邻外)
.判断 (参_指针坐标.垂直 ≤ 参_区域位置.顶边 或 参_指针坐标.垂直 ≥ 参_区域位置.底边)  ' 鼠标指针在选择区域的垂直范围之外
    返回 (#常_指针_邻外)
.默认

.判断结束
' 接下来是综合判断相邻的具体位置了
.如果真 (取绝对值 (参_区域位置.顶边 － 参_指针坐标.垂直) ≤ 私_数据.距离邻近)
    局_指针位置 ＝ #常_指针_邻顶
.如果真结束
.如果真 (取绝对值 (参_区域位置.底边 － 参_指针坐标.垂直) ≤ 私_数据.距离邻近)
    局_指针位置 ＝ 局_指针位置 ＋ #常_指针_邻底
.如果真结束
.如果真 (取绝对值 (参_区域位置.左边 － 参_指针坐标.水平) ≤ 私_数据.距离邻近)
    局_指针位置 ＝ 局_指针位置 ＋ #常_指针_邻左
.如果真结束
.如果真 (取绝对值 (参_区域位置.右边 － 参_指针坐标.水平) ≤ 私_数据.距离邻近)
    局_指针位置 ＝ 局_指针位置 ＋ #常_指针_邻右
.如果真结束
返回 (局_指针位置)

.子程序 执行累加功能, 文本型, , 将选择区域内的数值全部相加。不支持非数值列
.参数 参_指针坐标, 自_坐标, , 鼠标指针在表格中的绝对坐标
.参数 参_功能状态, 整数型, , 可选值：1、#常_执行_设置 2、#常_执行_调整 3、#常_执行_应用(使用此值时参数一可以为空)
.局部变量 局_起始单元, 自_坐标
.局部变量 局_已选区域, 矩形
.局部变量 局_信息文本, 文本型, , , 提示当前功能的执行情况啦
.局部变量 局_累加结果, 双精度小数型
.局部变量 局_列类型, 整数型
.局部变量 局_列号, 整数型

.判断开始 (参_功能状态 ＝ #常_执行_设置)
    私_状态 ＝ #常_状态_执行
    私_功能 ＝ #常_功能_累加
    局_信息文本 ＝ “当前状态：已就绪，请按住左键不放并移动鼠标到需要累加的单元即可”
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_调整)
    .如果真 (取已选择区域 (局_已选区域) ＝ 假)
        返回 (“功能提示：执行累加功能时请选中欲累加的单元格！”)
    .如果真结束
    .变量循环首 (局_已选区域.左边, 局_已选区域.右边, 1, 局_列号)
        局_列类型 ＝ 私_表格.取列类型 (局_列号)  ' 取列类型
        .如果真 (局_列类型 ≠ #表格常量.数值型 且 局_列类型 ≠ #表格常量.货币型 且 局_列类型 ≠ #表格常量.文本型)  ' 判断列类型
            局_信息文本 ＝ 局_信息文本 ＋ “功能提示：不支持的列类型，累加功能目前仅支持支” ＋ #换行符
            局_信息文本 ＝ 局_信息文本 ＋ “          持【数值型】、【货币型】、【文本型】”
            返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
        .如果真结束

    .变量循环尾 ()
    .如果真 (累加指定区域 (局_已选区域, 局_累加结果) ＝ 假)  ' 累加区域数据
        局_信息文本 ＝ 局_信息文本 ＋ “功能提示：区域内包含非数值数据未被累加” ＋ #换行符
    .如果真结束
    局_信息文本 ＝ 局_信息文本 ＋ “累加结果：” ＋ 到文本 (局_累加结果)
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.默认

.判断结束
返回 (“功能提示：！不支持的功能状态！”)

.子程序 执行复制功能, 文本型, , 纵向复制选中的单元格行数据
.参数 参_指针坐标, 自_坐标, 可空, 鼠标指针在表格中的绝对坐标
.参数 参_功能状态, 整数型, , 可选值：1、#常_执行_设置 2、#常_执行_调整 3、#常_执行_应用(使用此值时参数一可以为空)
.局部变量 局_单元内容, 文本型, 静态, , 被复制的内容
.局部变量 局_已选区域, 矩形, 静态, , 被复制的区域信息
.局部变量 局_单元坐标, 自_坐标
.局部变量 局_信息文本, 文本型, , , 提示当前功能的执行情况啦

.判断开始 (参_功能状态 ＝ #常_执行_设置)
    私_功能 ＝ #常_功能_复制
    .判断开始 (取已选择区域 (局_已选区域) ＝ 假)
        局_信息文本 ＝ “功能提示：执行复制功能时请选中欲复制的单元格！”
    .判断 (局_已选区域.顶边 ≠ 局_已选区域.底边)
        局_信息文本 ＝ “功能提示：暂不支持多行数据复制功能！”
    .默认
        私_表格.复制选定文本 ()  ' 取欲复制数据
        局_单元内容 ＝ 取剪辑板文本 ()  ' 保存
        .如果 (检查指定数据 (局_单元内容, #常_检查_空白))
            私_状态 ＝ #常_状态_执行
            局_信息文本 ＝ “当前状态：已就绪，请移动鼠标选择区域，区域确定后松开鼠标完成复制”
        .否则
            局_信息文本 ＝ “功能提示：已选择单元区域为空白，复制已取消！”
        .如果结束

    .判断结束
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_调整)
    .判断开始 (计算单元位置 (参_指针坐标, 局_单元坐标) ＝ 假)
        局_信息文本 ＝ “功能提示：指针已超出有效单元格范围！”
    .判断 (局_已选区域.顶边 ＜ 局_单元坐标.垂直)  ' 数据向下复制
        局_信息文本 ＝ “当前方向：向下复制” ＋ 到文本 (局_单元坐标.垂直 － 局_已选区域.顶边) ＋ “行”
        私_表格.选择区域 (局_已选区域.顶边, 局_已选区域.左边, 局_单元坐标.垂直, 局_已选区域.右边)  ' 选择向下移动
    .判断 (局_已选区域.顶边 ＞ 局_单元坐标.垂直)  ' 数据向上复制
        局_信息文本 ＝ “当前方向：向上复制” ＋ 到文本 (局_已选区域.顶边 － 局_单元坐标.垂直) ＋ “行”
        私_表格.选择区域 (局_单元坐标.垂直, 局_已选区域.左边, 局_已选区域.底边, 局_已选区域.右边)  ' 选择向上移动
    .默认
        ' 复制起始位置，做些提示
        局_信息文本 ＝ “当前状态：已就绪，请移动鼠标选择区域，区域确定后松开鼠标完成复制” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “功能备注：由于列类型差异可能较大，不支持水平方向复制功能”
        私_表格.选择区域 (局_已选区域.顶边, 局_已选区域.左边, 局_已选区域.底边, 局_已选区域.右边)  ' 定位起始区域
    .判断结束
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_应用)
    .如果真 (取已选择区域 (局_已选区域) ＝ 假)
        返回 (“功能提示：复制功能执行失败！”)
    .如果真结束
    置剪辑板文本 (局_单元内容)  ' 准备复制
    .变量循环首 (局_已选区域.顶边, 局_已选区域.底边, 1, 局_已选区域.顶边)
        私_表格.置光标 (局_已选区域.顶边, 局_已选区域.左边)  ' 定位数据位置
        私_表格.粘贴 ()  ' 粘贴数据
    .变量循环尾 ()
    返回 (“功能提示：复制功能执行结束^_^”)
.默认

.判断结束
返回 (“功能提示：！不支持的功能状态！”)

.子程序 执行填充功能, 文本型, , 从选中的单元格开始纵向序列填充数据
.参数 参_指针坐标, 自_坐标, , 鼠标指针在表格中的绝对坐标
.参数 参_功能状态, 整数型, , 可选值：1、#常_执行_设置 2、#常_执行_调整
.局部变量 局_数字填充, 逻辑型, 静态, , 真-数字序列填充 假-自定义序列填充
.局部变量 局_填充序列, 文本型, 静态, "0", 自定义填充序列数据
.局部变量 局_起始指针, 整数型, 静态, , 备份的起始序列指针，还原时有用
.局部变量 局_序列指针, 整数型, 静态, , 指向实时填充的数据
.局部变量 局_已选区域, 矩形, 静态, , 填充起始区域信息，必须确保为一个单元格
.局部变量 局_起始序号, 整数型, 静态, , 备份的起始序号，还原时有用
.局部变量 局_填充行号, 整数型, 静态, , 保存最后一次填充的位置
.局部变量 局_填充序号, 整数型, 静态, , 保存最后一次填充的序号
.局部变量 局_单元坐标, 自_坐标
.局部变量 局_信息文本, 文本型, , , 提示当前功能的执行情况啦
.局部变量 局_单元内容, 文本型
.局部变量 局_数量, 整数型
.局部变量 局_计次, 整数型

.判断开始 (参_功能状态 ＝ #常_执行_设置)
    私_功能 ＝ #常_功能_填充
    .如果真 (取已选择区域 (局_已选区域) ＝ 假)
        局_信息文本 ＝ “功能提示：执行填充功能时请选中有效的单元格！”
        返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
    .如果真结束
    局_单元内容 ＝ 私_表格.取数据 (局_已选区域.顶边, 局_已选区域.左边)  ' 取出填充的数据
    .判断开始 (局_已选区域.顶边 ≠ 局_已选区域.底边 或 局_已选区域.左边 ≠ 局_已选区域.右边)
        局_信息文本 ＝ “功能提示：请只选择一个单元格作为填充的起始单元！”
    .判断 (检查指定数据 (局_单元内容, #常_检查_空白) ＝ 假)
        局_信息文本 ＝ “功能提示：已选择单元区为空，序列填充已取消！”
    .默认
        局_数字填充 ＝ 真
        .如果 (检查指定数据 (局_单元内容, #常_检查_数字) ＝ 假)
            局_数量 ＝ 更新填充序列 (, 局_填充序列)  ' 检查自定义填充序列
            .计次循环首 (局_数量, 局_计次)
                .如果真 (检查指定数据 (局_单元内容, #常_检查_包含, 局_填充序列 [局_计次]) ＝ 真)
                    跳出循环 ()
                .如果真结束

            .计次循环尾 ()
            .如果真 (局_计次 ＞ 局_数量)  ' 判断是否找到自定义的序列数据
                局_信息文本 ＝ “功能提示：已选择单元区内不是有效的填充数据，序列填充已取消！”
                返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
            .如果真结束
            局_数字填充 ＝ 假
            局_填充序列 ＝ 分割文本 (局_填充序列 [局_计次], , )  ' 取出当前使用的自定义填充序列
            .计次循环首 (取数组成员数 (局_填充序列), 局_计次)
                .如果真 (局_填充序列 [局_计次] ＝ 局_单元内容)
                    局_起始指针 ＝ 局_计次  ' 定位单元格中的数据在序列中的位置
                    局_序列指针 ＝ 局_起始指针
                    跳出循环 ()
                .如果真结束

            .计次循环尾 ()
        .否则
            局_起始序号 ＝ 到整数 (私_表格.取数据 (局_已选区域.顶边, 局_已选区域.左边))  ' 初始化数字填充数据和起始位置
            局_填充序号 ＝ 局_起始序号
            局_信息文本 ＝ “起始序号：” ＋ 到文本 (局_起始序号)
        .如果结束
        私_状态 ＝ #常_状态_执行
        局_填充行号 ＝ 局_已选区域.顶边
    .判断结束
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_调整)
    .如果真 (计算单元位置 (参_指针坐标, 局_单元坐标) ＝ 假)
        返回 (“功能提示：指针已超出有效单元格范围！”)
    .如果真结束
    .判断开始 (局_单元坐标.垂直 ＝ 局_已选区域.顶边)  ' 填充起始单元处理
        .判断开始 (局_填充行号 ＜ 局_已选区域.顶边)
            私_表格.清空单元格数据 (局_填充行号, 局_已选区域.左边, 局_已选区域.底边 － 1, 局_已选区域.右边)  ' 清除向上已填充数据
        .判断 (局_填充行号 ＞ 局_已选区域.顶边)
            私_表格.清空单元格数据 (局_已选区域.顶边 ＋ 1, 局_已选区域.左边, 局_填充行号, 局_已选区域.右边)  ' 清除向下已填充数据
        .默认

        .判断结束
        局_填充序号 ＝ 局_起始序号  ' 还原到初始化状态
        局_序列指针 ＝ 局_起始指针
        局_填充行号 ＝ 局_单元坐标.垂直
        .如果 (局_数字填充)
            私_表格.置数据 (局_单元坐标.垂直, 局_已选区域.左边, #表格常量.文本型, 局_起始序号)  ' 还原数字填充数据
        .否则
            私_表格.置数据 (局_单元坐标.垂直, 局_已选区域.左边, #表格常量.文本型, 局_填充序列 [局_起始指针])  ' 还原自定义填充数据
        .如果结束
        局_信息文本 ＝ “当前状态：已就绪，按住左键不放并移动鼠标即可进行实时填充” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “功能提示：不支持水平方向填充功能” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “功能备注：由于鼠标移动超快可能出现序号异常！” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “          别慌，将鼠标移动到起始单元即可还原” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “已知问题：鼠标到无效单元区域引起填充方向的变” ＋ #换行符
        局_信息文本 ＝ 局_信息文本 ＋ “          化将可能导致原方向已填充数据不能清除”
        私_表格.选择区域 (局_已选区域.顶边, 局_已选区域.左边, 局_已选区域.底边, 局_已选区域.右边)  ' 定位到起始区域
    .判断 (局_单元坐标.垂直 ＞ 局_已选区域.顶边)  ' 向下填充处理
        局_信息文本 ＝ “当前方向：向下填充” ＋ 到文本 (局_单元坐标.垂直 － 局_已选区域.顶边) ＋ “行”
        私_表格.选择区域 (局_已选区域.顶边, 局_已选区域.左边, 局_单元坐标.垂直, 局_已选区域.右边)  ' 选择向下移动
        .判断开始 (局_单元坐标.垂直 ＞ 局_填充行号)  ' 填充序号
            .变量循环首 (局_填充行号 ＋ 1, 局_单元坐标.垂直, 1, 局_填充行号)
                局_填充序号 ＝ 局_填充序号 ＋ 1
                局_序列指针 ＝ 局_序列指针 ＋ 1
                .如果真 (局_序列指针 ＞ 取数组成员数 (局_填充序列))
                    局_序列指针 ＝ 1  ' 复位序列指针
                .如果真结束
                .如果 (局_数字填充)
                    私_表格.置数据 (局_填充行号, 局_已选区域.左边, #表格常量.文本型, 局_填充序号)  ' 数字填充
                .否则
                    私_表格.置数据 (局_填充行号, 局_已选区域.左边, #表格常量.文本型, 局_填充序列 [局_序列指针])  ' 自定义填充
                .如果结束

            .变量循环尾 ()
        .判断 (局_单元坐标.垂直 ＜ 局_填充行号)  ' 清除序号
            私_表格.清空单元格数据 (局_单元坐标.垂直 ＋ 1, 局_已选区域.左边, 局_填充行号, 局_已选区域.右边)
            局_填充序号 ＝ 局_填充序号 － (局_填充行号 － 局_单元坐标.垂直)
        .默认
            ' 相等就不处理了
        .判断结束
        局_填充行号 ＝ 局_单元坐标.垂直
    .默认
        ' 向上填充处理
        局_信息文本 ＝ “当前方向：向上填充” ＋ 到文本 (局_已选区域.顶边 － 局_单元坐标.垂直) ＋ “行”
        .如果 (局_单元坐标.垂直 ＜ 私_表格.表头行数)  ' 表头行不进行填充
            局_信息文本 ＝ 局_信息文本 ＋ #换行符 ＋ “功能提示：表头行单元格不在填充范围！”
        .否则
            私_表格.选择区域 (局_单元坐标.垂直, 局_已选区域.左边, 局_已选区域.底边, 局_已选区域.右边)  ' 选择向上移动
            .判断开始 (局_单元坐标.垂直 ＜ 局_填充行号)  ' 填充序号
                .变量循环首 (局_填充行号 － 1, 局_单元坐标.垂直, -1, 局_填充行号)
                    局_填充序号 ＝ 局_填充序号 － 1
                    局_序列指针 ＝ 局_序列指针 － 1
                    .如果真 (局_序列指针 ＝ 0)
                        局_序列指针 ＝ 取数组成员数 (局_填充序列)  ' 复位序列指针
                    .如果真结束
                    .如果 (局_数字填充)
                        私_表格.置数据 (局_填充行号, 局_已选区域.左边, #表格常量.文本型, 局_填充序号)  ' 数字填充
                    .否则
                        私_表格.置数据 (局_填充行号, 局_已选区域.左边, #表格常量.文本型, 局_填充序列 [局_序列指针])  ' 自定义填充
                    .如果结束

                .变量循环尾 ()
            .判断 (局_单元坐标.垂直 ＞ 局_填充行号)  ' 清除序号
                私_表格.清空单元格数据 (局_填充行号, 局_已选区域.左边, 局_单元坐标.垂直 － 1, 局_已选区域.右边)
                局_填充序号 ＝ 局_填充序号 ＋ 局_单元坐标.垂直 － 局_填充行号
            .默认
                ' 相等就不处理了
            .判断结束
            局_填充行号 ＝ 局_单元坐标.垂直
        .如果结束

    .判断结束
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.默认

.判断结束
返回 (“功能提示：！不支持的功能状态！”)

.子程序 执行移动功能, 文本型, , 将选中单元格的数据移动到新的目标位置
.参数 参_指针坐标, 自_坐标, 可空, 鼠标指针在表格中的绝对坐标
.参数 参_功能状态, 整数型, , 可选值：1、#常_执行_设置 2、#常_执行_调整 3、#常_执行_应用(使用此值时参数一可以为空)
.局部变量 局_移动数据, 文本型, 静态, , 欲移动的数据
.局部变量 局_原始区域, 矩形, 静态, , 目标区域在此基础上调整
.局部变量 局_目标区域, 矩形
.局部变量 局_起始单元, 自_坐标, 静态, , 调整时以此单元为原点
.局部变量 局_终止单元, 自_坐标
.局部变量 局_信息文本, 文本型, , , 提示当前功能的执行情况啦

.判断开始 (参_功能状态 ＝ #常_执行_设置)
    私_功能 ＝ #常_功能_移动
    .判断开始 (取已选择区域 (局_原始区域) ＝ 假)
        局_信息文本 ＝ “功能提示：执行移动功能时请选中欲移动的单元格！”
    .判断 (计算单元位置 (参_指针坐标, 局_起始单元) ＝ 假)
        局_信息文本 ＝ “功能提示：执行移动功能时请选中有效的单元格！”
    .默认
        私_表格.复制选定文本 ()  ' 取欲移动的数据
        局_移动数据 ＝ 取剪辑板文本 ()  ' 保存数据
        .如果 (检查指定数据 (局_移动数据, #常_检查_空白))
            私_状态 ＝ #常_状态_执行
            局_信息文本 ＝ “当前状态：已就绪，请移动鼠标选择区域，区域确定后松开鼠标完成移动”
        .否则
            局_信息文本 ＝ “功能提示：已选择单元区域内无有效数据，移动已取消！”
        .如果结束

    .判断结束
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_调整)
    .如果真 (计算单元位置 (参_指针坐标, 局_终止单元) ＝ 假)
        返回 (“功能提示：指针已超出有效单元格范围！”)
    .如果真结束
    局_目标区域.顶边 ＝ 局_原始区域.顶边 ＋ 局_终止单元.垂直 － 局_起始单元.垂直  ' 计算目标区域
    局_目标区域.底边 ＝ 局_原始区域.底边 ＋ 局_终止单元.垂直 － 局_起始单元.垂直
    局_目标区域.左边 ＝ 局_原始区域.左边 ＋ 局_终止单元.水平 － 局_起始单元.水平
    局_目标区域.右边 ＝ 局_原始区域.右边 ＋ 局_终止单元.水平 － 局_起始单元.水平
    私_表格.选择区域 (局_目标区域.顶边, 局_目标区域.左边, 局_目标区域.底边, 局_目标区域.右边)
    局_信息文本 ＝ “当前状态：已就绪，请移动鼠标选择区域，区域确定后松开鼠标完成移动” ＋ #换行符
    局_信息文本 ＝ 局_信息文本 ＋ “功能备注：1、不同类型列之间进行移动，可能出现会数据丢失” ＋ #换行符
    局_信息文本 ＝ 局_信息文本 ＋ “          2、目标区域超出有效单元格范围部分的数据不会被保留” ＋ #换行符
    局_信息文本 ＝ 局_信息文本 ＋ “             请自行确认移动范围！”
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ 局_信息文本)
.判断 (参_功能状态 ＝ #常_执行_应用)
    .如果真 (取已选择区域 (局_目标区域) ＝ 假)
        返回 (“功能提示：未检测到已选择区域，复制功能执行失败！”)
    .如果真结束
    私_表格.清空单元格数据 (局_原始区域.顶边, 局_原始区域.左边, 局_原始区域.底边, 局_原始区域.右边)  ' 清除原始区域内容
    私_表格.置光标 (局_目标区域.顶边, 局_目标区域.左边)  ' 定位粘贴的区域
    置剪辑板文本 (局_移动数据)  ' 准备粘贴
    私_表格.粘贴 ()  ' 将欲移动的数据粘贴到目标区域
    返回 (“功能状态：” ＋ 取当前功能名 () ＋ #换行符 ＋ “功能提示：复制功能执行结束^_^”)
.默认

.判断结束
返回 (“功能提示：！不支持的功能状态！”)

.子程序 更新指针形状, 逻辑型, , 根据鼠标指针在表格中的绝对位置来确定当前鼠标指针的形状。成功返回真，失败返回假，说明未曾成功调用【置入高级表格】方法
.参数 参_指针坐标, 自_坐标, 可空, 鼠标指针在表格中的绝对坐标。为空则使用默认形状的指针
.局部变量 局_区域位置, 矩形, , , 被选择区域在表格中的绝对坐标
.局部变量 局_表头尺寸, 自_尺寸
.局部变量 局_提示信息, 文本型
.局部变量 局_指针形状, 字节集
.局部变量 局_指针位置, 整数型

.如果真 (置入高级表格 () ＝ 假)
    返回 (假)
.如果真结束
局_指针形状 ＝ 到字节集 (#常_形状_默认)  ' 指针默认为箭头
.如果真 (是否为空 (参_指针坐标) ＝ 假)
    计算表头尺寸 (局_表头尺寸)
    .如果 (局_表头尺寸.宽度 ＞ 参_指针坐标.水平 或 局_表头尺寸.高度 ＞ 参_指针坐标.垂直)  ' 说明在表头区域
        局_提示信息 ＝ “功能提示：双击当前位置下单元格中部可以编辑单元内容”
    .否则
        局_指针位置 ＝ 计算位置关系 (参_指针坐标, 私_区域位置)
        .判断开始 (局_指针位置 ＝ #常_指针_邻右 ＋ #常_指针_邻底)  ' 表示指针在当前选择区域的右下角
            局_指针形状 ＝ 到字节集 (#常_形状_十字)
            局_提示信息 ＝ “功能提示：1、按下鼠标左键为复制功能” ＋ #换行符
            局_提示信息 ＝ 局_提示信息 ＋ “          2、按下Ctrl键时按下鼠标左键为填充功能”
        .判断 (局_指针位置 ≠ #常_指针_邻外 且 局_指针位置 ≠ #常_指针_邻内)  ' 表示指针在当前选择区域的其它相邻位置，但是不包含内部
            局_指针形状 ＝ 到字节集 (#常_形状_箭头)
            局_提示信息 ＝ “功能提示：按下鼠标左键为移动功能”
        .默认
            局_提示信息 ＝ “功能提示：按下鼠标左键为累加功能”
        .判断结束

    .如果结束

.如果真结束
.如果真 (私_表格.鼠标指针 ≠ 局_指针形状)  ' 更新指针将导致产生【鼠标位置被移动】事件，所以判断下，避免产生不必要的事件
    私_表格.鼠标指针 ＝ 局_指针形状
.如果真结束
.如果真 (私_数据.显示方式 ＝ #常_方式_永久显示)
    显示提示信息 (局_提示信息, 参_指针坐标)  ' 显示当前位置可执行的功能
.如果真结束
返回 (真)

.子程序 更新功能类型, 逻辑型, , 根据鼠标指针在表格中的形状来选择扩展功能的类型。
.参数 参_指针坐标, 自_坐标, , 鼠标指针在表格中的绝对坐标
.参数 参_功能键状态, 整数型, , 可以为以下常量值或其和： 1、#Ctrl键状态； 2、#Shift键状态； 4、#Alt键状态
.局部变量 局_指针形状, 字节集
.局部变量 局_更新信息, 文本型
.局部变量 局_指针位置, 整数型
.局部变量 局_单元坐标, 自_坐标

.如果真 (置入高级表格 () ＝ 假)
    返回 (假)
.如果真结束
局_指针形状 ＝ 私_表格.鼠标指针  ' 取指针形状
.判断开始 (局_指针形状 ＝ 到字节集 (#常_形状_十字))
    .如果 (位与 (参_功能键状态, #Ctrl键状态) ＝ #Ctrl键状态)  ' Ctrl键用于选择填充功能
        局_更新信息 ＝ 执行填充功能 (参_指针坐标, #常_执行_设置)  ' 填充功能初始化
    .否则
        局_更新信息 ＝ 执行复制功能 (参_指针坐标, #常_执行_设置)  ' 复制功能初始化
    .如果结束

.判断 (局_指针形状 ＝ 到字节集 (#常_形状_箭头))
    局_更新信息 ＝ 执行移动功能 (参_指针坐标, #常_执行_设置)  ' 移动功能初始化
.默认
    局_更新信息 ＝ 执行累加功能 (参_指针坐标, #常_执行_设置)  ' 累加功能初始化
.判断结束
显示提示信息 (局_更新信息, 参_指针坐标)  ' 显示执行的结果
返回 (真)

.子程序 处理扩展功能, , 公开, 对鼠标在表格中的相关操作进行扩展。！将此方法放到【高级表格】的【鼠标位置被移动】子程序下并传入对应的参数即可！
.参数 参_横向位置, 整数型
.参数 参_纵向位置, 整数型
.参数 参_功能键状态, 整数型
.局部变量 局_指针坐标, 自_坐标, 静态, , 备份鼠标指针在表格中的绝对位置
.局部变量 局_提示信息, 文本型

.如果真 (私_状态 ＝ #常_状态_禁止 或 局_指针坐标.水平 ＝ 参_横向位置 且 局_指针坐标.垂直 ＝ 参_纵向位置)  ' 禁止状态和坐标相同不做处理
    返回 ()
.如果真结束
局_指针坐标.水平 ＝ 参_横向位置  ' 更新指针坐标
局_指针坐标.垂直 ＝ 参_纵向位置
.判断开始 (私_状态 ＝ #常_状态_关闭)
    更新指针形状 (局_指针坐标)
.判断 (私_状态 ＝ #常_状态_执行)  ' 对功能执行的过程进行处理
    .判断开始 (私_功能 ＝ #常_功能_累加)
        局_提示信息 ＝ 执行累加功能 (局_指针坐标, #常_执行_调整)
    .判断 (私_功能 ＝ #常_功能_复制)
        局_提示信息 ＝ 执行复制功能 (局_指针坐标, #常_执行_调整)
    .判断 (私_功能 ＝ #常_功能_填充)
        局_提示信息 ＝ 执行填充功能 (局_指针坐标, #常_执行_调整)
    .判断 (私_功能 ＝ #常_功能_移动)
        局_提示信息 ＝ 执行移动功能 (局_指针坐标, #常_执行_调整)
    .默认
        返回 ()
    .判断结束
    显示提示信息 (局_提示信息, 局_指针坐标)  ' 显示处理的结果
.默认

.判断结束


.子程序 打开扩展功能, 逻辑型, 公开, 打开鼠标在表格中的扩展操作。！将此方法放到【高级表格】的【鼠标左键被按下】子程序下并传入对应的参数即可！
.参数 参_横向位置, 整数型
.参数 参_纵向位置, 整数型
.参数 参_功能键状态, 整数型
.局部变量 局_表头尺寸, 自_尺寸
.局部变量 局_指针坐标, 自_坐标, , , 鼠标指针在表格中的绝对位置
.局部变量 局_功能类型, 整数型

局_指针坐标.水平 ＝ 参_横向位置
局_指针坐标.垂直 ＝ 参_纵向位置
.如果真 (计算表头尺寸 (局_表头尺寸))
    .如果真 (参_横向位置 ＞ 局_表头尺寸.宽度 且 参_纵向位置 ＞ 局_表头尺寸.高度)  ' 位于表格区域内
        更新起始行列 (局_指针坐标)
        .如果真 (更新功能类型 (局_指针坐标, 参_功能键状态))
            .如果真 (私_功能 ≠ #常_功能_累加)
                返回 (假)  ' ！用于上级函数拦截事件！
            .如果真结束

        .如果真结束

    .如果真结束

.如果真结束
返回 (真)

.子程序 关闭扩展功能, 逻辑型, 公开, 关闭正在进行的扩展操作。！将此方法放到【高级表格】的【鼠标左键被放开】、【将被编辑】、【结束编辑】子程序下并传入对应的参数即可(注意参数选择)！
.参数 参_横向位置, 整数型, 可空
.参数 参_纵向位置, 整数型, 可空
.参数 参_功能键状态, 整数型, 可空
.参数 参_功能禁止, 逻辑型, 可空, 真-禁止全部扩展功能，假-运行执行扩展功能。在【将被编辑】子程序下使用本参数且必须为真，其它子程序下请保留为空即可
.局部变量 局_指针坐标, 自_坐标, , , 鼠标指针在表格中的绝对位置
.局部变量 局_已选区域, 矩形

.如果真 (取已选择区域 (局_已选区域))
    局_指针坐标.水平 ＝ 参_横向位置
    局_指针坐标.垂直 ＝ 参_纵向位置
    更新起始行列 (, 局_指针坐标)
    计算区域位置 (局_已选区域, 私_区域位置)
.如果真结束
显示提示信息 ()  ' 关闭信息显示
.判断开始 (参_功能禁止)
    更新指针形状 ()  ' 更新为默认的鼠标指针
    私_状态 ＝ #常_状态_禁止  ' 禁止扩展功能运行
.判断 (私_状态 ＝ #常_状态_禁止 或 私_状态 ＝ #常_状态_打开)
    私_状态 ＝ #常_状态_关闭
.判断 (私_状态 ＝ #常_状态_执行)  ' 执行结束处理
    .判断开始 (私_功能 ＝ #常_功能_复制)
        执行复制功能 (, #常_执行_应用)
        返回 (假)  ' ！用于上级函数拦截事件！
    .判断 (私_功能 ＝ #常_功能_填充)  ' 实时填充，不需要应用
        ' 填充数据 (, #常_执行_应用)
    .判断 (私_功能 ＝ #常_功能_移动)
        执行移动功能 (, #常_执行_应用)
        返回 (假)  ' ！用于上级函数拦截事件！
    .判断 (私_功能 ＝ #常_功能_累加)  ' 实时累加，不需要应用
        ' 累加数据 (, #常_执行_应用)
    .默认

    .判断结束
    私_状态 ＝ #常_状态_关闭
.默认

.判断结束
返回 (真)

.子程序 编辑行列表头, , 公开, 编辑行或者列表头单元的内容。！将此方法放到【高级表格】的【被双击】子程序下并传入对应的参数即可！
.参数 参_横向位置, 整数型
.参数 参_纵向位置, 整数型
.参数 参_功能键状态, 整数型
.局部变量 局_边距尺寸, 整数型
.局部变量 局_表头尺寸, 自_尺寸
.局部变量 局_临时文本, 文本型
.局部变量 局_单元坐标, 自_坐标
.局部变量 局_指针坐标, 自_坐标
.局部变量 局_起始位置, 整数型

.如果真 (置入高级表格 ())
    局_指针坐标.水平 ＝ 参_横向位置
    局_指针坐标.垂直 ＝ 参_纵向位置
    .如果真 (计算单元位置 (局_指针坐标, 局_单元坐标))
        .判断开始 (局_单元坐标.水平 ＜ 私_表格.表头列数 且 局_单元坐标.垂直 ＜ 私_表格.表头行数)  ' 表头交汇区域单元
            信息框 (“不支持表头交汇区域单元编辑！”, 0, )  ' 有需要可以自行修改
            返回 ()
        .判断 (局_单元坐标.水平 ≥ 私_表格.表头列数 且 局_单元坐标.垂直 ＜ 私_表格.表头行数)  ' 行表头
            局_起始位置 ＝ 计算行列尺寸 (0, 局_单元坐标.水平 － 1, 假)
            .如果真 (参_横向位置 － 局_起始位置 ＜ #常_数据_边距水平 或 局_起始位置 ＋ 私_表格.取单元格列宽 (局_单元坐标.垂直, 局_单元坐标.水平) － 参_横向位置 ＜ #常_数据_边距水平)  ' 位于单元格中间则继续编辑
                返回 ()  ' 否则可能是双击表格调整单元格尺寸，直接返回
            .如果真结束
            局_临时文本 ＝ “提示：正在修改行表头：行号=” ＋ 到文本 (局_单元坐标.垂直) ＋ “ 列号=” ＋ 到文本 (局_单元坐标.水平) ＋ “ 内容=”
        .判断 (局_单元坐标.垂直 ≥ 私_表格.表头行数 且 局_单元坐标.水平 ＜ 私_表格.表头列数)  ' 列表头
            局_起始位置 ＝ 计算行列尺寸 (0, 局_单元坐标.垂直 － 1, 真)
            .如果真 (参_纵向位置 － 局_起始位置 ＜ #常_数据_边距垂直 或 局_起始位置 ＋ 私_表格.取单元格行高 (局_单元坐标.垂直, 局_单元坐标.水平) － 参_纵向位置 ＜ #常_数据_边距垂直)  ' 位于单元格中间则继续编辑
                返回 ()  ' 否则可能是双击表格调整单元格尺寸，直接返回
            .如果真结束
            局_临时文本 ＝ “提示：正在修改列表头＋行号=” ＋ 到文本 (局_单元坐标.垂直) ＋ “ 列号=” ＋ 到文本 (局_单元坐标.水平) ＋ “ 内容=”
        .默认
            返回 ()  ' 其它操作直接返回
        .判断结束
        局_临时文本 ＝ 局_临时文本 ＋ 私_表格.取数据 (局_单元坐标.垂直, 局_单元坐标.水平) ＋ #换行符
        局_临时文本 ＝ 局_临时文本 ＋ “注意：不输入内容直接确定则清除单元格内容，不想修改按取消或者关闭即可。”
        .如果真 (输入框 (局_临时文本, “请输入新的内容...”, , 局_临时文本, ))  ' 输入确认
            私_表格.置数据 (局_单元坐标.垂直, 局_单元坐标.水平, #表格常量.文本型, 局_临时文本)  ' 则修改单元内容
        .如果真结束

    .如果真结束

.如果真结束

@易语言资源网站