.版本 2
.支持库 iext
.支持库 iext2

.程序集 窗口集
.程序集变量 集_类型, 字节型, , , 0=直接运行  1=双击模块传进来的  2=从易工具箱打开的
.程序集变量 集_父窗口句柄, 整数型
.程序集变量 集_支持库树型框句柄, 整数型
.程序集变量 集_播放中, 逻辑型
.程序集变量 _置父, 逻辑型, , , 是否置到易语言里
.程序集变量 集_旧窗口过程, 整数型

.子程序 __启动窗口_创建完毕
.局部变量 命令行, 文本型, , "0"
.局部变量 窗口的宽度, 整数型
.局部变量 窗口的高度, 整数型

.如果真 (是否为调试版 () ＝ 假)
    写注册项 (#现行用户, “Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION\” ＋ 取执行文件名 (), 8888)
.如果真结束

.如果真 (是否为调试版 ())
    编辑框_关键字.内容 ＝ “没有”
    总在最前 ＝ 假
.如果真结束
全_运行目录 ＝ 取运行目录 () ＋ “\”
目录_创建 (全_运行目录 ＋ “Data”)
目录_创建 (目录_取临时目录 () ＋ “ecCache\”)

配置.初始化 (全_运行目录 ＋ “Data\Config.ini”)

取命令行 (命令行)
关联模块 (命令行)
.判断开始 (取数组成员数 (命令行) ＝ 1)  ' 关联模块后传进来的，模块路径

    ' 如果仅有一个参数，且为关联的时候。
    .判断开始 (命令行 [1] ＝ “关联”)
        文件_关联 (取运行目录 () ＋ “\” ＋ 取执行文件名 (), “ec”, , “易语言模块”, )
        结束 ()
    .默认
        全_模块信息.模块路径 ＝ 命令行 [1]
        .如果真 (文件是否存在 (全_模块信息.模块路径) ＝ 假)
            wDebugText (“命令行：” ＋ 命令行 [1])
            wDebugText (“模块路径有误：” ＋ 全_模块信息.模块路径)
            进程_结束 ()
        .如果真结束
        集_类型 ＝ 1
    .判断结束


.判断 (取数组成员数 (命令行) ＝ 2)  ' 命令行格式： 1:模块路径 2:父窗口句柄-0(0=置父，1=不置父)
    全_模块信息.模块路径 ＝ 命令行 [1]
    .判断开始 (寻找文本 (命令行 [2], “-”, , 假) ≠ -1)
        集_父窗口句柄 ＝ 到数值 (文本_取左边 (命令行 [2], “-”, , , ))
        .如果 (文本_取右边 (命令行 [2], “-”, , , ) ＝ “1”)
            _置父 ＝ 假
        .否则
            _置父 ＝ 真
        .如果结束

    .默认
        _置父 ＝ 真
        集_父窗口句柄 ＝ 到数值 (命令行 [2])
    .判断结束

    .如果真 (文件是否存在 (全_模块信息.模块路径) ＝ 假)
        wDebugText (“命令行：” ＋ 命令行 [1] ＋ “|” ＋ 命令行 [2])
        wDebugText (“模块路径有误：” ＋ 全_模块信息.模块路径)
        进程_结束 ()
    .如果真结束
    .如果真 (_置父 ＝ 真 且 窗口_句柄是否有效 (集_父窗口句柄) ＝ 假)
        wDebugText (“命令行：” ＋ 命令行 [1] ＋ “|” ＋ 命令行 [2])
        wDebugText (“父窗口句柄：” ＋ 到文本 (集_父窗口句柄))
        进程_结束 ()
    .如果真结束
    .如果真 (_置父)
        窗口_置父 (_启动窗口.取窗口句柄 (), 集_父窗口句柄)
    .如果真结束
    集_类型 ＝ 2


.判断 (取数组成员数 (命令行) ＝ 0)
    ' 如果直接双击打开，就先检查是否关联，如果没有关联，就关联起来。
    ' 如果已经有了关联，那么就直接结束了

    .如果真 (GetAsyncKeyState (#Shift键) ≠ 0)
        写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinTop”, 到文本 (100))
        写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinLeft”, 到文本 (100))
        写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinHeight”, 到文本 (680))
        写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinWidth”, 到文本 (484))
        信息框 (“按住Shift启动，设置已经重置，请重新打开”, 0, , )
        进程_结束 ()
    .如果真结束


    .如果真 (文件_取关联 (“ec”) ≠ 取运行目录 () ＋ “\” ＋ 取执行文件名 ())
        程序_提权运行 (全_运行目录 ＋ 取执行文件名 (), “关联”)
    .如果真结束

    集_类型 ＝ 0
    进程_结束 ()


.默认

.判断结束

集_旧窗口过程 ＝ SetWindowLongA (_启动窗口.取窗口句柄 (), -4, 到整数 (&新窗口过程))
功能_读取配置 ()
外部编辑框_左边留空 (编辑框_关键字.取窗口句柄 (), 3)

.子程序 新窗口过程, 整数型
.参数 hwnd, 整数型
.参数 msg, 整数型
.参数 wparam, 整数型
.参数 lparam, 整数型
.局部变量 大小信息, 大小信息

.如果真 (msg ＝ #WM_GETMINMAXINFO)
    复制内存_获取大小信息 (大小信息, lparam, 40)
    大小信息.最小拖动尺寸.x ＝ 766
    大小信息.最小拖动尺寸.y ＝ 666
    大小信息.最大拖动尺寸.x ＝ 99999
    大小信息.最大拖动尺寸.y ＝ 99999
    复制内存_设置大小信息 (lparam, 大小信息, 40)
.如果真结束

返回 (CallWindowProcA (集_旧窗口过程, hwnd, msg, wparam, lparam))

.子程序 __启动窗口_首次激活

.如果真 (_启动窗口.位置 ＝ 3)
    _启动窗口.位置 ＝ 3
    处理事件 ()
.如果真结束

.如果真 (_启动窗口.左边 ＜ 0)
    _启动窗口.左边 ＝ 0
    _启动窗口.顶边 ＝ 0
.如果真结束

.如果真 (_启动窗口.顶边 ＜ 0)
    _启动窗口.左边 ＝ 0
    _启动窗口.顶边 ＝ 0
.如果真结束


.如果真 (_启动窗口.左边 ＞ 1920 × 2)
    _启动窗口.左边 ＝ 0
.如果真结束

.如果真 (_启动窗口.顶边 ＞ 取屏幕高度 () － 30)
    _启动窗口.左边 ＝ 0
    _启动窗口.顶边 ＝ 0
.如果真结束

.如果真 (_启动窗口.宽度 ＜ 766)
    _启动窗口.宽度 ＝ 766
.如果真结束

.如果真 (_启动窗口.高度 ＜ 666)
    _启动窗口.高度 ＝ 666
.如果真结束

_启动窗口.标题 ＝ “易模块公开信息 V” ＋ #常_标题Version ＋ “ - ” ＋ 全_模块信息.模块路径
树型框_命令.加入项目 (, “载入中...”, , , , , )
模块分析_开始 (全_模块信息.模块路径, 真)



.子程序 关联模块
.参数 命令行, 文本型, 数组
.局部变量 File, 文本型

.如果真 (取数组成员数 (命令行) ＝ 1)
    .如果真 (命令行 [1] ＝ “关联”)
        文件_关联 (取运行目录 () ＋ “\” ＋ 取执行文件名 (), “ec”, , “易语言模块”, “ec”)
        进程_结束 ()
    .如果真结束

.如果真结束
.如果真 (是否为调试版 ())
    返回 ()
.如果真结束

.如果真 (文件_是否关联 (“ec”) ≠ 1)
    ' 正常权限的方式下直接关联
    文件_关联 (取运行目录 () ＋ “\” ＋ 取执行文件名 (), “ec”, , “易语言模块”, “ec”)

    ' 如果正常权限关联不了，只能提权关联了
    .如果真 (文件_是否关联 (“ec”) ≠ 1)
        程序_提权运行 (取运行目录 () ＋ “\” ＋ 取执行文件名 (), “关联”)
    .如果真结束

.如果真结束


.子程序 __启动窗口_尺寸被改变

选择框_搜索命令.移动 (48, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 5, , )
选择框_搜索备注.移动 (124, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 5, , )


树型框_命令.移动 (8, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 30, 取用户区宽度 () × 0.618 ÷ 2, 取用户区高度 () － 选择框_搜索备注.顶边 － 选择框_搜索备注.高度 － 26)

树型框_查找.移动 (树型框_命令.左边, 树型框_命令.顶边, 树型框_命令.宽度, 树型框_命令.高度)


编辑框_关键字.移动 (, , 树型框_命令.宽度 － 37, )
图形按钮_返回.移动 (编辑框_关键字.左边 ＋ 编辑框_关键字.宽度 － 19, 编辑框_关键字.顶边 ＋ 3, , )
分隔条_树形框.移动 (树型框_命令.左边 ＋ 树型框_命令.宽度 ＋ 4, 0, , 取用户区高度 () － 20)


编辑框_命令.移动 (分隔条_树形框.左边 ＋ 分隔条_树形框.宽度 ＋ 4, 编辑框_关键字.顶边, 取用户区宽度 () － 树型框_命令.宽度 － 24, 取用户区高度 () － 34)
互联网浏览器.移动 (编辑框_命令.左边, 编辑框_命令.顶边, 编辑框_命令.宽度, 编辑框_命令.高度)


.子程序 wDebugText
.参数 text, 文本型
.局部变量 log, _Log, 静态

.如果真 (文件是否存在 (取运行目录 () ＋ “\debug.txt”))
    log.初始化 (全_运行目录 ＋ “debug.txt”, , )
    log.写日志 (text)
.如果真结束
' 信息框 (text, 0, , )

.子程序 功能_读取配置
.局部变量 局_高度, 整数型
.局部变量 局_宽度, 整数型
.局部变量 父窗口位置, 精易_矩形

' 信息框 (“集_类型 = ” ＋ 到文本 (集_类型) ＋ “ , _置父=” ＋ 到文本 (_置父), 0, , )
分隔条_树形框.左边 ＝ 到整数 (配置.读 (, “分隔条左边”, “240”))
.如果真 (分隔条_树形框.左边 ＞ _启动窗口.宽度 － 260)
    分隔条_树形框.左边 ＝ 216
    配置.写 (, “分隔条左边”, “216”)
.如果真结束


窗口置顶.选中 ＝ 配置.读 (, “窗口置顶”, “假”) ＝ “真”
总在最前 ＝ 窗口置顶.选中

.' 如果 (_置父)
    ' 配置.窗口位置_读取 (_启动窗口, 真, 集_父窗口句柄)
.否则
    ' 配置.窗口位置_读取 (_启动窗口, 真, )
.如果结束

' _启动窗口.顶边 ＝ 到整数 (读配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinTop”, “50”))
' _启动窗口.左边 ＝ 到整数 (读配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinLeft”, “50”))
_启动窗口.高度 ＝ 到整数 (读配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinHeight”, “50”))
_启动窗口.宽度 ＝ 到整数 (读配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinWidth”, “50”))

.如果 (_置父)
    父窗口位置 ＝ 窗口_取位置和大小 (集_父窗口句柄)
    .如果真 (_启动窗口.左边 ＜ 0 或 _启动窗口.左边 ＞ 父窗口位置.右边 ＋ 父窗口位置.左边)
        _启动窗口.左边 ＝ 50
    .如果真结束

    .如果真 (_启动窗口.顶边 ＜ 0 或 _启动窗口.顶边 ＞ 父窗口位置.顶边 ＋ 父窗口位置.底边)
        _启动窗口.顶边 ＝ 50
    .如果真结束



.否则

    .如果真 (_启动窗口.左边 ＜ 50)
        _启动窗口.左边 ＝ 50
    .如果真结束

    .如果真 (_启动窗口.顶边 ＜ 50)
        _启动窗口.顶边 ＝ 50
    .如果真结束

.如果结束

.如果真 (_启动窗口.宽度 ＜ 500)
    _启动窗口.宽度 ＝ 500
.如果真结束

.如果真 (_启动窗口.高度 ＜ 450)
    _启动窗口.高度 ＝ 450
.如果真结束

' 信息框 (“_启动窗口.左边 = ” ＋ 到文本 (_启动窗口.左边) ＋ #换行符 ＋ “_启动窗口.顶边=” ＋ 到文本 (_启动窗口.顶边) ＋ #换行符 ＋ “_启动窗口.宽度=” ＋ 到文本 (_启动窗口.宽度) ＋ #换行符 ＋ “_启动窗口.高度=” ＋ 到文本 (_启动窗口.高度), 0, , )


.判断开始 (配置.读 (取执行文件名 (), “文本模式”, “假”, ) ＝ “真”)  ' 真 = 文本模式
    文本模式.选中 ＝ 真
    互联网浏览器 ＝ 假  ' <!!!>
.默认
    互联网浏览器 ＝ 真  ' <!!!>
.判断结束




.子程序 _树型框_命令_项目被选择
.参数 选择方式, 整数型
.局部变量 局_现行选中项, 整数型
.局部变量 局_类型, 文本型
.局部变量 局_层次, 整数型
.局部变量 tag, 整数型
.局部变量 子项目数, 整数型
.局部变量 t, 整数型
.局部变量 耗时统计, 文本型

t ＝ 取启动时间 ()
tag ＝ 树型框_命令.取项目数值 (树型框_命令.现行选中项)

功能_播放声音 (真)  ' 停止播放

局_现行选中项 ＝ 树型框_命令.现行选中项
.判断开始 (树型框_命令.禁止)  ' 排序时会禁止树型框
    返回 ()

.默认

.判断结束

配置.写 (“现行选中项”, 取模块MD5 (), 到文本 (局_现行选中项))

.如果真 (功能_是否为命令 () ＝ 假)
    .如果真 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “类”)
        全_当前选中项数据.易代码 ＝ 功能_取子项目所有文本 (子项目数)
        编辑框_命令.内容 ＝ 全_当前选中项数据.易代码
        在浏览器中显示 (全_当前选中项数据.易代码, 真, 子项目数)
    .如果真结束
    返回 ()
.如果真结束

耗时统计 ＝ “第一阶段: ” ＋ 到文本 (取启动时间 () － t)
t ＝ 取启动时间 ()

.如果真 (局_现行选中项 ＝ 0)  ' 顶级分类，读取模块属性
    编辑框_命令.内容 ＝ 文本_替换 (全_模块信息.整体信息, , , , “<pre>”, “”, “</pre>”, , , , , , , )
    在浏览器中显示 (全_模块信息.整体信息HTML, 真)
    树型框_命令.扩展 (0)
    返回 ()
.如果真结束

耗时统计 ＝ 耗时统计 ＋ #换行符 ＋ “第二阶段: ” ＋ 到文本 (取启动时间 () － t)
t ＝ 取启动时间 ()

局_层次 ＝ 树型框_命令.取缩进层次 (局_现行选中项)
.判断开始 (局_层次 ＝ 2)  ' 选择父类
    输出调试文本 (11)

.判断 (局_层次 ＝ 3)  ' 正常命令
    易代码读取 (树型框_命令.取项目文本 (树型框_命令.取父项目 (局_现行选中项)), tag)

.判断 (局_层次 ＝ 4)  ' 类命令
    易代码读取 (“类”, tag)
.默认

.判断结束

耗时统计 ＝ 耗时统计 ＋ #换行符 ＋ “第三阶段: ” ＋ 到文本 (取启动时间 () － t)

t ＝ 取启动时间 ()
置状态文本 (树型框_命令.取项目文本 (树型框_命令.取父项目 (局_现行选中项)) ＋ “ → ” ＋ 树型框_命令.取项目文本 (局_现行选中项))

编辑框_命令.内容 ＝ 全_当前选中项数据.易代码
在浏览器中显示 (全_当前选中项数据.易代码, 真, )

耗时统计 ＝ 耗时统计 ＋ #换行符 ＋ “第四阶段: ” ＋ 到文本 (取启动时间 () － t)
t ＝ 取启动时间 ()

' 信息框 (“耗时统计:” ＋ 耗时统计, 0, , )


.子程序 功能_取子项目所有文本, 文本型
.参数 子项目数, 整数型, 参考 可空
.局部变量 局_计次, 整数型
.局部变量 局_文本, 文本型
.局部变量 局_显示文本, 文本型
.局部变量 局_缩进层次, 整数型
.局部变量 局_类, 文本型
.局部变量 局_类一行声明文本, 文本型
.局部变量 备注指针, 整数型

子项目数 ＝ 外部树型框_命令.取子项目数 ()

局_缩进层次 ＝ 树型框_命令.取缩进层次 (树型框_命令.现行选中项 ＋ 1)

局_类 ＝ 树型框_命令.取项目文本 (树型框_命令.现行选中项)
备注指针 ＝ 树型框_命令.取项目数值 (树型框_命令.现行选中项)
移到文件首 (备注指针)
局_类一行声明文本 ＝ 读入文本 (备注指针, )
局_显示文本 ＝ 局_类一行声明文本
.变量循环首 (树型框_命令.现行选中项 ＋ 1, 树型框_命令.现行选中项 ＋ 子项目数, 1, 局_计次)
    .判断开始 (局_缩进层次 ＝ 3)  ' 正常命令
        局_文本 ＝ 易代码读取 (局_类, 外部树型框_命令.取项目数值 (局_计次))

    .判断 (局_缩进层次 ＝ 4)  ' 类命令
        局_文本 ＝ 易代码读取 (“类”, 外部树型框_命令.取项目数值 (局_计次))
    .默认

    .判断结束

    局_显示文本 ＝ 局_显示文本 ＋ 局_文本 ＋ #换行符
    .如果真 (局_计次 ≥ 局_计次 ＋ 子项目数)
        跳出循环 ()
    .如果真结束

.变量循环尾 ()
返回 (局_显示文本)

.子程序 功能_是否为命令, 逻辑型
.局部变量 外部树形框, 外部树型框
.局部变量 现行选中项, 整数型
.局部变量 局_文本, 文本型
.局部变量 局_名称, 文本型

外部树形框.初始化 (树型框_命令.取窗口句柄 (), , 假)
现行选中项 ＝ 外部树形框.取现行选中项 ()

.如果真 (外部树形框.是否有子项目 (现行选中项) ＝ 假 或 现行选中项 ＝ 0)
    返回 (真)
.如果真结束
局_名称 ＝ 外部树形框.取项目文本 (现行选中项)

.判断开始 (外部树形框.取项目文本 (现行选中项) ＝ “类”)
    局_名称 ＝ “类”

.判断 (树型框_命令.取项目文本 (树型框_命令.取父项目 (现行选中项)) ＝ “类”)
    局_名称 ＝ “类方法”

.判断 (局_名称 ＝ “全局变量”)
    局_名称 ＝ “全局变量”

.判断 (局_名称 ＝ “类”)
    返回 (假)
.默认

.判断结束
局_文本 ＝ “<HTML><HEAD><TITLE>精易论坛 bbs.125.la</TITLE></HEAD><body style='border:0px none #CCCCCC;font-size:12px;padding-top:0px;'>共有” ＋ 到文本 (外部树型框_命令.取子项目数 ()) ＋ “个” ＋ 局_名称 ＋ “</BODY></HTML>”
写到文件 (目录_取临时目录 () ＋ 全_模块信息.模块MD5 ＋ “_ec.html”, 到字节集 (局_文本))

??? ()  ' <!!!>
返回 (假)

.子程序 在浏览器中显示
.参数 显示的文本, 文本型
.参数 自动宽度, 逻辑型
.参数 子项目数, 整数型, 可空
.局部变量 局_文本, 文本型
.局部变量 局_width, 文本型

.如果真 (文本模式.选中)  ' 文本模式直接返回
    返回 ()
.如果真结束

.如果 (自动宽度)
    局_width ＝ “width:auto;”
.否则
    局_width ＝ “min-width:860px;”
.如果结束

.判断开始 (树型框_命令.现行选中项 ＝ 0)
    局_文本 ＝ 子文本替换 (显示的文本, #换行符, “<br>”, , , 真)
    .如果真 (取文本左边 (局_文本, 4) ＝ “<br>”)
        局_文本 ＝ 取文本右边 (局_文本, 取文本长度 (局_文本) － 4)
    .如果真结束
    局_文本 ＝ #HTML_头 ＋ “<body style='border:0px none #CCCCCC;font-size:12px;padding-top:0px;” ＋ 局_width ＋ “'>” ＋ 局_文本 ＋ “</BODY></HTML>”
    写到文件 (目录_取临时目录 () ＋ 全_模块信息.模块MD5 ＋ “_ec.html”, 到字节集 (局_文本))

.判断 (子项目数 ＞ 0)
    写到文件 (目录_取临时目录 () ＋ 全_模块信息.模块MD5 ＋ “_ec.html”, 到字节集 (易代码.转换 (显示的文本, 真, 真, 子项目数)))

.默认
    写到文件 (目录_取临时目录 () ＋ 全_模块信息.模块MD5 ＋ “_ec.html”, 到字节集 (易代码.转换 (显示的文本, 真, , )))
.判断结束

??? ()  ' <!!!>

.子程序 _树型框_命令_右键单击项目

连续赋值 (真, 全部扩展.可视, 全部收缩.可视, 复制.可视, 复制类变量声明.可视, 分割条2.可视)

转到命令所在位置.可视 ＝ 假
.如果 (树型框_命令.是否有子项目 (树型框_命令.现行选中项))
    复制.标题 ＝ “复制所有声明(&C)”
    连续赋值 (真, 插入到易语言.禁止)

.否则
    连续赋值 (假, 插入到易语言.禁止)
    复制.标题 ＝ “复制(&C)”
.如果结束


连续赋值 (树型框_命令.现行选中项 ＞ 0, 复制.可视, 插入到易语言.可视)
复制类变量声明.可视 ＝ 树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “类”
.如果真 (树型框_命令.取项目文本 (树型框_命令.现行选中项) ＝ “类”)
    复制.可视 ＝ 假
.如果真结束
弹出菜单 (文件, , )

.子程序 _复制_被选择

.如果真 (树型框_命令.是否有子项目 (树型框_命令.现行选中项))
    置状态文本 (“复制中，请稍等...”)
    置剪辑板文本 (功能_取子项目所有文本 ())
    置状态文本 (“复制【” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “】下所有声明代码成功！”)
    返回 ()
.如果真结束
置剪辑板文本 (功能_形成命令 (编辑框_命令.内容))
置状态文本 (“复制[” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “]命令成功”)

.子程序 _复制类变量声明_被选择
.局部变量 局_文本, 文本型
.局部变量 局_类名, 文本型

局_类名 ＝ 树型框_命令.取项目文本 (树型框_命令.现行选中项)
局_文本 ＝ “.版本 2” ＋ #换行符 ＋ #换行符
局_文本 ＝ 局_文本 ＋ “.局部变量 ” ＋ 局_类名 ＋ “, ” ＋ 局_类名
置剪辑板文本 (局_文本)
置状态文本 (“复制类声明成功！”)

.子程序 功能_形成命令, 文本型
.参数 参_易代码, 文本型
.参数 不带命令参数说明, 逻辑型, 可空
.局部变量 局_命令名称, 文本型
.局部变量 局_数组, 文本型, , "0"
.局部变量 局_计次, 整数型
.局部变量 局_函数类型, 整数型
.局部变量 局_类名称, 文本型

局_函数类型 ＝ 功能_取函数类型和名称 (参_易代码, 局_命令名称)
.如果真 (局_命令名称 ＝ “”)
    返回 (参_易代码)
.如果真结束

.如果 (树型框_命令.取图片 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ 0 且 树型框_命令.是否有子项目 (树型框_命令.现行选中项) ＝ 假)  ' 复制类里面的方法
    局_类名称 ＝ 树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＋ “.”
.否则
    局_类名称 ＝ “”
.如果结束

.如果真 (不带命令参数说明)
    返回 (局_类名称 ＋ 局_命令名称 ＋ “(” ＋ 取重复文本 (功能_取命令参数数量 (参_易代码) － 1, “, ”) ＋ “)”)
.如果真结束
局_数组 ＝ 分割文本 (参_易代码, #换行符, )
局_命令名称 ＝ 局_命令名称 ＋ “ (”
.计次循环首 (取数组成员数 (局_数组), 局_计次)
    局_数组 [局_计次] ＝ 删首尾空 (局_数组 [局_计次])
    .如果真 (取文本左边 (局_数组 [局_计次], 6) ＝ “.参数 ”)
        局_命令名称 ＝ 局_命令名称 ＋ #引号 ＋ 文本_取出中间文本 (局_数组 [局_计次], “.参数 ”, “,”) ＋ 取变量类型 (局_数组 [局_计次]) ＋ #引号 ＋ “, ”
    .如果真结束

.计次循环尾 ()
.如果真 (取文本右边 (局_命令名称, 2) ＝ “, ”)
    局_命令名称 ＝ 取文本左边 (局_命令名称, 取文本长度 (局_命令名称) － 2)
.如果真结束
返回 (局_类名称 ＋ 局_命令名称 ＋ “)”)

.子程序 功能_取命令参数数量, 整数型
.参数 易语言代码, 文本型
.局部变量 局_数组, 文本型, , "0"
.局部变量 局_计次, 整数型
.局部变量 局_数量, 整数型

局_数组 ＝ 分割文本 (易语言代码, #换行符, )
.计次循环首 (取数组成员数 (局_数组), 局_计次)
    局_数组 [局_计次] ＝ 删首尾空 (局_数组 [局_计次])
    .如果真 (取文本左边 (局_数组 [局_计次], 6) ＝ “.参数 ”)
        局_数量 ＝ 局_数量 ＋ 1
    .如果真结束

.计次循环尾 ()
返回 (局_数量)

.子程序 功能_取参数声明代码, 文本型
.参数 参_易代码, 文本型
.局部变量 arr, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 Str, 文本型

arr ＝ 分割文本 (参_易代码, #换行符, )
.计次循环首 (取数组成员数 (arr), i)
    .如果真 (寻找文本 (arr [i], “.参数 ”, , 假) ＝ -1 且 寻找文本 (arr [i], “.成员 ”, , 假) ＝ -1)
        到循环尾 ()
    .如果真结束
    Str ＝ Str ＋ 删首尾空 (arr [i]) ＋ #换行符
.计次循环尾 ()
.如果真 (Str ≠ “”)
    Str ＝ “.版本 2” ＋ #换行符 ＋ #换行符 ＋ Str
.如果真结束
返回 (Str)

.子程序 功能_取函数类型和名称, 整数型, , 如果是“子程序”返回1，“DLL命令”返回2，其它命令返回-1
.参数 参_易代码, 文本型
.参数 命令名称, 文本型, 可空, 请提供一个用于存放命令名称的文本型变量

命令名称 ＝ 删首尾空 (文本_取出中间文本 (参_易代码, “.子程序 ”, “,”))
.如果真 (命令名称 ≠ “”)
    返回 (1)
.如果真结束
命令名称 ＝ 删首尾空 (文本_取出中间文本 (参_易代码, “.DLL命令 ”, “,”))
.如果真 (命令名称 ≠ “”)
    返回 (2)
.如果真结束
返回 (-1)

.子程序 取变量类型, 文本型
.参数 参_易代码, 文本型
.局部变量 局_文本, 文本型

局_文本 ＝ 删首尾空 (文本_取出中间文本 (参_易代码, “,”, “,”))
.如果真 (局_文本 ＝ “”)
    局_文本 ＝ “整数型”
.如果真结束
返回 (“[” ＋ 局_文本 ＋ “]”)

.子程序 _插入到易语言_被选择

.如果真 (集_类型 ≠ 2)
    提示框 (“你是直接双击打开模块的，无法插入到易语言。” ＋ #换行符 ＋ #换行符 ＋ “如果要使用本功能，请在易语言里查看模块信息。”, #错误图标 ＋ #位于前台, , )
    返回 ()
.如果真结束


.判断开始 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “常量”)
    信息框 (“常量不支持插入到易语言，请手动操作。”, 0, , _启动窗口)
.判断 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “DLL命令”)
    功能_插入到易语言 (编辑框_命令.内容)
.默认
    功能_插入到易语言 (功能_形成命令 (编辑框_命令.内容, ))
.判断结束


.子程序 _转到命令所在位置_被选择

_图形按钮_返回_被单击 ()
树型框_命令.获取焦点 ()
树型框_命令.保证显示 (树型框_命令.现行选中项)

.子程序 _文本模式_被选择
.局部变量 子项目数, 整数型

文本模式.选中 ＝ 取反 (文本模式.选中)
.判断开始 (文本模式.选中 ＝ 假)  ' 文本模式
    互联网浏览器 ＝ 真  ' <!!!>
    .判断开始 (树型框_命令.现行选中项 ＝ 0)
        在浏览器中显示 (全_模块信息.整体信息HTML, 真)

    .判断 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “类”)
        全_当前选中项数据.易代码 ＝ 功能_取子项目所有文本 (子项目数)
        编辑框_命令.内容 ＝ 全_当前选中项数据.易代码
        在浏览器中显示 (全_当前选中项数据.易代码, 真, 子项目数)

    .默认
        在浏览器中显示 (全_当前选中项数据.易代码, 真)
    .判断结束

.默认
    互联网浏览器 ＝ 假  ' <!!!>
.判断结束
配置.写 (“ViewEcInfo”, “文本模式”, 到文本 (文本模式.选中))

.子程序 功能_插入到易语言
.参数 参_易代码, 文本型
.局部变量 局_文本, 文本型
.局部变量 局_句柄, 整数型

.如果真 (删首尾空 (参_易代码) ＝ “”)
    返回 ()
.如果真结束
局_文本 ＝ 取剪辑板文本 ()
置剪辑板文本 (参_易代码)
' 剪辑板_置文本_1 (参_易代码)
局_句柄 ＝ 窗口_取易编辑器句柄 (集_父窗口句柄)

.计次循环首 (10, )
    窗口_置焦点 (局_句柄)
    程序_延时 (80, )
    .如果真 (窗口_取顶端窗口句柄 () ＝ 局_句柄)
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
程序_延时 (10, )
键盘_组合按键 (#V键, #Ctrl键, , )

程序_延时 (1000, )
置剪辑板文本 (局_文本)


.子程序 窗口_取易编辑器句柄, 整数型, , 本子程序采用【精易编程助手】生成,成功返回窗口句柄,失败返回0
.参数 顶级句柄, 整数型
.局部变量 局_2级句柄, 整数型
.局部变量 局_3级句柄, 整数型
.局部变量 局_编辑器标题, 文本型
.局部变量 局_句柄, 整数型

局_编辑器标题 ＝ 文本_取出中间文本 (窗口_取标题 (顶级句柄), “ - [”, “]”)
局_2级句柄 ＝ 窗口_取句柄 (顶级句柄, , “MDIClient”, )
.如果真 (局_2级句柄 ＝ -1)
    返回 (0)
.如果真结束
局_3级句柄 ＝ SendMessage (局_2级句柄, 553, 0, 0)
' 局_3级句柄 ＝ 窗口_取句柄 (局_2级句柄, , 字符 (0), 局_编辑器标题)
.如果真 (局_3级句柄 ＝ -1)
    返回 (0)
.如果真结束
局_句柄 ＝ 查找子窗口句柄 (局_3级句柄, 1, )
' 局_句柄 ＝ GetWindow (局_3级句柄, #GW_CHILD)
' 局_句柄 ＝ GetWindow (局_句柄, #GW_CHILD)
' 局_句柄 ＝ GetWindow (局_句柄, #GW_HWNDNEXT)
' 局_句柄 ＝ GetWindow (局_句柄, #GW_HWNDNEXT)
' 局_句柄 ＝ GetWindow (局_句柄, #GW_HWNDNEXT)
' 局_句柄 ＝ GetWindow (局_句柄, #GW_CHILD)
返回 (局_句柄)

.子程序 窗口_取标题, 文本型
.参数 窗口句柄, 整数型
.局部变量 标题, 文本型

标题 ＝ 取空白文本 (256)
GetWindowTextA (窗口句柄, 标题, 256)
返回 (标题)

.子程序 取整数型引用, 整数型
.参数 整数, 整数型, 参考

置入代码 ({ 139, 69, 8, 201, 194, 4, 0 })
返回 (0)

.子程序 查找子窗口句柄, 整数型
.参数 窗口句柄, 整数型
.参数 窗口标识, 整数型
.参数 跳过次数, 整数型, 可空
.局部变量 result, 整数型
.局部变量 skip, 整数型

result ＝ 窗口标识
skip ＝ 跳过次数
.如果真 (EnumChildWindows (窗口句柄, &查找子窗口句柄_处理函数, 取整数型引用 (result)) ≠ 0 或 result ＝ 窗口标识)
    返回 (0)
.如果真结束
返回 (result)

.子程序 查找子窗口句柄_处理函数, 逻辑型
.参数 hwnd, 整数型
.参数 lParam, 整数型
.局部变量 skip, 整数型

.如果真 (GetDlgCtrlID (hwnd) ＝ 指针到整数 (lParam))
    skip ＝ 指针到整数 (lParam － 4)
    .如果真 (skip ＝ 0)
        写到内存 (hwnd, lParam, 4)
        返回 (假)
    .如果真结束
    skip ＝ skip － 1
    写到内存 (skip, lParam － 4, 4)
.如果真结束
返回 (真)

.子程序 _全部收缩_被选择

外部树型框_命令.收缩全部 ()
树型框_命令.获取焦点 ()

.子程序 _全部扩展_被选择

外部树型框_命令.扩展全部 ()
树型框_命令.获取焦点 ()
树型框_命令.现行选中项 ＝ 0
树型框_命令.保证显示 (0)

.子程序 _树型框_查找_项目被选择
.参数 选择方式, 整数型


树型框_命令.现行选中项 ＝ 树型框_查找.取项目数值 (树型框_查找.现行选中项)
输出调试文本 (树型框_查找.取项目数值 (树型框_查找.现行选中项))
置状态文本 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＋ “ - ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))


.子程序 _树型框_查找_右键单击项目

连续赋值 (假, 全部扩展.可视, 全部收缩.可视, 复制.可视, 复制类变量声明.可视, 分割条2.可视)


转到命令所在位置.可视 ＝ 真
弹出菜单 (文件, , )


.子程序 _编辑框_关键字_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型
.局部变量 树型框, 外部树型框
.局部变量 t, 整数型
.局部变量 Count, 整数型

.判断开始 (键代码 ＝ #回车键)
    .如果 (删首尾空 (编辑框_关键字.内容) ＝ “”)
        连续赋值 (假, 树型框_查找.可视, 图形按钮_返回.可视)

    .否则

        .如果真 (选择框_搜索命令.选中 ＝ 假 且 选择框_搜索备注.选中 ＝ 假)
            信息框 (“请勾选至少一个搜索项目”, 0, , )
            返回 ()
        .如果真结束

        连续赋值 (真, 树型框_查找.可视, 图形按钮_返回.可视)
        树型框_查找.图片组 ＝ #模块__树型框图片组
        t ＝ 取启动时间 ()

        状态条.置文本 (1, “正在查找中...”)
        系统_处理事件 ()
        置等待鼠标 ()
        Count ＝ 子程序_全部查找 (删首尾空 (编辑框_关键字.内容), 选择框_搜索命令.选中, 选择框_搜索备注.选中)
        恢复鼠标 ()
        状态条.置文本 (1, “查找完毕”)

        .判断开始 (Count ＝ 0)
            ' 没找到的就要搜搜备注喽~
            树型框_查找.清空 ()
            树型框_查找.加入项目 (, “共查找到 0 条相关记录，耗时：” ＋ 到文本 (取启动时间 () － t) ＋ “毫秒”, , , , , )
            置状态文本 (“共查找到 0 条相关记录，耗时：” ＋ 到文本 (取启动时间 () － t) ＋ “毫秒”)


        .默认
            树型框_查找.置项目文本 (0, “共查找到 ” ＋ 到文本 (Count) ＋ “ 条相关记录，耗时：” ＋ 到文本 (取启动时间 () － t) ＋ “毫秒”)
            置状态文本 (“共查找到 ” ＋ 到文本 (Count) ＋ “ 条相关记录，耗时：” ＋ 到文本 (取启动时间 () － t) ＋ “毫秒”)
        .判断结束

    .如果结束

    ' 备注查找 (编辑框_关键字.内容)


.判断 (键代码 ＝ #下光标键 且 树型框_查找.可视)
    树型框_查找.获取焦点 ()
    .如果真 (树型框_查找.现行选中项 ＝ -1)
        树型框_查找.现行选中项 ＝ 0
    .如果真结束

.默认

.判断结束


.子程序 子程序_全部查找, 整数型, , 返回结果数量，被查找出来的项目数值，对应目标树型框的项目索引
.参数 欲查找的文本, 文本型
.参数 选项_寻找子程序及参数名, 逻辑型
.参数 选项_寻找备注, 逻辑型
.局部变量 命令树形框, 外部树型框
.局部变量 树型框, 外部树型框
.局部变量 t, 整数型
.局部变量 Count, 整数型
.局部变量 搜索结果数量, 整数型
.局部变量 图片索引, 整数型
.局部变量 一级项目, 整数型
.局部变量 索引, 整数型
.局部变量 被查找索引, 整数型
.局部变量 父项目索引, 整数型
.局部变量 i, 整数型
.局部变量 code, 文本型

树型框.初始化 (树型框_查找.取窗口句柄 (), , )
树型框_查找.清空 ()
命令树形框.初始化 (树型框_命令.取窗口句柄 (), , )
集_支持库树型框句柄 ＝ 树型框_命令.取窗口句柄 ()
树型框.清空 ()
树型框.更新缓存 ()

搜索结果数量 ＝ 0
图片索引 ＝ 命令树形框.取图片 (0)
树型框.加入项目1 (, 命令树形框.取项目文本 (0), 图片索引, 图片索引, 命令树形框.取项目数值 (0), 真)
树型框.更新缓存 ()

发送消息整数 (树型框_查找.取窗口句柄 (), #WM_SETREDRAW, 0, 0)
一级项目 ＝ SendMessageA_整数 (集_支持库树型框句柄, #TVM_GETNEXTITEM, #TVGN_ROOT, 0)

内部_递归子项目 (集_支持库树型框句柄, 命令树形框, 一级项目, 欲查找的文本, 索引, 被查找索引, 父项目索引, 树型框, , 真, 搜索结果数量, 选项_寻找子程序及参数名, 选项_寻找备注)

.判断循环首 (一级项目 ＞ 0)
    索引 ＝ 索引 ＋ 1
    被查找索引 ＝ 被查找索引 ＋ 1
    一级项目 ＝ SendMessageA_整数 (集_支持库树型框句柄, #TVM_GETNEXTITEM, #TVGN_NEXT, 一级项目)  ' 取兄弟
    .如果真 (一级项目 ＝ 0)
        跳出循环 ()
    .如果真结束

    图片索引 ＝ 命令树形框.取图片 (一级项目)
    树型框.加入项目1 (, 命令树形框.取项目文本 (一级项目), 图片索引, 图片索引, 命令树形框.取项目数值 (一级项目), 真)
    树型框.更新缓存 ()

    父项目索引 ＝ 索引
    内部_递归子项目 (集_支持库树型框句柄, 命令树形框, 一级项目, 欲查找的文本, 索引, 被查找索引, 父项目索引, 树型框, , 真, 搜索结果数量, 选项_寻找子程序及参数名, 选项_寻找备注)
    .如果真 (树型框.取子项目数 (父项目索引) ＝ 0)
        树型框.删除项目 (父项目索引)
        索引 ＝ 索引 － 1
    .如果真结束

.判断循环尾 ()

发送消息整数 (树型框_查找.取窗口句柄 (), #WM_SETREDRAW, 1, 0)
树型框.扩展全部 ()
树型框.置现行选中项 (0)

返回 (搜索结果数量)

.子程序 内部_递归子项目, 逻辑型, , 【查找项目_外部】
.参数 树型框句柄, 整数型
.参数 命令树形框, 外部树型框
.参数 父项目句柄, 整数型, 可空
.参数 欲查找的文本, 文本型
.参数 索引, 整数型, 参考
.参数 被查找索引, 整数型, 参考
.参数 主父项目索引, 整数型, 可空
.参数 树型框, 外部树型框, 可空
.参数 有查找到结果, 逻辑型, 参考 可空
.参数 是否同步图标, 逻辑型, 可空, 是否同步项目的图标，会影响速度
.参数 搜索结果数量, 整数型, 参考
.参数 选项_寻找子程序及参数名, 逻辑型
.参数 选项_寻找备注, 逻辑型
.局部变量 局_子项目, 整数型
.局部变量 局_文本, 文本型
.局部变量 内部_父项目索引, 整数型
.局部变量 图片索引, 整数型
.局部变量 Temp, 文本型

局_子项目 ＝ SendMessageA_整数 (树型框句柄, #TVM_GETNEXTITEM, #TVGN_CHILD, 父项目句柄)  ' 取子项目的句柄
.如果真 (局_子项目 ＝ 0)
    返回 (假)
.如果真结束
.判断循环首 (局_子项目 ＞ 0)
    被查找索引 ＝ 被查找索引 ＋ 1
    局_文本 ＝ 取项目文本_句柄1 (局_子项目, )
    .判断开始 (SendMessageA_整数 (树型框句柄, #TVM_GETNEXTITEM, #TVGN_CHILD, 局_子项目) ＞ 0)  ' 取子程序下是否有子
        索引 ＝ 索引 ＋ 1
        有查找到结果 ＝ 假

        图片索引 ＝ 命令树形框.取图片 (被查找索引)

        内部_父项目索引 ＝ 树形框_加入父项目 (树型框, 主父项目索引, 局_文本, 局_子项目, 索引, 图片索引, 被查找索引)
        内部_递归子项目 (树型框句柄, 命令树形框, 局_子项目, 欲查找的文本, 索引, 被查找索引, 内部_父项目索引, 树型框, 有查找到结果, 是否同步图标, 搜索结果数量, 选项_寻找子程序及参数名, 选项_寻找备注)

        .判断开始 (树型框.取子项目数 (内部_父项目索引) ＝ 0 且 寻找文本 (局_文本, 欲查找的文本, , 真) ＝ -1)
            索引 ＝ 索引 － 1
            树型框.删除项目 (内部_父项目索引)
        .默认

            .如果真 (选项_寻找子程序及参数名 且 寻找文本 (局_文本, 欲查找的文本, , 真) ≠ -1)
                搜索结果数量 ＝ 搜索结果数量 ＋ 1
            .如果真结束


            .如果真 (选项_寻找备注 且 内部_备注查找 (易备注读取 (内部_取总父项目名 (局_子项目, 命令树形框), 命令树形框.取项目数值_句柄 (局_子项目)), 欲查找的文本))
                搜索结果数量 ＝ 搜索结果数量 ＋ 1
            .如果真结束

        .判断结束

    .判断 (选项_寻找子程序及参数名 且 寻找文本 (局_文本, 欲查找的文本, , 真) ≠ -1)
        搜索结果数量 ＝ 搜索结果数量 ＋ 1
        索引 ＝ 索引 ＋ 1
        有查找到结果 ＝ 真

        图片索引 ＝ 树型框_命令.取图片 (被查找索引)
        树型框.加入项目1 (主父项目索引, 局_文本, 图片索引, 图片索引, 被查找索引, )

    .判断 (选项_寻找备注 且 内部_备注查找 (易备注读取 (内部_取总父项目名 (局_子项目, 命令树形框), 命令树形框.取项目数值_句柄 (局_子项目)), 欲查找的文本))
        搜索结果数量 ＝ 搜索结果数量 ＋ 1
        索引 ＝ 索引 ＋ 1
        有查找到结果 ＝ 真

        图片索引 ＝ 树型框_命令.取图片 (被查找索引)
        树型框.加入项目1 (主父项目索引, 局_文本, 图片索引, 图片索引, 被查找索引)

    .默认

    .判断结束
    局_子项目 ＝ SendMessageA_整数 (树型框句柄, #TVM_GETNEXTITEM, #TVGN_NEXT, 局_子项目)  ' 取兄弟
.判断循环尾 ()
返回 (真)

.子程序 树形框_加入父项目, 整数型, , 【查找项目_外部】
.参数 树型框, 外部树型框, 可空
.参数 主父项目索引, 整数型, 可空, -1=初始化
.参数 项目文本, 文本型, 可空
.参数 父项目句柄, 整数型, 可空
.参数 索引, 整数型, 可空
.参数 图片索引, 整数型, 可空
.参数 被查找索引, 整数型, 可空
.局部变量 句项数组, 整数型, , "0"
.局部变量 索引数组, 整数型, , "0"
.局部变量 i, 整数型

.如果真 (主父项目索引 ＝ -1)
    清除数组 (句项数组)
    清除数组 (索引数组)
    返回 (0)
.如果真结束
.计次循环首 (取数组成员数 (索引数组), i)
    .如果真 (句项数组 [i] ＝ 父项目句柄)
        返回 (索引数组 [i])
    .如果真结束

.计次循环尾 ()
树型框.加入项目1 (主父项目索引, 项目文本, 图片索引, 图片索引, 被查找索引, 真)
树型框.更新缓存 ()
加入成员 (句项数组, 父项目句柄)
加入成员 (索引数组, 索引)
返回 (索引)

.子程序 内部_备注查找, 逻辑型, , 如果在【备注文本】中存在欲寻找文本，则返回真。
.参数 备注文本, 文本型
.参数 欲寻找文本, 文本型

' 输出调试文本 (“备注文本:” ＋ 备注文本)
' 输出调试文本 (“欲寻找文本:” ＋ 欲寻找文本)
返回 (寻找文本 (备注文本, 欲寻找文本, , 假) ≠ -1)


.子程序 内部_取总父项目名, 文本型
.参数 当前索引, 整数型
.参数 命令树形框, 外部树型框
.局部变量 层次, 整数型
.局部变量 项目名, 文本型

层次 ＝ 命令树形框.取缩进层次_句柄 (当前索引)
.判断开始 (层次 ＝ 3)  ' 正常命令
    项目名 ＝ 命令树形框.取项目文本_句柄 (树形框_取父项目句柄 (集_支持库树型框句柄, 当前索引))
.判断 (层次 ＝ 4)  ' 类命令
    项目名 ＝ “类”
.默认
    项目名 ＝ “”
.判断结束

' 输出调试文本 (层次, 命令树形框.取项目文本_句柄 (当前索引), 项目名)
' 暂停 ()
返回 (项目名)

.子程序 树形框_取父项目句柄, 整数型
.参数 树型框句柄, 整数型
.参数 当前项目, 整数型

返回 (发送消息整数 (树型框句柄, #TVM_GETNEXTITEM, #TVGN_PARENT, 当前项目))

.子程序 取项目文本_句柄1, 文本型, 公开
.参数 项目句柄, 整数型
.参数 结束操作, 逻辑型, 可空
.局部变量 缓冲区, 文本型
.局部变量 项目地址, 整数型
.局部变量 局_缓冲区, 文本型
.局部变量 项目, TVITEMEX
.局部变量 数据地址1, 整数型

.如果真 (项目.mask ＝ 0)
    项目.cchTextMax ＝ 120
    项目.pszText ＝ 取空白文本 (120)
    项目.mask ＝ #TVIF_TEXT
.如果真结束
项目.hItem ＝ 项目句柄
项目地址 ＝ 取内存变量地址_TVITEMEX (项目, 项目, 0)
发送消息整数 (集_支持库树型框句柄, #TVM_GETITEMA, 0, 项目地址)
返回 (删首尾空 (项目.pszText))


.子程序 备注查找, , , 通过遍历树形框，查找所有【命令】的备注。
.参数 欲查找的文本, 文本型
.局部变量 tag, 整数型
.局部变量 局_层次, 整数型
.局部变量 当前项目, 整数型
.局部变量 code, 文本型

.如果真 (树型框_查找.取项目数 () ＝ 1)
    树型框_查找.加入项目 (, 树型框_命令.取项目文本 (0), 树型框_命令.取图片 (0), 树型框_命令.取图片 (0), 树型框_命令.取项目数值 (0), 真, )
.如果真结束

.计次循环首 (树型框_命令.取项目数 (), 当前项目)

    局_层次 ＝ 树型框_命令.取缩进层次 (当前项目)
    tag ＝ 树型框_命令.取项目数值 (当前项目)



    .判断开始 (局_层次 ＝ 3)  ' 正常命令
        code ＝ 易代码读取 (树型框_命令.取项目文本 (树型框_命令.取父项目 (当前项目)), tag)
    .判断 (局_层次 ＝ 4)  ' 类命令
        code ＝ 易代码读取 (“类”, tag)

    .默认

    .判断结束


    .如果真 (寻找文本 (code, 欲查找的文本, , 假) ≠ -1)
        树型框_查找.加入项目 (, 树型框_命令.取项目文本 (当前项目), , , , , )
    .如果真结束

.计次循环尾 ()

.子程序 _图形按钮_返回_被单击

连续赋值 (假, 树型框_查找.可视, 图形按钮_返回.可视)

.子程序 树型框_取图片, 整数型
.参数 项目句柄, 整数型
.局部变量 集_单一项目, TVITEMEX
.局部变量 集_项目地址, 整数型

集_单一项目.hItem ＝ 项目句柄
集_单一项目.mask ＝ 2
集_项目地址 ＝ 取内存变量地址_TVITEMEX (集_单一项目, 集_单一项目, 0)
SendMessage (树型框_命令.取窗口句柄 (), 4364, 0, 集_项目地址)
返回 (集_单一项目.iImage)

.子程序 _互联网浏览器_弹出右键菜单, 逻辑型
.参数 事件对象, 对象, 参考

.如果真 (树型框_命令.现行选中项 ＝ 0)
    返回 ()
.如果真结束
.如果真 (编辑框_命令.内容 ≠ “”)
    弹出菜单 (浏览器, , )
    返回 (假)
.如果真结束


.子程序 _复制命令代码简单_被选择

置剪辑板文本 (功能_形成命令 (编辑框_命令.内容, 真))
置状态文本 (“复制【简单】命令代码成功”)

.子程序 _复制命令代码带参数说明_被选择

置剪辑板文本 (功能_形成命令 (编辑框_命令.内容))
置状态文本 (“复制【带参数说明】命令代码成功”)

.子程序 _复制参数声明_被选择

置剪辑板文本 (功能_取参数声明代码 (编辑框_命令.内容))
置状态文本 (“复制【参数声明】代码成功”)

.子程序 _复制声明代码_被选择

置剪辑板文本 (“.版本 2” ＋ #换行符 ＋ #换行符 ＋ 编辑框_命令.内容)
置状态文本 (“复制【声明代码】命令代码成功”)

.子程序 _插入到易语言_浏览器_被选择

_插入到易语言_被选择 ()

.子程序 _编辑框_命令_鼠标右键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果真 (树型框_命令.现行选中项 ＝ 0)
    返回 ()
.如果真结束
.如果真 (编辑框_命令.内容 ≠ “”)
    弹出菜单 (浏览器, , )
    返回 (假)
.如果真结束


.子程序 _树型框_查找_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

_树型框_命令_按下某键 (键代码, 功能键状态)

.子程序 _树型框_命令_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

.判断开始 (功能键状态 ＝ #Ctrl键状态 且 键代码 ＝ #C键)
    _复制_被选择 ()

.判断 (功能键状态 ＝ #Ctrl键状态 且 键代码 ＝ #G键)
    _转到命令所在位置_被选择 ()

.判断 (功能键状态 ＝ #Ctrl键状态 且 键代码 ＝ #F键)
    编辑框_关键字.获取焦点 ()


.判断 (键代码 ＝ #F1键)

    _插入到易语言_被选择 ()

.判断 (键代码 ＝ #F3键)
    编辑框_关键字.获取焦点 ()

.判断 (键代码 ＝ #F5键)
    树型框_命令.清空 ()
    模块分析_开始 (全_模块信息.模块路径, 真)

.判断 (键代码 ＝ #F6键)
    _文本模式_被选择 ()

.判断 (键代码 ＝ #F7键)
    _全部收缩_被选择 ()

.判断 (键代码 ＝ #F8键)
    _全部扩展_被选择 ()
.默认

.判断结束


.子程序 置状态文本
.参数 文本, 文本型

状态条.置文本 (1, 文本)

.子程序 _互联网浏览器_网页被单击, 逻辑型
.参数 事件对象, 对象, 参考
.局部变量 元素对象, 对象
.局部变量 元素标题, 文本型
.局部变量 Str, 文本型

元素对象 ＝ 事件对象.读对象型属性 (“srcElement”, )
Str ＝ 元素对象.读文本属性 (“rel”, )
.如果真 (Str ＝ “”)
    Str ＝ 元素对象.读文本属性 (“alt”, )
.如果真结束
.判断开始 (Str ＝ #点击_复制命令简单)
    _复制命令代码简单_被选择 ()

.判断 (Str ＝ #点击_复制命令带参数)
    _复制命令代码带参数说明_被选择 ()

.判断 (Str ＝ #点击_插入到易语言)
    _插入到易语言_被选择 ()

.判断 (Str ＝ #点击_复制参数声明)
    _复制参数声明_被选择 ()

.判断 (Str ＝ #点击_复制声明代码)
    _复制声明代码_被选择 ()

.判断 (Str ＝ #点击_复制常量字符串值)
    .如果真 (树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＝ “常量”)
        易代码读取 (“常量”, 树型框_命令.取项目数值 (树型框_命令.现行选中项))
        置剪辑板文本 (全_当前选中项数据.常量字符串)
        置状态文本 (“复制【常量】字符串值成功”)
    .如果真结束

.判断 (Str ＝ #点击_保存文件)
    Str ＝ 对话框_另存文件 (取窗口句柄 (), 目录_取特定目录 (), “请输入要保存的文件名:”, 全_当前选中项数据.保存文件的过虑器 ＋ “所有文件(*.*)|*.*”)
    .如果真 (Str ＝ “”)
        置状态文本 (树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “ → 保存文件被取消！”)
    .如果真结束
    .如果真 (写到文件 (Str, 全_当前选中项数据.字节集数据))
        置状态文本 (树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “ → 保存文件成功！”)
    .如果真结束

.判断 (Str ＝ #点击_记事本打开)
    Str ＝ 目录_取临时目录 () ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “.txt”
    写到文件 (Str, 全_当前选中项数据.字节集数据)
    运行 (“notepad.exe ” ＋ 目录_取临时目录 () ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “.txt”, 假, )

.判断 (Str ＝ #点击_复制图片到剪辑板)
    剪辑板_置图片 (全_当前选中项数据.字节集数据)
    置状态文本 (树型框_命令.取项目文本 (树型框_命令.现行选中项) ＋ “ → 复制图片到剪辑板成功！”)

.判断 (Str ＝ #点击_播放声音)
    功能_播放声音 ()

.判断 (Str ＝ #点击_停止播放)
    功能_播放声音 (真)

.判断 (Str ＝ #点击_弹出网页)
    网页_打开指定网址 (元素对象.读文本属性 (“href”, ))
.默认

.判断结束
返回 (假)

.子程序 功能_播放声音
.参数 停止播放, 逻辑型, 可空

.判断开始 (全_当前选中项数据.文件格式 ＝ “(WAV)” 或 全_当前选中项数据.文件格式 ＝ “(MID)”)
    .判断开始 (停止播放)
        停止播放 ()
        置状态文本 (“已停止播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))

    .默认
        播放音乐 (全_当前选中项数据.文件路径, )
        置状态文本 (“播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))
    .判断结束


.判断 (全_当前选中项数据.文件格式 ＝ “(WMA)”)
    .判断开始 (停止播放)
        音乐_停止 (全_当前选中项数据.文件路径)
        置状态文本 (“已停止播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))

    .默认
        音乐_播放 (全_当前选中项数据.文件路径)
        置状态文本 (“播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))
    .判断结束

.判断 (全_当前选中项数据.文件格式 ＝ “(MP3)”)
    .判断开始 (停止播放)
        停止播放 ()
        置状态文本 (“已停止播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))

    .默认
        播放MP3 (1, 全_当前选中项数据.文件路径)
        置状态文本 (“播放 → ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项))
    .判断结束

.默认

.判断结束


.子程序 _窗口置顶_被选择

窗口置顶.选中 ＝ 取反 (窗口置顶.选中)
总在最前 ＝ 窗口置顶.选中
配置.写 (, “窗口置顶”, 到文本 (窗口置顶.选中))

.子程序 _在百度搜索_被选择

网页_打开指定网址 (“http://www.baidu.com/s?wd=” ＋ 搜索_组成关键字 () ＋ “&ie=UTF-8”)

.子程序 _在官方搜索_被选择

网页_打开指定网址 (“http://www.baidu.com/s?wd=” ＋ 搜索_组成关键字 () ＋ “ site:bbs.eyuyan.com&ie=UTF-8”)

.子程序 _在精易搜索_被选择

网页_打开指定网址 (“http://www.baidu.com/s?wd=” ＋ 搜索_组成关键字 () ＋ “ site:bbs.125.la&ie=UTF-8”)

.子程序 搜索_组成关键字, 文本型
.局部变量 局_文本, 文本型
.局部变量 Str, 文本型

.如果 (树型框_命令.取缩进层次 (树型框_命令.现行选中项) ＝ 4)  ' 类
    局_文本 ＝ 树型框_命令.取项目文本 (树型框_命令.取父项目 (树型框_命令.现行选中项)) ＋ “ ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项)

.否则
    局_文本 ＝ 树型框_命令.取项目文本 (0)
    .如果真 (寻找文本 (局_文本, “ ”, , 假) ≠ -1)
        Str ＝ 文本_取右边 (局_文本, “ ”)
        .如果真 (取文本左边 (到大写 (Str), 1) ＝ “V”)
            局_文本 ＝ 文本_取左边 (局_文本, “ ”)
        .如果真结束

    .如果真结束
    局_文本 ＝ 局_文本 ＋ “ ” ＋ 树型框_命令.取项目文本 (树型框_命令.现行选中项)
.如果结束
返回 (局_文本)

.子程序 _标签_搜索提示_鼠标左键被放开, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

编辑框_关键字.获取焦点 ()

.子程序 _编辑框_关键字_失去焦点

.如果真 (删首尾空 (编辑框_关键字.内容) ＝ “”)
    标签_搜索提示.可视 ＝ 真
.如果真结束


.子程序 _编辑框_关键字_内容被改变

.判断开始 (删首尾空 (编辑框_关键字.内容) ＝ “”)
    标签_搜索提示.可视 ＝ 真
    编辑框_关键字.获取焦点 ()
.默认
    标签_搜索提示.可视 ＝ 假
.判断结束


.子程序 __启动窗口_将被销毁

删除文件 (目录_取临时目录 () ＋ 全_模块信息.模块MD5 ＋ “_ec.html”)


.子程序 _分隔条_树形框_被拖动
.参数 原位置, 整数型
.参数 目的位置, 整数型

' 输出调试文本 (原位置, 目的位置)
.如果真 (目的位置 ＜ 210)
    目的位置 ＝ 210
.如果真结束

.如果真 (目的位置 ＞ _启动窗口.宽度 － 250)
    目的位置 ＝ _启动窗口.宽度 － 250
.如果真结束

尺寸_调整界面尺寸 (目的位置)


.子程序 尺寸_调整界面尺寸
.参数 分割条位置, 整数型

分隔条_树形框.移动 (分割条位置, 0, , 取用户区高度 () － 20)
选择框_搜索命令.移动 (48, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 5, , )
选择框_搜索备注.移动 (124, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 5, , )

树型框_命令.移动 (8, 编辑框_关键字.顶边 ＋ 编辑框_关键字.高度 ＋ 30, 分隔条_树形框.左边 － 12, 取用户区高度 () － 选择框_搜索备注.顶边 － 选择框_搜索备注.高度 － 26)
树型框_查找.移动 (树型框_命令.左边, 树型框_命令.顶边, 树型框_命令.宽度, 树型框_命令.高度)


编辑框_关键字.移动 (, , 树型框_命令.宽度 － 37, )

图形按钮_返回.移动 (编辑框_关键字.左边 ＋ 编辑框_关键字.宽度 － 19, 编辑框_关键字.顶边 ＋ 3, , )
编辑框_命令.移动 (分隔条_树形框.左边 ＋ 分隔条_树形框.宽度 ＋ 4, 编辑框_关键字.顶边, 取用户区宽度 () － 树型框_命令.宽度 － 24, 取用户区高度 () － 34)
互联网浏览器.移动 (编辑框_命令.左边, 编辑框_命令.顶边, 编辑框_命令.宽度, 编辑框_命令.高度)

_启动窗口.重画 ()

.子程序 __启动窗口_窗口可否被关闭, 逻辑型

系统_处理事件 ()
_启动窗口.可视 ＝ 假
窗口_置状态 (取窗口句柄 (), 0)
.如果 (_置父)
    配置.窗口位置_保存 (_启动窗口, 真, 集_父窗口句柄)
.否则
    ' 配置.窗口位置_保存 (_启动窗口, 真, )
    ' 写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinTop”, 到文本 (_启动窗口.顶边))
    ' 写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinLeft”, 到文本 (_启动窗口.左边))
    写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinHeight”, 到文本 (_启动窗口.高度))
    写配置项 (全_运行目录 ＋ “Data\Config.ini”, 取执行文件名 (), “WinWidth”, 到文本 (_启动窗口.宽度))
.如果结束


配置.写 (, “分隔条左边”, 到文本 (分隔条_树形框.左边))

进程_结束 ()


.子程序 _复制选中文本_被选择

??? ()  ' <!!!>
