JavGo源码

“使用易语言编写，可以直接复制到易语言内查看代码逻辑，声明一下：非程序员，所以写的非常乱，只为实现功能优先，所以仅供参考。”


.版本 2
.支持库 shellEx
.支持库 eGrid
.支持库 shell
.支持库 iext2
.支持库 iext
.支持库 spec
.支持库 commobj
.支持库 iconv
.支持库 eAPI
.支持库 internet
.支持库 btdownload
.支持库 BmpOperate

.程序集 窗口程序集_窗口_下拉列表
.程序集变量 j, 类组件_拖放对象, , "2"
.程序集变量 人脸识别动画框标识, 整数型
.程序集变量 人脸识别动画框2标识, 整数型
.程序集变量 头像动画框标识, 整数型
.程序集变量 色花缩略图动画框标识, 整数型
.程序集变量 刮削文件番号, 文本型, , "0"
.程序集变量 句柄, 整数型
.程序集变量 置宽度, 整数型
.程序集变量 置高度, 整数型
.程序集变量 字体, GP字体
.程序集变量 文本格式, GP文本格式
.程序集变量 句柄终止, 整数型
.程序集变量 标题字数, 整数型

.子程序 _窗口_下拉列表_创建完毕

' 窗口_下拉列表.宽度 ＝ 1230
' 窗口_下拉列表.高度 ＝ 720


句柄 ＝ 圆形进度外形框.取窗口句柄 ()
置宽度 ＝ 圆形进度外形框.宽度
置高度 ＝ 圆形进度外形框.高度
' -------------------------------------- 初始化
Gdiplus初始化 ()
' -------------------------------------- 创建字体
字体.创建自名称 (“微软雅黑”, 10)
' -------------------------------------- 创建文本格式
文本格式.创建 (#文本格式标志_不换行)
文本格式.置对齐 (#文本对齐_居中)
文本格式.置行对齐 (#文本对齐_居中)
' -------------------------------------- 启动

标题字数 ＝ 60












log许可证 ＝ 线程_创建许可证 ()
添加提示 (关闭.取窗口句柄 (), “窗口关闭”, 假, 假)
添加提示 (最大化.取窗口句柄 (), “窗口最大化”, 假, 假)
添加提示 (最小化.取窗口句柄 (), “窗口最小化”, 假, 假)
添加提示 (设置.取窗口句柄 (), “保存程序设置”, 假, 假)
添加提示 (设置2.取窗口句柄 (), “程序设置”, 假, 假)
添加提示 (帮助.取窗口句柄 (), “使用说明”, 假, 假)
添加提示 (代理.取窗口句柄 (), “代理开关”, 假, 假)
添加提示 (截图.取窗口句柄 (), “快捷截图识别演员”, 假, 假)
添加提示 (右箭头.取窗口句柄 (), “下一页”, 假, 假)
添加提示 (左箭头.取窗口句柄 (), “上一页”, 假, 假)
添加提示 (缩略图右箭头.取窗口句柄 (), “下一张”, 假, 假)
添加提示 (缩略图左箭头.取窗口句柄 (), “上一张”, 假, 假)
添加提示 (窗口_大小控制.取窗口句柄 (), “放大缩小窗口”, 假, 假)
添加提示 (搜索图形按钮.取窗口句柄 (), “本地搜索中多标签搜索以” ＋ #引号 ＋ “/” ＋ #引号 ＋ “分隔开” ＋ #换行符 ＋ “bus磁力搜索/bus番号搜索/library搜索/” ＋ #换行符 ＋ “以上三种方式仅支持输入番号搜索。” ＋ #换行符 ＋ “fc2搜索只需输入数字，例如'1379638'” ＋ #换行符 ＋ “如果有些网址无法搜索，请到配置.ini更换最新网址”, 假, 假)
添加提示 (播放按钮.取窗口句柄 (), “播放影片”, 假, 假)
添加提示 (删除按钮.取窗口句柄 (), “删除影片”, 假, 假)
添加提示 (返回按钮.取窗口句柄 (), “返回封面”, 假, 假)
添加提示 (中文按钮.取窗口句柄 (), “标记字幕”, 假, 假)
添加提示 (影片信息按钮.取窗口句柄 (), “获取影片信息”, 假, 假)
添加提示 (下拉图形按钮2.取窗口句柄 (), “本地搜索中多标签搜索以” ＋ #引号 ＋ “/” ＋ #引号 ＋ “分隔开” ＋ #换行符 ＋ “bus磁力搜索/bus番号搜索/library搜索/” ＋ #换行符 ＋ “以上三种方式仅支持输入番号搜索。” ＋ #换行符 ＋ “fc2搜索只需输入数字，例如'1379638'” ＋ #换行符 ＋ “如果有些网址无法搜索，请到配置.ini更换最新网址”, 假, 假)
添加提示 (刷新所有目录按钮.取窗口句柄 (), “刷新所有文件夹。”, 假, 假)
读配置 ()
' 橙色：251,86,60
' 底色：48,48,56
' 横幅：42，42,49
' 颜色 ＝ 颜色 － 2000
' 窗口_下拉列表.底色 ＝ 颜色
' 搜索外形框.填充颜色 ＝ 颜色
' 缩略图标题外形框.填充颜色 ＝ 颜色
' 缩略图信息外形框.填充颜色 ＝ 颜色

' 搜索编辑框.背景颜色 ＝ 颜色
' 缩略图标题编辑框.背景颜色 ＝ 颜色

' 封面分组框.背景颜色 ＝ 颜色
' 目录分组框.背景颜色 ＝ 颜色
' 缩略图分组框.背景颜色 ＝ 颜色

' 搜索图形按钮.通常背景色 ＝ 颜色
' 搜索图形按钮.点燃背景色 ＝ 颜色

' 缩略图番号标签.背景颜色 ＝ 颜色
' 缩略图日期标签.背景颜色 ＝ 颜色
' 缩略图时长标签.背景颜色 ＝ 颜色
' 缩略图制作商标签.背景颜色 ＝ 颜色
' 缩略图发行商标签.背景颜色 ＝ 颜色
' 缩略图系列标签.背景颜色 ＝ 颜色
' 缩略图类别标签.背景颜色 ＝ 颜色
' 缩略图演员标签.背景颜色 ＝ 颜色
' 缩略图简介标签.背景颜色 ＝ 颜色
.' 计次循环首 (5, i)
    ' 文件夹超级按钮数组 [i].通常背景色 ＝ 颜色
    ' 文件夹超级按钮数组 [i].点燃背景色 ＝ 颜色
.' 计次循环尾 ()
' 
' 目录外形框数组 [i].填充颜色 ＝ 颜色
' 目录超级按钮数组 [i].通常背景色 ＝ 颜色
' 目录超级按钮数组 [i].点燃背景色 ＝ 颜色
' 计次循环尾 ()
j [1].拖放对象_注册 (接收文件列表框.取窗口句柄 (), &子程序1_取回文件名)
j [2].拖放对象_注册 (接受文件外形框.取窗口句柄 (), &子程序1_取回文件名2)
磁力高级表格.置列宽 (0, 80)
磁力高级表格.置列宽 (1, 100)
磁力高级表格.置列宽 (2, 80)
磁力高级表格.置列宽 (3, 80)
磁力高级表格.置列宽 (4, 300)
磁力高级表格.置列宽 (5, 80)
磁力高级表格.置列宽 (6, 80)
磁力高级表格.置数据 (0, 0, 1, “番号”)
磁力高级表格.置数据 (0, 1, 1, “片名”)
磁力高级表格.置数据 (0, 2, 1, “大小”)
磁力高级表格.置数据 (0, 3, 1, “日期”)
磁力高级表格.置数据 (0, 4, 1, “磁力”)
磁力高级表格.置数据 (0, 5, 1, “分辨率”)
磁力高级表格.置数据 (0, 6, 1, “字幕”)

.如果 (文本_寻找文本 (环境.读环境变量 (真, “PATH”), 取特定目录 (9) ＋ “ffmpeg;”, , 真) ＝ -1)
    配置环境变量按钮.标题 ＝ “请先点击这里” ＋ #换行符 ＋ “配置环境变量”
.否则
    配置环境变量按钮.标题 ＝ “配置环境成功”

.如果结束

自创组合框初始化 ()

LOGO标签.标题 ＝ #版本

封面项 ＝ 0

标签项 ＝ 0
标签子项 ＝ 0

演员项 ＝ 0
演员子项 ＝ 0

标签演员状态 ＝ “假”

所有影片状态 ＝ 真

缩略图分组框.可视 ＝ 假
目录分组框.可视 ＝ 假
标签分组框.可视 ＝ 假

加入组件 ()
读取目录 ()
取耗时 (1)
加载索引 (“所有影片”)
log (“加载所有影片完成，” ＋ 取耗时 (2))
搜索状态 ＝ 假
' 缓动.创建过程 (750, 0, #缓动_圆曲线缓动_InOut, 到数值 (&开场动画1), , 40)
缓动.创建过程 (750, 0, #缓动_弹性缓动, 到数值 (&开场动画1), , 40)
' _启动窗口.边框 ＝ 0
' SetWindowPos (_启动窗口.取窗口句柄 (), -1, 0, 0, 取屏幕宽度 (), 取屏幕高度 (), 0)

.子程序 自创组合框初始化
.局部变量 i, 整数型

下拉图形按钮2.标题 ＝ “本地搜索”
下拉高级表格.置数据 (0, 0, 1, “本地搜索”)
下拉高级表格.置数据 (1, 0, 1, “db磁力搜索”)
下拉高级表格.置数据 (2, 0, 1, “bus磁力搜索”)
下拉高级表格.置数据 (3, 0, 1, “bus番号搜索”)
下拉高级表格.置数据 (4, 0, 1, “bus模糊搜索”)
下拉高级表格.置数据 (5, 0, 1, “FC2番号搜索”)
下拉高级表格.置数据 (6, 0, 1, “wiki辞典搜索”)
下拉高级表格.置数据 (7, 0, 1, “javdb搜索”)
下拉高级表格.置数据 (8, 0, 1, “library搜索”)
下拉高级表格.置数据 (9, 0, 1, “色花模糊搜索”)
下拉高级表格.置数据 (10, 0, 1, “jav321搜索”)
.计次循环首 (30, i)
    搜索记录高级表格.置数据 (i － 1, 0, 1, 文本_取出中间文本 (搜索历史记录, “<” ＋ 到文本 (i) ＋ “>”, “<” ＋ 到文本 (i) ＋ “>”))
.计次循环尾 ()


.子程序 _下拉图形按钮_被单击

.如果 (下拉高级表格.可视 ＝ 假)
    下拉高级表格.可视 ＝ 真
.否则
    下拉高级表格.可视 ＝ 假

.如果结束



.子程序 _下拉图形按钮2_被单击

.如果 (下拉高级表格.可视 ＝ 假)
    下拉高级表格.可视 ＝ 真
.否则
    下拉高级表格.可视 ＝ 假

.如果结束



.子程序 _下拉高级表格_被单击
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.局部变量 行号, 整数型

行号 ＝ 下拉高级表格.取光标行号 ()
.如果真 (行号 ＜ 0)
    返回 ()
.如果真结束

.如果真 (行号 ＝ 0)
    下拉图形按钮2.标题 ＝ “本地搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 1)
    下拉图形按钮2.标题 ＝ “db磁力搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束


.如果真 (行号 ＝ 2)
    下拉图形按钮2.标题 ＝ “bus磁力搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 3)
    下拉图形按钮2.标题 ＝ “bus番号搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 4)
    下拉图形按钮2.标题 ＝ “bus模糊搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 5)
    下拉图形按钮2.标题 ＝ “FC2番号搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 6)
    下拉图形按钮2.标题 ＝ “wiki辞典搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 7)
    下拉图形按钮2.标题 ＝ “javdb搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 8)
    下拉图形按钮2.标题 ＝ “library搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 9)
    下拉图形按钮2.标题 ＝ “色花模糊搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束

.如果真 (行号 ＝ 10)
    下拉图形按钮2.标题 ＝ “jav321搜索”
    下拉高级表格.可视 ＝ 假
.如果真结束




.子程序 读配置

批量_选择框_读取配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_编辑框_读取配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_组合框_读取配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “选择框”, “人脸识别”, ) ＝ “真”)
    .如果 (初始化key () ＝ “1”)
        人脸识别选择框.选中 ＝ 真
    .否则
        人脸识别选择框.选中 ＝ 假
        批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
    .如果结束

.否则
    人脸识别选择框.选中 ＝ 假
.如果结束

.如果真 (本地刮削编辑框.内容 ＝ “”)
    本地刮削编辑框.内容 ＝ 根目录 ＋ “索引\目录索引_封面#.txt”
.如果真结束




.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javbus”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javbus”, “https://www.cdnbus.in/”)
    bus网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javbus”, ))
.否则
    bus网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javbus”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “jav321”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “jav321”, “https://www.jav321.com/”)
    jav321网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “jav321”, ))
.否则
    jav321网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “jav321”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javdb”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javdb”, “https://www.javdb4.com/”)
    javdb网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javdb”, ))
.否则
    javdb网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “javdb”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “library”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “library”, “http://www.g46e.com/”)
    library网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “library”, ))
.否则
    library网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “library”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “wiki辞典”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “wiki辞典”, “https://av-help.memo.wiki/”)
    wiki辞典网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “wiki辞典”, ))
.否则
    wiki辞典网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “wiki辞典”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “fc2”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “fc2”, “https://adult.contents.fc2.com/”)
    fc2网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “fc2”, ))
.否则
    fc2网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “fc2”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “色花”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “色花”, “https://www.98rewer.xyz/”)
    色花网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “色花”, ))
.否则
    色花网址 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “网址”, “色花”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “路径”, “SeHua图片包”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “路径”, “SeHua图片包”, “空”)
    SeHua图片包路径 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “路径”, “SeHua图片包”, ))
.否则
    SeHua图片包路径 ＝ 是否有下划线 (读配置项 (根目录 ＋ “配置\配置.ini”, “路径”, “SeHua图片包”, ))
.如果结束

.如果 (读配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, ) ＝ “”)
    写配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, #搜索历史记录空文本)
    搜索历史记录 ＝ 读配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, )
.否则
    搜索历史记录 ＝ 读配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, )
    .如果 (文本_寻找文本 (搜索历史记录, “<30>”) ＝ -1)
        写配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, #搜索历史记录空文本)
        搜索历史记录 ＝ #搜索历史记录空文本
    .否则

    .如果结束

.如果结束

.如果 (文件是否存在 (根目录 ＋ “资源\演员文本包.txt”) ＝ 真)
    演员三围数组 ＝ 分割文本 (编码_Utf8到Ansi (读入文件 (根目录 ＋ “资源\演员文本包.txt”)), #换行符, )
.否则

.如果结束


.如果 (代理选择框.选中 ＝ 假)
    代理IP ＝ “”
.否则
    代理IP ＝ 代理编辑框.内容
.如果结束

刮削javbus编辑框.内容 ＝ bus网址
刮削jav321编辑框.内容 ＝ jav321网址
刮削library编辑框.内容 ＝ library网址
刮削javdb编辑框.内容 ＝ javdb网址
刮削运行编辑框.内容 ＝ “运行日志：”
.如果 (到整数 (超时时间编辑框.内容) ＜ 10)
    超时时间 ＝ 10
.否则
    .如果 (到整数 (超时时间编辑框.内容) ＞ 60)
        超时时间 ＝ 60
    .否则
        超时时间 ＝ 到整数 (超时时间编辑框.内容)
    .如果结束

.如果结束

.如果 (代理选择框.选中 ＝ 真)
    代理.点燃图片 ＝ #代理普通
    代理.正常图片 ＝ #代理点燃
.否则
    代理.点燃图片 ＝ #代理点燃
    代理.正常图片 ＝ #代理普通
.如果结束
缺失文件检测 ()

.子程序 缺失文件检测

缺失文件检测编辑框.内容 ＝ “缺失文件检测：//缺失的文件请下载完整版，完整版包含所有缺失文件。” ＋ #换行符
.如果真 (文件是否存在 (根目录 ＋ “资源\色花文本包.txt”) ＝ 假)
    缺失文件检测编辑框.加入文本 (“缺失色花文本包，色花列表将无法使用。” ＋ #换行符)
.如果真结束


.如果真 (文件是否存在 (根目录 ＋ “资源\演员文本包.txt”) ＝ 假)
    缺失文件检测编辑框.加入文本 (“缺失演员文本包，演员个人信息将无法显示。” ＋ #换行符)

.如果真结束

.如果真 (文件是否存在 (根目录 ＋ “资源\磁力文本包.txt”) ＝ 假)
    缺失文件检测编辑框.加入文本 (“缺失磁力文本包，本地磁力功能将无法使用。” ＋ #换行符)

.如果真结束
.如果真 (文件是否存在 (根目录 ＋ “资源\ffmpeg.exe”) ＝ 假)
    缺失文件检测编辑框.加入文本 (“缺失ffmpeg.exe，裁剪广告和截预览图等功能将无法使用。” ＋ #换行符)

.如果真结束

.如果真 (文件是否存在 (取运行目录 () ＋ “\MediaInfo.dll”) ＝ 假)
    缺失文件检测编辑框.加入文本 (“缺失MediaInfo.dll，将无法查看影片个属性信息。” ＋ #换行符)

.如果真结束


.子程序 是否有下划线, 文本型
.参数 文本, 文本型

.如果真 (取文本右边 (文本, 1) ≠ “/”)
    文本 ＝ 文本 ＋ “/”

.如果真结束
返回 (文本)


.子程序 ts
.参数 文本, 文本型

调试输出 (文本)

.子程序 _窗口_下拉列表_首次激活



.子程序 加入组件
.局部变量 i, 整数型

.计次循环首 (27, i)
    复制窗口组件 (封面动画框0, 动画框数组 [i])
    复制窗口组件 (封面标题标签0, 封面标题标签数组 [i])
    动画框数组 [i].标记 ＝ 到文本 (i)
    动画框标识数组 [i] ＝ 动画框数组 [i].创建物体 (, 0, 0, , )
    封面标题标签数组 [i].标记 ＝ 到文本 (i)
.计次循环尾 ()
缩略图动画框标识 ＝ 缩略图动画框.创建物体 (, 0, 0, , )
人脸识别动画框标识 ＝ 人脸识别动画框.创建物体 (, 0, 0, , )
人脸识别动画框2标识 ＝ 人脸识别动画框2.创建物体 (, 0, 0, , )
头像动画框标识 ＝ 头像动画框.创建物体 (, 0, 0, , )
色花缩略图动画框标识 ＝ 色花缩略图动画框.创建物体 (, 0, 0, , )
.计次循环首 (63, i)
    复制窗口组件 (目录外形框0, 目录外形框数组 [i])
    复制窗口组件 (目录图形按钮0, 目录图形按钮数组 [i])
    复制窗口组件 (目录超级按钮0, 目录超级按钮数组 [i])
    目录超级按钮数组 [i].标记 ＝ 到文本 (i)
    添加提示 (目录超级按钮数组 [i].取窗口句柄 (), “如果目录里删除或添加了影片，请右键点击刷新目录。” ＋ #换行符 ＋ “屏蔽目录后本目录影片和标签在所有影片里不再显示。”, 假, 假)
.计次循环尾 ()

.计次循环首 (10, i)
    复制窗口组件 (文件夹图形按钮0, 文件夹图形按钮数组 [i])
    复制窗口组件 (文件夹超级按钮0, 文件夹超级按钮数组 [i])
    文件夹超级按钮数组 [i].标记 ＝ 到文本 (i)
    .如果真 (i ＝ 1)
        添加提示 (文件夹超级按钮数组 [i].取窗口句柄 (), “请选择已经刮削过的影片文件夹。”, 假, 假)
    .如果真结束
    .如果真 (i ＝ 2)
        添加提示 (文件夹超级按钮数组 [i].取窗口句柄 (), “显示已添加目录包含的所有影片。”, 假, 假)
    .如果真结束

.计次循环尾 ()

.计次循环首 (300, i)
    复制窗口组件 (标签超级按钮0, 标签超级按钮数组 [i])
    标签超级按钮数组 [i].标记 ＝ 到文本 (i)
.计次循环尾 ()


.子程序 加载图片
.参数 项, 整数型
.局部变量 图片, 字节集

图片 ＝ 读入文件 (图片路径数组 [项])
图片 ＝ 图片_缩放_透明 (图片, 196, 280)
动画框数组 [项].置图片 (动画框标识数组 [项], 图片, )

.子程序 排列封面标签
.参数 项, 整数型
.局部变量 横排数, 整数型
.局部变量 纵排数, 整数型
.局部变量 i, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 临时poster, 文本型
.局部变量 k, 整数型
.局部变量 图片, 字节集
.局部变量 图片号, 整数型

.如果 (初次加载状态 ＝ 真)
    设置透明度 ()
.否则

.如果结束

.如果真 (封面分组框.可视 ＝ 真 或 初次加载状态 ＝ 假)
    初次加载状态 ＝ 真
    横排数 ＝ 取整 (窗口_下拉列表.宽度 ÷ 200) － 1
    纵排数 ＝ 取整 (窗口_下拉列表.高度 ÷ 290)

    _启动窗口.宽度 ＝ 230 ＋ 横排数 × 200
    _启动窗口.高度 ＝ 纵排数 × 360

    .如果 (搜索状态 ＝ 假)
        .如果 (项 ＝ 2)
            封面项 ＝ 封面项 ＋ 横排数 × 纵排数
            .如果真 (封面项 ＞ 取数组成员数 (影片))
                封面项 ＝ 取数组成员数 (影片) － (横排数 × 纵排数 － (封面项 － 取数组成员数 (影片)))
                .如果真 (封面项 ＜ 0)
                    封面项 ＝ 0
                .如果真结束

            .如果真结束

        .否则

        .如果结束
        .如果 (项 ＝ 3)
            封面项 ＝ 封面项 － 横排数 × 纵排数
            .如果真 (封面项 ＜ 0)
                封面项 ＝ 0
            .如果真结束




        .否则

        .如果结束

        页数标签.标题 ＝ 到文本 (封面项) ＋ “/” ＋ 到文本 (取数组成员数 (影片))
        .如果 (封面项 ≥ 0)
            .计次循环首 (取整 (横排数 × 纵排数), i)
                .如果 (i ＋ 封面项 ≤ 取数组成员数 (影片))
                    .如果 (取数组成员数 (影片) ≥ i)
                        文件_枚举_升级版 (影片 [i ＋ 封面项].目录, #图片格式, 临时数组, 0, 假, 假)
                        .如果 (取数组成员数 (临时数组) ＞ 0)
                            临时poster ＝ “空”
                            .计次循环首 (取数组成员数 (临时数组), k)
                                .如果真 (寻找文本 (文件_取文件名 (临时数组 [k]), “poster”, , 真) ≠ -1)
                                    临时poster ＝ 临时数组 [k]
                                    跳出循环 ()
                                .如果真结束

                            .计次循环尾 ()
                        .否则
                            临时poster ＝ “空”
                        .如果结束
                        .如果 (临时poster ≠ “空”)
                            图片路径数组 [i] ＝ 临时poster
                            线程_启动 (&加载图片, i)
                        .否则
                            .如果 (取数组成员数 (临时数组) ＞ 0)
                                .如果 (取数组成员数 (临时数组) ＞ 1)
                                    图片路径数组 [i] ＝ 临时数组 [2]
                                    图片路径数组 [i] ＝ 临时数组 [1]
                                .否则

                                .如果结束
                                线程_启动 (&加载图片, i)

                            .否则
                                动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                            .如果结束

                        .如果结束


                        .如果 (取文本左边 (影片 [i ＋ 封面项].番号, 2) ＝ “tt”)
                            封面标题标签数组 [i].标题 ＝ 影片 [i ＋ 封面项].标题
                            添加提示 (封面标题标签数组 [i].取窗口句柄 (), 影片 [i ＋ 封面项].日期 ＋ “ ” ＋ 影片 [i ＋ 封面项].番号, 假, 假)
                        .否则
                            .如果 (封面标签日期选择框.选中 ＝ 假)
                                封面标题标签数组 [i].标题 ＝ 影片 [i ＋ 封面项].日期 ＋ “ ” ＋ 影片 [i ＋ 封面项].番号
                            .否则
                                封面标题标签数组 [i].标题 ＝ 影片 [i ＋ 封面项].番号
                            .如果结束
                            添加提示 (封面标题标签数组 [i].取窗口句柄 (), 影片 [i ＋ 封面项].标题, 假, 假)

                            .如果 (取文本长度 (影片 [i ＋ 封面项].番号) ＞ 22)
                                封面标题标签数组 [i].横向对齐方式 ＝ 0
                                封面标题标签数组 [i].字体.字体大小 ＝ 9
                            .否则
                                封面标题标签数组 [i].横向对齐方式 ＝ 1
                                封面标题标签数组 [i].字体.字体大小 ＝ 12

                            .如果结束

                        .如果结束
                        清除数组 (临时数组)
                    .否则
                        动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                        封面标题标签数组 [i].标题 ＝ “”
                        添加提示 (封面标题标签数组 [i].取窗口句柄 (), “”, 假, 假)

                    .如果结束

                .否则
                    动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                    封面标题标签数组 [i].标题 ＝ “”
                    添加提示 (封面标题标签数组 [i].取窗口句柄 (), “”, 假, 假)
                .如果结束

            .计次循环尾 ()




        .否则

        .如果结束

    .否则



        .如果 (项 ＝ 2)
            搜索封面项 ＝ 搜索封面项 ＋ 横排数 × 纵排数
            .如果真 (搜索封面项 ＞ 取数组成员数 (搜索))
                搜索封面项 ＝ 取数组成员数 (搜索) － (横排数 × 纵排数 － (搜索封面项 － 取数组成员数 (搜索)))
                .如果真 (搜索封面项 ＜ 0)
                    搜索封面项 ＝ 0
                .如果真结束

            .如果真结束



        .否则

        .如果结束
        .如果 (项 ＝ 3)
            搜索封面项 ＝ 搜索封面项 － 横排数 × 纵排数
            .如果真 (搜索封面项 ＜ 0)
                搜索封面项 ＝ 0
            .如果真结束



        .否则

        .如果结束

        页数标签.标题 ＝ 到文本 (搜索封面项) ＋ “/” ＋ 到文本 (取数组成员数 (搜索))
        .如果 (搜索封面项 ≥ 0)
            .计次循环首 (取整 (横排数 × 纵排数), i)
                .如果 (i ＋ 搜索封面项 ≤ 取数组成员数 (搜索))
                    .如果 (取数组成员数 (搜索) ≥ i)
                        文件_枚举_升级版 (文件_取目录 (搜索 [i ＋ 搜索封面项].文件), #图片格式, 临时数组, 0, 假, 真)
                        .如果 (取数组成员数 (临时数组) ＞ 0)
                            临时poster ＝ “空”
                            .计次循环首 (取数组成员数 (临时数组), k)
                                .如果真 (寻找文本 (文件_取文件名 (临时数组 [k]), “poster”, , 真) ≠ -1)
                                    临时poster ＝ 临时数组 [k]
                                    跳出循环 ()
                                .如果真结束

                            .计次循环尾 ()
                        .否则
                            临时poster ＝ “空”
                        .如果结束

                        .如果 (临时poster ≠ “空”)
                            图片路径数组 [i] ＝ 临时poster
                            线程_启动 (&加载图片, i)
                        .否则
                            .如果 (取数组成员数 (临时数组) ＞ 0)
                                .如果 (取数组成员数 (临时数组) ＞ 1)
                                    图片路径数组 [i] ＝ 临时数组 [2]
                                .否则
                                    图片路径数组 [i] ＝ 临时数组 [1]
                                .如果结束
                                线程_启动 (&加载图片, i)
                            .否则
                                动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                            .如果结束

                        .如果结束
                        .如果 (取文本左边 (文本_取出中间文本 (搜索 [i].nfo, “<id>”, “<id>”, , 真), 2) ＝ “tt”)
                            封面标题标签数组 [i].标题 ＝ 搜索 [i ＋ 搜索封面项].标题
                            添加提示 (封面标题标签数组 [i].取窗口句柄 (), 搜索 [i ＋ 搜索封面项].日期 ＋ “ ” ＋ 搜索 [i ＋ 搜索封面项].番号, 假, 假)
                        .否则
                            .如果 (封面标签日期选择框.选中 ＝ 假)

                                封面标题标签数组 [i].标题 ＝ 搜索 [i ＋ 搜索封面项].日期 ＋ “ ” ＋ 搜索 [i ＋ 搜索封面项].番号
                            .否则
                                封面标题标签数组 [i].标题 ＝ 搜索 [i ＋ 搜索封面项].番号
                            .如果结束
                            添加提示 (封面标题标签数组 [i].取窗口句柄 (), 搜索 [i ＋ 搜索封面项].标题, 假, 假)
                        .如果结束

                    .否则
                        动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                        封面标题标签数组 [i].标题 ＝ “”
                        添加提示 (封面标题标签数组 [i].取窗口句柄 (), “”, 假, 假)
                    .如果结束
                    清除数组 (临时数组)
                .否则
                    动画框数组 [i].置图片 (动画框标识数组 [i], #背景色, )
                    封面标题标签数组 [i].标题 ＝ “”
                    添加提示 (封面标题标签数组 [i].取窗口句柄 (), “”, 假, 假)
                .如果结束

            .计次循环尾 ()



        .否则

        .如果结束



    .如果结束

    .计次循环首 (24, i)
        .如果 (i ≤ 横排数)
            动画框数组 [i].左边 ＝ 取整 ((i － 1) × 200 ＋ 5)
            封面标题标签数组 [i].左边 ＝ 取整 ((i － 1) × 200 ＋ 5)
            动画框数组 [i].顶边 ＝ 动画框数组 [1].顶边
            封面标题标签数组 [i].顶边 ＝ 动画框数组 [1].顶边 ＋ 280
            动画框数组 [i].可视 ＝ 真
            封面标题标签数组 [i].可视 ＝ 真
        .否则


        .如果结束

        .如果 (纵排数 ≥ 2)
            .如果 (i ＞ 横排数)
                .如果 (i ≤ 横排数 × 2)
                    动画框数组 [i].左边 ＝ (i － 横排数 － 1) × 200 ＋ 5
                    封面标题标签数组 [i].左边 ＝ (i － 横排数 － 1) × 200 ＋ 5
                    动画框数组 [i].顶边 ＝ 动画框数组 [1].顶边 ＋ 300
                    封面标题标签数组 [i].顶边 ＝ 动画框数组 [1].顶边 ＋ 300 ＋ 280
                    动画框数组 [i].可视 ＝ 真
                    封面标题标签数组 [i].可视 ＝ 真
                .否则
                    动画框数组 [i].可视 ＝ 假
                    封面标题标签数组 [i].可视 ＝ 假


                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束


        .如果 (纵排数 ≥ 3)
            .如果 (i ＞ 横排数 × 2)
                .如果 (i ≤ 横排数 × 3)
                    动画框数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 200 ＋ 5
                    封面标题标签数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 200 ＋ 5
                    动画框数组 [i].顶边 ＝ 动画框数组 [1].顶边 ＋ 300 × 2
                    封面标题标签数组 [i].顶边 ＝ 动画框数组 [1].顶边 ＋ 300 × 2 ＋ 280
                    动画框数组 [i].可视 ＝ 真
                    封面标题标签数组 [i].可视 ＝ 真


                .否则
                    动画框数组 [i].可视 ＝ 假
                    封面标题标签数组 [i].可视 ＝ 假

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束

    .计次循环尾 ()
.如果真结束



.如果真 (目录分组框.可视 ＝ 真)

    .计次循环首 (63, i)
        目录外形框数组 [i].可视 ＝ 假
        目录图形按钮数组 [i].可视 ＝ 假
        目录超级按钮数组 [i].可视 ＝ 假
        目录超级按钮数组 [i].标题 ＝ 到文本 (i)
    .计次循环尾 ()

    横排数 ＝ 取整 (窗口_下拉列表.宽度 ÷ 170) － 1
    纵排数 ＝ 取整 (窗口_下拉列表.高度 ÷ 130)

    .如果真 (228 ＋ 横排数 × 167 ＝ 1230)
        _启动窗口.宽度 ＝ 1230
        横排数 ＝ 6
    .如果真结束


    .如果 (228 ＋ 横排数 × 167 ＞ 1230)
        .如果 (228 ＋ 横排数 × 167 ≤ 1430)
            _启动窗口.宽度 ＝ 1430
            横排数 ＝ 7
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (228 ＋ 横排数 × 167 ＞ 1430)
        .如果 (228 ＋ 横排数 × 167 ≤ 1630)
            _启动窗口.宽度 ＝ 1630
            横排数 ＝ 8
        .否则

        .如果结束

    .否则

    .如果结束



    .如果 (228 ＋ 横排数 × 167 ＞ 1630)
        .如果 (228 ＋ 横排数 × 167 ≤ 1830)
            _启动窗口.宽度 ＝ 1830
            横排数 ＝ 9
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (20 ＋ 纵排数 × 140 ＝ 720)
        _启动窗口.高度 ＝ 720
        纵排数 ＝ 5
    .否则

    .如果结束

    .如果 (20 ＋ 纵排数 × 140 ＞ 720)
        .如果 (20 ＋ 纵排数 × 140 ≤ 1020)
            .如果 (20 ＋ 纵排数 × 140 － 720 ≤ 150)
                _启动窗口.高度 ＝ 720
                纵排数 ＝ 5
            .否则
                _启动窗口.高度 ＝ 1020
                纵排数 ＝ 7
            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束

    .计次循环首 (63, i)
        .如果 (i ≤ 横排数)
            目录外形框数组 [i].左边 ＝ (i － 1) × 167 ＋ 10
            目录外形框数组 [i].顶边 ＝ 15
            目录图形按钮数组 [i].左边 ＝ (i － 1) × 167 ＋ 70
            目录图形按钮数组 [i].顶边 ＝ 25
            目录超级按钮数组 [i].左边 ＝ (i － 1) × 167 ＋ 17
            目录超级按钮数组 [i].顶边 ＝ 70
        .否则

        .如果结束

        .如果 (i ＞ 横排数)
            .如果 (i ≤ 横排数 × 2)
                目录外形框数组 [i].左边 ＝ (i － 横排数 － 1) × 167 ＋ 10
                目录外形框数组 [i].顶边 ＝ 15 ＋ 120
                目录图形按钮数组 [i].左边 ＝ (i － 横排数 － 1) × 167 ＋ 70
                目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120
                目录超级按钮数组 [i].左边 ＝ (i － 横排数 － 1) × 167 ＋ 17
                目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120
            .否则

            .如果结束

        .否则

        .如果结束

        .如果 (i ＞ 横排数 × 2)
            .如果 (i ≤ 横排数 × 3)
                目录外形框数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 167 ＋ 10
                目录外形框数组 [i].顶边 ＝ 15 ＋ 120 × 2
                目录图形按钮数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 167 ＋ 70
                目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120 × 2
                目录超级按钮数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 167 ＋ 17
                目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120 × 2
            .否则

            .如果结束

        .否则

        .如果结束

        .如果 (i ＞ 横排数 × 3)
            .如果 (i ≤ 横排数 × 4)
                目录外形框数组 [i].左边 ＝ (i － 横排数 × 3 － 1) × 167 ＋ 10
                目录外形框数组 [i].顶边 ＝ 15 ＋ 120 × 3
                目录图形按钮数组 [i].左边 ＝ (i － 横排数 × 3 － 1) × 167 ＋ 70
                目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120 × 3
                目录超级按钮数组 [i].左边 ＝ (i － 横排数 × 3 － 1) × 167 ＋ 17
                目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120 × 3
            .否则

            .如果结束

        .否则

        .如果结束

        .如果 (i ＞ 横排数 × 4)
            .如果 (i ≤ 横排数 × 5)
                目录外形框数组 [i].左边 ＝ (i － 横排数 × 4 － 1) × 167 ＋ 10
                目录外形框数组 [i].顶边 ＝ 15 ＋ 120 × 4
                目录图形按钮数组 [i].左边 ＝ (i － 横排数 × 4 － 1) × 167 ＋ 70
                目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120 × 4
                目录超级按钮数组 [i].左边 ＝ (i － 横排数 × 4 － 1) × 167 ＋ 17
                目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120 × 4
            .否则

            .如果结束

        .否则

        .如果结束
        .如果 (纵排数 ≥ 6)
            .如果 (i ＞ 横排数 × 5)
                .如果 (i ≤ 横排数 × 6)
                    目录外形框数组 [i].左边 ＝ (i － 横排数 × 5 － 1) × 167 ＋ 10
                    目录外形框数组 [i].顶边 ＝ 15 ＋ 120 × 5
                    目录图形按钮数组 [i].左边 ＝ (i － 横排数 × 5 － 1) × 167 ＋ 70
                    目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120 × 5
                    目录超级按钮数组 [i].左边 ＝ (i － 横排数 × 5 － 1) × 167 ＋ 17
                    目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120 × 5
                .否则

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束

        .如果 (纵排数 ≥ 7)
            .如果 (i ＞ 横排数 × 6)
                .如果 (i ≤ 横排数 × 7)
                    目录外形框数组 [i].左边 ＝ (i － 横排数 × 6 － 1) × 167 ＋ 10
                    目录外形框数组 [i].顶边 ＝ 15 ＋ 120 × 6
                    目录图形按钮数组 [i].左边 ＝ (i － 横排数 × 6 － 1) × 167 ＋ 70
                    目录图形按钮数组 [i].顶边 ＝ 25 ＋ 120 × 6
                    目录超级按钮数组 [i].左边 ＝ (i － 横排数 × 6 － 1) × 167 ＋ 17
                    目录超级按钮数组 [i].顶边 ＝ 70 ＋ 120 × 6
                .否则

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束



    .计次循环尾 ()
.如果真结束

.如果真 (标签分组框.可视 ＝ 真)

    横排数 ＝ 取整 (窗口_下拉列表.宽度 ÷ 111) － 1
    纵排数 ＝ 取整 (窗口_下拉列表.高度 ÷ 70)


    .如果真 (230 ＋ 横排数 × 100 ＝ 1230)
        _启动窗口.宽度 ＝ 1230
        横排数 ＝ 10
    .如果真结束


    .如果 (230 ＋ 横排数 × 100 ＞ 1230)
        .如果 (230 ＋ 横排数 × 100 ≤ 1430)
            _启动窗口.宽度 ＝ 1430
            横排数 ＝ 12
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (230 ＋ 横排数 × 100 ＞ 1430)
        .如果 (230 ＋ 横排数 × 100 ≤ 1630)
            _启动窗口.宽度 ＝ 1630
            横排数 ＝ 14
        .否则

        .如果结束

    .否则

    .如果结束



    .如果 (230 ＋ 横排数 × 100 ＞ 1630)
        .如果 (230 ＋ 横排数 × 100 ≤ 1830)
            _启动窗口.宽度 ＝ 1830
            横排数 ＝ 16
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (纵排数 × 72 ＝ 720)
        _启动窗口.高度 ＝ 720
    .否则

    .如果结束

    .如果 (纵排数 × 72 ＞ 720)
        .如果 (纵排数 × 72 ≤ 1020)
            .如果 (纵排数 × 72 － 720 ≤ 150)
                _启动窗口.高度 ＝ 720
                纵排数 ＝ 10
            .否则
                _启动窗口.高度 ＝ 1020
                纵排数 ＝ 15
            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束

    .如果真 (标签演员状态 ＝ “标签真”)
        .计次循环首 (取数组成员数 (影片标签), i)
            .如果 (i ≤ 300)
                .如果 (标签项 ≤ 取数组成员数 (影片标签) ÷ (横排数 × 纵排数))
                    .如果 (标签项 ＝ 0)
                        标签超级按钮数组 [i].标题 ＝ 影片标签 [i]

                    .否则
                        .如果 (标签项 ＜ 0)
                            标签项 ＝ 0
                        .否则

                        .如果结束
                        .如果 (i ＋ 横排数 × 纵排数 × 标签项 ≤ 取数组成员数 (影片标签))
                            标签子项 ＝ 横排数 × 纵排数 × 标签项
                            标签超级按钮数组 [i].标题 ＝ 影片标签 [i ＋ 横排数 × 纵排数 × 标签项]
                        .否则
                            标签超级按钮数组 [i].标题 ＝ “”
                        .如果结束

                    .如果结束



                .否则

                .如果结束

            .否则

            .如果结束

        .计次循环尾 ()

        .如果 (标签项 ＝ 0)
            页数标签.标题 ＝ 到文本 (0) ＋ “/” ＋ 到文本 (取数组成员数 (影片标签))
        .否则
            页数标签.标题 ＝ 到文本 (标签子项) ＋ “/” ＋ 到文本 (取数组成员数 (影片标签))
        .如果结束





        .如果 (横排数 × 纵排数 × (标签项 ＋ 1) ≥ 取数组成员数 (影片标签))
            标签项 ＝ -1
            标签子项 ＝ 0
        .否则

        .如果结束

    .如果真结束

    .如果真 (标签演员状态 ＝ “演员真”)
        .计次循环首 (取数组成员数 (影片演员), i)
            .如果 (i ≤ 300)
                .如果 (演员项 ≤ 取数组成员数 (影片) ÷ (横排数 × 纵排数))
                    .如果 (演员项 ＝ 0)
                        标签超级按钮数组 [i].标题 ＝ 影片演员 [i]
                    .否则
                        .如果 (演员项 ＜ 0)
                            标签项 ＝ 0
                        .否则

                        .如果结束

                        .如果 (i ＋ 横排数 × 纵排数 × 演员项 ≤ 取数组成员数 (影片演员))
                            演员子项 ＝ 横排数 × 纵排数 × 演员项
                            标签超级按钮数组 [i].标题 ＝ 影片演员 [i ＋ 横排数 × 纵排数 × 演员项]
                        .否则
                            标签超级按钮数组 [i].标题 ＝ “”
                        .如果结束

                    .如果结束



                .否则

                .如果结束

            .否则

            .如果结束

        .计次循环尾 ()

        .如果 (演员项 ＝ 0)
            页数标签.标题 ＝ 到文本 (0) ＋ “/” ＋ 到文本 (取数组成员数 (影片演员))
        .否则
            页数标签.标题 ＝ 到文本 (演员子项) ＋ “/” ＋ 到文本 (取数组成员数 (影片演员))
        .如果结束





        .如果 (横排数 × 纵排数 × (演员项 ＋ 1) ≥ 取数组成员数 (影片演员))
            演员项 ＝ -1
            演员子项 ＝ 0
        .否则

        .如果结束

    .如果真结束




    .计次循环首 (300, i)
        .如果 (i ≤ 横排数 × 纵排数)
            .如果 (i ≤ 横排数)
                标签超级按钮数组 [i].左边 ＝ (i － 1) × 100 ＋ 5
                标签超级按钮数组 [i].顶边 ＝ 15
                .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                    标签超级按钮数组 [i].可视 ＝ 真
                .否则
                    标签超级按钮数组 [i].可视 ＝ 假
                .如果结束

            .否则

            .如果结束



            .如果 (i ＞ 横排数)
                .如果 (i ≤ 横排数 × 2)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 60
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则


                .如果结束

            .否则

            .如果结束


            .如果 (i ＞ 横排数 × 2)
                .如果 (i ≤ 横排数 × 3)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 2 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 120
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束

            .如果 (i ＞ 横排数 × 3)
                .如果 (i ≤ 横排数 × 4)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 3 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 180
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束



            .如果 (i ＞ 横排数 × 4)
                .如果 (i ≤ 横排数 × 5)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 4 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 240
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束


                .否则

                .如果结束

            .否则

            .如果结束




            .如果 (i ＞ 横排数 × 5)
                .如果 (i ≤ 横排数 × 6)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 5 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 300
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束


                .否则

                .如果结束

            .否则

            .如果结束




            .如果 (i ＞ 横排数 × 6)
                .如果 (i ≤ 横排数 × 7)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 6 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 360
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束


                .否则

                .如果结束

            .否则

            .如果结束
            .如果 (i ＞ 横排数 × 7)
                .如果 (i ≤ 横排数 × 8)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 7 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 420
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束


                .否则

                .如果结束

            .否则

            .如果结束
            .如果 (i ＞ 横排数 × 8)
                .如果 (i ≤ 横排数 × 9)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 8 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 480
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束



            .如果 (i ＞ 横排数 × 9)
                .如果 (i ≤ 横排数 × 10)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 9 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 540
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束


                .否则

                .如果结束

            .否则

            .如果结束




            .如果 (i ＞ 横排数 × 10)
                .如果 (i ≤ 横排数 × 11)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 10 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 600
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束


            .如果 (i ＞ 横排数 × 11)
                .如果 (i ≤ 横排数 × 12)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 11 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 660
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束



            .如果 (i ＞ 横排数 × 12)
                .如果 (i ≤ 横排数 × 13)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 12 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 720
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束

            .如果 (i ＞ 横排数 × 13)
                .如果 (i ≤ 横排数 × 14)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 13 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 780
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束
            .如果 (i ＞ 横排数 × 14)
                .如果 (i ≤ 横排数 × 15)
                    标签超级按钮数组 [i].左边 ＝ (i － 横排数 × 14 － 1) × 100 ＋ 5
                    标签超级按钮数组 [i].顶边 ＝ 15 ＋ 840
                    .如果 (标签超级按钮数组 [i].标题 ≠ “”)
                        标签超级按钮数组 [i].可视 ＝ 真
                    .否则
                        标签超级按钮数组 [i].可视 ＝ 假
                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束

        .否则
            标签超级按钮数组 [i].可视 ＝ 假
        .如果结束



    .计次循环尾 ()




.如果真结束

.计次循环首 (10, i)
    文件夹超级按钮数组 [i].左边 ＝ 5
    文件夹超级按钮数组 [i].顶边 ＝ 85 ＋ 55 × (i － 0)

    文件夹图形按钮数组 [i].左边 ＝ 15
    文件夹图形按钮数组 [i].顶边 ＝ 95 ＋ 55 × (i － 0)
    .如果真 (i ＝ 1)
        文件夹超级按钮数组 [i].标题 ＝ “添加文件夹+”
        文件夹图形按钮数组 [i].正常图片 ＝ #添加文件夹
    .如果真结束
    .如果真 (i ＝ 2)
        文件夹超级按钮数组 [i].标题 ＝ “所有影片”
    .如果真结束
    .如果真 (i ＝ 3)
        文件夹超级按钮数组 [i].标题 ＝ “目录管理”
    .如果真结束
    .如果真 (i ＝ 4)
        文件夹超级按钮数组 [i].标题 ＝ “标签管理”
        文件夹图形按钮数组 [i].正常图片 ＝ #标签文件夹
    .如果真结束
    .如果真 (i ＝ 5)
        文件夹超级按钮数组 [i].标题 ＝ “演员管理”
        文件夹图形按钮数组 [i].正常图片 ＝ #演员文件夹
    .如果真结束
    .如果真 (i ＝ 6)
        文件夹超级按钮数组 [i].标题 ＝ “收藏影片”
        文件夹图形按钮数组 [i].正常图片 ＝ #收藏文件夹
    .如果真结束
    .如果真 (i ＝ 7)
        文件夹超级按钮数组 [i].标题 ＝ “已看影片”
        文件夹图形按钮数组 [i].正常图片 ＝ #已看文件夹
    .如果真结束
    .如果真 (i ＝ 8)
        文件夹超级按钮数组 [i].标题 ＝ “影片刮削”
        文件夹图形按钮数组 [i].正常图片 ＝ #刮削文件夹
    .如果真结束
    .如果真 (i ＝ 9)
        文件夹超级按钮数组 [i].标题 ＝ “色花列表”
        文件夹图形按钮数组 [i].正常图片 ＝ #表格文件夹
    .如果真结束
    .如果真 (i ＝ 10)
        文件夹超级按钮数组 [i].标题 ＝ “其他设置”
        文件夹图形按钮数组 [i].正常图片 ＝ #设置图标
    .如果真结束



.计次循环尾 ()





读取目录 ()
封面滚动状态 ＝ 假

.子程序 _窗口_下拉列表_尺寸被改变

圆形进度外形框.左边 ＝ 4
圆形进度外形框.顶边 ＝ 4

标签_分割线.顶边 ＝ 窗口_下拉列表.高度 － 40
标签_分割线.宽度 ＝ 宽度
_竖线.左边 ＝ 199
_竖线.顶边 ＝ 60
_竖线.高度 ＝ 窗口_下拉列表.高度 － 97

温馨提示.顶边 ＝ 窗口_下拉列表.高度 － 30
温馨提示.左边 ＝ 10
温馨提示.宽度 ＝ 窗口_下拉列表.宽度 － 90

封面分组框.宽度 ＝ 窗口_下拉列表.宽度 － 220
封面分组框.高度 ＝ 窗口_下拉列表.高度 － 100
封面分组框.左边 ＝ 205
封面分组框.顶边 ＝ 55

' 影片刮削分组框.宽度 ＝ 窗口_下拉列表.宽度 － 220
' 影片刮削分组框.高度 ＝ 窗口_下拉列表.高度 － 100
' 影片刮削分组框.左边 ＝ 205
' 影片刮削分组框.顶边 ＝ 55
' 浏览器关闭按钮.左边 ＝ 窗口_下拉列表.宽度 － 235 － 10

影片刮削分组框.宽度 ＝ 1010
影片刮削分组框.高度 ＝ 620
影片刮削分组框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 190
影片刮削分组框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2

影片刮削外形框1.宽度 ＝ 990
影片刮削外形框2.宽度 ＝ 990
影片刮削外形框3.宽度 ＝ 990
刮削运行编辑框.宽度 ＝ 975

浏览器关闭按钮.左边 ＝ 975
浏览器关闭按钮.顶边 ＝ 10

程序设置关闭按钮.左边 ＝ 975
程序设置关闭按钮.顶边 ＝ 10

标签分组框.宽度 ＝ 窗口_下拉列表.宽度 － 220
标签分组框.高度 ＝ 窗口_下拉列表.高度 － 100
标签分组框.左边 ＝ 205
标签分组框.顶边 ＝ 55

表格外形框.宽度 ＝ 窗口_下拉列表.宽度 － 220
表格外形框.高度 ＝ 窗口_下拉列表.高度 － 100
表格外形框.左边 ＝ 205
表格外形框.顶边 ＝ 55

色花超级列表框.宽度 ＝ 窗口_下拉列表.宽度 － 230
色花超级列表框.高度 ＝ 窗口_下拉列表.高度 － 115
色花超级列表框.左边 ＝ 5
色花超级列表框.顶边 ＝ 5

色花超级列表框2.宽度 ＝ 窗口_下拉列表.宽度 － 230
色花超级列表框2.高度 ＝ 窗口_下拉列表.高度 － 115
色花超级列表框2.左边 ＝ 5
色花超级列表框2.顶边 ＝ 5

信息提示外形框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 400
信息提示外形框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2 ＋ 150

色花缩略图分组框.左边 ＝ 窗口_下拉列表.宽度 － 245 － 800
色花缩略图分组框.顶边 ＝ 30

.如果 (窗口_下拉列表.高度 ＝ 720)
    色花缩略图分组框.高度 ＝ 575
.否则
    色花缩略图分组框.高度 ＝ 816
.如果结束

表格提示.左边 ＝ 窗口_下拉列表.宽度 － 265
表格提示.顶边 ＝ 10

色花复制磁力级按钮.左边 ＝ 400
色花复制磁力级按钮.顶边 ＝ 10

目录提示.左边 ＝ 窗口_下拉列表.宽度 － 260
目录提示.顶边 ＝ 20


刷新所有目录按钮.左边 ＝ 窗口_下拉列表.宽度 － 265
刷新所有目录按钮.顶边 ＝ 窗口_下拉列表.高度 － 150

下拉高级表格.左边 ＝ 0
下拉高级表格.顶边 ＝ 140
下拉图形按钮.左边 ＝ 184
下拉图形按钮.顶边 ＝ 112
下拉图形按钮2.左边 ＝ 0
下拉图形按钮2.顶边 ＝ 112


缩略图分组框.宽度 ＝ 1010
缩略图分组框.高度 ＝ 620
缩略图分组框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 190
缩略图分组框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2 － 5

目录分组框.宽度 ＝ 窗口_下拉列表.宽度 － 220
目录分组框.高度 ＝ 窗口_下拉列表.高度 － 100
目录分组框.左边 ＝ 205
目录分组框.顶边 ＝ 55

设置外形框.宽度 ＝ 1010
设置外形框.高度 ＝ 620
设置外形框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 190
设置外形框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2

程序设置外形框.宽度 ＝ 1010
程序设置外形框.高度 ＝ 620
程序设置外形框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 190
程序设置外形框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2


裁剪广告外形框.宽度 ＝ 392
裁剪广告外形框.高度 ＝ 96
裁剪广告外形框.左边 ＝ (窗口_下拉列表.宽度 － 1200) ÷ 2 ＋ 500
裁剪广告外形框.顶边 ＝ (窗口_下拉列表.高度 － 600) ÷ 2 ＋ 300

搜索记录高级表格.左边 ＝ 2
搜索记录高级表格.顶边 ＝ 101

程序设置竖线.高度 ＝ 615
程序设置竖线.左边 ＝ 145
程序设置竖线.顶边 ＝ 0

设置外形框1.宽度 ＝ 1010 － 155
设置外形框1.高度 ＝ 605
设置外形框1.左边 ＝ 150
设置外形框1.顶边 ＝ 5

设置外形框2.宽度 ＝ 1010 － 155
设置外形框2.高度 ＝ 605
设置外形框2.左边 ＝ 150
设置外形框2.顶边 ＝ 5

设置外形框3.宽度 ＝ 1010 － 155
设置外形框3.高度 ＝ 605
设置外形框3.左边 ＝ 150
设置外形框3.顶边 ＝ 5

设置外形框4.宽度 ＝ 1010 － 155
设置外形框4.高度 ＝ 605
设置外形框4.左边 ＝ 150
设置外形框4.顶边 ＝ 5


设置外形框5.宽度 ＝ 1010 － 155
设置外形框5.高度 ＝ 605
设置外形框5.左边 ＝ 150
设置外形框5.顶边 ＝ 5

设置外形框6.宽度 ＝ 1010 － 155
设置外形框6.高度 ＝ 605
设置外形框6.左边 ＝ 150
设置外形框6.顶边 ＝ 5

设置外形框7.宽度 ＝ 1010 － 155
设置外形框7.高度 ＝ 605
设置外形框7.左边 ＝ 150
设置外形框7.顶边 ＝ 5

批处理横线标签.宽度 ＝ 1010 － 210
批处理横线标签.左边 ＝ 30
批处理横线标签.顶边 ＝ 270

设置关闭按钮.左边 ＝ 975
设置关闭按钮.顶边 ＝ 10

信息提示外形框.宽度 ＝ 496
信息提示外形框.高度 ＝ 328

窗口_大小控制.顶边 ＝ 窗口_下拉列表.高度 － 20
窗口_大小控制.左边 ＝ 窗口_下拉列表.宽度 － 20

左箭头.顶边 ＝ 窗口_下拉列表.高度 － 35
左箭头.左边 ＝ 窗口_下拉列表.宽度 － 186
右箭头.顶边 ＝ 窗口_下拉列表.高度 － 35
右箭头.左边 ＝ 窗口_下拉列表.宽度 － 50
页数标签.顶边 ＝ 窗口_下拉列表.高度 － 32
页数标签.左边 ＝ 窗口_下拉列表.宽度 － 170

代理.左边 ＝ 窗口_下拉列表.宽度 － 210
帮助.左边 ＝ 窗口_下拉列表.宽度 － 240
设置2.左边 ＝ 窗口_下拉列表.宽度 － 180
设置.左边 ＝ 窗口_下拉列表.宽度 － 150
截图.左边 ＝ 窗口_下拉列表.宽度 － 120
最小化.左边 ＝ 窗口_下拉列表.宽度 － 90
最大化.左边 ＝ 窗口_下拉列表.宽度 － 60
关闭.左边 ＝ 窗口_下拉列表.宽度 － 30

影片A.左边 ＝ 窗口_下拉列表.宽度 ÷ 2 － 100
演员组件.左边 ＝ 窗口_下拉列表.宽度 ÷ 2 － 25
标签.左边 ＝ 窗口_下拉列表.宽度 ÷ 2 ＋ 50
列表.左边 ＝ 窗口_下拉列表.宽度 ÷ 2 ＋ 125

顶部横幅外形框.宽度 ＝ 窗口_下拉列表.宽度 ＋ 1
搜索外形框.左边 ＝ 4
搜索外形框.顶边 ＝ 61


.子程序 log
.参数 文本, 文本型

线程_进入许可区 (log许可证)

.如果 (取文本长度 (文本) ＞ 100)
    .如果 (取文本长度 (文本) ＞ 130)
        温馨提示.字体.字体大小 ＝ 8
    .否则
        温馨提示.字体.字体大小 ＝ 10
    .如果结束

.否则
    温馨提示.字体.字体大小 ＝ 12
.如果结束
温馨提示.标题 ＝ “运行信息： ” ＋ 文本
.如果 (取文本左边 (文本, 6) ＝ “写日志”)
    程序_写日志 (文本, 根目录 ＋ “配置\运行日志.ini”)
.否则

.如果结束
线程_退出许可区 (log许可证)


.子程序 _窗口_顶部导航_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

_启动窗口.发送信息 (161, 2, 0)

.子程序 导航菜单
.参数 ID, 整数型

影片A.文本颜色 ＝ #浅灰
演员组件.文本颜色 ＝ #浅灰
标签.文本颜色 ＝ #浅灰
列表.文本颜色 ＝ #浅灰
.如果真 (ID ＝ 1)
    影片A.文本颜色 ＝ #白色
.如果真结束
.如果真 (ID ＝ 2)
    演员组件.文本颜色 ＝ #白色
.如果真结束
.如果真 (ID ＝ 3)
    标签.文本颜色 ＝ #白色
.如果真结束
.如果真 (ID ＝ 4)
    列表.文本颜色 ＝ #白色
.如果真结束


.子程序 _关闭_被单击

.如果 (_启动窗口.可视 ＝ 假)
    _显示主程序_被选择 ()
.否则
    .如果 (取消置托盘选择框.选中 ＝ 假)
        _启动窗口.可视 ＝ 假
        窗口_下拉列表.可视 ＝ 假
    .否则
        批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
        批量_编辑框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
        批量_组合框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
        __启动窗口_将被销毁 ()
    .如果结束

.如果结束


.子程序 _最大化_被单击


.如果 (_启动窗口.宽度 ＝ 1230)
    _启动窗口.宽度 ＝ 1830
    _启动窗口.高度 ＝ 1020
.否则
    _启动窗口.宽度 ＝ 1230
    _启动窗口.高度 ＝ 720
.如果结束
排列封面标签 (1)


.子程序 _窗口_大小控制_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

SendMessageA (_启动窗口.取窗口句柄 (), 161, 17, 0)
排列封面标签 (1)

.子程序 _顶部横幅外形框_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

_启动窗口.发送信息 (161, 2, 0)

.子程序 _目录超级按钮0_被单击
.局部变量 按钮_来源, 超级按钮
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (63, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        目录超级按钮单击 (i)
    .默认

    .判断结束

.计次循环尾 ()


.子程序 目录超级按钮单击
.参数 项, 整数型

.如果 (封面滚动状态 ≠ 真)
    封面滚动状态 ＝ 真
    所有影片状态 ＝ 假
    封面项 ＝ 0
    取耗时 (1)
    加载索引 (“其他影片” ＋ 目录数组 [项])
    log (“加载影片完成，” ＋ 取耗时 (2))

.否则

.如果结束


.子程序 _目录超级按钮0_鼠标右键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 按钮_来源, 超级按钮
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (63, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        目录超级按钮右键单击 (i)
    .默认

    .判断结束

.计次循环尾 ()


.子程序 目录超级按钮右键单击
.参数 项, 整数型

目录项 ＝ 项
弹出菜单 (目录操作, , )

.子程序 _文件夹超级按钮0_被单击
.局部变量 按钮_来源, 超级按钮
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (10, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        文件夹超级按钮左键单击 (i)
    .默认

    .判断结束

.计次循环尾 ()


.子程序 文件夹超级按钮左键单击
.参数 项, 整数型

取耗时 (1)



.如果真 (项 ＝ 1)
    禁止 ()
    搜索返回 ()
    生成索引 (目录_浏览 (“生成索引 ”))
    分组框可视 (3)
    取禁 ()
.如果真结束
.如果真 (项 ＝ 2)
    搜索返回 ()
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (2)
        .如果 (所有影片状态 ＝ 假)
            所有影片状态 ＝ 真
            封面项 ＝ 0
        .否则

        .如果结束
        加载索引 (“所有影片”)
        log (“加载所有影片完成，” ＋ 取耗时 (2))
    .否则

    .如果结束

.如果真结束
.如果真 (项 ＝ 3)
    搜索返回 ()
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (3)
        页数标签.标题 ＝ “”
        排列封面标签 (1)
        读取目录 ()
        log (“加载目录管理完成，” ＋ 取耗时 (2))
    .否则

    .如果结束

.如果真结束
.如果真 (项 ＝ 4)
    搜索返回 ()

    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (4)
        标签演员状态 ＝ “标签真”
        .如果 (标签项 ＜ 0)
            标签项 ＝ 0
            标签子项 ＝ 0
        .否则

        .如果结束
        .如果 (收藏已看状态 ＝ 真)
            收藏已看状态 ＝ 假
            .如果 (所有影片状态 ＝ 假)
                所有影片状态 ＝ 真
                封面项 ＝ 0
            .否则

            .如果结束
            加载索引 (“所有影片”)

        .否则
            排列封面标签 (1)
        .如果结束
        设置透明度 ()
        log (“加载标签管理完成，” ＋ 取耗时 (2))

    .否则

    .如果结束

.如果真结束

.如果真 (项 ＝ 5)
    搜索返回 ()

    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (4)
        标签演员状态 ＝ “演员真”
        .如果 (演员项 ＜ 0)
            演员项 ＝ 0
            演员子项 ＝ 0
        .否则

        .如果结束
        .如果 (收藏已看状态 ＝ 真)
            收藏已看状态 ＝ 假
            .如果 (所有影片状态 ＝ 假)
                所有影片状态 ＝ 真
                封面项 ＝ 0
            .否则

            .如果结束
            加载索引 (“所有影片”)

        .否则
            排列封面标签 (1)
        .如果结束
        设置透明度 ()
        log (“加载演员管理完成，” ＋ 取耗时 (2))

    .否则

    .如果结束

.如果真结束



.如果真 (项 ＝ 6)
    收藏已看状态 ＝ 真
    搜索返回 ()
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (2)
        封面项 ＝ 0
        加载索引 (“收藏影片”)
        log (“加载收藏影片完成，” ＋ 取耗时 (2))

    .否则

    .如果结束

.如果真结束
.如果真 (项 ＝ 7)
    收藏已看状态 ＝ 真
    搜索返回 ()
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        分组框可视 (2)
        封面项 ＝ 0
        加载索引 (“已看影片”)
        log (“加载已看影片完成，” ＋ 取耗时 (2))
    .否则

    .如果结束

.如果真结束
.如果真 (项 ＝ 8)
    .如果 (影片刮削分组框.可视 ＝ 假)
        表格外形框.可视 ＝ 假
        设置外形框.可视 ＝ 假
        影片刮削分组框.可视 ＝ 真
    .否则
        影片刮削分组框.可视 ＝ 假
    .如果结束


    设置透明度 ()
.如果真结束
.如果真 (项 ＝ 9)
    .如果 (表格外形框.可视 ＝ 假)
        设置外形框.可视 ＝ 假
        表格外形框.可视 ＝ 真
        影片刮削分组框.可视 ＝ 假
        加载本地色花文本包 ()
    .否则
        表格外形框.可视 ＝ 假
    .如果结束
    设置透明度 ()
.如果真结束
.如果真 (项 ＝ 10)
    .如果 (设置外形框.可视 ＝ 假)
        表格外形框.可视 ＝ 假
        设置外形框.可视 ＝ 真
        影片刮削分组框.可视 ＝ 假
    .否则
        设置外形框.可视 ＝ 假
    .如果结束
    设置透明度 ()
.如果真结束



.子程序 读取目录
.局部变量 目录路径, 文本型
.局部变量 i, 整数型

清除数组 (目录数组)
文件_枚举_关键词 (根目录 ＋ “索引”, “txt”, “目录索引_”, 目录数组, 0, 假, 假)
.计次循环首 (取数组成员数 (目录数组), i)
    目录超级按钮数组 [i].标题 ＝ 文本_删左边 (文件_取文件名 (目录数组 [i]), 9)
    目录外形框数组 [i].可视 ＝ 真
    目录图形按钮数组 [i].可视 ＝ 真
    目录超级按钮数组 [i].可视 ＝ 真
.计次循环尾 ()

.子程序 _打开目录_被选择

执行 (, 根目录 ＋ “索引”, , , )
log (“打开程序根目录：” ＋ 根目录 ＋ “索引”)

.子程序 _删除目录_被选择
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

禁止 ()
取耗时 (1)
目录刷新状态 ＝ 真
封面项 ＝ 0
加载索引 (“所有影片”)
文件_删除 (目录数组 [目录项])
读取目录 ()
排列封面标签 (1)
目录刷新状态 ＝ 假
log (“删除目录完成，” ＋ 取耗时 (2))
取禁 ()

.子程序 生成索引
.参数 目录路径, 文本型
.参数 刷新目录啊, 逻辑型, 可空
.局部变量 i, 整数型
.局部变量 临时nfo数组, 文本型, , "0"
.局部变量 nfo文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 目录存在, 逻辑型
.局部变量 nfo读入文本, 文本型
.局部变量 nfovideogo文本, 文本型
.局部变量 nfoid文本, 文本型
.局部变量 nfo写出文本, 文本型
.局部变量 目录路径名, 文本型
.局部变量 文件名2, 文本型
.局部变量 文件名1, 文本型
.局部变量 临时写出数组, 文本型, , "0"
.局部变量 临时文件数组, 文本型, , "0"
.局部变量 创建时间, 文本型

目录存在 ＝ 假
log (“正在遍历目录，请等待...”)
取耗时 (1)
.如果 (目录路径 ≠ “”)
    文件_枚举_升级版 (目录路径, #视频格式, 临时文件数组, 0, 假, 真)
    重定义数组 (影片, 假, 取数组成员数 (临时文件数组))
    .计次循环首 (取数组成员数 (临时文件数组), i)
        影片 [i].文件 ＝ 临时文件数组 [i]
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (影片), i)
        文件名1 ＝ 到大写 (取文本右边 (文件_取文件名 (影片 [i].文件), 3))
        文件名2 ＝ 到大写 (取文本左边 (文件名1, 2))
        .如果 (文件名1 ＝ “CD1” 或 文件名2 ≠ “CD”)
            影片 [i].目录 ＝ 文件_取目录 (影片 [i].文件)
            文件_取时间 (影片 [i].文件, 创建时间)
            影片 [i].时间 ＝ 到整数 (文本_替换 (取文本左边 (创建时间, 10), , , , “-”, “”))
            文件_枚举_升级版 (影片 [i].目录, “nfo”, 临时nfo数组, 0, 假, 假)
            .如果 (取数组成员数 (临时nfo数组) ＞ 0)
                nfo读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时nfo数组 [1]))
                .如果 (文本_取出现次数 (nfo读入文本, “?”) ＞ 150)
                    nfo读入文本 ＝ 到文本 (读入文件 (临时nfo数组 [1]))
                .否则

                .如果结束
                nfovideogo文本 ＝ 文本_取出中间文本 (nfo读入文本, “<VideoGo>”, “</VideoGo>”, , 真)
                .如果 (nfovideogo文本 ＝ “”)
                    nfoid文本 ＝ 文本_取出中间文本 (nfo读入文本, “<id>”, “</id>”, , 真)
                    .如果 (nfoid文本 ≠ “”)
                        nfo写出文本 ＝ 文本_替换 (nfo读入文本, , , , “<id>” ＋ nfoid文本 ＋ “</id>”, “<id>” ＋ nfoid文本 ＋ “</id>” ＋ #换行符 ＋ #videonfo)
                        写到文件 (临时nfo数组 [1], 编码_Ansi到Utf8 (nfo写出文本))
                    .否则

                    .如果结束

                .否则
                    ' nfo写出文本 ＝ 文本_替换 (nfo读入文本, , , , nfovideogo文本, #videonfo3)
                    ' 写到文件 (临时nfo数组 [1], 编码_Ansi到Utf8 (nfo写出文本))
                .如果结束

                nfo文本 ＝ 文本_替换 (获取nfo信息 (编码_Utf8到Ansi (读入文件 (临时nfo数组 [1]))), , , , #换行符, “”, 字符 (10), “”)
                影片 [i].nfo ＝ nfo文本
                nfo文本 ＝ “”

            .否则
                影片 [i].nfo ＝ “<title>” ＋ 文件_取文件名 (影片 [i].文件) ＋ #空nfo ＋ 文件_取文件名 (影片 [i].文件) ＋ #空nfo2
            .如果结束
            清除数组 (临时nfo数组)
        .否则
            影片 [i].文件 ＝ “空”
            影片 [i].目录 ＝ “空”
            影片 [i].nfo ＝ “空”
        .如果结束

        .如果真 (圆形进度外形框.可视 ＝ 假)
            圆形进度外形框.可视 ＝ 真
            LOGO图形按钮.可视 ＝ 假
        .如果真结束
        进度窗口 (到整数 (i ÷ 取数组成员数 (影片) × 100))
        log (“正在生成目录索引，请等待_读取文件” ＋ 到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (影片)) ＋ “个”)
    .计次循环尾 ()
    .如果真 (圆形进度外形框.可视 ＝ 真)
        圆形进度外形框.可视 ＝ 假
        LOGO图形按钮.可视 ＝ 真
    .如果真结束


    清除数组 (临时写出数组)
    加入成员 (临时写出数组, “<目录路径>” ＋ 目录路径 ＋ “</目录路径>”)
    .计次循环首 (取数组成员数 (影片), i)
        .如果真 (影片 [i].文件 ≠ “空”)
            加入成员 (临时写出数组, 影片 [i].文件 ＋ “|” ＋ 影片 [i].nfo ＋ “<etad>” ＋ 到文本 (影片 [i].时间) ＋ “<etad>”)
        .如果真结束

    .计次循环尾 ()
    .如果 (目录_取尾部目录名或文件名 (目录路径) ＝ “”)
        目录路径名 ＝ 取文本左边 (目录路径, 1) ＋ “盘”
    .否则
        目录路径名 ＝ 目录_取尾部目录名或文件名 (目录路径)
    .如果结束

    .如果 (刷新目录啊 ≠ 真)
        .如果 (文件是否存在 (根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “.txt”) ≠ 真)
            写到文本 (临时写出数组, , 根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “.txt”, , “真”)
        .否则
            写到文本 (临时写出数组, , 根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “[” ＋ 文本_取随机字母 (1, 2) ＋ “]” ＋ “.txt”, , “真”)
        .如果结束

    .否则
        .如果 (文件是否存在 (根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “#.txt”) ≠ 真)
            写到文本 (临时写出数组, , 根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “.txt”, , “真”)
        .否则
            写到文本 (临时写出数组, , 根目录 ＋ “索引\目录索引_” ＋ 目录路径名 ＋ “#.txt”, , “真”)
        .如果结束


    .如果结束


    读取目录 ()
    log (“目录索引已生成，耗时：” ＋ 取耗时 (2))
.否则
    log (“请选择目录文件夹！”)
.如果结束


.子程序 获取nfo信息, 文本型
.参数 nfo信息, 文本型
.局部变量 正则, 正则表达式类
.局部变量 id, 整数型
.局部变量 r, 文本型
.局部变量 x, 字节集
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 a, 整数型, , "2"
.局部变量 题目, 文本型
.局部变量 封面, 文本型
.局部变量 号番, 文本型
.局部变量 网址数组, 文本型, , "0"
.局部变量 发行日期, 文本型
.局部变量 长度, 文本型
.局部变量 导演, 文本型
.局部变量 简介, 文本型
.局部变量 导演分割, 文本型, , "99"
.局部变量 制作商, 文本型
.局部变量 制作商分割, 文本型, , "99"
.局部变量 发行商, 文本型
.局部变量 发行商分割, 文本型, , "99"
.局部变量 系列, 文本型
.局部变量 系列分割, 文本型, , "99"
.局部变量 演员, 文本型, , "9999"
.局部变量 演员分割, 文本型, , "99"
.局部变量 演员累加, 文本型
.局部变量 类别, 文本型, , "9999"
.局部变量 类别分割, 文本型, , "99"
.局部变量 类别累加, 文本型
.局部变量 标签累加, 文本型
.局部变量 nfo文本, 文本型
.局部变量 系别, 文本型, , "999"
.局部变量 路径, 文本型
.局部变量 文件数, 文本型, , "0"
.局部变量 videogo文本, 文本型

r ＝ nfo信息
题目 ＝ 文本_取出中间文本 (r, “<title>”, “</title>”)
简介 ＝ 文本_取出中间文本 (r, “<plot>”, “</plot>”)
缩略图简介编辑框.内容 ＝ “    简介：” ＋ 简介
号番 ＝ 文本_取出中间文本 (r, “<id>”, “</id>”)
缩略图番号编辑框.内容 ＝ “番号：” ＋ 号番
发行日期 ＝ 文本_取出中间文本 (r, “<premiered>”, “</premiered>”)
缩略图日期标签.标题 ＝ “日期：” ＋ 发行日期
长度 ＝ 文本_取出中间文本 (r, “<runtime>”, “</runtime>”)
缩略图时长标签.标题 ＝ “时长：” ＋ 长度
制作商 ＝ 文本_取出中间文本 (r, “<studio>”, “</studio>”)
缩略图制作商标签.标题 ＝ “制作商：” ＋ 制作商
发行商 ＝ 文本_取出中间文本 (r, “<Publisher>”, “</Publisher>”)
缩略图发行商标签.标题 ＝ “发行商：” ＋ 发行商
系列 ＝ 文本_取出中间文本 (r, “<set>”, “</set>”)
缩略图系列标签.标题 ＝ “系列：” ＋ 系列
正则.创建 (#nfo类别, 到文本 (r))
.计次循环首 (正则.取匹配数量 (), i)
    类别 [i] ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<genre>”, “</genre>”)
    .如果 (取数组成员数 (类别) ＞ 1)
        类别累加 ＝ 类别 [i] ＋ “/” ＋ 类别累加
    .否则

    .如果结束

.计次循环尾 ()
缩略图类别标签.标题 ＝ “类别：” ＋ 类别累加

正则.创建 (#nfo演员, 到文本 (r))
.计次循环首 (正则.取匹配数量 (), i)
    演员 [i] ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<name>”, “</name>”)
    .如果 (取数组成员数 (演员) ＞ 1)
        演员累加 ＝ 演员 [i] ＋ “/” ＋ 演员累加
    .否则

    .如果结束

.计次循环尾 ()
缩略图演员标签.标题 ＝ “演员：” ＋ 演员累加
videogo文本 ＝ 文本_取出中间文本 (r, “<videogo>”, “</videogo>”)
返回 (“<title>” ＋ 题目 ＋ “<title>^<date>” ＋ 发行日期 ＋ “<date>^<time>” ＋ 长度 ＋ “<time>^<name>” ＋ 演员累加 ＋ “<name>^<genre>” ＋ 类别累加 ＋ “<genre>^<other>” ＋ 制作商 ＋ “/” ＋ 系列 ＋ “/” ＋ 发行商 ＋ “/” ＋ 制作商 ＋ “<other>^<id>” ＋ 号番 ＋ “<id>” ＋ “^<videogo>” ＋ videogo文本 ＋ “<videogo>”)

.子程序 文件_枚举_升级版, 整数型, , 提供一个目录,获取目录下指定格式文件,成功返回获取到的数量,失败返回0
.参数 欲寻找的目录, 文本型, 可空, 提供一个目录,比如 “c:” 为空则搜索程序运行的目录
.参数 欲寻找的文件名, 文本型, 可空, 提供一个或多个扩展名,多个扩展名请用"|" 隔开,扩展名的点可加可不加,比如: ".jpg|exe|png|.e" 留空则获取全部搜索到的文件
.参数 文件数组名, 文本型, 参考 可空 数组, 提供一个文本型的数组变量,接受结果
.参数 路径格式, 整数型, 可空, 0为获取完整路径,比如"c:\123.txt" 1为获取文件名,含扩展名,比如"123.txt" 2为文件名,不含扩展名 比如"123" 默认为0,获取完整路径
.参数 是否添加目录, 逻辑型, 可空, 为真时,搜索到的目录也加入到文件数组,默认为假,不加入目录
.参数 是否包含子目录, 逻辑型, 可空, 为真则子目录下文件也搜索,默认为假,不搜索子目录
.局部变量 局_搜索文件, 文本型
.局部变量 局_扩展名, 文本型, , "0"
.局部变量 局_搜到文件, 文本型
.局部变量 局_加入的文件, 文本型
.局部变量 i, 整数型

.如果真 (欲寻找的目录 ＝ “”)
    欲寻找的目录 ＝ 取运行目录 ()
.如果真结束
.如果真 (取文本右边 (欲寻找的目录, 1) ≠ “\”)
    欲寻找的目录 ＝ 欲寻找的目录 ＋ “\”
.如果真结束
局_搜索文件 ＝ 寻找文件 (欲寻找的目录 ＋ “*.*”, )
.判断循环首 (局_搜索文件 ≠ “”)
    处理事件 ()
    .判断开始 (欲寻找的文件名 ＝ “*.*” 或 欲寻找的文件名 ＝ “.*” 或 欲寻找的文件名 ＝ “*”)
        局_搜到文件 ＝ 局_搜索文件
    .判断 (是否为空 (欲寻找的文件名) ＝ 假 且 欲寻找的文件名 ≠ “”)
        局_扩展名 ＝ 分割文本 (欲寻找的文件名, “|”, )
        .计次循环首 (取数组成员数 (局_扩展名), i)
            .如果真 (取文本左边 (局_扩展名 [i], 1) ≠ “.”)
                局_扩展名 [i] ＝ “.” ＋ 局_扩展名 [i]
            .如果真结束
            .如果真 (到小写 (局_扩展名 [i]) ＝ 到小写 (取文本右边 (局_搜索文件, 取文本长度 (局_扩展名 [i]))))
                局_搜到文件 ＝ 局_搜索文件
                跳出循环 ()
            .如果真结束

        .计次循环尾 ()
    .默认
        局_搜到文件 ＝ 局_搜索文件
    .判断结束

    .如果真 (局_搜到文件 ≠ “”)
        .判断开始 (路径格式 ＝ 0)
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件
        .判断 (路径格式 ＝ 1)
            局_加入的文件 ＝ 局_搜到文件
        .判断 (路径格式 ＝ 2)
            局_加入的文件 ＝ 取文本左边 (局_搜到文件, 倒找文本 (局_搜到文件, “.”, , 假) － 1)
        .默认
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件  ' 其他情况都返回全路径
        .判断结束
        加入成员 (文件数组名, 局_加入的文件)
    .如果真结束
    局_搜到文件 ＝ “”
    局_搜索文件 ＝ 寻找文件 (, )
.判断循环尾 ()
.如果真 (是否添加目录 或 是否包含子目录)
    局_搜索文件 ＝ 寻找文件 (欲寻找的目录 ＋ “*.*”, #子目录)
    .判断循环首 (局_搜索文件 ≠ “”)
        .如果真 (取文本左边 (局_搜索文件, 1) ≠ “.”)
            .如果真 (是否添加目录)
                加入成员 (文件数组名, 欲寻找的目录 ＋ 局_搜索文件)
            .如果真结束
            .如果真 (是否包含子目录)
                文件_枚举_升级版 (欲寻找的目录 ＋ 局_搜索文件, 欲寻找的文件名, 文件数组名, 路径格式, 是否添加目录, 是否包含子目录)  ' 递归
            .如果真结束

        .如果真结束
        局_搜索文件 ＝ 寻找文件 (, #子目录)
    .判断循环尾 ()
.如果真结束
返回 (取数组成员数 (文件数组名))


.子程序 文件_枚举_关键词, 整数型, , 提供一个目录,获取目录下指定格式文件,成功返回获取到的数量,失败返回0
.参数 欲寻找的目录, 文本型, 可空, 提供一个目录,比如 “c:” 为空则搜索程序运行的目录
.参数 欲寻找的文件名, 文本型, 可空, 提供一个或多个扩展名,多个扩展名请用"|" 隔开,扩展名的点可加可不加,比如: ".jpg|exe|png|.e" 留空则获取全部搜索到的文件
.参数 欲寻找的关键字, 文本型, 可空, 提供一个文件名关键词
.参数 文件数组名, 文本型, 参考 可空 数组, 提供一个文本型的数组变量,接受结果
.参数 路径格式, 整数型, 可空, 0为获取完整路径,比如"c:\123.txt" 1为获取文件名,含扩展名,比如"123.txt" 2为文件名,不含扩展名 比如"123" 默认为0,获取完整路径
.参数 是否添加目录, 逻辑型, 可空, 为真时,搜索到的目录也加入到文件数组,默认为假,不加入目录
.参数 是否包含子目录, 逻辑型, 可空, 为真则子目录下文件也搜索,默认为假,不搜索子目录
.局部变量 局_搜索文件, 文本型
.局部变量 局_扩展名, 文本型, , "0"
.局部变量 局_搜到文件, 文本型
.局部变量 局_加入的文件, 文本型
.局部变量 i, 整数型

.如果真 (欲寻找的目录 ＝ “”)
    欲寻找的目录 ＝ 取运行目录 ()
.如果真结束
.如果真 (取文本右边 (欲寻找的目录, 1) ≠ “\”)
    欲寻找的目录 ＝ 欲寻找的目录 ＋ “\”
.如果真结束
局_搜索文件 ＝ 寻找文件 (欲寻找的目录 ＋ “*.*”, )
.判断循环首 (局_搜索文件 ≠ “”)
    处理事件 ()
    .判断开始 (欲寻找的文件名 ＝ “*.*” 或 欲寻找的文件名 ＝ “.*” 或 欲寻找的文件名 ＝ “*”)
        局_搜到文件 ＝ 局_搜索文件
    .判断 (是否为空 (欲寻找的文件名) ＝ 假 且 欲寻找的文件名 ≠ “”)
        局_扩展名 ＝ 分割文本 (欲寻找的文件名, “|”, )
        .计次循环首 (取数组成员数 (局_扩展名), i)
            .如果真 (取文本左边 (局_扩展名 [i], 1) ≠ “.”)
                局_扩展名 [i] ＝ “.” ＋ 局_扩展名 [i]
            .如果真结束
            .如果真 (到小写 (局_扩展名 [i]) ＝ 到小写 (取文本右边 (局_搜索文件, 取文本长度 (局_扩展名 [i]))))
                局_搜到文件 ＝ 局_搜索文件
                跳出循环 ()
            .如果真结束

        .计次循环尾 ()
    .默认
        局_搜到文件 ＝ 局_搜索文件
    .判断结束

    .如果真 (局_搜到文件 ≠ “”)
        .判断开始 (路径格式 ＝ 0)
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件
        .判断 (路径格式 ＝ 1)
            局_加入的文件 ＝ 局_搜到文件
        .判断 (路径格式 ＝ 2)
            局_加入的文件 ＝ 取文本左边 (局_搜到文件, 倒找文本 (局_搜到文件, “.”, , 假) － 1)
        .默认
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件  ' 其他情况都返回全路径
        .判断结束
        .如果 (欲寻找的关键字 ≠ “”)
            .如果真 (文本_寻找文本 (文件_取文件名 (局_加入的文件), 欲寻找的关键字, , 真) ≠ -1)
                加入成员 (文件数组名, 局_加入的文件)
            .如果真结束

        .否则
            加入成员 (文件数组名, 局_加入的文件)
        .如果结束


    .如果真结束
    局_搜到文件 ＝ “”
    局_搜索文件 ＝ 寻找文件 (, )
.判断循环尾 ()
.如果真 (是否添加目录 或 是否包含子目录)
    局_搜索文件 ＝ 寻找文件 (欲寻找的目录 ＋ “*.*”, #子目录)
    .判断循环首 (局_搜索文件 ≠ “”)
        .如果真 (取文本左边 (局_搜索文件, 1) ≠ “.”)
            .如果真 (是否添加目录)

                加入成员 (文件数组名, 欲寻找的目录 ＋ 局_搜索文件)

            .如果真结束
            .如果真 (是否包含子目录)
                文件_枚举_关键词 (欲寻找的目录 ＋ 局_搜索文件, 欲寻找的文件名, 欲寻找的关键字, 文件数组名, 路径格式, 是否添加目录, 是否包含子目录)  ' 递归
            .如果真结束

        .如果真结束
        局_搜索文件 ＝ 寻找文件 (, #子目录)
    .判断循环尾 ()
.如果真结束
返回 (取数组成员数 (文件数组名))


.子程序 取耗时, 文本型
.参数 运行项, 整数型

.如果真 (运行项 ＝ 1)
    耗时 ＝ 取启动时间 ()
    返回 (“1”)
.如果真结束

.如果真 (运行项 ＝ 2)
    .如果 (到整数 ((取启动时间 () － 耗时) ÷ 1000) ＝ 0)
        返回 (“耗时：” ＋ 到文本 (取启动时间 () － 耗时) ＋ “毫秒”)
    .否则
        返回 (“耗时：” ＋ 到文本 (到整数 ((取启动时间 () － 耗时) ÷ 1000)) ＋ “秒”)
    .如果结束

.如果真结束
返回 (“0”)




.子程序 _刷新目录_被选择

禁止 ()
目录刷新状态 ＝ 真
封面项 ＝ 0
加载索引 (“所有影片”)
生成索引 (文本_取出中间文本 (编码_Utf8到Ansi (读入文件 (目录数组 [目录项])), “<目录路径>”, “</目录路径>”), 真)
目录刷新状态 ＝ 假
取禁 ()

.子程序 取视频信息, 文本型
.参数 路径, 文本型
.局部变量 分辨率, 文本型
.局部变量 高啊, 文本型
.局部变量 宽啊, 文本型
.局部变量 时长, 文本型
.局部变量 大小, 文本型
.局部变量 码率, 文本型
.局部变量 info, 类_MediaInfo
.局部变量 影片信息, 文本型

info.打开 (路径)
高啊 ＝ 文本_替换 (文本_取出中间文本 (info.取摘要 (), “Height                                   : ”, “ pixels”, , 真), , , , “ ”, “”)
宽啊 ＝ 文本_替换 (文本_取出中间文本 (info.取摘要 (), “Width                                    : ”, “ pixels”, , 真), , , , “ ”, “”)
大小 ＝ info.取信息 (“FileSize/String”)
时长 ＝ 到文本 (到整数 (到整数 (info.取信息 (“Duration”)) ÷ 60000))
码率 ＝ 到文本 (到整数 (到整数 (info.取信息 (“OverallBitRate”)) ÷ 1000))
info.关闭 ()
' 视频信息标签.标题 ＝ “视频信息” ＋ #换行符 ＋ “分辨率  ：  ” ＋ 高啊 ＋ “p” ＋ #换行符 ＋ “文件大小：  ” ＋ 大小 ＋ #换行符 ＋ “影片时长：  ” ＋ 时长 ＋ “分钟” ＋ #换行符 ＋ “码率    ：  ” ＋ 码率 ＋ “/kbps”
影片信息 ＝ “视频信息” ＋ #换行符 ＋ #换行符 ＋ “分辨率  ：  ” ＋ 宽啊 ＋ “*” ＋ 高啊 ＋ #换行符 ＋ #换行符 ＋ “文件大小：  ” ＋ 大小 ＋ #换行符 ＋ #换行符 ＋ “影片时长：  ” ＋ 时长 ＋ “分钟” ＋ #换行符 ＋ #换行符 ＋ “码率    ：  ” ＋ 码率 ＋ “/kbps” ＋ #换行符 ＋ #换行符 ＋ “路径    ：  ” ＋ 路径
信息框_z (“【影片信息】”, 影片信息, “”, “”, )
' log (“分辨率:” ＋ 宽啊 ＋ “*” ＋ 高啊 ＋ “  文件大小:” ＋ 大小 ＋ “  时长:” ＋ 时长 ＋ “分钟  码率” ＋ 码率 ＋ “/kbps”)
返回 (“<宽度>” ＋ 宽啊 ＋ “<宽度>” ＋ “<高度>” ＋ 高啊 ＋ “<高度>” ＋ “<大小>” ＋ 大小 ＋ “<大小>” ＋ “<时长>” ＋ 时长 ＋ “<时长>” ＋ “<码率>” ＋ 码率 ＋ “<码率>”)






.子程序 加载索引
.参数 目录路径, 文本型
.局部变量 临时分割, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 z, 整数型
.局部变量 临时分割2, 文本型, , "0"
.局部变量 临时分割3, 文本型, , "0"
.局部变量 临时分割4, 文本型, , "0"
.局部变量 分割文本, 文本型, , "0"
.局部变量 目录数组项, 整数型
.局部变量 x, 整数型
.局部变量 数组成员数, 整数型
.局部变量 临时数组, 整数型, , "0"
.局部变量 计数, 整数型
.局部变量 数组位置, 整数型, , "0"
.局部变量 文本对象, 快速文本对象


.如果 (取文本左边 (目录路径, 8) ＝ “其他影片”)
    目录路径 ＝ 文本_删左边 (目录路径, 8)
    ' 封面项 ＝ 0
    清除数组 (临时)
    清除数组 (影片)
    清除数组 (影片演员)
    清除数组 (影片标签)
    .计次循环首 (取数组成员数 (目录数组), i)
        .如果 (目录路径 ＝ 目录数组 [i])
            目录数组项 ＝ i
        .否则

        .如果结束

    .计次循环尾 ()

    .如果 (取文本右边 (目录路径, 5) ＝ “%.txt” 且 取数组成员数 (缓存) ≠ 0)
        重定义数组 (影片, 假, 取数组成员数 (缓存))
        .计次循环首 (取数组成员数 (缓存), i)
            影片 [i].文件 ＝ 缓存 [i].文件
            影片 [i].目录 ＝ 缓存 [i].目录
            影片 [i].nfo ＝ 缓存 [i].nfo
            影片 [i].标题 ＝ 缓存 [i].标题
            影片 [i].番号 ＝ 缓存 [i].番号
            影片 [i].日期 ＝ 缓存 [i].日期
            影片 [i].整数 ＝ 缓存 [i].整数
            影片 [i].时间 ＝ 缓存 [i].时间
        .计次循环尾 ()
    .否则
        分割文本 ＝ 分割文本 (文本_删除空行_汇编 (编码_Utf8到Ansi (读入文件 (目录路径))), #换行符, )
        .计次循环首 (取数组成员数 (分割文本), i)
            .如果 (i ＝ 1)

            .否则
                加入成员 (临时分割, 分割文本 [i])
            .如果结束

        .计次循环尾 ()
        数组成员数 ＝ 取数组成员数 (临时分割)
        重定义数组 (影片, 假, 数组成员数)
        .计次循环首 (取数组成员数 (临时分割), i)
            临时分割2 ＝ 分割文本 (临时分割 [i], “|”, )
            影片 [i].文件 ＝ 临时分割2 [1]
            影片 [i].目录 ＝ 文件_取目录 (临时分割2 [1])
            .如果 (取数组成员数 (临时分割2) ＞ 1)
                影片 [i].nfo ＝ 临时分割2 [2] ＋ “<mulu>” ＋ 目录数组 [目录数组项] ＋ “<mulu>”
                影片 [i].标题 ＝ 文本_取出中间文本 (影片 [i].nfo, “<title>”, “<title>”, , 真)
                影片 [i].日期 ＝ 文本_取出中间文本 (影片 [i].nfo, “<date>”, “<date>”, , 真)
                影片 [i].整数 ＝ 到整数 (文本_替换 (影片 [i].日期, , , , “-”, “”, “_”, “”, “空”, “”))
                影片 [i].时间 ＝ 到整数 (文本_取出中间文本 (影片 [i].nfo, “<etad>”, “<etad>”, , 真))
                影片 [i].番号 ＝ 文本_取出中间文本 (影片 [i].nfo, “<id>”, “<id>”, , 真)
                .如果 (数组成员数 ＜ 10000)

                    临时分割3 ＝ 分割文本 (文本_替换 (文本_取出中间文本 (临时分割2 [2], “<genre>”, “<genre>”, , 真), , , , “系列:”, “”, “片商:”, “”), “/”, )
                    .计次循环首 (取数组成员数 (临时分割3), k)
                        .如果 (临时分割3 [k] ≠ “”)
                            .如果 (文本_取长度 (临时分割3 [k]) ＜ 20)
                                加入成员 (影片标签, 临时分割3 [k])


                            .否则

                            .如果结束



                        .否则

                        .如果结束

                    .计次循环尾 ()

                    临时分割4 ＝ 分割文本 (文本_替换 (文本_取出中间文本 (临时分割2 [2], “<name>”, “<name>”, , 真), , , , “演员:”, “”, “片商:”, “”), “/”, )
                    .计次循环首 (取数组成员数 (临时分割4), k)
                        .如果 (临时分割4 [k] ≠ “”)
                            .如果 (文本_取长度 (临时分割4 [k]) ＜ 20)
                                加入成员 (影片演员, 临时分割4 [k])

                            .否则

                            .如果结束



                        .否则

                        .如果结束

                    .计次循环尾 ()

                .否则

                .如果结束





            .否则
                影片 [i].nfo ＝ “空”
                影片 [i].标题 ＝ “空”
                影片 [i].番号 ＝ “空”
                影片 [i].日期 ＝ “空”
                影片 [i].整数 ＝ 0

            .如果结束

        .计次循环尾 ()
        清除数组 (分割文本)
    .如果结束

    数组_去重复 (影片标签)
    数组_去重复 (影片演员)

    .如果 (取文本右边 (目录路径, 5) ＝ “%.txt”)
        .如果 (缓存排序状态 ＝ 假)
            影片排序 ()
            缓存排序状态 ＝ 真
        .否则

        .如果结束

    .否则
        影片排序 ()
    .如果结束

    .如果 (取文本右边 (目录路径, 5) ＝ “%.txt”)
        .如果 (取数组成员数 (缓存) ＝ 0)
            重定义数组 (缓存, 假, 取数组成员数 (影片))
            .计次循环首 (取数组成员数 (影片), i)
                缓存 [i].文件 ＝ 影片 [i].文件
                缓存 [i].目录 ＝ 影片 [i].目录
                缓存 [i].nfo ＝ 影片 [i].nfo
                缓存 [i].标题 ＝ 影片 [i].标题
                缓存 [i].番号 ＝ 影片 [i].番号
                缓存 [i].日期 ＝ 影片 [i].日期
                缓存 [i].整数 ＝ 影片 [i].整数
                缓存 [i].时间 ＝ 影片 [i].时间
            .计次循环尾 ()

        .否则

        .如果结束

    .否则

    .如果结束



    目录分组框.可视 ＝ 假

    封面分组框.可视 ＝ 真


    排列封面标签 (1)




.否则

.如果结束

.如果真 (目录路径 ＝ “所有影片”)
    .如果 (所有影片状态 ≠ 真)
        封面项 ＝ 0
    .否则

    .如果结束

    清除数组 (临时)
    清除数组 (影片)
    清除数组 (临时分割)
    .计次循环首 (取数组成员数 (目录数组), z)
        .如果 (取文本右边 (目录数组 [z], 5) ≠ “%.txt”)
            .如果 (取文本右边 (目录数组 [z], 5) ≠ “#.txt”)
                分割文本 ＝ 分割文本 (文本_删除空行_汇编 (编码_Utf8到Ansi (读入文件 (目录数组 [z]))), #换行符, )
                .计次循环首 (取数组成员数 (分割文本), i)
                    .如果 (i ＝ 1)

                    .否则
                        加入成员 (临时分割, 分割文本 [i] ＋ “<mulu>” ＋ 目录数组 [z] ＋ “<mulu>”)
                    .如果结束

                .计次循环尾 ()
            .否则

            .如果结束

        .否则

        .如果结束

    .计次循环尾 ()
    数组成员数 ＝ 取数组成员数 (临时分割)
    重定义数组 (影片, 假, 数组成员数)
    .计次循环首 (取数组成员数 (临时分割), i)
        临时分割2 ＝ 分割文本 (临时分割 [i], “|”, )
        影片 [i].文件 ＝ 临时分割2 [1]
        影片 [i].目录 ＝ 文件_取目录 (临时分割2 [1])
        .如果 (取数组成员数 (临时分割2) ＞ 1)
            影片 [i].nfo ＝ 临时分割2 [2]
            影片 [i].标题 ＝ 文本_取出中间文本 (影片 [i].nfo, “<title>”, “<title>”, , 真)
            影片 [i].日期 ＝ 文本_取出中间文本 (影片 [i].nfo, “<date>”, “<date>”, , 真)
            影片 [i].整数 ＝ 到整数 (文本_替换 (影片 [i].日期, , , , “-”, “”, “_”, “”, “空”, “”))
            影片 [i].时间 ＝ 到整数 (文本_取出中间文本 (影片 [i].nfo, “<etad>”, “<etad>”, , 真))
            影片 [i].番号 ＝ 文本_取出中间文本 (影片 [i].nfo, “<id>”, “<id>”, , 真)
            .如果 (数组成员数 ＜ 10000)

                临时分割3 ＝ 分割文本 (文本_替换 (文本_取出中间文本 (影片 [i].nfo, “<genre>”, “<genre>”, , 真), , , , “系列:”, “”, “片商:”, “”), “/”, )
                .计次循环首 (取数组成员数 (临时分割3), k)
                    .如果 (临时分割3 [k] ≠ “”)
                        .如果 (文本_取长度 (临时分割3 [k]) ＜ 20)
                            加入成员 (影片标签, 临时分割3 [k])
                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .计次循环尾 ()

                临时分割4 ＝ 分割文本 (文本_替换 (文本_取出中间文本 (影片 [i].nfo, “<name>”, “<name>”, , 真), , , , “演员:”, “”, “片商:”, “”), “/”, )
                .计次循环首 (取数组成员数 (临时分割4), k)
                    .如果 (临时分割4 [k] ≠ “”)
                        .如果 (文本_取长度 (临时分割4 [k]) ＜ 20)
                            加入成员 (影片演员, 临时分割4 [k])
                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .计次循环尾 ()

            .否则

            .如果结束

        .否则
            影片 [i].nfo ＝ “空”
            影片 [i].标题 ＝ “空”
            影片 [i].番号 ＝ “空”
            影片 [i].日期 ＝ “空”
            影片 [i].整数 ＝ 0
        .如果结束

    .计次循环尾 ()

    数组_去重复 (影片标签)
    数组_去重复 (影片演员)
    影片排序 ()
    .如果 (目录刷新状态 ＝ 假)
        目录分组框.可视 ＝ 假
        .如果 (初次加载状态 ＝ 真)
            封面分组框.可视 ＝ 真
        .否则

        .如果结束

        排列封面标签 (1)
    .否则

    .如果结束


.如果真结束


.如果真 (目录路径 ＝ “收藏影片”)
    .如果 (取数组成员数 (临时) ＝ 0)
        重定义数组 (临时, 假, 取数组成员数 (影片))
        .计次循环首 (取数组成员数 (影片), i)
            临时 [i].文件 ＝ 影片 [i].文件
            临时 [i].目录 ＝ 影片 [i].目录
            临时 [i].nfo ＝ 影片 [i].nfo
            临时 [i].标题 ＝ 影片 [i].标题
            临时 [i].番号 ＝ 影片 [i].番号
            临时 [i].日期 ＝ 影片 [i].日期
            临时 [i].整数 ＝ 影片 [i].整数
            临时 [i].时间 ＝ 影片 [i].时间
        .计次循环尾 ()

    .否则

    .如果结束
    清除数组 (临时数组)
    .计次循环首 (取数组成员数 (临时), i)
        .如果 (文本_取出中间文本 (临时 [i].nfo, “[sc]”, “[sc]”, , 真) ＝ “真”)
            加入成员 (临时数组, 1)
        .否则

        .如果结束

    .计次循环尾 ()
    重定义数组 (影片, 假, 取数组成员数 (临时数组))
    计数 ＝ 0
    .计次循环首 (取数组成员数 (临时), i)
        .如果 (文本_取出中间文本 (临时 [i].nfo, “[sc]”, “[sc]”, , 真) ＝ “真”)
            计数 ＝ 计数 ＋ 1
            影片 [计数].文件 ＝ 临时 [i].文件
            影片 [计数].目录 ＝ 临时 [i].目录
            影片 [计数].nfo ＝ 临时 [i].nfo
            影片 [计数].标题 ＝ 临时 [i].标题
            影片 [计数].番号 ＝ 临时 [i].番号
            影片 [计数].日期 ＝ 临时 [i].日期
            影片 [计数].整数 ＝ 临时 [i].整数
            影片 [计数].时间 ＝ 临时 [i].时间
        .否则

        .如果结束

    .计次循环尾 ()
    影片排序 ()
    目录分组框.可视 ＝ 假
    封面分组框.可视 ＝ 真
    排列封面标签 (1)

.如果真结束

.如果真 (目录路径 ＝ “已看影片”)
    .如果 (取数组成员数 (临时) ＝ 0)
        重定义数组 (临时, 假, 取数组成员数 (影片))
        .计次循环首 (取数组成员数 (影片), i)
            临时 [i].文件 ＝ 影片 [i].文件
            临时 [i].目录 ＝ 影片 [i].目录
            临时 [i].nfo ＝ 影片 [i].nfo
            临时 [i].标题 ＝ 影片 [i].标题
            临时 [i].番号 ＝ 影片 [i].番号
            临时 [i].日期 ＝ 影片 [i].日期
            临时 [i].整数 ＝ 影片 [i].整数
            临时 [i].时间 ＝ 影片 [i].时间
        .计次循环尾 ()

    .否则

    .如果结束
    清除数组 (临时数组)
    .计次循环首 (取数组成员数 (临时), i)
        .如果 (文本_取出中间文本 (临时 [i].nfo, “[yk]”, “[yk]”, , 真) ＝ “真”)
            加入成员 (临时数组, 1)
        .否则

        .如果结束

    .计次循环尾 ()
    重定义数组 (影片, 假, 取数组成员数 (临时数组))
    计数 ＝ 0
    .计次循环首 (取数组成员数 (临时), i)
        .如果 (文本_取出中间文本 (临时 [i].nfo, “[yk]”, “[yk]”, , 真) ＝ “真”)
            计数 ＝ 计数 ＋ 1
            影片 [计数].文件 ＝ 临时 [i].文件
            影片 [计数].目录 ＝ 临时 [i].目录
            影片 [计数].nfo ＝ 临时 [i].nfo
            影片 [计数].标题 ＝ 临时 [i].标题
            影片 [计数].番号 ＝ 临时 [i].番号
            影片 [计数].日期 ＝ 临时 [i].日期
            影片 [计数].整数 ＝ 临时 [i].整数
            影片 [计数].时间 ＝ 临时 [i].时间
        .否则

        .如果结束

    .计次循环尾 ()

    影片排序 ()
    目录分组框.可视 ＝ 假
    封面分组框.可视 ＝ 真
    排列封面标签 (1)


.如果真结束






.子程序 影片排序

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “发行日期升序”)
    希尔排序 (取数组成员数 (影片), 到整数 (&处理函数_希尔_自定义_影片), 0, 假)

.如果真结束

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “发行日期降序”)
    希尔排序 (取数组成员数 (影片), 到整数 (&处理函数_希尔_自定义_影片), 0, 真)

.如果真结束

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “文件夹升序”)

.如果真结束

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “文件夹降序”)
    数组反转 ()
.如果真结束

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “创建日期升序”)
    希尔排序 (取数组成员数 (影片), 到整数 (&处理函数_希尔_自定义_影片2), 0, 假)

.如果真结束

.如果真 (影片排序组合框.取项目文本 (影片排序组合框.现行选中项) ＝ “创建日期降序”)
    希尔排序 (取数组成员数 (影片), 到整数 (&处理函数_希尔_自定义_影片2), 0, 真)

.如果真结束


.子程序 数组反转
.局部变量 i, 整数型
.局部变量 临时数组, 影片数组, , "0"
.局部变量 计数, 整数型

计数 ＝ 取数组成员数 (影片)
重定义数组 (临时数组, 假, 取数组成员数 (影片))
.计次循环首 (取数组成员数 (影片), i)
    临时数组 [计数] ＝ 影片 [i]
    计数 ＝ 计数 － 1
.计次循环尾 ()
.计次循环首 (取数组成员数 (影片), i)
    影片 [i] ＝ 临时数组 [i]
.计次循环尾 ()
清除数组 (临时数组)

.子程序 _封面动画框0_滚轮被滚动, 逻辑型
.参数 滚动距离, 整数型
.参数 功能键状态, 整数型
.局部变量 按钮_来源, 动画框
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (24, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        .如果 (滚动距离 ＝ -1)
            .如果 (封面滚动状态 ≠ 真)
                封面滚动状态 ＝ 真
                排列封面标签 (2)
            .否则

            .如果结束

        .否则
            .如果 (封面滚动状态 ≠ 真)
                封面滚动状态 ＝ 真
                排列封面标签 (3)
            .否则

            .如果结束

        .如果结束

    .默认

    .判断结束

.计次循环尾 ()


.子程序 禁止
.局部变量 i, 整数型

.计次循环首 (24, i)
    动画框数组 [i].禁止 ＝ 真
.计次循环尾 ()
.计次循环首 (63, i)
    目录超级按钮数组 [i].禁止 ＝ 真
.计次循环尾 ()
.计次循环首 (10, i)
    文件夹超级按钮数组 [i].禁止 ＝ 真
.计次循环尾 ()
.计次循环首 (300, i)
    标签超级按钮数组 [i].禁止 ＝ 真
.计次循环尾 ()
搜索图形按钮.禁止 ＝ 真
搜索编辑框.禁止 ＝ 真
窗口_大小控制.禁止 ＝ 真
最大化.禁止 ＝ 真
最小化.禁止 ＝ 真
关闭.禁止 ＝ 真
设置.禁止 ＝ 真
截图.禁止 ＝ 真
左箭头.禁止 ＝ 真
右箭头.禁止 ＝ 真
刷新所有目录按钮.禁止 ＝ 真
.如果 (设置外形框.可视 ＝ 真)
    设置关闭按钮.禁止 ＝ 真
    设置关闭按钮.禁止 ＝ 真
    设置超级按钮1.禁止 ＝ 真
    设置超级按钮2.禁止 ＝ 真
    设置超级按钮3.禁止 ＝ 真
    设置超级按钮4.禁止 ＝ 真
    设置超级按钮5.禁止 ＝ 真
    设置超级按钮6.禁止 ＝ 真
    设置超级按钮7.禁止 ＝ 真
    批处理超级按钮1.禁止 ＝ 真
    批处理超级按钮2.禁止 ＝ 真
    批处理超级按钮3.禁止 ＝ 真
    批处理素人选择框.禁止 ＝ 真
    批处理欧美选择框.禁止 ＝ 真
    批处理国产选择框.禁止 ＝ 真
    批处理有码选择框.禁止 ＝ 真
    批处理无码选择框.禁止 ＝ 真
    批处理中字选择框.禁止 ＝ 真
    批处理HD选择框.禁止 ＝ 真
    批处理FHD选择框.禁止 ＝ 真
    批处理2K选择框.禁止 ＝ 真
    批处理4K选择框.禁止 ＝ 真
    加入已看选择框.禁止 ＝ 真
    关闭置剪贴板选择框.禁止 ＝ 真
    磁力链接包选择框.禁止 ＝ 真
    为影片刮削磁力按钮.禁止 ＝ 真
    色花超级列表框.禁止 ＝ 真
    色花超级列表框2.禁止 ＝ 真
    .如果 (设置外形框7.可视 ＝ 真)
        配置环境变量按钮.禁止 ＝ 真
        视频截图按钮.禁止 ＝ 真
        裁剪视频按钮.禁止 ＝ 真
        执行命令按钮.禁止 ＝ 真
        起始编辑框.禁止 ＝ 真
        结束编辑框.禁止 ＝ 真
        cmd命令编辑框.禁止 ＝ 真
        清空列表按钮.禁止 ＝ 真
        接收文件列表框.禁止 ＝ 真
        合并视频按钮.禁止 ＝ 真
    .否则

    .如果结束

.否则

.如果结束


.如果 (裁剪广告外形框.可视 ＝ 真)
    开始裁剪广告按钮.禁止 ＝ 真
    裁剪广告按钮.禁止 ＝ 真
    起始时间编辑框.禁止 ＝ 真
    结束时间编辑框.禁止 ＝ 真
.否则

.如果结束

.如果 (影片刮削分组框.可视 ＝ 真)
    开始刮削按钮.禁止 ＝ 真
.否则

.如果结束


.子程序 取禁
.局部变量 i, 整数型

.计次循环首 (24, i)
    动画框数组 [i].禁止 ＝ 假
.计次循环尾 ()
.计次循环首 (63, i)
    目录超级按钮数组 [i].禁止 ＝ 假
.计次循环尾 ()
.计次循环首 (10, i)
    文件夹超级按钮数组 [i].禁止 ＝ 假
.计次循环尾 ()
.计次循环首 (300, i)
    标签超级按钮数组 [i].禁止 ＝ 假
.计次循环尾 ()
搜索图形按钮.禁止 ＝ 假
搜索编辑框.禁止 ＝ 假
窗口_大小控制.禁止 ＝ 假
最大化.禁止 ＝ 假
最小化.禁止 ＝ 假
关闭.禁止 ＝ 假
设置.禁止 ＝ 假
截图.禁止 ＝ 假
左箭头.禁止 ＝ 假
右箭头.禁止 ＝ 假

刷新所有目录按钮.禁止 ＝ 假
.如果 (设置外形框.可视 ＝ 真)
    设置关闭按钮.禁止 ＝ 假
    设置超级按钮1.禁止 ＝ 假
    设置超级按钮2.禁止 ＝ 假
    设置超级按钮3.禁止 ＝ 假
    设置超级按钮4.禁止 ＝ 假
    设置超级按钮5.禁止 ＝ 假
    设置超级按钮6.禁止 ＝ 假
    设置超级按钮7.禁止 ＝ 假
    批处理超级按钮1.禁止 ＝ 假
    批处理超级按钮2.禁止 ＝ 假
    批处理超级按钮3.禁止 ＝ 假
    批处理素人选择框.禁止 ＝ 假
    批处理欧美选择框.禁止 ＝ 假
    批处理国产选择框.禁止 ＝ 假
    批处理有码选择框.禁止 ＝ 假
    批处理无码选择框.禁止 ＝ 假
    批处理中字选择框.禁止 ＝ 假
    批处理HD选择框.禁止 ＝ 假
    批处理FHD选择框.禁止 ＝ 假
    批处理2K选择框.禁止 ＝ 假
    批处理4K选择框.禁止 ＝ 假
    加入已看选择框.禁止 ＝ 假
    关闭置剪贴板选择框.禁止 ＝ 真
    磁力链接包选择框.禁止 ＝ 假
    为影片刮削磁力按钮.禁止 ＝ 假
    色花超级列表框.禁止 ＝ 假
    色花超级列表框2.禁止 ＝ 假
    .如果 (设置外形框7.可视 ＝ 真)
        配置环境变量按钮.禁止 ＝ 假
        视频截图按钮.禁止 ＝ 假
        裁剪视频按钮.禁止 ＝ 假
        执行命令按钮.禁止 ＝ 假
        起始编辑框.禁止 ＝ 假
        结束编辑框.禁止 ＝ 假
        cmd命令编辑框.禁止 ＝ 假
        清空列表按钮.禁止 ＝ 假
        接收文件列表框.禁止 ＝ 假
        合并视频按钮.禁止 ＝ 假
    .否则

    .如果结束


.否则

.如果结束

.如果 (裁剪广告外形框.可视 ＝ 真)
    开始裁剪广告按钮.禁止 ＝ 假
    裁剪广告按钮.禁止 ＝ 假
    起始时间编辑框.禁止 ＝ 假
    结束时间编辑框.禁止 ＝ 假
.否则

.如果结束

.如果 (影片刮削分组框.可视 ＝ 真)
    开始刮削按钮.禁止 ＝ 假
.否则

.如果结束


.子程序 _封面动画框0_物体右键被按下
.参数 物体标识值, 整数型
.局部变量 按钮_来源, 动画框
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (24, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        .如果 (搜索状态 ＝ 假)
            封面子项 ＝ 封面项 ＋ i
            弹出菜单 (封面操作, , )

        .否则
            搜索封面子项 ＝ 搜索封面项 ＋ i
            弹出菜单 (封面操作, , )

        .如果结束

    .默认

    .判断结束

.计次循环尾 ()


.子程序 _封面动画框0_物体左键被按下
.参数 物体标识值, 整数型
.局部变量 按钮_来源, 动画框
.局部变量 i, 整数型
.局部变量 翻译结果, 文本型

按钮_来源 ＝ 取事件组件 ()
.计次循环首 (24, i)
    .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
        .如果 (搜索状态 ＝ 假)
            封面子项 ＝ 封面项 ＋ i
            .如果 (封面子项 ≤ 取数组成员数 (影片))
                加载缩略图 ()
                缩略图分组框.可视 ＝ 真
                缩略图页数标签.标题 ＝ 到文本 (1) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
                页数标签.标题 ＝ 到文本 (封面子项) ＋ “/” ＋ 到文本 (取数组成员数 (影片))
                log (“打开：” ＋ 影片 [封面项 ＋ i].文件)
            .否则

            .如果结束

        .否则
            搜索封面子项 ＝ 搜索封面项 ＋ i
            .如果 (搜索封面子项 ≤ 取数组成员数 (搜索))
                加载缩略图 ()
                缩略图分组框.可视 ＝ 真
                缩略图页数标签.标题 ＝ 到文本 (1) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
                页数标签.标题 ＝ 到文本 (搜索封面子项) ＋ “/” ＋ 到文本 (取数组成员数 (搜索))
                log (“打开：” ＋ 搜索 [搜索封面子项].文件)
            .否则

            .如果结束

        .如果结束

    .默认

    .判断结束

.计次循环尾 ()
.如果 (开启实时翻译选择框.选中 ＝ 真)
    .如果 (百度翻译选择框.选中 ＝ 真)
        翻译结果 ＝ 百度翻译 (缩略图简介编辑框.内容)
        .如果 (翻译结果 ≠ “失败”)
            缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
        .否则

        .如果结束
        程序_延时 (1000)
        翻译结果 ＝ 百度翻译 (缩略图标题编辑框.内容)
        .如果 (翻译结果 ≠ “失败”)
            缩略图标题编辑框.内容 ＝ 翻译结果
        .否则

        .如果结束


    .否则
        .如果 (谷歌翻译选择框.选中 ＝ 真)
            翻译结果 ＝ 谷歌翻译 (缩略图简介编辑框.内容)
            .如果 (翻译结果 ≠ “”)
                缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
            .否则

            .如果结束
            翻译结果 ＝ 谷歌翻译 (缩略图标题编辑框.内容)
            .如果 (翻译结果 ≠ “”)
                缩略图标题编辑框.内容 ＝ 翻译结果
            .否则

            .如果结束

        .否则
            .如果 (必应翻译选择框.选中 ＝ 真)
                翻译结果 ＝ 必应翻译 (缩略图简介编辑框.内容)
                .如果 (翻译结果 ≠ “”)
                    缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
                .否则

                .如果结束
                翻译结果 ＝ 必应翻译 (缩略图标题编辑框.内容)
                .如果 (翻译结果 ≠ “”)
                    缩略图标题编辑框.内容 ＝ 翻译结果
                .否则

                .如果结束

            .否则

            .如果结束

        .如果结束

    .如果结束

.否则

.如果结束





.子程序 加载缩略图
.局部变量 临时fanart, 文本型
.局部变量 i, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 图片, 字节集
.局部变量 图片号, 整数型
.局部变量 磁力文本分割, 文本型, , "0"
.局部变量 宽, 整数型
.局部变量 高, 整数型

清除数组 (缩略图路径)
加入成员 (缩略图路径, “”)
缩略图页 ＝ 1
读入磁力文本 ＝ “”
.如果 (搜索状态 ＝ 假)
    标记收藏已看 (影片 [封面子项].nfo, “”)
    文件_枚举_升级版 (文件_取目录 (影片 [封面子项].文件), “txt”, 临时数组, 0, 假, 假)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            文件_取文件名 (临时数组 [i])
            .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “Torrent”, , 真) ≠ -1)
                读入磁力文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))

            .否则

            .如果结束

        .计次循环尾 ()

    .否则

    .如果结束
    .如果 (读入磁力文本 ≠ “”)
        磁力文本分割 ＝ 分割文本 (读入磁力文本, #换行符, )
        .计次循环首 (取数组成员数 (磁力文本分割), i)
            磁力文本分割 [i] ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<id>”, “<id>”) ＋ “|” ＋ 磁力文本分割 [i]
        .计次循环尾 ()
        批处理超级按钮14.标题 ＝ 到文本 (取数组成员数 (磁力文本分割)) ＋ “条磁力链接”
        批处理超级按钮14.可视 ＝ 真
    .否则
        批处理超级按钮14.可视 ＝ 假
    .如果结束
    清除数组 (临时数组)
    文件_枚举_升级版 (文件_取目录 (影片 [封面子项].文件), #图片格式, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        临时fanart ＝ “空”
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “fanart”, , 真) ≠ -1)
                临时fanart ＝ 临时数组 [i]
            .否则
                .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “poster”, , 真) ≠ -1)

                .否则
                    加入成员 (缩略图路径, 临时数组 [i])
                .如果结束

            .如果结束


        .计次循环尾 ()
    .否则
        临时fanart ＝ “空”
    .如果结束
    .如果 (临时fanart ≠ “空”)
        缩略图路径 [1] ＝ 临时fanart
        图片 ＝ 读入文件 (缩略图路径 [1])
        图片号 ＝ 载入图片 (图片)
        宽 ＝ 画板.取图片宽度 (图片号)
        高 ＝ 画板.取图片高度 (图片号)
        .如果 (高 ＞ 宽)
            图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
        .否则
            图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        .如果结束

        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .否则
        清除数组 (临时数组)
        .如果 (取数组成员数 (缩略图路径) ＞ 1)
            .计次循环首 (取数组成员数 (缩略图路径), i)
                .如果 (i ≠ 1)
                    加入成员 (临时数组, 缩略图路径 [i])
                .否则

                .如果结束

            .计次循环尾 ()
            清除数组 (缩略图路径)
            .计次循环首 (取数组成员数 (临时数组), i)
                加入成员 (缩略图路径, 临时数组 [i])
            .计次循环尾 ()
            清除数组 (临时数组)
        .否则

        .如果结束
        图片 ＝ 读入文件 (缩略图路径 [1])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )

    .如果结束
    缩略图标题编辑框.内容 ＝ 影片 [封面子项].标题
    清除数组 (临时数组)
    文件_枚举_升级版 (文件_取目录 (影片 [封面子项].文件), “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        获取nfo信息 (编码_Utf8到Ansi (读入文件 (临时数组 [1])))
    .否则

    .如果结束

.否则
    标记收藏已看 (搜索 [搜索封面子项].nfo, “”)
    文件_枚举_升级版 (文件_取目录 (搜索 [搜索封面子项].文件), “txt”, 临时数组, 0, 假, 假)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            文件_取文件名 (临时数组 [i])
            .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “Torrent”, , 真) ≠ -1)
                读入磁力文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))

            .否则

            .如果结束

        .计次循环尾 ()

    .否则

    .如果结束
    .如果 (读入磁力文本 ≠ “”)
        磁力文本分割 ＝ 分割文本 (读入磁力文本, #换行符, )
        .计次循环首 (取数组成员数 (磁力文本分割), i)
            磁力文本分割 [i] ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<id>”, “<id>”) ＋ “|” ＋ 磁力文本分割 [i]
        .计次循环尾 ()
        批处理超级按钮14.标题 ＝ 到文本 (取数组成员数 (磁力文本分割)) ＋ “条磁力链接”
        批处理超级按钮14.可视 ＝ 真
    .否则
        批处理超级按钮14.可视 ＝ 假
    .如果结束
    清除数组 (临时数组)
    文件_枚举_升级版 (文件_取目录 (搜索 [搜索封面子项].文件), #图片格式, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        临时fanart ＝ “空”
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “fanart”, , 真) ≠ -1)
                临时fanart ＝ 临时数组 [i]
            .否则
                .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “poster”, , 真) ≠ -1)

                .否则
                    加入成员 (缩略图路径, 临时数组 [i])
                .如果结束

            .如果结束


        .计次循环尾 ()
    .否则
        临时fanart ＝ “空”
    .如果结束
    .如果 (临时fanart ≠ “空”)
        缩略图路径 [1] ＝ 临时fanart
        图片 ＝ 读入文件 (缩略图路径 [1])
        图片号 ＝ 载入图片 (图片)
        宽 ＝ 画板.取图片宽度 (图片号)
        高 ＝ 画板.取图片高度 (图片号)
        .如果 (高 ＞ 宽)
            图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
        .否则
            图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        .如果结束
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .否则
        清除数组 (临时数组)
        .如果 (取数组成员数 (缩略图路径) ＞ 1)
            .计次循环首 (取数组成员数 (缩略图路径), i)
                .如果 (i ≠ 1)
                    加入成员 (临时数组, 缩略图路径 [i])
                .否则

                .如果结束

            .计次循环尾 ()
            清除数组 (缩略图路径)
            .计次循环首 (取数组成员数 (临时数组), i)
                加入成员 (缩略图路径, 临时数组 [i])
            .计次循环尾 ()
            清除数组 (临时数组)
        .否则

        .如果结束
        图片 ＝ 读入文件 (缩略图路径 [1])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .如果结束

    缩略图标题编辑框.内容 ＝ 搜索 [搜索封面子项].标题
    清除数组 (临时数组)
    文件_枚举_升级版 (文件_取目录 (搜索 [搜索封面子项].文件), “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        获取nfo信息 (编码_Utf8到Ansi (读入文件 (临时数组 [1])))
    .否则

    .如果结束


.如果结束


.子程序 _播放影片_被选择

.如果 (搜索状态 ＝ 假)
    .如果真 (加入已看选择框.选中 ＝ 假)
        标记 (“标记已看”)
        播放视频 (影片 [封面子项].文件)
    .如果真结束

    log (“播放影片：” ＋ 影片 [封面子项].文件)
.否则
    .如果真 (加入已看选择框.选中 ＝ 假)
        标记 (“标记已看”)
    .如果真结束
    播放视频 (搜索 [搜索封面子项].文件)
    log (“播放影片：” ＋ 搜索 [搜索封面子项].文件)
.如果结束


.子程序 _缩略图动画框_物体左键被按下
.参数 物体标识值, 整数型

缩略图分组框.可视 ＝ 假


.子程序 _搜索图形按钮_被单击

开始搜索 (“普通搜索”)

.子程序 开始搜索
.参数 文本, 文本型
.局部变量 r, 文本型
.局部变量 正则, 正则表达式类

.如果 (表格外形框.可视 ＝ 假)
    .如果真 (下拉图形按钮2.标题 ＝ “本地搜索”)

        .如果 (文本 ＝ “普通搜索”)
            .如果 (搜索状态 ＝ 假)
                .如果 (封面滚动状态 ≠ 真)
                    封面滚动状态 ＝ 真
                    搜索状态 ＝ 真
                    搜索图形按钮.标题 ＝ “返回”
                    标签分组框.可视 ＝ 假
                    目录分组框.可视 ＝ 假
                    缩略图分组框.可视 ＝ 假
                    封面分组框.可视 ＝ 真
                    搜索 ()

                .否则

                .如果结束





            .否则
                .如果 (封面滚动状态 ≠ 真)
                    封面滚动状态 ＝ 真
                    搜索状态 ＝ 假
                    搜索图形按钮.标题 ＝ “搜索”
                    排列封面标签 (1)
                .否则

                .如果结束

            .如果结束

        .否则
            .如果 (文本 ＝ “继续搜索”)
                .如果 (封面滚动状态 ≠ 真)
                    封面滚动状态 ＝ 真
                    搜索状态 ＝ 真
                    搜索图形按钮.标题 ＝ “返回”
                    标签分组框.可视 ＝ 假
                    目录分组框.可视 ＝ 假
                    缩略图分组框.可视 ＝ 假
                    封面分组框.可视 ＝ 真
                    搜索 ()

                .否则

                .如果结束

            .否则

            .如果结束


        .如果结束

    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “bus番号搜索”)
        打开网址 (bus网址 ＋ 搜索编辑框.内容)
    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “bus模糊搜索”)
        打开网址 (bus网址 ＋ “search/” ＋ 搜索编辑框.内容)
    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “javdb搜索”)
        打开网址 (javdb网址 ＋ “search?q=” ＋ 搜索编辑框.内容 ＋ “&f=all”)

    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “library搜索”)
        打开网址 (library网址 ＋ “cn/vl_searchbyid.php?keyword=” ＋ 搜索编辑框.内容)
    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “fc2番号搜索”)
        打开网址 (fc2网址 ＋ “article/” ＋ 搜索编辑框.内容 ＋ “/”)

    .如果真结束


    .如果真 (下拉图形按钮2.标题 ＝ “wiki辞典搜索”)
        打开网址 (wiki辞典网址 ＋ “search?keywords=” ＋ 编码_URL编码 (到文本 (编码_编码转换对象 (编码_Ansi到Utf8 (搜索编辑框.内容), #编码_UTF_8, #编码_EUC_JP))))
    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “色花模糊搜索”)
        打开网址 (色花网址 ＋ “search.php?mod=forumformhash=c134ac5d&srchtxt=” ＋ 编码_URL编码 (搜索编辑框.内容, , 真) ＋ “&searchsubmit=yes”)
    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “jav321搜索”)
        r ＝ 网页_访问S (“https://www.jav321.com/search”, 1, “sn=” ＋ 搜索编辑框.内容, , , , , , , , 代理IP, , , 10, , , , , , )
        .如果 (取文本长度 (r) ＞ 500)
            .如果 (文本_寻找文本 (r, “抱歉，未找到您要找的AV。”) ＝ -1)
                正则.创建 (#网址321, 到文本 (r))
                打开网址 (文本_取出中间文本 (正则.取匹配文本 (1), #网址321头, #网址321尾))
            .否则
                log (“未获取到网页，请重试。”)

            .如果结束

        .否则
            log (“无法打开网页，请先在<影片刮削>界面勾选代理并测试是否可连接。”)

        .如果结束

    .如果真结束

    .如果真 (下拉图形按钮2.标题 ＝ “db磁力搜索”)
        线程_启动 (&获取db磁力2)

    .如果真结束


    .如果真 (下拉图形按钮2.标题 ＝ “bus磁力搜索”)
        线程_启动 (&磁力搜索)

    .如果真结束

.否则

    .如果 (搜索图形按钮.标题 ＝ “搜索”)
        .如果 (取数组成员数 (色花行数组) ≠ 0)
            搜索图形按钮.标题 ＝ “返回”
            线程_启动 (&色花搜索)
        .否则
            log (“未加载本地文本包，请先点击按钮加载。”)
        .如果结束

    .否则
        色花超级列表框.可视 ＝ 真
        色花超级列表框2.可视 ＝ 假
        搜索图形按钮.标题 ＝ “搜索”
    .如果结束

.如果结束


.子程序 打开网址
.参数 网址, 文本型

.如果 (内置浏览器选择框.选中 ＝ 真)
    影片刮削分组框.可视 ＝ 真
.否则
    打开指定网址 (网址)
.如果结束



.子程序 磁力搜索
.参数 参数, 整数型
.参数 传入文本, 文本型
.局部变量 分割文本, 文本型, , "0"
.局部变量 文本, 文本型
.局部变量 i, 整数型
.局部变量 分割文本2, 文本型, , "0"
.局部变量 k, 整数型
.局部变量 s, 整数型
.局部变量 搜索框内容, 文本型
.局部变量 写出文本, 文本型

log (“磁力搜索中，请等待...”)
.如果 (参数 ＝ 1)
    禁止 ()
    .如果 (传入文本 ≠ “”)
        磁力高级表格.清空数据 ()
        磁力高级表格.置列宽 (0, 80)
        磁力高级表格.置列宽 (1, 100)
        磁力高级表格.置列宽 (2, 80)
        磁力高级表格.置列宽 (3, 80)
        磁力高级表格.置列宽 (4, 300)
        磁力高级表格.置列宽 (5, 80)
        磁力高级表格.置列宽 (6, 80)
        磁力高级表格.置数据 (0, 0, 1, “番号”)
        磁力高级表格.置数据 (0, 1, 1, “片名”)
        磁力高级表格.置数据 (0, 2, 1, “大小”)
        磁力高级表格.置数据 (0, 3, 1, “日期”)
        磁力高级表格.置数据 (0, 4, 1, “磁力”)
        磁力高级表格.置数据 (0, 5, 1, “分辨率”)
        磁力高级表格.置数据 (0, 6, 1, “字幕”)
        s ＝ 0

        分割文本 ＝ 分割文本 (传入文本, #换行符, )
        .计次循环首 (取数组成员数 (分割文本), i)
            分割文本2 ＝ 分割文本 (分割文本 [i], “|”, )
            .计次循环首 (取数组成员数 (分割文本2), k)
                .如果 (搜索状态 ＝ 假)
                    磁力高级表格.置数据 (i, 0, 1, 文本_取出中间文本 (影片 [封面子项].nfo, “<id>”, “<id>”))
                .否则
                    磁力高级表格.置数据 (i, 0, 1, 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<id>”, “<id>”))
                .如果结束
                磁力高级表格.置数据 (i, k, 1, 分割文本2 [k])
            .计次循环尾 ()

        .计次循环尾 ()







        设置超级按钮 (1)
        设置透明度 ()
        log (“磁力搜索完成。”)
    .否则
        log (“未搜索到磁力链接。”)
    .如果结束

.否则

    禁止 ()
    .如果 (磁力链接包选择框.选中 ＝ 假)
        搜索框内容 ＝ 到大写 (搜索编辑框.内容)
        文本 ＝ 获取磁力链接 (搜索框内容)
        处理事件 ()
        .如果 (文本 ≠ “”)
            磁力高级表格.清空数据 ()
            磁力高级表格.置列宽 (0, 80)
            磁力高级表格.置列宽 (1, 100)
            磁力高级表格.置列宽 (2, 80)
            磁力高级表格.置列宽 (3, 80)
            磁力高级表格.置列宽 (4, 300)
            磁力高级表格.置列宽 (5, 80)
            磁力高级表格.置列宽 (6, 80)
            磁力高级表格.置数据 (0, 0, 1, “番号”)
            磁力高级表格.置数据 (0, 1, 1, “片名”)
            磁力高级表格.置数据 (0, 2, 1, “大小”)
            磁力高级表格.置数据 (0, 3, 1, “日期”)
            磁力高级表格.置数据 (0, 4, 1, “磁力”)
            磁力高级表格.置数据 (0, 5, 1, “分辨率”)
            磁力高级表格.置数据 (0, 6, 1, “字幕”)
            s ＝ 0

            .如果 (菜单磁力状态 ＝ 真)
                .如果 (搜索状态 ＝ 假)
                    分割文本 ＝ 分割文本 (文本, #换行符, )
                    .计次循环首 (取数组成员数 (分割文本), i)
                        分割文本 [i] ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<id>”, “<id>”) ＋ “|” ＋ 分割文本 [i]
                        .如果 (i ＝ 1)
                            写出文本 ＝ 分割文本 [i]
                        .否则
                            写出文本 ＝ 写出文本 ＋ #换行符 ＋ 分割文本 [i]
                        .如果结束

                    .计次循环尾 ()
                    写到文件 (文件_取目录 (影片 [封面子项].文件) ＋ 文本_取出中间文本 (影片 [封面子项].nfo, “<id>”, “<id>”) ＋ “_bus_Torrent.txt”, 编码_Ansi到Utf8 (写出文本))
                .否则
                    分割文本 ＝ 分割文本 (文本, #换行符, )
                    .计次循环首 (取数组成员数 (分割文本), i)
                        分割文本 [i] ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<id>”, “<id>”) ＋ “|” ＋ 分割文本 [i]
                        .如果 (i ＝ 1)
                            写出文本 ＝ 分割文本 [i]
                        .否则
                            写出文本 ＝ 写出文本 ＋ #换行符 ＋ 分割文本 [i]
                        .如果结束

                    .计次循环尾 ()
                    写到文件 (文件_取目录 (搜索 [搜索封面子项].文件) ＋ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<id>”, “<id>”) ＋ “_bus_Torrent.txt”, 编码_Ansi到Utf8 (写出文本))
                .如果结束

            .否则
                分割文本 ＝ 分割文本 (文本, #换行符, )
                .计次循环首 (取数组成员数 (分割文本), i)
                    分割文本 [i] ＝ 搜索编辑框.内容 ＋ 分割文本 [i]
                .计次循环尾 ()

            .如果结束


            .计次循环首 (取数组成员数 (分割文本), i)
                分割文本2 ＝ 分割文本 (分割文本 [i], “|”, )
                .计次循环首 (取数组成员数 (分割文本2), k)
                    磁力高级表格.置数据 (i, k － 1, 1, 分割文本2 [k])
                .计次循环尾 ()

            .计次循环尾 ()







            设置超级按钮 (1)
            设置透明度 ()
            log (“磁力搜索完成。”)
        .否则
            log (“未搜索到磁力链接。”)
        .如果结束

    .否则
        磁力高级表格.清空数据 ()
        磁力高级表格.置列宽 (0, 80)
        磁力高级表格.置列宽 (1, 100)
        磁力高级表格.置列宽 (2, 80)
        磁力高级表格.置列宽 (3, 80)
        磁力高级表格.置列宽 (4, 300)
        磁力高级表格.置列宽 (5, 80)
        磁力高级表格.置列宽 (6, 80)
        磁力高级表格.置数据 (0, 0, 1, “番号”)
        磁力高级表格.置数据 (0, 1, 1, “片名”)
        磁力高级表格.置数据 (0, 2, 1, “大小”)
        磁力高级表格.置数据 (0, 3, 1, “日期”)
        磁力高级表格.置数据 (0, 4, 1, “磁力”)
        磁力高级表格.置数据 (0, 5, 1, “分辨率”)
        磁力高级表格.置数据 (0, 6, 1, “字幕”)
        s ＝ 0
        搜索框内容 ＝ 到大写 (搜索编辑框.内容)
        .计次循环首 (取数组成员数 (磁力文本数组), i)
            .如果 (文本_寻找文本 (磁力文本数组 [i], 搜索框内容, , 真) ≠ -1)
                s ＝ s ＋ 1
                .如果 (s ≥ 100)
                    磁力高级表格.插入行 (, s)
                .否则

                .如果结束
                分割文本2 ＝ 分割文本 (磁力文本数组 [i], “|”, )
                .计次循环首 (取数组成员数 (分割文本2), k)
                    磁力高级表格.置数据 (s, k － 1, 1, 分割文本2 [k])
                .计次循环尾 ()
            .否则

            .如果结束

        .计次循环尾 ()


        设置超级按钮 (1)
        设置透明度 ()
        log (“磁力搜索完成。”)

    .如果结束

.如果结束












菜单磁力状态 ＝ 假
取禁 ()


.子程序 搜索返回


.如果 (搜索状态 ＝ 真)
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        搜索状态 ＝ 假
        搜索图形按钮.标题 ＝ “搜索”
        排列封面标签 (1)
    .否则

    .如果结束


.否则

.如果结束


.子程序 搜索
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 计数, 整数型
.局部变量 表项索引, 整数型
.局部变量 分割, 文本型, , "0"
.局部变量 图片, 字节集
.局部变量 关键词, 文本型
.局部变量 记录A, 文本型
.局部变量 记录B, 文本型
.局部变量 记录C, 文本型
.局部变量 临时文件, 文本型, , "0"
.局部变量 临时nfo, 文本型, , "0"
.局部变量 临时标题, 文本型, , "0"
.局部变量 临时番号, 文本型, , "0"
.局部变量 临时日期, 文本型, , "0"
.局部变量 临时整数, 整数型, , "0"
.局部变量 临时标签, 文本型, , "0"
.局部变量 临时演员, 文本型, , "0"

关键词 ＝ 搜索编辑框.内容
.如果 (文本_寻找文本 (搜索历史记录, 关键词, , 真) ＝ -1)
    k ＝ 30
    .计次循环首 (30, i)
        记录A ＝ 文本_取出中间文本 (搜索历史记录, “<” ＋ 到文本 (k) ＋ “>”, “<” ＋ 到文本 (k) ＋ “>”)
        .如果 (k ≠ 1)
            记录B ＝ 文本_取出中间文本 (搜索历史记录, “<” ＋ 到文本 (k － 1) ＋ “>”, “<” ＋ 到文本 (k － 1) ＋ “>”)
            搜索历史记录 ＝ 文本_替换 (搜索历史记录, , , , “<” ＋ 到文本 (k) ＋ “>” ＋ 记录A ＋ “<” ＋ 到文本 (k) ＋ “>”, “<” ＋ 到文本 (k) ＋ “>” ＋ 记录B ＋ “<” ＋ 到文本 (k) ＋ “>”)
        .否则
            搜索历史记录 ＝ 文本_替换 (搜索历史记录, , , , “<” ＋ 到文本 (k) ＋ “>” ＋ 记录A ＋ “<” ＋ 到文本 (k) ＋ “>”, “<” ＋ 到文本 (k) ＋ “>” ＋ 关键词 ＋ “<” ＋ 到文本 (k) ＋ “>”)
        .如果结束
        k ＝ k － 1
    .计次循环尾 ()
    写配置项 (根目录 ＋ “配置\配置.ini”, “搜索”, “历史记录”, 搜索历史记录)

.否则

.如果结束
搜索封面项 ＝ 0

清除数组 (临时文件)
清除数组 (临时nfo)
清除数组 (临时标题)
清除数组 (临时番号)
清除数组 (临时日期)
清除数组 (临时整数)
清除数组 (临时标签)
清除数组 (临时演员)

取耗时 (1)
.计次循环首 (取数组成员数 (影片), i)
    计数 ＝ 0
    .如果 (文本_寻找文本 (关键词, “/”, , 真) ≠ -1)
        文本_分割文本 (关键词, “/”, , 分割)
        .计次循环首 (取数组成员数 (分割), k)
            .如果 (文本_寻找文本 (文本_到大写 (影片 [i].nfo), 文本_到大写 (分割 [k]), , 真) ≠ -1)
                计数 ＝ 计数 ＋ 1
            .否则

            .如果结束

        .计次循环尾 ()

        .如果 (计数 ＝ 取数组成员数 (分割))
            加入成员 (临时文件, 影片 [i].文件)
            加入成员 (临时nfo, 影片 [i].nfo)
            加入成员 (临时标题, 影片 [i].标题)
            加入成员 (临时番号, 影片 [i].番号)
            加入成员 (临时日期, 影片 [i].日期)
            加入成员 (临时整数, 影片 [i].整数)
        .否则

        .如果结束

    .否则
        .如果 (文本_寻找文本 (文本_到大写 (影片 [i].nfo), 文本_到大写 (关键词), , 真) ≠ -1)
            加入成员 (临时文件, 影片 [i].文件)
            加入成员 (临时nfo, 影片 [i].nfo)
            加入成员 (临时标题, 影片 [i].标题)
            加入成员 (临时番号, 影片 [i].番号)
            加入成员 (临时日期, 影片 [i].日期)
            加入成员 (临时整数, 影片 [i].整数)
        .否则

        .如果结束

    .如果结束

.计次循环尾 ()
重定义数组 (搜索, 假, 取数组成员数 (临时文件))

.计次循环首 (取数组成员数 (临时文件), i)
    搜索 [i].文件 ＝ 临时文件 [i]
    搜索 [i].nfo ＝ 临时nfo [i]
    搜索 [i].标题 ＝ 临时标题 [i]
    搜索 [i].番号 ＝ 临时番号 [i]
    搜索 [i].日期 ＝ 临时日期 [i]
    搜索 [i].整数 ＝ 临时整数 [i]
.计次循环尾 ()

排列封面标签 (1)
log (“搜索完成，” ＋ 取耗时 (2))


.子程序 _搜索编辑框_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型

.如果 (键代码 ＝ 13)
    开始搜索 (“普通搜索”)

.否则

.如果结束


.子程序 _删除影片_被选择
.局部变量 目录路径文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 读入文本, 文本型


.如果 (关闭删除文件提示选择框.选中 ＝ 真)
    .如果 (搜索状态 ＝ 假)
        删除目录 (文件_取目录 (影片 [封面子项].文件))
        目录路径文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<mulu>”, “<mulu>”)
        写出文本 ＝ 影片 [封面子项].nfo
        写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
        读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
        读入文本 ＝ 文本_替换 (读入文本, , , , 影片 [封面子项].文件 ＋ “|” ＋ 写出文本, “”)
        写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
        log (“已删除目录：” ＋ 影片 [封面子项].文件)
    .否则

        删除目录 (文件_取目录 (搜索 [搜索封面子项].文件))
        目录路径文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<mulu>”, “<mulu>”)
        写出文本 ＝ 搜索 [搜索封面子项].nfo
        写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
        读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
        读入文本 ＝ 文本_替换 (读入文本, , , , 搜索 [搜索封面子项].文件 ＋ “|” ＋ 写出文本, “”)
        写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
        log (“已删除目录：” ＋ 搜索 [搜索封面子项].文件)

    .如果结束

.否则
    .如果 (信息框 (#删除影片提示, 4 ＋ 48, “【删除影片提示】”, ) ＝ 5)
        .如果 (搜索状态 ＝ 假)
            删除目录 (文件_取目录 (影片 [封面子项].文件))
            目录路径文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<mulu>”, “<mulu>”)
            写出文本 ＝ 影片 [封面子项].nfo
            写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
            读入文本 ＝ 文本_替换 (读入文本, , , , 影片 [封面子项].文件 ＋ “|” ＋ 写出文本, “”)
            写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
            log (“已删除目录：” ＋ 影片 [封面子项].文件)
        .否则

            删除目录 (文件_取目录 (搜索 [搜索封面子项].文件))
            目录路径文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<mulu>”, “<mulu>”)
            写出文本 ＝ 搜索 [搜索封面子项].nfo
            写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
            读入文本 ＝ 文本_替换 (读入文本, , , , 搜索 [搜索封面子项].文件 ＋ “|” ＋ 写出文本, “”)
            写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
            log (“已删除目录：” ＋ 搜索 [搜索封面子项].文件)

        .如果结束

    .否则
        log (“取消删除文件。”)
    .如果结束

.如果结束



.子程序 _缩略图动画框_物体右键被按下
.参数 物体标识值, 整数型
.局部变量 按钮_来源, 动画框
.局部变量 i, 整数型

.如果 (搜索状态 ＝ 假)
    弹出菜单 (封面操作, , )
.否则
    弹出菜单 (封面操作, , )
.如果结束






.子程序 _缩略图动画框_滚轮被滚动, 逻辑型
.参数 滚动距离, 整数型
.参数 功能键状态, 整数型
.局部变量 图片, 字节集
.局部变量 图片号, 整数型
.局部变量 宽, 整数型
.局部变量 高, 整数型


.如果 (取数组成员数 (缩略图路径) ＞ 1)

    .如果 (滚动距离 ＝ -1)
        缩略图页 ＝ 缩略图页 ＋ 1
        .如果 (缩略图页 ≤ 取数组成员数 (缩略图路径))
            缩略图页数标签.标题 ＝ 到文本 (缩略图页) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果 (高 ＞ 宽)
                图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
            .否则
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
            .如果结束
            缩略图动画框.置图片 (缩略图动画框标识, 图片, )


        .否则
            缩略图页 ＝ 1
            缩略图页数标签.标题 ＝ 到文本 (1) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果 (高 ＞ 宽)
                图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
            .否则
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
            .如果结束
            缩略图动画框.置图片 (缩略图动画框标识, 图片, )


        .如果结束

    .否则
        缩略图页 ＝ 缩略图页 － 1
        .如果 (缩略图页 ≥ 1)
            缩略图页数标签.标题 ＝ 到文本 (缩略图页) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果 (高 ＞ 宽)
                图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
            .否则
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
            .如果结束
            缩略图动画框.置图片 (缩略图动画框标识, 图片, )

        .否则
            缩略图页 ＝ 取数组成员数 (缩略图路径)
            缩略图页数标签.标题 ＝ 到文本 (取数组成员数 (缩略图路径)) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果 (高 ＞ 宽)
                图片 ＝ 图片_缩放_透明 (图片, 宽 × 540 ÷ 高, 540)
            .否则
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
            .如果结束
            缩略图动画框.置图片 (缩略图动画框标识, 图片, )


        .如果结束

    .如果结束

.否则

.如果结束


.子程序 _打开路径_被选择


.如果 (搜索状态 ＝ 假)
    执行 (, 文件_取目录 (影片 [封面子项].文件), , , )
    log (“打开影片文件夹：” ＋ 文件_取目录 (影片 [封面子项].文件))
.否则

    执行 (, 文件_取目录 (搜索 [搜索封面子项].文件), , , )
    log (“打开影片文件夹：” ＋ 文件_取目录 (搜索 [搜索封面子项].文件))
.如果结束



.子程序 _屏蔽目录_被选择
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

文件_改名 (目录数组 [目录项], 文件_取目录 (目录数组 [目录项]) ＋ 文件_取文件名 (目录数组 [目录项]) ＋ “#.txt”)
读取目录 ()
排列封面标签 (1)
log (“屏蔽目录完成，所有影片和标签管理内将不再显示此目录的影片和标签。”)

.子程序 _屏蔽取消_被选择
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

.如果真 (取文本右边 (文件_取文件名 (目录数组 [目录项]), 1) ＝ “#”)
    文件_改名 (目录数组 [目录项], 文件_取目录 (目录数组 [目录项]) ＋ 文本_删右边 (文件_取文件名 (目录数组 [目录项]), 1) ＋ “.txt”)
.如果真结束
读取目录 ()
排列封面标签 (1)
log (“取消屏蔽目录，所有影片和标签管理内将显示此目录的影片和标签。”)


.子程序 _设置背景_被选择
.局部变量 临时fanart, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型

.' 如果 (缩略图分组框.可视 ＝ 真)
    .' 如果 (搜索状态 ＝ 假)
        ' 文件_复制 (缩略图路径 [缩略图页], 根目录 ＋ “图片\背景图片.jpg”)
        ' log (“设置图片为程序背景图：” ＋ 缩略图路径 [缩略图页])
    .否则
        ' 文件_复制 (缩略图路径 [缩略图页], 根目录 ＋ “图片\背景图片.jpg”)
        ' log (“设置图片为程序背景图：” ＋ 缩略图路径 [缩略图页])
    .如果结束


.否则
    ' log (“请点击封面在缩略图内设置图片为程序背景图。”)
.如果结束


.子程序 _设置_被单击

批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_编辑框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_组合框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
log (“保存程序设置成功。”)

.子程序 _缩略图演员标签_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 菜单标题, 文本型
.局部变量 子菜单, 类_菜单
.局部变量 子菜单标题, 文本型

分割数组 ＝ 分割文本 (文本_替换 (缩略图演员标签.标题, , , , “演员：”, “”), “/”, )
.如果 (取数组成员数 (分割数组) ＞ 0)
    菜单.创建 (分割数组, , , )
    菜单标题 ＝ 菜单.取标题 ()
    .如果 (菜单标题 ≠ “”)
        搜索编辑框.内容 ＝ 菜单标题
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            搜索状态 ＝ 真
            搜索图形按钮.标题 ＝ “返回”
            缩略图分组框.可视 ＝ 假
            搜索 ()

        .否则

        .如果结束

    .否则

    .如果结束

.否则


.如果结束


.子程序 _缩略图类别标签_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 菜单标题, 文本型
.局部变量 子菜单, 类_菜单
.局部变量 子菜单标题, 文本型

分割数组 ＝ 分割文本 (文本_替换 (缩略图类别标签.标题, , , , “类别：”, “”), “/”, )
.如果 (取数组成员数 (分割数组) ＞ 0)
    菜单.创建 (分割数组, , , )
    菜单标题 ＝ 菜单.取标题 ()
    .如果 (菜单标题 ≠ “”)
        搜索编辑框.内容 ＝ 菜单标题
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            搜索状态 ＝ 真
            搜索图形按钮.标题 ＝ “返回”
            线程_启动 (&搜索, )
            缩略图分组框.可视 ＝ 假
        .否则

        .如果结束



    .否则

    .如果结束


.否则

.如果结束


.子程序 _标签超级按钮0_被单击
.局部变量 按钮_来源, 超级按钮
.局部变量 i, 整数型

按钮_来源 ＝ 取事件组件 ()
.如果真 (标签演员状态 ＝ “标签真”)
    .计次循环首 (300, i)
        .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
            .如果 (标签项 ＝ -1)
                标签项 ＝ 0
                标签子项 ＝ 0
                排列封面标签 (1)

            .否则
                .如果 (标签子项 ＋ i ≤ 取数组成员数 (影片标签))
                    搜索编辑框.内容 ＝ 影片标签 [标签子项 ＋ i]
                    开始搜索 (“继续搜索”)
                .否则
                    标签项 ＝ 0
                    标签子项 ＝ 0
                    排列封面标签 (1)
                .如果结束


            .如果结束


        .默认

        .判断结束

    .计次循环尾 ()


.如果真结束

.如果真 (标签演员状态 ＝ “演员真”)
    .计次循环首 (300, i)
        .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
            .如果 (演员项 ＝ -1)
                演员项 ＝ 0
                演员子项 ＝ 0
                排列封面标签 (1)

            .否则
                .如果 (演员子项 ＋ i ≤ 取数组成员数 (影片演员))
                    搜索编辑框.内容 ＝ 影片演员 [演员子项 ＋ i]
                    开始搜索 (“继续搜索”)
                .否则
                    演员项 ＝ 0
                    演员子项 ＝ 0
                    排列封面标签 (1)
                .如果结束


            .如果结束


        .默认

        .判断结束

    .计次循环尾 ()


.如果真结束



.子程序 _标签超级按钮0_滚轮被滚动, 逻辑型
.参数 滚动距离, 整数型
.参数 功能键状态, 整数型

.如果真 (标签演员状态 ＝ “标签真”)
    .如果 (滚动距离 ＝ -1)
        标签项 ＝ 标签项 ＋ 1
    .否则
        标签项 ＝ 标签项 － 1


    .如果结束


    .如果 (标签项 ≤ 0)
        标签项 ＝ 0
        标签子项 ＝ 0
    .否则

    .如果结束

    排列封面标签 (1)


.如果真结束

.如果真 (标签演员状态 ＝ “演员真”)
    .如果 (滚动距离 ＝ -1)
        演员项 ＝ 演员项 ＋ 1
    .否则
        演员项 ＝ 演员项 － 1


    .如果结束


    .如果 (演员项 ≤ 0)
        演员项 ＝ 0
        演员子项 ＝ 0
    .否则

    .如果结束

    排列封面标签 (1)


.如果真结束




.子程序 _标记已看_被选择

标记 (“标记已看”)


.子程序 _取消已看_被选择

标记 (“取消标记已看”)

.子程序 _标记收藏_被选择


标记 (“标记收藏”)

.子程序 _取消收藏_被选择

标记 (“取消标记收藏”)

.子程序 标记
.参数 标记内容, 文本型
.局部变量 目录数组文本, 文本型
.局部变量 读入文本, 文本型
.局部变量 临时nfo数组, 文本型, , "0"
.局部变量 nfo读入文本, 文本型
.局部变量 nfovideogo文本, 文本型
.局部变量 yk文本, 文本型
.局部变量 nfovideogo文本2, 文本型
.局部变量 写出文本, 文本型
.局部变量 耗时1, 整数型
.局部变量 临时文本, 文本型
.局部变量 i, 整数型
.局部变量 临时项, 整数型
.局部变量 标记前缀, 文本型
.局部变量 标记状态, 文本型
.局部变量 标记状态2, 文本型

.如果真 (标记内容 ＝ “标记已看”)
    标记前缀 ＝ “[yk]”
    标记状态 ＝ “真”
    标记状态2 ＝ “假”
.如果真结束
.如果真 (标记内容 ＝ “取消标记已看”)
    标记前缀 ＝ “[yk]”
    标记状态 ＝ “假”
    标记状态2 ＝ “真”
.如果真结束
.如果真 (标记内容 ＝ “标记收藏”)
    标记前缀 ＝ “[sc]”
    标记状态 ＝ “真”
    标记状态2 ＝ “假”
.如果真结束
.如果真 (标记内容 ＝ “取消标记收藏”)
    标记前缀 ＝ “[sc]”
    标记状态 ＝ “假”
    标记状态2 ＝ “真”


.如果真结束


.如果 (搜索状态 ＝ 假)
    取耗时 (1)
    文件_枚举_升级版 (影片 [封面子项].目录, “nfo”, 临时nfo数组, 0, 假, 假)
    .如果 (取数组成员数 (临时nfo数组) ＞ 0)
        nfo读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时nfo数组 [1]))
        .如果 (文本_取出现次数 (nfo读入文本, “?”) ＞ 150)
            nfo读入文本 ＝ 到文本 (读入文件 (临时nfo数组 [1]))
        .否则

        .如果结束

        nfovideogo文本 ＝ 文本_取出中间文本 (nfo读入文本, “<VideoGo>”, “</VideoGo>”, , 真)
        .如果 (nfovideogo文本 ≠ “”)
            yk文本 ＝ 文本_取出中间文本 (nfovideogo文本, 标记前缀, 标记前缀, , 真)
            .如果 (yk文本 ≠ 标记状态)
                nfovideogo文本2 ＝ 文本_替换 (nfovideogo文本, , , , 标记前缀 ＋ yk文本 ＋ 标记前缀, 标记前缀 ＋ 标记状态 ＋ 标记前缀)
                写出文本 ＝ 文本_替换 (nfo读入文本, , , , nfovideogo文本, nfovideogo文本2)
                写到文件 (临时nfo数组 [1], 编码_Ansi到Utf8 (写出文本))
            .否则

            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束
    目录数组文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<mulu>”, “<mulu>”)
    写出文本 ＝ 影片 [封面子项].nfo
    临时文本 ＝ 文本_取出中间文本 (写出文本, “<mulu>”, “<mulu>”)
    写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 临时文本 ＋ “<mulu>”, “”)
    影片 [封面子项].nfo ＝ 文本_替换 (影片 [封面子项].nfo, , , , 标记前缀 ＋ 标记状态2 ＋ 标记前缀, 标记前缀 ＋ 标记状态 ＋ 标记前缀)
    读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录数组文本))
    读入文本 ＝ 文本_替换 (读入文本, , , , 写出文本, 影片 [封面子项].nfo)
    写到文件 (目录数组文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
    读入文本 ＝ “”
    log (标记内容 ＋ “完成，” ＋ 取耗时 (2))
.否则
    取耗时 (1)
    文件_枚举_升级版 (搜索 [搜索封面子项].目录, “nfo”, 临时nfo数组, 0, 假, 假)
    .如果 (取数组成员数 (临时nfo数组) ＞ 0)
        nfo读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时nfo数组 [1]))
        .如果 (文本_取出现次数 (nfo读入文本, “?”) ＞ 150)
            nfo读入文本 ＝ 到文本 (读入文件 (临时nfo数组 [1]))
        .否则

        .如果结束

        nfovideogo文本 ＝ 文本_取出中间文本 (nfo读入文本, “<VideoGo>”, “</VideoGo>”, , 真)
        .如果 (nfovideogo文本 ≠ “”)
            yk文本 ＝ 文本_取出中间文本 (nfovideogo文本, 标记前缀, 标记前缀, , 真)
            .如果 (yk文本 ≠ 标记状态)
                nfovideogo文本2 ＝ 文本_替换 (nfovideogo文本, , , , 标记前缀 ＋ yk文本 ＋ 标记前缀, 标记前缀 ＋ 标记状态 ＋ 标记前缀)
                写出文本 ＝ 文本_替换 (nfo读入文本, , , , nfovideogo文本, nfovideogo文本2)
                写到文件 (临时nfo数组 [1], 编码_Ansi到Utf8 (写出文本))
            .否则

            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束
    目录数组文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<mulu>”, “<mulu>”)
    写出文本 ＝ 搜索 [搜索封面子项].nfo
    临时文本 ＝ 文本_取出中间文本 (写出文本, “<mulu>”, “<mulu>”)
    写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 临时文本 ＋ “<mulu>”, “”)
    .计次循环首 (取数组成员数 (影片), i)
        .如果 (影片 [i].nfo ＝ 搜索 [搜索封面子项].nfo)
            临时项 ＝ i
            跳出循环 ()
        .否则

        .如果结束

    .计次循环尾 ()
    搜索 [搜索封面子项].nfo ＝ 文本_替换 (搜索 [搜索封面子项].nfo, , , , 标记前缀 ＋ 标记状态2 ＋ 标记前缀, 标记前缀 ＋ 标记状态 ＋ 标记前缀)
    影片 [临时项].nfo ＝ 搜索 [搜索封面子项].nfo
    读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录数组文本))
    读入文本 ＝ 文本_替换 (读入文本, , , , 写出文本, 搜索 [搜索封面子项].nfo)
    写到文件 (目录数组文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
    读入文本 ＝ “”
    log (标记内容 ＋ “完成，” ＋ 取耗时 (2))
.如果结束


.子程序 nfo编码转换
.局部变量 临时nfo数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

文件_枚举_升级版 (“X:\动画\动画\合集”, “nfo”, 临时nfo数组, 0, 假, 真)
.计次循环首 (取数组成员数 (临时nfo数组), i)

    写出文本 ＝ 编码_Utf8到Ansi (读入文件 (临时nfo数组 [i]))
    写到文件 (临时nfo数组 [i], 编码_Ansi到Utf8 (写出文本))
    log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时nfo数组)))
.计次循环尾 ()

.子程序 修改视频名称
.局部变量 临时nfo数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

.计次循环首 (取数组成员数 (影片), i)
    文件_枚举_升级版 (文件_取目录 (影片 [i].文件), “nfo”, 临时nfo数组, 0, 假, 真)
    .如果 (取数组成员数 (临时nfo数组) ＞ 0)
        写出文本 ＝ 编码_Utf8到Ansi (读入文件 (临时nfo数组 [i]))
        文件_改名 (影片 [i].文件, 文件_取目录 (影片 [i].文件) ＋ 文本_取出中间文本 (写出文本, “<id>”, “</id>”) ＋ “.mp4”)
    .否则

    .如果结束

    log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (影片)))
.计次循环尾 ()

.子程序 _打开文件_被选择

执行 (, 目录数组 [目录项], , , )
log (“打开索引文件：” ＋ 目录数组 [目录项])

.子程序 _添加文件夹_被选择

生成索引 (目录_浏览 (“生成索引 ”))

.子程序 _顶部横幅外形框_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果 (_启动窗口.宽度 ＝ 1230)
    _启动窗口.宽度 ＝ 1830
    _启动窗口.高度 ＝ 1020
.否则
    _启动窗口.宽度 ＝ 1230
    _启动窗口.高度 ＝ 720
.如果结束
排列封面标签 (1)


.子程序 _右箭头_被单击

.如果真 (标签演员状态 ＝ “标签真”)
    .如果 (封面分组框.可视 ＝ 真)
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            排列封面标签 (2)
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (标签分组框.可视 ＝ 真)
        标签项 ＝ 标签项 ＋ 1
        .如果 (标签项 ≤ 0)
            标签项 ＝ 0
            标签子项 ＝ 0
        .否则

        .如果结束
        排列封面标签 (1)

    .否则

    .如果结束

.如果真结束

.如果真 (标签演员状态 ＝ “演员真”)
    .如果 (封面分组框.可视 ＝ 真)
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            排列封面标签 (2)
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (标签分组框.可视 ＝ 真)
        演员项 ＝ 演员项 ＋ 1
        .如果 (演员项 ≤ 0)
            演员项 ＝ 0
            演员子项 ＝ 0
        .否则

        .如果结束
        排列封面标签 (1)

    .否则

    .如果结束

.如果真结束

.如果 (封面分组框.可视 ＝ 真)
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        排列封面标签 (2)
    .否则

    .如果结束

.否则

.如果结束






.子程序 _左箭头_被单击

.如果真 (标签演员状态 ＝ “标签真”)
    .如果 (封面分组框.可视 ＝ 真)
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            排列封面标签 (3)
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (标签分组框.可视 ＝ 真)
        标签项 ＝ 标签项 － 1
        .如果 (标签项 ≤ 0)
            标签项 ＝ 0
            标签子项 ＝ 0
        .否则

        .如果结束
        排列封面标签 (1)
    .否则

    .如果结束

.如果真结束

.如果真 (标签演员状态 ＝ “演员真”)
    .如果 (封面分组框.可视 ＝ 真)
        .如果 (封面滚动状态 ≠ 真)
            封面滚动状态 ＝ 真
            排列封面标签 (3)
        .否则

        .如果结束

    .否则

    .如果结束

    .如果 (标签分组框.可视 ＝ 真)
        演员项 ＝ 演员项 － 1
        .如果 (演员项 ≤ 0)
            演员项 ＝ 0
            演员子项 ＝ 0
        .否则

        .如果结束
        排列封面标签 (1)
    .否则

    .如果结束

.如果真结束

.如果 (封面分组框.可视 ＝ 真)
    .如果 (封面滚动状态 ≠ 真)
        封面滚动状态 ＝ 真
        排列封面标签 (3)
    .否则

    .如果结束

.否则

.如果结束




.子程序 _缩略图左箭头_被单击
.局部变量 图片, 字节集
.局部变量 图片号, 整数型

.如果 (取数组成员数 (缩略图路径) ＞ 1)
    缩略图页 ＝ 缩略图页 － 1
    .如果 (缩略图页 ≥ 1)
        缩略图页数标签.标题 ＝ 到文本 (缩略图页) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
        图片 ＝ 读入文件 (缩略图路径 [缩略图页])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .否则
        缩略图页 ＝ 取数组成员数 (缩略图路径)
        缩略图页数标签.标题 ＝ 到文本 (取数组成员数 (缩略图路径)) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
        图片 ＝ 读入文件 (缩略图路径 [缩略图页])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .如果结束

.否则

.如果结束


.子程序 _缩略图右箭头_被单击
.局部变量 图片, 字节集
.局部变量 图片号, 整数型

.如果 (取数组成员数 (缩略图路径) ＞ 1)
    缩略图页 ＝ 缩略图页 ＋ 1
    .如果 (缩略图页 ≤ 取数组成员数 (缩略图路径))
        缩略图页数标签.标题 ＝ 到文本 (缩略图页) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
        图片 ＝ 读入文件 (缩略图路径 [缩略图页])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .否则
        缩略图页 ＝ 1
        缩略图页数标签.标题 ＝ 到文本 (1) ＋ “/” ＋ 到文本 (取数组成员数 (缩略图路径))
        图片 ＝ 读入文件 (缩略图路径 [缩略图页])
        图片 ＝ 图片_缩放_透明 (图片, 800, 540)
        缩略图动画框.置图片 (缩略图动画框标识, 图片, )
    .如果结束

.否则

.如果结束


.子程序 为视频创建文件夹
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 临时数组2, 文本型, , "0"
.局部变量 i, 整数型

路径 ＝ 目录_浏览 (“为视频创建文件夹”)
文件_枚举_升级版 (路径, #视频格式, 临时数组, 0, 假, 真)
.计次循环首 (取数组成员数 (临时数组), i)
    清除数组 (临时数组2)

    文件_枚举_升级版 (文件_取目录 (临时数组 [i]), #视频格式, 临时数组2, 0, 假, 假)
    .如果 (取数组成员数 (临时数组2) ＞ 1)
        目录_创建 (文件_取目录 (临时数组 [i]) ＋ 文件_取文件名 (临时数组 [i]))
        文件_移动 (临时数组 [i], 文件_取目录 (临时数组 [i]) ＋ 文件_取文件名 (临时数组 [i]) ＋ “\” ＋ 文件_取文件名 (临时数组 [i]) ＋ 文件_取扩展名 (临时数组 [i]))


    .否则
        .如果 (目录_是否有子目录 (文件_取目录 (临时数组 [i])) ＝ 真)
            目录_创建 (文件_取目录 (临时数组 [i]) ＋ 文件_取文件名 (临时数组 [i]))
            文件_移动 (临时数组 [i], 文件_取目录 (临时数组 [i]) ＋ 文件_取文件名 (临时数组 [i]) ＋ “\” ＋ 文件_取文件名 (临时数组 [i]) ＋ 文件_取扩展名 (临时数组 [i]))
        .否则

        .如果结束

    .如果结束



    log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)))
.计次循环尾 ()

.子程序 _最小化_被单击

窗口_最小化 (_启动窗口.取窗口句柄 ())

.子程序 _修改nfo_被选择
.局部变量 临时数组, 文本型, , "0"

.如果 (搜索状态 ≠ 真)
    文件_枚举_升级版 (文件_取目录 (影片 [封面子项].文件), “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        执行 (, 临时数组 [1], , , )
        log (“打开nfo文件：” ＋ 临时数组 [1])

    .否则
        log (“此影片未找到nfo文件。”)
    .如果结束


.否则
    文件_枚举_升级版 (文件_取目录 (搜索 [搜索封面子项].文件), “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        执行 (, 临时数组 [1], , , )
        log (“打开nfo文件：” ＋ 临时数组 [1])

    .否则
        log (“此影片未找到nfo文件。”)
    .如果结束


.如果结束


.子程序 _设置关闭按钮_被单击

设置外形框.可视 ＝ 假
设置透明度 ()

.子程序 _裁剪中间_被选择

裁剪封面 (1)

.子程序 _裁左半边_被选择

裁剪封面 (2)

.子程序 _裁右半边_被选择

裁剪封面 (3)

.子程序 _裁左15_被选择

裁剪封面 (4)

.子程序 _裁左25_被选择

裁剪封面 (5)

.子程序 _裁左35_被选择

裁剪封面 (6)

.子程序 裁剪封面
.参数 尺寸, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 临时fanart, 文本型
.局部变量 临时poster, 文本型
.局部变量 i, 整数型
.局部变量 图片, 字节集
.局部变量 图片号, 整数型
.局部变量 宽, 整数型
.局部变量 高, 整数型

.如果 (搜索状态 ≠ 真)
    清除数组 (缩略图路径)
    加入成员 (缩略图路径, “”)
    文件_枚举_升级版 (文件_取目录 (影片 [封面子项].文件), #图片格式, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        临时fanart ＝ “空”
        临时poster ＝ “空”
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “fanart”, , 真) ≠ -1)
                临时fanart ＝ 临时数组 [i]
            .否则
                .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “poster”, , 真) ≠ -1)
                    临时poster ＝ 临时数组 [i]
                .否则
                    加入成员 (缩略图路径, 临时数组 [i])
                .如果结束

            .如果结束

        .计次循环尾 ()
    .否则

    .如果结束
    .如果 (缩略图分组框.可视 ≠ 真)
        .如果 (临时fanart ≠ “空”)
            缩略图路径 [1] ＝ 临时fanart
            图片 ＝ 读入文件 (缩略图路径 [1])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果真 (尺寸 ＝ 1)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 2)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 3)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 4)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 5)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 6)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果 (临时poster ≠ “空”)
                写到文件 (临时poster, 图片_转换Ex (图片, 2))
            .否则
                写到文件 (文本_替换 (临时fanart, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
            .如果结束
            图片 ＝ 图片_缩放_透明 (图片, 196, 280)
            动画框数组 [取整 (封面子项 － 封面项)].置图片 (动画框标识数组 [取整 (封面子项 － 封面项)], 图片, )
            卸载图片 (图片号)


        .否则

        .如果结束

    .否则
        .如果 (临时fanart ≠ “空”)
            缩略图路径 [1] ＝ 临时fanart
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果真 (尺寸 ＝ 1)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 2)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 3)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 4)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 5)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 6)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果 (临时poster ≠ “空”)
                写到文件 (临时poster, 图片_转换Ex (图片, 2))
            .否则
                写到文件 (文本_替换 (临时fanart, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
            .如果结束
            图片 ＝ 图片_缩放_透明 (图片, 196, 280)
            动画框数组 [取整 (封面子项 － 封面项)].置图片 (动画框标识数组 [取整 (封面子项 － 封面项)], 图片, )
            卸载图片 (图片号)


        .否则
            清除数组 (临时数组)
            .如果 (取数组成员数 (缩略图路径) ＞ 1)
                .计次循环首 (取数组成员数 (缩略图路径), i)
                    .如果 (i ≠ 1)
                        加入成员 (临时数组, 缩略图路径 [i])
                    .否则

                    .如果结束

                .计次循环尾 ()
                清除数组 (缩略图路径)
                .计次循环首 (取数组成员数 (临时数组), i)
                    加入成员 (缩略图路径, 临时数组 [i])
                .计次循环尾 ()
                清除数组 (临时数组)

                图片 ＝ 读入文件 (缩略图路径 [缩略图页])
                图片号 ＝ 载入图片 (图片)
                宽 ＝ 画板.取图片宽度 (图片号)
                高 ＝ 画板.取图片高度 (图片号)
                .如果真 (尺寸 ＝ 1)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 2)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 3)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 4)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 5)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 6)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果 (临时poster ≠ “空”)
                    写到文件 (临时poster, 图片_转换Ex (图片, 2))
                .否则
                    写到文件 (文件_取目录 (缩略图路径 [缩略图页]) ＋ 文件_取文件名 (缩略图路径 [缩略图页]) ＋ “-poster.jpg”, 图片_转换Ex (图片, 2))
                .如果结束
                图片 ＝ 图片_缩放_透明 (图片, 196, 280)
                动画框数组 [取整 (封面子项 － 封面项)].置图片 (动画框标识数组 [取整 (封面子项 － 封面项)], 图片, )
                卸载图片 (图片号)


            .否则

            .如果结束

        .如果结束

    .如果结束


    .如果 (缩略图分组框.可视 ＝ 真)
        缩略图分组框.可视 ＝ 假
    .否则

    .如果结束

.否则
    清除数组 (缩略图路径)
    加入成员 (缩略图路径, “”)
    文件_枚举_升级版 (文件_取目录 (搜索 [搜索封面子项].文件), #图片格式, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        临时fanart ＝ “空”
        临时poster ＝ “空”
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “fanart”, , 真) ≠ -1)
                临时fanart ＝ 临时数组 [i]
            .否则
                .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “poster”, , 真) ≠ -1)
                    临时poster ＝ 临时数组 [i]
                .否则
                    加入成员 (缩略图路径, 临时数组 [i])
                .如果结束

            .如果结束

        .计次循环尾 ()
    .否则

    .如果结束
    .如果 (缩略图分组框.可视 ≠ 真)
        .如果 (临时fanart ≠ “空”)
            缩略图路径 [1] ＝ 临时fanart
            图片 ＝ 读入文件 (缩略图路径 [1])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果真 (尺寸 ＝ 1)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 2)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 3)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 4)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 5)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 6)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果 (临时poster ≠ “空”)
                写到文件 (临时poster, 图片_转换Ex (图片, 2))
            .否则
                写到文件 (文本_替换 (临时fanart, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
            .如果结束
            图片 ＝ 图片_缩放_透明 (图片, 196, 280)
            动画框数组 [取整 (搜索封面子项 － 搜索封面项)].置图片 (动画框标识数组 [取整 (搜索封面子项 － 搜索封面项)], 图片, )
            卸载图片 (图片号)


        .否则

        .如果结束

    .否则
        .如果 (临时fanart ≠ “空”)
            缩略图路径 [1] ＝ 临时fanart
            图片 ＝ 读入文件 (缩略图路径 [缩略图页])
            图片号 ＝ 载入图片 (图片)
            宽 ＝ 画板.取图片宽度 (图片号)
            高 ＝ 画板.取图片高度 (图片号)
            .如果真 (尺寸 ＝ 1)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 2)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 3)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 4)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 5)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果真 (尺寸 ＝ 6)
                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
            .如果真结束
            .如果 (临时poster ≠ “空”)
                写到文件 (临时poster, 图片_转换Ex (图片, 2))
            .否则
                写到文件 (文本_替换 (临时fanart, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
            .如果结束
            图片 ＝ 图片_缩放_透明 (图片, 196, 280)
            动画框数组 [取整 (搜索封面子项 － 搜索封面项)].置图片 (动画框标识数组 [取整 (搜索封面子项 － 搜索封面项)], 图片, )
            卸载图片 (图片号)


        .否则
            清除数组 (临时数组)
            .如果 (取数组成员数 (缩略图路径) ＞ 1)
                .计次循环首 (取数组成员数 (缩略图路径), i)
                    .如果 (i ≠ 1)
                        加入成员 (临时数组, 缩略图路径 [i])
                    .否则

                    .如果结束

                .计次循环尾 ()
                清除数组 (缩略图路径)
                .计次循环首 (取数组成员数 (临时数组), i)
                    加入成员 (缩略图路径, 临时数组 [i])
                .计次循环尾 ()
                清除数组 (临时数组)

                图片 ＝ 读入文件 (缩略图路径 [缩略图页])
                图片号 ＝ 载入图片 (图片)
                宽 ＝ 画板.取图片宽度 (图片号)
                高 ＝ 画板.取图片高度 (图片号)
                .如果真 (尺寸 ＝ 1)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 4, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 2)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 0, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 3)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 20, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 4)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 5)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 2, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果真 (尺寸 ＝ 6)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 5 × 3, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .如果真结束
                .如果 (临时poster ≠ “空”)
                    写到文件 (临时poster, 图片_转换Ex (图片, 2))
                .否则
                    写到文件 (文件_取目录 (缩略图路径 [缩略图页]) ＋ 文件_取文件名 (缩略图路径 [缩略图页]) ＋ “-poster.jpg”, 图片_转换Ex (图片, 2))
                .如果结束
                图片 ＝ 图片_缩放_透明 (图片, 196, 280)
                动画框数组 [取整 (搜索封面子项 － 搜索封面项)].置图片 (动画框标识数组 [取整 (搜索封面子项 － 搜索封面项)], 图片, )
                卸载图片 (图片号)


            .否则

            .如果结束

        .如果结束

    .如果结束


    .如果 (缩略图分组框.可视 ＝ 真)
        缩略图分组框.可视 ＝ 假
    .否则

    .如果结束

.如果结束



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

缩略图分组框.可视 ＝ 假

.子程序 _播放按钮_被单击

.如果 (搜索状态 ＝ 假)
    .如果真 (加入已看选择框.选中 ＝ 假)
        标记 (“标记已看”)
    .如果真结束
    播放视频 (影片 [封面子项].文件)
    log (“播放影片：” ＋ 影片 [封面子项].文件)
.否则
    .如果真 (加入已看选择框.选中 ＝ 假)
        标记 (“标记已看”)
    .如果真结束
    播放视频 (搜索 [搜索封面子项].文件)
    log (“播放影片：” ＋ 搜索 [搜索封面子项].文件)
.如果结束



.子程序 _删除按钮_被单击
.局部变量 目录路径文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 读入文本, 文本型

.如果 (关闭删除文件提示选择框.选中 ＝ 真)
    .如果 (搜索状态 ＝ 假)
        删除目录 (文件_取目录 (影片 [封面子项].文件))
        目录路径文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<mulu>”, “<mulu>”)
        写出文本 ＝ 影片 [封面子项].nfo
        写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
        读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
        读入文本 ＝ 文本_替换 (读入文本, , , , 影片 [封面子项].文件 ＋ “|” ＋ 写出文本, “”)
        写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
        log (“已删除目录：” ＋ 影片 [封面子项].文件)
    .否则

        删除目录 (文件_取目录 (搜索 [搜索封面子项].文件))
        目录路径文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<mulu>”, “<mulu>”)
        写出文本 ＝ 搜索 [搜索封面子项].nfo
        写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
        读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
        读入文本 ＝ 文本_替换 (读入文本, , , , 搜索 [搜索封面子项].文件 ＋ “|” ＋ 写出文本, “”)
        写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
        log (“已删除目录：” ＋ 搜索 [搜索封面子项].文件)

    .如果结束

.否则
    .如果 (信息框 (#删除影片提示, 4 ＋ 48, “【删除影片提示】”, ) ＝ 5)
        .如果 (搜索状态 ＝ 假)
            删除目录 (文件_取目录 (影片 [封面子项].文件))
            目录路径文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<mulu>”, “<mulu>”)
            写出文本 ＝ 影片 [封面子项].nfo
            写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
            读入文本 ＝ 文本_替换 (读入文本, , , , 影片 [封面子项].文件 ＋ “|” ＋ 写出文本, “”)
            写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
            log (“已删除目录：” ＋ 影片 [封面子项].文件)
        .否则

            删除目录 (文件_取目录 (搜索 [搜索封面子项].文件))
            目录路径文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<mulu>”, “<mulu>”)
            写出文本 ＝ 搜索 [搜索封面子项].nfo
            写出文本 ＝ 文本_替换 (写出文本, , , , “<mulu>” ＋ 目录路径文本 ＋ “<mulu>”, “”)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (目录路径文本))
            读入文本 ＝ 文本_替换 (读入文本, , , , 搜索 [搜索封面子项].文件 ＋ “|” ＋ 写出文本, “”)
            写到文件 (目录路径文本, 编码_Ansi到Utf8 (文本_删除空行_汇编 (读入文本)))
            log (“已删除目录：” ＋ 搜索 [搜索封面子项].文件)
        .如果结束

    .否则
        log (“取消删除文件。”)
    .如果结束

.如果结束


.子程序 _喜爱按钮_被单击


.如果 (搜索状态 ＝ 假)
    标记收藏已看 (影片 [封面子项].nfo, “收藏点击”)
.否则
    标记收藏已看 (搜索 [搜索封面子项].nfo, “收藏点击”)
.如果结束


.子程序 _已看按钮_被单击

.如果 (搜索状态 ＝ 假)
    标记收藏已看 (影片 [封面子项].nfo, “已看点击”)
.否则
    标记收藏已看 (搜索 [搜索封面子项].nfo, “已看点击”)
.如果结束


.子程序 标记收藏已看
.参数 nfo文本, 文本型
.参数 按钮点击, 文本型

.如果 (文本_取出中间文本 (nfo文本, “[sc]”, “[sc]”) ＝ “真”)
    喜爱按钮.正常图片 ＝ #收藏红
    喜爱按钮.点燃图片 ＝ #收藏红
    添加提示 (喜爱按钮.取窗口句柄 (), “取消收藏”, 假, 假)
    .如果真 (按钮点击 ＝ “收藏点击”)
        标记 (“取消标记收藏”)
        喜爱按钮.正常图片 ＝ #收藏白
        喜爱按钮.点燃图片 ＝ #收藏白
        添加提示 (喜爱按钮.取窗口句柄 (), “标记收藏”, 假, 假)

    .如果真结束

.否则
    喜爱按钮.正常图片 ＝ #收藏白
    喜爱按钮.点燃图片 ＝ #收藏白
    添加提示 (喜爱按钮.取窗口句柄 (), “标记收藏”, 假, 假)
    .如果真 (按钮点击 ＝ “收藏点击”)
        标记 (“标记收藏”)
        喜爱按钮.正常图片 ＝ #收藏红
        喜爱按钮.点燃图片 ＝ #收藏红
        添加提示 (喜爱按钮.取窗口句柄 (), “取消收藏”, 假, 假)

    .如果真结束


.如果结束

.如果 (文本_取出中间文本 (nfo文本, “[yk]”, “[yk]”) ＝ “真”)
    已看按钮.正常图片 ＝ #已看红
    已看按钮.点燃图片 ＝ #已看红
    添加提示 (已看按钮.取窗口句柄 (), “取消已看”, 假, 假)
    .如果真 (按钮点击 ＝ “已看点击”)
        标记 (“取消标记已看”)
        已看按钮.正常图片 ＝ #已看白
        已看按钮.点燃图片 ＝ #已看白
        添加提示 (已看按钮.取窗口句柄 (), “标记已看”, 假, 假)

    .如果真结束



.否则
    已看按钮.正常图片 ＝ #已看白
    已看按钮.点燃图片 ＝ #已看白
    添加提示 (已看按钮.取窗口句柄 (), “标记已看”, 假, 假)
    .如果真 (按钮点击 ＝ “已看点击”)
        标记 (“标记已看”)
        已看按钮.正常图片 ＝ #已看红
        已看按钮.点燃图片 ＝ #已看红
        添加提示 (已看按钮.取窗口句柄 (), “取消已看”, 假, 假)

    .如果真结束

.如果结束


.子程序 加水印
.局部变量 图片, 字节集

图片 ＝ 图片_加水印 (图片_到24位图 (读入文件 (“C:\Users\Administrator\Desktop\1.jpg”)), 图片_到24位图 (读入文件 (“C:\Users\Administrator\Desktop\4.jpg”)), 0, 0, )
图片 ＝ 图片_转换Ex (图片, 2)
写到文件 (“C:\Users\Administrator\Desktop\3.jpg”, 图片)

.子程序 _中文按钮_被单击
.局部变量 图片, 字节集

.如果 (搜索状态 ＝ 假)
    图片 ＝ 图片_加水印 (图片_到24位图 (读入文件 (图片路径数组 [封面子项 － 封面项])), 图片_到24位图 (#中字水印), 0, 0, )
    图片 ＝ 图片_转换Ex (图片, 2)
    写到文件 (图片路径数组 [封面子项 － 封面项], 图片)
    图片 ＝ 图片_缩放 (图片, 196, 280)
    动画框数组 [封面子项 － 封面项].置图片 (动画框标识数组 [封面子项 － 封面项], 图片, )
    log (“封面添加中字水印完成，” ＋ 图片路径数组 [封面子项 － 封面项])
.否则
    图片 ＝ 图片_加水印 (图片_到24位图 (读入文件 (图片路径数组 [搜索封面子项 － 搜索封面项])), 图片_到24位图 (#中字水印), 0, 0, )
    图片 ＝ 图片_转换Ex (图片, 2)
    写到文件 (图片路径数组 [搜索封面子项 － 搜索封面项], 图片)
    图片 ＝ 图片_缩放 (图片, 196, 280)
    动画框数组 [搜索封面子项 － 搜索封面项].置图片 (动画框标识数组 [搜索封面子项 － 搜索封面项], 图片, )
    log (“封面添加中字水印完成，” ＋ 图片路径数组 [封面子项 － 封面项])
.如果结束


.子程序 _标记中字_被选择
.局部变量 图片, 字节集

.如果 (搜索状态 ＝ 假)
    图片 ＝ 图片_加水印 (图片_到24位图 (读入文件 (图片路径数组 [封面子项 － 封面项])), 图片_到24位图 (#中字水印), 0, 0, )
    图片 ＝ 图片_转换Ex (图片, 2)
    写到文件 (图片路径数组 [封面子项 － 封面项], 图片)
    图片 ＝ 图片_缩放 (图片, 196, 280)
    动画框数组 [封面子项 － 封面项].置图片 (动画框标识数组 [封面子项 － 封面项], 图片, )
    log (“封面添加中字水印完成，” ＋ 图片路径数组 [封面子项 － 封面项])
.否则
    图片 ＝ 图片_加水印 (图片_到24位图 (读入文件 (图片路径数组 [搜索封面子项 － 搜索封面项])), 图片_到24位图 (#中字水印), 0, 0, )
    图片 ＝ 图片_转换Ex (图片, 2)
    写到文件 (图片路径数组 [搜索封面子项 － 搜索封面项], 图片)
    图片 ＝ 图片_缩放 (图片, 196, 280)
    动画框数组 [搜索封面子项 － 搜索封面项].置图片 (动画框标识数组 [搜索封面子项 － 搜索封面项], 图片, )
    log (“封面添加中字水印完成，” ＋ 图片路径数组 [搜索封面子项 － 搜索封面项])

.如果结束


.子程序 _批处理超级按钮1_被单击

添加中字水印 ()

.子程序 添加中字水印
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 图片, 字节集
.局部变量 水印宽度, 整数型

禁止 ()
取耗时 (1)
路径 ＝ 目录_浏览 (“添加中字水印”)
.如果 (路径 ≠ “”)
    文件_枚举_升级版 (路径, #图片格式, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果真 (圆形进度外形框.可视 ＝ 假)
                圆形进度外形框.可视 ＝ 真
                LOGO图形按钮.可视 ＝ 假
            .如果真结束
            进度窗口 (到整数 (i ÷ 取数组成员数 (临时数组) × 100))
            log (“正在为第” ＋ 到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个图片添加水印。”)
            .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “poster”, , 真) ≠ -1)
                水印宽度 ＝ 0
                图片 ＝ 图片_到24位图 (读入文件 (临时数组 [i]))
                .如果 (批处理素人选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#素人水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束
                .如果 (批处理欧美选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#欧美水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束
                .如果 (批处理国产选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#国产水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束
                .如果 (批处理有码选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#有码水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束
                .如果 (批处理无码选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#无码水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束
                .如果 (批处理中字选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#中字水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束

                .如果 (批处理HD选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#HD水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束

                .如果 (批处理FHD选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#FHD水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束

                .如果 (批处理2K选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#K2水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束

                .如果 (批处理4K选择框.选中 ＝ 真)
                    图片 ＝ 图片_加水印 (图片, 图片_到24位图 (#K4水印), 水印宽度 × 44, 0, )
                    水印宽度 ＝ 水印宽度 ＋ 1
                .否则

                .如果结束


                图片 ＝ 图片_转换Ex (图片, 2)
                写到文件 (临时数组 [i], 图片)

            .否则

            .如果结束

        .计次循环尾 ()
        .如果真 (圆形进度外形框.可视 ＝ 真)
            圆形进度外形框.可视 ＝ 假
            LOGO图形按钮.可视 ＝ 真
        .如果真结束

        log (“为” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “张图片添加中字水印完成，” ＋ 取耗时 (2))
    .否则
        log (“文件夹内未找到图片”)
    .如果结束

.否则
    log (“请选择正确的文件夹”)
.如果结束
取禁 ()



.子程序 _批处理超级按钮2_被单击

批量裁剪封面 (0)

.子程序 批量裁剪封面
.参数 项, 整数型
.参数 路径地址, 文本型, 可空
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 图片, 字节集
.局部变量 图片号, 整数型
.局部变量 宽, 整数型
.局部变量 高, 整数型
.局部变量 裁剪宽1, 整数型
.局部变量 裁剪宽2, 整数型
.局部变量 识别X坐标, 整数型
.局部变量 人脸选择框, 逻辑型

.如果 (项 ＝ 0)
    禁止 ()
    取耗时 (1)
    人脸选择框 ＝ 人脸识别选择框.选中
    路径 ＝ 目录_浏览 (“批量裁剪封面”)
    .如果 (路径 ≠ “”)
        文件_枚举_关键词 (路径, #图片格式, “fanart”, 临时数组, 0, 假, 真)
        .如果 (取数组成员数 (临时数组) ＞ 0)
            .计次循环首 (取数组成员数 (临时数组), i)
                log (“正在为第” ＋ 到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个图片裁剪封面。”)
                .如果 (寻找文本 (文件_取文件名 (临时数组 [i]), “fanart”, , 真) ≠ -1)
                    图片 ＝ 读入文件 (临时数组 [i])
                    图片号 ＝ 载入图片 (图片)
                    宽 ＝ 画板.取图片宽度 (图片号)
                    高 ＝ 画板.取图片高度 (图片号)
                    .如果 (高 ＜ 宽)
                        .如果 (人脸选择框 ＝ 真)
                            识别X坐标 ＝ 人脸识别 (临时数组 [i])
                            .如果 (识别X坐标 ≠ 0)
                                裁剪宽1 ＝ 识别X坐标
                                裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                                .如果 (识别X坐标 ＞ 宽 ÷ 5 × 3)
                                    裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                                    裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                                    .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                                    .否则
                                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                                    .如果结束
                                    写到文件 (文本_替换 (临时数组 [i], , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                                    卸载图片 (图片号)



                                .否则
                                    .如果 (识别X坐标 － 50 ＜ 0)
                                        识别X坐标 ＝ 0
                                    .否则
                                        识别X坐标 ＝ 识别X坐标 － 50
                                    .如果结束

                                    .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 识别X坐标, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                                    .否则
                                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 识别X坐标, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                                    .如果结束
                                    写到文件 (文本_替换 (临时数组 [i], , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                                    卸载图片 (图片号)


                                .如果结束

                            .否则
                                裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                                裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                                .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                                .否则
                                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                                .如果结束
                                写到文件 (文本_替换 (临时数组 [i], , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                                卸载图片 (图片号)




                            .如果结束

                        .否则
                            裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                            裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                            .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                            .否则
                                图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                            .如果结束
                            写到文件 (文本_替换 (临时数组 [i], , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                            卸载图片 (图片号)

                        .如果结束

                    .否则
                        写到文件 (文本_替换 (临时数组 [i], , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                        卸载图片 (图片号)

                    .如果结束

                .否则

                .如果结束

                程序_延时 (300)
            .计次循环尾 ()
            log (“裁剪” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “张封面完成，” ＋ 取耗时 (2))
        .否则
            log (“未找到图片。”)
        .如果结束

    .否则
        log (“请选择正确的文件夹。”)
    .如果结束
    取禁 ()


.否则
    .如果 (寻找文本 (文件_取文件名 (路径地址), “fanart”, , 真) ≠ -1)
        图片 ＝ 读入文件 (路径地址)
        图片号 ＝ 载入图片 (图片)
        宽 ＝ 画板.取图片宽度 (图片号)
        高 ＝ 画板.取图片高度 (图片号)
        .如果 (高 ＜ 宽)
            人脸选择框 ＝ 人脸识别选择框.选中
            .如果 (人脸选择框 ＝ 真)
                识别X坐标 ＝ 人脸识别 (路径地址)

                .如果 (识别X坐标 ≠ 0)
                    裁剪宽1 ＝ 识别X坐标
                    裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                    .如果 (识别X坐标 ＞ 宽 ÷ 5 × 3)
                        裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                        裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                        .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                            图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                        .否则
                            图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                        .如果结束
                        写到文件 (文本_替换 (路径地址, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                        卸载图片 (图片号)



                    .否则
                        .如果 (识别X坐标 － 50 ＜ 0)
                            识别X坐标 ＝ 0
                        .否则
                            识别X坐标 ＝ 识别X坐标 － 50
                        .如果结束

                        .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                            图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 识别X坐标, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                        .否则
                            图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 识别X坐标, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                        .如果结束
                        写到文件 (文本_替换 (路径地址, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                        卸载图片 (图片号)


                    .如果结束

                .否则
                    裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                    裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                    .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                    .否则
                        图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                    .如果结束
                    写到文件 (文本_替换 (路径地址, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                    卸载图片 (图片号)




                .如果结束

            .否则
                裁剪宽1 ＝ 画板.取图片宽度 (图片号) ÷ 2 ＋ 26
                裁剪宽2 ＝ 画板.取图片高度 (图片号) ÷ 27 × 19
                .如果 (宽 － 裁剪宽1 ≥ 裁剪宽2)
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 画板.取图片高度 (图片号) ÷ 27 × 19, 画板.取图片高度 (图片号))
                .否则
                    图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 画板.取图片宽度 (图片号) ÷ 2 ＋ 26, 0, 宽 － 裁剪宽1, 画板.取图片高度 (图片号))
                .如果结束
                写到文件 (文本_替换 (路径地址, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
                卸载图片 (图片号)

            .如果结束

        .否则
            写到文件 (文本_替换 (路径地址, , , , “fanart”, “poster”), 图片_转换Ex (图片, 2))
            卸载图片 (图片号)

        .如果结束




    .否则

    .如果结束

.如果结束



.子程序 _批处理超级按钮3_被单击

遍历番号 ()

.子程序 遍历番号
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 图片, 字节集
.局部变量 读入文本, 文本型
.局部变量 番号文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 写出数组, 文本型, , "0"

禁止 ()
取耗时 (1)
路径 ＝ 目录_浏览 (“遍历番号”)
.如果 (路径 ≠ “”)
    文件_枚举_升级版 (路径, “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))
            .如果 (文本_寻找文本 (读入文本, “</id>”, , 真) ≠ -1)
                番号文本 ＝ 文本_取出中间文本 (读入文本, “<id>”, “</id>”)
                番号文本 ＝ 番号文本 ＋ “|” ＋ 临时数组 [i]
                加入成员 (写出数组, 番号文本)

            .否则
                番号文本 ＝ “未找到番号” ＋ “|” ＋ 临时数组 [i]
                加入成员 (写出数组, 番号文本)

            .如果结束

            .如果真 (圆形进度外形框.可视 ＝ 假)
                圆形进度外形框.可视 ＝ 真
                LOGO图形按钮.可视 ＝ 假
            .如果真结束
            进度窗口 (到整数 (i ÷ 取数组成员数 (临时数组) × 100))
            log (“获取到” ＋ 到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个番号”)
        .计次循环尾 ()
        .如果真 (圆形进度外形框.可视 ＝ 真)
            圆形进度外形框.可视 ＝ 假
            LOGO图形按钮.可视 ＝ 真
        .如果真结束
        进度窗口 (到整数 (i ÷ 取数组成员数 (临时数组) × 100))

        写到文本 (写出数组, , 根目录 ＋ “遍历番号.txt”)
        执行 (, 根目录, , , )
        log (“获取到” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个番号，文本保存在程序data文件夹内，” ＋ 取耗时 (2))

    .否则
        log (“未找到nfo文件。”)
    .如果结束

.否则
    log (“请选择正确的文件夹。”)
.如果结束
取禁 ()


.子程序 _更新网盘超级按钮_被单击

打开指定网址 (“https://goyunpan.lanzous.com/b0c2eoohe”)

.子程序 初始化key, 文本型
.局部变量 key状态, 文本型

key状态 ＝ 识别.获取access_token (api_key编辑框.内容, Secret_key编辑框.内容)
返回 (key状态)

.子程序 人脸识别, 整数型
.参数 路径, 文本型
.局部变量 文本, 文本型

文本 ＝ 识别.API_人脸识别 (读入文件 (路径))
返回 (到整数 (文本_取出中间文本 (文本, #X坐标头, #X坐标尾)))

.子程序 _人脸识别选择框_被单击

.如果 (人脸识别选择框.选中 ＝ 假)
    写配置项 (根目录 ＋ “配置\配置.ini”, “选择框”, “人脸识别”, “ 假”)
.否则
    .如果 (初始化key () ＝ “1”)
        log (“---服务器验证成功”)
        写配置项 (根目录 ＋ “配置\配置.ini”, “选择框”, “人脸识别”, “真”)
    .否则
        人脸识别选择框.选中 ＝ 假
        log (“服务器授权失败！请检查API KEY，如果没有KEY，请到百度申请。”)
    .如果结束

.如果结束





.子程序 百度翻译, 文本型, , ' 拼接post文本
.参数 传入文本, 文本型
.局部变量 post, 文本型
.局部变量 salt, 文本型
.局部变量 sign, 文本型
.局部变量 appid, 文本型
.局部变量 key, 文本型
.局部变量 q, 文本型

q ＝ 到文本 (编码_UTF8编码 (传入文本))
salt ＝ 文本_取随机数字 (10)
appid ＝ appid编辑框.内容
key ＝ 密钥编辑框.内容
sign ＝ 校验_取md5 (到字节集 (appid ＋ q ＋ salt ＋ key), 假, 假)
post ＝ “q=” ＋ q ＋ “&” ＋ “from=” ＋ “auto” ＋ “&” ＋ “to=” ＋ “zh” ＋ “&” ＋ “appid=” ＋ appid ＋ “&” ＋ “salt=” ＋ salt ＋ “&” ＋ “sign=” ＋ sign
返回 (功能_网页访问 (post))



.子程序 功能_网页访问, 文本型, , ' post提交并接受返回参数
.参数 post, 文本型
.局部变量 局_网址, 文本型
.局部变量 局_方式, 整数型
.局部变量 局_提交数据, 文本型
.局部变量 局_提交协议头, 文本型
.局部变量 局_结果, 字节集
.局部变量 局_返回, 文本型


局_网址 ＝ “http://api.fanyi.baidu.com/api/trans/vip/translate”
局_方式 ＝ 1
局_提交数据 ＝ post
局_提交协议头 ＝ “User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.87 Safari/537.36”
局_结果 ＝ 网页_访问 (局_网址, 局_方式, 局_提交数据, , , 局_提交协议头, , , , , )
局_返回 ＝ 编码_usc2到ansi (到文本 (局_结果))
返回 (子_结果处理 (局_返回))

.子程序 子_结果处理, 文本型, , ' 处理返回的结果
.参数 Json数据, 文本型
.局部变量 局_JSON, 类_json
.局部变量 局_结果, 文本型
.局部变量 局_类型, 整数型

.如果 (局_JSON.解析 (Json数据) ＝ 真)
    局_结果 ＝ 局_JSON.取通用属性 (“['trans_result'][0].dst”)
    .如果 (局_结果 ＝ “”)
        log (子_错误码列表 (局_JSON.取通用属性 (“['error_code']”)))
        返回 (“失败”)
    .否则
        返回 (局_结果)
    .如果结束

.否则
    返回 (“失败”)
.如果结束




.子程序 子_错误码列表, 文本型, , 通过错误码判断错误原因，解决办法，并返回赋值
.参数 错误码, 文本型


.判断开始 (错误码 ＝ “52001”)
    返回 (“请求超时，请重试”)
.判断 (错误码 ＝ “52002”)
    返回 (“系统错误，请重试”)
.判断 (错误码 ＝ “52003”)
    返回 (“未授权用户，请检查您的 appid是否正确,或者服务是否开通”)
.判断 (错误码 ＝ “54000”)
    返回 (“必填参数为空，请检查是否少传参数”)
.判断 (错误码 ＝ “54001”)
    返回 (“签名错误，请检查您的签名生成方法”)
.判断 (错误码 ＝ “54003”)
    返回 (“访问频率受限，请降低您的调用频率,或进行身份认证后切换为高级版尊享版”)
.判断 (错误码 ＝ “54004”)
    返回 (“账户余额不足，请前往管理控制台为账户充值”)
.判断 (错误码 ＝ “54005”)
    返回 (“长query请求频繁,请降低长的发送频率,3s后再试”)
.判断 (错误码 ＝ “58000”)
    返回 (“客户端IP非法，请检查个人资料里填写的P地址是否正确,可前往开发者信息基本信息修改,IP限制,IP可留空”)
.判断 (错误码 ＝ “58001”)
    返回 (“译文语言方向不支持,检查译文语言是否在语言列表里”)
.判断 (错误码 ＝ “58002”)
    返回 (“服务当前已关闭,请前往管理控制台开启服务”)
.判断 (错误码 ＝ “90107”)
    返回 (“认证未通过或未生效,请前往我的认证查看认证进度”)
.默认

.判断结束
返回 (“未知原因”)



.子程序 _设置超级按钮1_被单击

设置超级按钮 (1)


.子程序 _设置超级按钮2_被单击

设置超级按钮 (2)


.子程序 _设置超级按钮3_被单击

设置超级按钮 (3)


.子程序 _设置超级按钮4_被单击

设置超级按钮 (4)


.子程序 _设置超级按钮5_被单击

设置超级按钮 (5)


.子程序 _设置超级按钮6_被单击

设置超级按钮 (6)


.子程序 _设置超级按钮7_被单击

设置超级按钮 (7)

.子程序 设置超级按钮
.参数 参数, 整数型

.如果 (参数 ＝ 0)
    设置外形框.可视 ＝ 假
.否则
    设置外形框.可视 ＝ 真
.如果结束

.如果 (参数 ＝ 1)
    设置外形框1.可视 ＝ 真
.否则
    设置外形框1.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 2)
    设置外形框2.可视 ＝ 真
.否则
    设置外形框2.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 3)
    设置外形框3.可视 ＝ 真
.否则
    设置外形框3.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 4)
    设置外形框4.可视 ＝ 真
.否则
    设置外形框4.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 5)
    设置外形框5.可视 ＝ 真
.否则
    设置外形框5.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 6)
    设置外形框6.可视 ＝ 真
.否则
    设置外形框6.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 7)
    设置外形框7.可视 ＝ 真
.否则
    设置外形框7.可视 ＝ 假
.如果结束




设置透明度 ()


.子程序 分组框可视
.参数 参数, 整数型

.如果 (参数 ＝ 1)
    缩略图分组框.可视 ＝ 真
.否则
    缩略图分组框.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 2)
    封面分组框.可视 ＝ 真
.否则
    封面分组框.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 3)
    目录分组框.可视 ＝ 真
.否则
    目录分组框.可视 ＝ 假
.如果结束

.如果 (参数 ＝ 4)
    标签分组框.可视 ＝ 真
.否则
    标签分组框.可视 ＝ 假
.如果结束

.如果 (设置外形框.可视 ＝ 真)
    设置外形框.可视 ＝ 假
.否则

.如果结束

.如果 (表格外形框.可视 ＝ 真)
    表格外形框.可视 ＝ 假
.否则

.如果结束

.如果 (影片刮削分组框.可视 ＝ 真)
    影片刮削分组框.可视 ＝ 假
.否则

.如果结束

.如果 (程序设置外形框.可视 ＝ 真)
    程序设置外形框.可视 ＝ 假
.否则

.如果结束


.子程序 _批处理超级按钮10_被单击

.如果 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“意见反馈：” ＋ 意见反馈编辑框.内容)) ＝ “收到反馈”)
    意见反馈编辑框.内容 ＝ “提交意见成功！”
    log (“提交意见成功！”)
.否则
    log (“提交意见失败，请重新提交！”)
.如果结束


.子程序 _批处理超级按钮7_被单击

打开指定网址 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“获取网址JAVBUS”)))

.子程序 _批处理超级按钮8_被单击

打开指定网址 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“获取网址JAV321”)))

.子程序 _批处理超级按钮9_被单击

打开指定网址 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“获取网址LIBRARY”)))

.子程序 _批处理超级按钮11_被单击

打开指定网址 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“获取网址JAVDB”)))

.子程序 _批处理超级按钮12_被单击

.如果 (网页_访问S (#post端, 1, , , , , , , , , , , , , , , , , , 到字节集 (“服务器状态”)) ＝ “服务器已启动”)
    log (“服务器在线。”)
.否则
    log (“服务器未启动。”)
.如果结束


.子程序 有道翻译, 文本型
.参数 待翻译文本, 文本型
.局部变量 返回内容, 文本型

返回内容 ＝ 网页_访问S (“http://fy.iciba.com/ajax.php?a=fy&f=ja&t=zh&w=” ＋ 待翻译文本, , , , , , , , , , , , , 超时时间)
返回内容 ＝ 编码_URL解码 (返回内容, 真)
返回 (编码_usc2到ansi (文本_取出中间文本 (返回内容, #有道头, #有道尾)))

.子程序 必应翻译, 文本型
.参数 待翻译文本, 文本型
.局部变量 返回内容, 文本型
.局部变量 IG, 文本型

返回内容 ＝ 到文本 (网页_访问_对象 (“https://cn.bing.com/translator/”, , , , , , , , , , , 超时时间, , , , , , , ))
IG ＝ 文本_取出中间文本 (返回内容, “,IG:” ＋ #引号, #引号, , )
返回内容 ＝ 到文本 (网页_访问_对象 (“https://cn.bing.com/ttranslatev3?isVertical=1&&IG=” ＋ IG ＋ “&IID=translator.5028.4”, 1, “&fromLang=ja&text=” ＋ 编码_URL编码 (待翻译文本, 真, 真) ＋ “&to=zh-Hans”, , , #必应协议头, , , , , , 超时时间, , , , , , , ))
返回内容 ＝ 编码_URL解码 (返回内容, 真)
返回 (文本_取出中间文本 (返回内容, #必应头, #必应尾))

.子程序 谷歌翻译, 文本型
.参数 参_待翻译文本, 文本型
.局部变量 局_JS, 类_脚本组件
.局部变量 局_POST数据, 文本型
.局部变量 局_POST网址, 文本型
.局部变量 局_tk, 文本型
.局部变量 局_源码, 文本型
.局部变量 英翻译中, 文本型
.局部变量 局_json, 类_json
.局部变量 i, 整数型
.局部变量 局_翻译结果, 文本型

局_JS.执行 (#常量_JS_谷歌翻译)
局_tk ＝ 局_JS.运行 (“tk”, 参_待翻译文本, , , , , )
局_POST网址 ＝ “https://translate.google.cn/translate_a/single?client=t&sl=ja&tl=zh-CN&hl=zh-CN&dt=at&dt=bd&dt=ex&dt=ld&dt=md&dt=qca&dt=rw&dt=rm&dt=sos&dt=ss&dt=t&otf=2&ssel=4&tsel=0&kc=1&tk=” ＋ 局_tk
局_POST数据 ＝ “q=” ＋ 编码_URL编码 (参_待翻译文本, 真, 真)
局_源码 ＝ 编码_URL解码 (网页_访问S (局_POST网址, 1, 局_POST数据, , , , , , , , , , , , , , , , , , ), 真)
局_json.解析 (局_源码)
.计次循环首 (局_json.成员数 (“[0]”), i)
    局_翻译结果 ＝ 局_翻译结果 ＋ 局_json.取通用属性 (“[0][” ＋ 到文本 (i － 1) ＋ “][0]”, )

.计次循环尾 ()
局_json.清除 ()
返回 (局_翻译结果)

.子程序 搜狗识别
.参数 路径, 文本型
.局部变量 文件名, 文本型
.局部变量 数据, 字节集
.局部变量 响应, 文本型
.局部变量 链接, 文本型
.局部变量 json, 类_json
.局部变量 名字, 文本型
.局部变量 人物图片, 文本型
.局部变量 图片, 字节集

log (“图像识别中，请等待...”)
图片 ＝ 读入文件 (路径)
图片 ＝ 图片_缩放_透明 (图片, 272, 288)
人脸识别动画框2.置图片 (人脸识别动画框2标识, 图片, )
文件名 ＝ 取文本右边 (路径, 取文本长度 (路径) － 倒找文本 (路径, “\”, , 假))

数据 ＝ 到字节集 (#搜狗识图)
数据 ＝ 子字节集替换 (数据, 到字节集 (“文件名”), 到字节集 (文件名), , )
数据 ＝ 子字节集替换 (数据, 到字节集 (“路径”), 读入文件 (路径), , )
响应 ＝ 到文本 (网页_访问_对象 (“http://pic.sogou.com/ris_upload”, 1, , , , “Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryYTwvlk5brGmyD3Mn”, , , 真, 数据))


链接 ＝ 文本_取出中间文本 (响应, “<a href=” ＋ #引号, #引号 ＋ “>”)

响应 ＝ 到文本 (网页_访问_对象 (取文本左边 (链接, 倒找文本 (链接, “&oname=”, , 假) － 1) ＋ “&flag=1&reqType=ajax&st=12&reqFrom=result”))
json.解析 (响应)
链接 ＝ json.取通用属性 (“query”)
json.清除 ()

响应 ＝ 编码_Utf8到Ansi (网页_访问 (“https://pic.sogou.com/ris?query=http%3A%2F%2Fimg03.sogoucdn.com%2Fapp%2Fa%2F” ＋ 文本_取出中间文本 (链接, “app/a/”, “/”) ＋ “%2F” ＋ 取文本右边 (链接, 32) ＋ “&flag=1&reqType=ajax&st=14&reqFrom=result”))
json.解析 (响应)
名字 ＝ json.取通用属性 (“star_name”)
名字 ＝ 编码_URL编码 (名字, , 真)
json.清除 ()
.如果 (名字 ≠ “”)
    响应 ＝ 编码_Utf8到Ansi (网页_访问 (“https://pic.sogou.com/ris/risBaike?query=http%3A%2F%2Fimg03.sogoucdn.com%2Fapp%2Fa%2F100520146%2FC50E8307AA106C55F78287C6C4B1280A&name=” ＋ 名字 ＋ “&baike_xiaoqi=true”))
    json.解析 (响应)
    人脸识别编辑框.内容 ＝ “识别结果：” ＋ #换行符 ＋ json.取通用属性 (“cardItem”)
    人物图片 ＝ json.取通用属性 (“image”)
    图片 ＝ HTTP读文件 (人物图片)
    图片 ＝ 图片_缩放_透明 (图片, 272, 288)
    人脸识别动画框.置图片 (人脸识别动画框标识, 图片, )
    json.清除 ()

.否则
    人脸识别动画框.置图片 (人脸识别动画框标识, #LOGO, )
    人脸识别编辑框.内容 ＝ “识别失败，请换其他图片重新尝试。”
.如果结束
log (“图像识别完成。”)


.子程序 识图2
.参数 路径, 文本型
.局部变量 文件名, 文本型
.局部变量 数据, 字节集
.局部变量 响应, 文本型
.局部变量 正则, 正则表达式类
.局部变量 i, 整数型
.局部变量 文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 头像网址, 文本型
.局部变量 图片, 字节集
.局部变量 姓名, 文本型

清除数组 (人脸识别网址数组)
log (“图像识别中，请等待...”)
图片 ＝ 读入文件 (路径)
图片 ＝ 图片_缩放_透明 (图片, 272, 288)
人脸识别动画框2.置图片 (人脸识别动画框2标识, 图片, )
文件名 ＝ 取文本右边 (路径, 取文本长度 (路径) － 倒找文本 (路径, “\”, , 假))
数据 ＝ 到字节集 (#识图2)
数据 ＝ 子字节集替换 (数据, 到字节集 (“文件名”), 到字节集 (文件名), , )
数据 ＝ 子字节集替换 (数据, 到字节集 (“路径”), 读入文件 (路径), , )
响应 ＝ 编码_Utf8到Ansi (网页_访问_对象 (“https://xslist.org/search/pic”, 1, , , , “X-Requested-With: XMLHttpRequest” ＋ #换行符 ＋ “content-type: multipart/form-data; boundary=----WebKitFormBoundaryE466F7vBHSZD3hE5”, , , 真, 数据, , , , , , , , , ))
正则.创建 (#识图2正则, 响应)
.计次循环首 (正则.取匹配数量 (), i)
    文本 ＝ 正则.取匹配文本 (i)
    .如果 (i ＝ 1)
        姓名 ＝ 文本_取出中间文本 (文本, #识图2姓名头, #识图2姓名尾)
        写出文本 ＝ “姓名：” ＋ 姓名 ＋ “|识别率：” ＋ 文本_取出中间文本 (文本, 姓名 ＋ “ - ”, “ similarity”)
        加入成员 (人脸识别网址数组, 文本_取出中间文本 (文本, 姓名 ＋ #识图2网址头, #识图2网址尾 ＋ 姓名))
    .否则
        姓名 ＝ 文本_取出中间文本 (文本, #识图2姓名头, #识图2姓名尾)
        写出文本 ＝ 写出文本 ＋ #换行符 ＋ “姓名：” ＋ 姓名 ＋ “|识别率：” ＋ 文本_取出中间文本 (文本, 姓名 ＋ “ - ”, “ similarity”)
        加入成员 (人脸识别网址数组, 文本_取出中间文本 (文本, 姓名 ＋ #识图2网址头, #识图2网址尾 ＋ 姓名))
    .如果结束

.计次循环尾 ()
人脸识别编辑框.内容 ＝ “识别结果：//右键可打开网页查看。” ＋ #换行符 ＋ #换行符 ＋ 写出文本
.如果 (窗口_搜索.可视 ＝ 真)
    置识别结果 (写出文本, 图片)
.否则

.如果结束
log (“图像识别完成。”)

.子程序 子程序1_取回文件名
.参数 路径, 文本型
.局部变量 表项索引, 整数型
.局部变量 时间, 文本型

表项索引 ＝ 接收文件列表框.插入表项 (, , , , , )
接收文件列表框.置标题 (表项索引, 0, 到文本 (表项索引 ＋ 1))
接收文件列表框.置标题 (表项索引, 1, 路径)
加入成员 (接收文件数组, 路径)
.如果 (表项索引 ＝ 0)
    时间 ＝ 文本_取出中间文本 (取DOS返回文本1 (“ffmpeg -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [1], “to10un”) ＋ #引号, &子程序_显示), “Duration: ”, “, start”)
    结束编辑框.内容 ＝ 取文本左边 (时间, 2) ＋ “:” ＋ 取文本中间 (时间, 4, 2) ＋ “:” ＋ 取文本中间 (时间, 7, 2)


.否则

.如果结束
.' 如果 (搜狗识图选择框.选中 ＝ 真)
    ' 搜狗识别 (路径)
.否则
    ' 识图2 (路径)
.如果结束


.子程序 子程序1_取回文件名2
.参数 路径, 文本型

.如果 (搜狗识图选择框.选中 ＝ 真)
    搜狗识别 (路径)
.否则
    识图2 (路径)
.如果结束


.子程序 _人脸识别编辑框_鼠标右键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 菜单标题, 文本型
.局部变量 子菜单, 类_菜单
.局部变量 子菜单标题, 文本型

.如果 (搜狗识图选择框.选中 ≠ 真)
    .如果 (取数组成员数 (人脸识别网址数组) ＞ 0)
        菜单.创建 (人脸识别网址数组, , , )
        菜单标题 ＝ 菜单.取标题 ()
        .如果 (菜单标题 ≠ “”)
            打开网址 (菜单标题)


        .否则

        .如果结束

    .否则

    .如果结束


.否则

.如果结束


.子程序 _截图_被单击

截图识别图片 ()

.子程序 截图识别图片
.局部变量 剪辑板文件, 文本型, , "1"
.局部变量 时间, 文本型
.局部变量 文件名, 文本型
.局部变量 图片, 字节集
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型

开始截图 ()
文件_枚举_升级版 (根目录 ＋ “图片”, “jpg”, 临时数组, 0, , )
.如果 (取数组成员数 (临时数组) ＞ 0)
    .计次循环首 (取数组成员数 (临时数组), i)
        .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “临时截图”) ≠ -1)
            文件_删除 (临时数组 [i])
        .否则

        .如果结束

    .计次循环尾 ()
.否则

.如果结束
时间 ＝ 到文本 (取现行时间 ())
文件名 ＝ 根目录 ＋ “图片\临时截图_” ＋ 时间 ＋ “.jpg”
.如果 (取字节集长度 (取剪贴板位图 ()) ＞ 100)
    图片 ＝ 图片_转换Ex (取剪贴板位图 (), 2)
    写到文件 (文件名, 图片)
    剪辑板文件 [1] ＝ 文件名
    剪辑板_置文件 (剪辑板文件)
    设置超级按钮 (2)
    .如果 (搜狗识图选择框.选中 ＝ 真)
        搜狗识别 (文件名)
    .否则
        识图2 (文件名)
    .如果结束


.否则
    log (“请重新截图。”)
.如果结束


.子程序 _截图识别_被选择
.局部变量 剪辑板文件, 文本型, , "1"
.局部变量 时间, 文本型
.局部变量 文件名, 文本型
.局部变量 图片, 字节集
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型

程序_延时 (400)
开始截图 ()
时间 ＝ 到文本 (取现行时间 ())
文件_枚举_升级版 (根目录 ＋ “图片”, “jpg”, 临时数组, 0, , )
.如果 (取数组成员数 (临时数组) ＞ 0)
    .计次循环首 (取数组成员数 (临时数组), i)
        .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “临时截图”) ≠ -1)
            文件_删除 (临时数组 [i])
        .否则

        .如果结束

    .计次循环尾 ()
.否则

.如果结束

文件名 ＝ 根目录 ＋ “图片\临时截图_” ＋ 时间 ＋ “.jpg”
.如果 (取字节集长度 (取剪贴板位图 ()) ＞ 100)
    图片 ＝ 图片_转换Ex (取剪贴板位图 (), 2)
    写到文件 (文件名, 图片)
    剪辑板文件 [1] ＝ 文件名
    剪辑板_置文件 (剪辑板文件)
    设置超级按钮 (2)
    .如果 (搜狗识图选择框.选中 ＝ 真)
        搜狗识别 (文件名)
    .否则
        识图2 (文件名)
    .如果结束


.否则
    log (“请重新截图。”)
.如果结束


.子程序 设置透明度


.' 如果 (表格外形框.可视 ＝ 真)
    ' 设置窗口透明度 (取窗口句柄 (), 255)
.否则
    .' 如果 (设置外形框.可视 ＝ 真)
        ' 设置窗口透明度 (取窗口句柄 (), 255)
    .否则
        .' 如果 (封面分组框.可视 ＝ 真)
            ' 设置窗口透明度 (取窗口句柄 (), 255)
        .否则
            ' 设置窗口透明度 (取窗口句柄 (), 230)
            .' 如果 (文件是否存在 (根目录 ＋ “图片\背景图片.jpg”) ＝ 真)
                ' _启动窗口.底图 ＝ 读入文件 (根目录 ＋ “图片\背景图片.jpg”)
            .否则

            .如果结束

        .如果结束

    .如果结束

.如果结束


.子程序 获取磁力链接, 文本型
.参数 传入文本, 文本型
.局部变量 文本, 文本型
.局部变量 正则, 正则表达式类
.局部变量 gid, 文本型
.局部变量 uc, 文本型
.局部变量 img, 文本型
.局部变量 磁力, 文本型
.局部变量 i, 整数型
.局部变量 磁力数组, 文本型, , "0"
.局部变量 临时文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 k, 整数型
.局部变量 临时文本1, 文本型
.局部变量 番号, 文本型

文本 ＝ 网页_访问S (bus网址 ＋ 传入文本, , , , , , , , , , 代理IP, , , 超时时间, , , , )
正则.创建 (#gid, 文本)
gid ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var gid = ”, “;”)
正则.创建 (#uc, 文本)
uc ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var uc = ”, “;”)
正则.创建 (#img, 文本)
img ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var img = '”, “';”)
磁力 ＝ 编码_Utf8到Ansi (网页_访问_对象 (“https://www.cdnbus.in/ajax/uncledatoolsbyajax.php?gid=” ＋ gid ＋ “&lang=zh&img=” ＋ img ＋ “&uc=0&floor=567”, , , , , , , , , , 代理IP, 超时时间))
清除数组 (磁力数组)
正则.创建 (#磁力, 磁力)
.计次循环首 (正则.取匹配数量 (), i)
    加入成员 (磁力数组, 正则.取匹配文本 (i))
.计次循环尾 ()

.计次循环首 (取数组成员数 (磁力数组), i)
    正则.创建 (“>” ＋ #换行符 ＋ “.+</a>”, 磁力数组 [i])
    .计次循环首 (正则.取匹配数量 (), k)
        .如果真 (k ＝ 1)
            .如果 (文本_寻找文本 (文本替换换行符 (正则.取匹配文本 (k)), “class”, , 真) ≠ -1)
                临时文本1 ＝ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (k)), “>”, “<aclass”)

            .否则
                临时文本1 ＝ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”)

            .如果结束

        .如果真结束

        .如果真 (k ＝ 2)
            临时文本1 ＝ 临时文本1 ＋ “|” ＋ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”)

        .如果真结束
        .如果真 (k ＝ 3)
            临时文本1 ＝ 临时文本1 ＋ “|” ＋ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”) ＋ “|”

        .如果真结束

    .计次循环尾 ()





    正则.创建 (#磁力链接, 磁力数组 [i])
    临时文本 ＝ “magnet:?” ＋ 编码_URL解码 (文本_取出中间文本 (磁力数组 [i], “magnet:?”, “','”), 真)
    .如果 (文本_寻找文本 (磁力数组 [i], “高清”, , 真) ≠ -1)
        临时文本 ＝ 临时文本 ＋ “|高清”
    .否则
        临时文本 ＝ 临时文本 ＋ “|非高清”
    .如果结束
    .如果 (文本_寻找文本 (磁力数组 [i], “字幕”, , 真) ≠ -1)
        临时文本 ＝ 临时文本 ＋ “|字幕”
    .否则
        临时文本 ＝ 临时文本 ＋ “|非字幕”
    .如果结束




    .如果 (i ＝ 1)
        写出文本 ＝ 临时文本1 ＋ 临时文本
    .否则
        写出文本 ＝ 写出文本 ＋ #换行符 ＋ 临时文本1 ＋ 临时文本
    .如果结束

.计次循环尾 ()
置剪辑板文本 (写出文本)
返回 (写出文本)

.子程序 文本替换换行符, 文本型
.参数 文本, 文本型

文本 ＝ 文本_替换 (文本, , , , #换行符, “”, 字符 (10), “”, 字符 (0), “”, “ ”, “”, #长空格, “”)
返回 (文本)

.子程序 _bus磁力_被选择
.局部变量 文本, 文本型
.局部变量 磁力结果, 文本型

下拉图形按钮2.标题 ＝ “本地搜索”
菜单磁力状态 ＝ 真
.如果 (搜索状态 ＝ 假)
    文本 ＝ 文本_取出中间文本 (影片 [封面子项].nfo, “<id>”, “<id>”)
    搜索编辑框.内容 ＝ 文本
    线程_启动 (&磁力搜索)

.否则
    文本 ＝ 文本_取出中间文本 (搜索 [搜索封面子项].nfo, “<id>”, “<id>”)
    搜索编辑框.内容 ＝ 文本
    线程_启动 (&磁力搜索)
.如果结束


.子程序 磁力链判断
.局部变量 磁力链, 发布文件信息

' 写到文件 (“C:\Users\Administrator\Desktop\1.torrent”, 网页_访问_对象 (“https://www.98rewer.xyz/forum.php?mod=attachment&aid=MTA2OTl8NDM1ZDI2ZWV8MTU5MDM5OTI5NHwwfDMwNjY3”))
磁力链 ＝ 分析发布文件 (“C:\Users\Administrator\Desktop\1.torrent”)
.判断开始 (磁力链.效验码 ≠ “”)
    调试输出 (“magnet:?xt=urn:btih:” ＋ 到大写 (磁力链.效验码))
.默认
    调试输出 (“这不是一个有效的 torrent种子文件，或该文件不完整或已损坏！”)
.判断结束





.子程序 取数组重复
.局部变量 c, 整数型
.局部变量 a, 整数型
.局部变量 i, 整数型
.局部变量 标记位, 文本型
.局部变量 转文本, 文本型
.局部变量 结果, 文本型
.局部变量 数组, 文本型, , "0"

log (“正在取重复影片，请等待...”)
禁止 ()
清除数组 (数组)
.计次循环首 (取数组成员数 (影片), i)
    加入成员 (数组, 影片 [i].番号)
.计次循环尾 ()
结果 ＝ “”
.计次循环首 (取数组成员数 (数组), c)
    转文本 ＝ 转文本 ＋ “丨” ＋ 到文本 (数组 [c])
.计次循环尾 ()
.计次循环首 (取数组成员数 (数组), i)
    .如果真 (文本_取出现次数 (转文本, 到文本 (数组 [i]), ) ≥ 2)
        .计次循环首 (取数组成员数 (数组), a)
            .如果真 (数组 [i] ＝ 数组 [a])
                标记位 ＝ 标记位 ＋ “丨” ＋ 影片 [a].文件
            .如果真结束

        .计次循环尾 ()
        结果 ＝ 结果 ＋ “数组成员 ” ＋ 到文本 (数组 [i]) ＋ “存在重复 位置：” ＋ 标记位 ＋ #换行符
        标记位 ＝ “”
    .如果真结束

.计次循环尾 ()
写到文件 (根目录 ＋ “重复影片_” ＋ 到文本 (取现行时间 ()) ＋ “.txt”, 到字节集 (文本_去重复文本 (结果, #换行符)))
取禁 ()
log (“取重复影片完成，请在data文件夹内查看。”)
执行 (, 根目录 ＋ “重复影片_” ＋ 到文本 (取现行时间 ()) ＋ “.txt”, , , )

.子程序 _批处理超级按钮13_被单击

取数组重复 ()

.子程序 种子文本
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 读入文本, 文本型
.局部变量 分割数组, 文本型, , "0"
.局部变量 分割数组2, 文本型

路径 ＝ “F:\封面”
log (“遍历开始”)
文件_枚举_升级版 (路径, “txt”, 临时数组, 0, 假, 真)
.如果 (取数组成员数 (临时数组) ＞ 0)
    .计次循环首 (取数组成员数 (临时数组), i)
        log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)))
        .如果 (取文本右边 (临时数组 [i], 12) ＝ “_Torrent.txt”)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))
            分割数组 ＝ 分割文本 (读入文本, #换行符, )
            .如果 (取数组成员数 (分割数组) ＞ 0)
                .计次循环首 (取数组成员数 (分割数组), k)
                    程序_写日志 (“|” ＋ 文本_删右边 (文件_取文件名 (临时数组 [i]), 8) ＋ “|” ＋ 分割数组 [k], 根目录 ＋ “写出种子” ＋ 到文本 (到整数 (i ÷ 5000)) ＋ “.txt”)
                .计次循环尾 ()

            .否则

            .如果结束

        .否则

        .如果结束


    .计次循环尾 ()
.否则

.如果结束
log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “遍历完成”)

.子程序 加载磁力链接文本包
.局部变量 i, 整数型

取耗时 (1)
禁止 ()
.如果 (文件是否存在 (根目录 ＋ “资源\磁力文本包.txt”) ＝ 真)
    清除数组 (磁力文本数组)
    磁力文本数组 ＝ 分割文本 (到文本 (读入文件 (根目录 ＋ “资源\磁力文本包.txt”)), #换行符, )
    log (“加载磁力文本包完成” ＋ 到文本 (取数组成员数 (磁力文本数组)) ＋ “个，” ＋ 取耗时 (2))
.否则
    log (“未找到本地磁力文本包，请在蓝奏云更新网盘下载<磁力文本包.txt>放在程序<data\资源>文件夹内即可。”)
    磁力链接包选择框.选中 ＝ 假
.如果结束
取禁 ()

.子程序 _磁力链接包选择框_被单击

.如果真 (磁力链接包选择框.选中 ＝ 真)
    log (“正在加载磁力文本包，请等待...”)
    线程_启动 (&加载磁力链接文本包)
.如果真结束



.子程序 写日志, , 公开, 在程序根目录建立一个txt文件用于记录相关日志内容
.参数 日志内容, 文本型
.参数 日志文件路径, 文本型, 可空, 写日记文件的路径，可空，默认在运行目录下写出
.局部变量 文件号, 整数型

.如果真 (是否为空 (日志文件路径))
    日志文件路径 ＝ 取运行目录 () ＋ “\运行日志.txt”
.如果真结束

.如果真 (文件是否存在 (日志文件路径) ＝ 假)
    写到文件 (日志文件路径, {  })
.如果真结束
文件号 ＝ 打开文件 (日志文件路径, , )
插入文本行 (文件号, 到文本 (日志内容))
关闭文件 (文件号)



.子程序 写出封面
.局部变量 i, 整数型
.局部变量 写出文本, 文本型

.计次循环首 (100, i)
    写出文本 ＝ 到文本 (读入文件 (“C:\Users\Administrator\Desktop\JAVGO\新模板\data\写出索引” ＋ 到文本 (i － 1) ＋ “.txt”)) ＋ 写出文本
    log (到文本 (i))
.计次循环尾 ()
写到文件 (“C:\Users\Administrator\Desktop\JAVGO\新模板\data\写出封面索引.txt”, 到字节集 (写出文本))
log (“写出封面完成。”)


.子程序 写到文本
.参数 数组, 文本型, 数组
.参数 数组2, 文本型, 可空 数组
.参数 文件名, 文本型
.参数 双数组, 文本型, 可空
.参数 编码, 文本型, 可空
.局部变量 i, 整数型
.局部变量 计次数, 整数型
.局部变量 缓存文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 数组成员数, 整数型

取耗时 (1)
计次数 ＝ 1
.如果 (双数组 ≠ “真”)
    数组_反转 (数组)
    数组成员数 ＝ 取数组成员数 (数组)
    .计次循环首 (数组成员数, i)
        .如果 (缓存文本 ＝ “”)
            缓存文本 ＝ 数组 [i]
        .否则
            缓存文本 ＝ 数组 [i] ＋ #换行符 ＋ 缓存文本
        .如果结束

        .如果 (i ＝ 1500 × 计次数)
            log (到文本 (计次数))
            写出文本 ＝ 缓存文本 ＋ #换行符 ＋ 写出文本
            缓存文本 ＝ “”
            计次数 ＝ 计次数 ＋ 1
        .否则
            .如果真 (i ＝ 数组成员数)
                写出文本 ＝ 缓存文本 ＋ #换行符 ＋ 写出文本
                缓存文本 ＝ “”
                计次数 ＝ 计次数 ＋ 1
            .如果真结束

        .如果结束

    .计次循环尾 ()
    写到文件 (文件名, 编码_Ansi到Utf8 (写出文本))
.否则
    .如果 (取数组成员数 (数组) ＝ 取数组成员数 (数组2))
        数组_反转 (数组)
        数组_反转 (数组2)
        数组成员数 ＝ 取数组成员数 (数组)
        .计次循环首 (数组成员数, i)
            .如果 (缓存文本 ＝ “”)
                缓存文本 ＝ 数组 [i] ＋ “|” ＋ 数组2 [i]
            .否则
                缓存文本 ＝ 数组 [i] ＋ “|” ＋ 数组2 [i] ＋ #换行符 ＋ 缓存文本
            .如果结束

            .如果 (i ＝ 1500 × 计次数)
                log (到文本 (计次数))
                写出文本 ＝ 缓存文本 ＋ #换行符 ＋ 写出文本
                缓存文本 ＝ “”
                计次数 ＝ 计次数 ＋ 1
            .否则
                .如果真 (i ＝ 数组成员数)
                    写出文本 ＝ 缓存文本 ＋ #换行符 ＋ 写出文本
                    缓存文本 ＝ “”
                    计次数 ＝ 计次数 ＋ 1
                .如果真结束

            .如果结束

        .计次循环尾 ()
        .如果 (编码 ＝ “真”)
            写到文件 (文件名, 编码_Ansi到Utf8 (写出文本))
        .否则
            写到文件 (文件名, 到字节集 (写出文本))
        .如果结束



    .否则
        log (“数组1和数组2不对等。”)
    .如果结束

.如果结束


.子程序 爬女优头像
.局部变量 i, 整数型
.局部变量 r, 文本型
.局部变量 正则, 正则表达式类
.局部变量 k, 整数型
.局部变量 取出内容, 文本型
.局部变量 写出文本, 文本型
.局部变量 写出数组, 文本型, , "0"
.局部变量 头像, 字节集

.计次循环首 (172, i)
    r ＝ 到文本 (读入文件 (“C:\Users\Administrator\Desktop\演员头像源网页\” ＋ 到文本 (i) ＋ “.txt”))
    正则.创建 (#演员信息, r)
    .计次循环首 (正则.取匹配数量 (), k)
        取出内容 ＝ 正则.取匹配文本 (k)
        写出文本 ＝ “<演员>” ＋ 文本_取出中间文本 (取出内容, #演员名头, #演员名尾) ＋ “</演员>|”
        写出文本 ＝ 写出文本 ＋ “<信息>” ＋ 文本_取出中间文本 (取出内容, #演员信息头, #演员信息尾) ＋ “</信息>|”
        写出文本 ＝ 写出文本 ＋ “<网页>” ＋ 文本_取出中间文本 (取出内容, #演员网页头, #演员网页尾) ＋ “.html” ＋ “</网页>|”
        写出文本 ＝ 写出文本 ＋ “<头像>” ＋ “https:” ＋ 文本_取出中间文本 (取出内容, #演员头像头, #演员头像尾) ＋ “.jpg” ＋ “</头像>”
        头像 ＝ 网页_访问 (“https:” ＋ 文本_取出中间文本 (取出内容, #演员头像头, #演员头像尾) ＋ “.jpg”, , , #cookies3, , , )
        写到文件 (根目录 ＋ “头像\” ＋ 文本_取出中间文本 (取出内容, #演员名头, #演员名尾) ＋ “.jpg”, 头像)
        加入成员 (写出数组, 写出文本)
    .计次循环尾 ()

    log (到文本 (i))
.计次循环尾 ()
写到文本 (写出数组, , 根目录 ＋ “演员信息.txt”)

.子程序 子程序1
.局部变量 文件数, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 文件名, 文本型
.局部变量 不存在, 整数型

文件数 ＝ 文件_枚举_升级版 (“C:\Users\Administrator\Desktop\1W8演员头像单文件夹包\中文”, “jpg”, 临时数组, 0, , 真)
不存在 ＝ 0

.计次循环首 (取数组成员数 (临时数组), i)
    文件名 ＝ 文件_取文件名 (临时数组 [i])
    .如果 (文件是否存在 (“C:\Users\Administrator\Desktop\演员头像\” ＋ 取文本左边 (文件名, 1) ＋ “\” ＋ 文件名 ＋ “.jpg”) ≠ 真)
        文件_移动 (临时数组 [i], “C:\Users\Administrator\Desktop\演员头像\” ＋ 取文本左边 (文件名, 1) ＋ “\” ＋ 文件名 ＋ “.jpg”)
        不存在 ＝ 不存在 ＋ 1
    .否则

    .如果结束

.计次循环尾 ()


.子程序 写到文件啊啊
.局部变量 文件数, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 临时数组2, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 正则, 正则表达式类

临时数组 ＝ 分割文本 (到文本 (读入文件 (“C:\Users\Administrator\Desktop\简介 (2)\简介数组 - 副本.txt”)), #换行符, )
.计次循环首 (取数组成员数 (临时数组), i)
    正则.创建 (“[a-zA-Z]”, 临时数组 [i])
    .如果 (正则.取匹配数量 () ＜ 21)
        加入成员 (临时数组2, 临时数组 [i])
    .否则

    .如果结束

.计次循环尾 ()
写到文本 (临时数组2, , 根目录 ＋ “简化简介.txt”)

.子程序 _批处理超级按钮14_被单击

.如果 (读入磁力文本 ≠ “”)
    磁力搜索 (1, 读入磁力文本)
.否则
    log (“未找到此影片磁力链接。”)
.如果结束


.子程序 _为影片刮削磁力按钮_被单击

.如果 (磁力链接包选择框.选中 ＝ 真)
    线程_启动 (&刮削磁力)
.否则
    log (“请先勾选前面的‘加载本地磁力链接包’选择框，来加载磁力文本包。”)
.如果结束


.子程序 刮削磁力
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 图片, 字节集
.局部变量 读入文本, 文本型
.局部变量 番号文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 写出数组, 文本型, , "0"
.局部变量 k, 整数型

禁止 ()
取耗时 (1)
路径 ＝ 目录_浏览 (“刮削磁力”)
.如果 (路径 ≠ “”)
    文件_枚举_升级版 (路径, “nfo”, 临时数组, 0, 假, 真)
    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            读入文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))
            .如果 (文本_寻找文本 (读入文本, “</id>”, , 真) ≠ -1)
                清除数组 (写出数组)
                写出文本 ＝ “”
                番号文本 ＝ 文本_取出中间文本 (读入文本, “<id>”, “</id>”)
                .计次循环首 (取数组成员数 (磁力文本数组), k)
                    .如果 (文本_寻找文本 (磁力文本数组 [k], 番号文本, , 真) ≠ -1)
                        加入成员 (写出数组, 磁力文本数组 [k])
                    .否则

                    .如果结束

                .计次循环尾 ()
                .计次循环首 (取数组成员数 (写出数组), k)
                    .如果 (k ＝ 1)
                        写出文本 ＝ 写出数组 [k]
                    .否则
                        写出文本 ＝ 写出文本 ＋ #换行符 ＋ 写出数组 [k]
                    .如果结束

                .计次循环尾 ()
                .如果 (取数组成员数 (写出数组) ＞ 0)
                    写到文件 (文件_取目录 (临时数组 [i]) ＋ 番号文本 ＋ “_Torrent.txt”, 编码_Ansi到Utf8 (写出文本))
                .否则

                .如果结束

            .否则

            .如果结束
            log (“刮削磁力到” ＋ 到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个番号”)
        .计次循环尾 ()
        log (“刮削磁力到” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “个番号，” ＋ 取耗时 (2))

    .否则
        log (“未找到nfo文件。”)
    .如果结束

.否则
    log (“请选择正确的文件夹。”)
.如果结束
取禁 ()


.子程序 _标签超级按钮0_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 按钮_来源, 超级按钮
.局部变量 i, 整数型

.如果 (取数组成员数 (演员三围数组) ＞ 0)
    按钮_来源 ＝ 取事件组件 ()
    .如果真 (标签演员状态 ＝ “演员真”)
        .计次循环首 (300, i)
            .判断开始 (按钮_来源.标记 ＝ 到文本 (i))
                .如果 (演员子项 ＋ i ≤ 取数组成员数 (影片))
                    加载演员头像 (影片演员 [演员子项 ＋ i], i)
                .否则

                .如果结束

            .默认

            .判断结束

        .计次循环尾 ()
    .如果真结束

.否则

.如果结束


.子程序 加载演员头像
.参数 演员名字, 文本型
.参数 按钮, 整数型, 可空
.局部变量 X, 整数型
.局部变量 Y, 整数型
.局部变量 图片, 字节集
.局部变量 i, 整数型

.如果 (演员头像显示 ≠ 演员名字)
    演员头像显示 ＝ 演员名字
    头像三围编辑框.内容 ＝ 演员名字 ＋ #换行符 ＋ “无信息”
    .如果 (文件是否存在 (根目录 ＋ “头像\” ＋ 演员名字 ＋ “.jpg”) ＝ 真)
        .如果 (标签分组框.可视 ＝ 真)

            .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ -95)
                头像外形框.左边 ＝ 350
            .否则
                .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 5)
                    头像外形框.左边 ＝ 450
                .否则
                    .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 105)
                        头像外形框.左边 ＝ 550
                    .否则
                        .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 205)
                            头像外形框.左边 ＝ 650
                        .否则
                            头像外形框.左边 ＝ 标签超级按钮数组 [按钮].左边 － 100
                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

            头像外形框.顶边 ＝ 标签超级按钮数组 [按钮].顶边 － 10
            图片 ＝ 读入文件 (根目录 ＋ “头像\” ＋ 演员名字 ＋ “.jpg”)
            图片 ＝ 图片_缩放_透明 (图片, 128, 152)
            头像动画框.置图片 (头像动画框标识, 图片, )
            .计次循环首 (取数组成员数 (演员三围数组), i)
                .如果 (取文本左边 (演员三围数组 [i], 取文本长度 (“<演员>” ＋ 演员名字)) ＝ “<演员>” ＋ 演员名字)
                    头像三围编辑框.内容 ＝ 演员名字 ＋ #换行符 ＋ “出生：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “出生: ”, “<br />三围”) ＋ #换行符 ＋ “三围：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “三围:”, “, 罩杯”) ＋ #换行符 ＋ “罩杯：” ＋ 文本_取出中间文本 (演员三围数组 [i], “罩杯: ”, “, 身高”) ＋ #换行符 ＋ “身高：” ＋ 文本_取出中间文本 (演员三围数组 [i], “身高: ”, “<br />出道日期”) ＋ #换行符 ＋ “出道日期：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “出道日期: ”, “</信息>”)
                    跳出循环 ()
                .否则

                .如果结束

            .计次循环尾 ()

            头像外形框.可视 ＝ 真

        .否则

        .如果结束
        .如果 (缩略图分组框.可视 ＝ 真)
            头像外形框.左边 ＝ 缩略图分组框.左边 ＋ 700
            头像外形框.顶边 ＝ 缩略图分组框.顶边 ＋ 150
            图片 ＝ 读入文件 (根目录 ＋ “头像\” ＋ 演员名字 ＋ “.jpg”)
            图片 ＝ 图片_缩放_透明 (图片, 128, 152)
            头像动画框.置图片 (头像动画框标识, 图片, )
            .计次循环首 (取数组成员数 (演员三围数组), i)
                .如果 (取文本左边 (演员三围数组 [i], 取文本长度 (“<演员>” ＋ 演员名字)) ＝ “<演员>” ＋ 演员名字)
                    头像三围编辑框.内容 ＝ 演员名字 ＋ #换行符 ＋ “出生：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “出生: ”, “<br />三围”) ＋ #换行符 ＋ “三围：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “三围:”, “, 罩杯”) ＋ #换行符 ＋ “罩杯：” ＋ 文本_取出中间文本 (演员三围数组 [i], “罩杯: ”, “, 身高”) ＋ #换行符 ＋ “身高：” ＋ 文本_取出中间文本 (演员三围数组 [i], “身高: ”, “<br />出道日期”) ＋ #换行符 ＋ “出道日期：” ＋ #换行符 ＋ 文本_取出中间文本 (演员三围数组 [i], “出道日期: ”, “</信息>”)
                    跳出循环 ()
                .否则

                .如果结束

            .计次循环尾 ()

            头像外形框.可视 ＝ 真


        .否则

        .如果结束

    .否则
        .如果 (标签分组框.可视 ＝ 真)
            .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ -95)
                头像外形框.左边 ＝ 350
            .否则
                .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 5)
                    头像外形框.左边 ＝ 450
                .否则
                    .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 105)
                        头像外形框.左边 ＝ 550
                    .否则
                        .如果 (标签超级按钮数组 [按钮].左边 － 100 ＝ 205)
                            头像外形框.左边 ＝ 650
                        .否则
                            头像外形框.左边 ＝ 标签超级按钮数组 [按钮].左边 － 100
                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

            头像三围编辑框.内容 ＝ 演员名字 ＋ #换行符 ＋ “无信息”
            头像动画框.置图片 (头像动画框标识, #空白头像, )
            头像外形框.可视 ＝ 真
        .否则

        .如果结束

        .如果 (缩略图分组框.可视 ＝ 真)
            头像外形框.左边 ＝ 缩略图分组框.左边 ＋ 700
            头像外形框.顶边 ＝ 缩略图分组框.顶边 ＋ 150
            头像三围编辑框.内容 ＝ 演员名字 ＋ #换行符 ＋ “无信息”
            头像动画框.置图片 (头像动画框标识, #空白头像, )
            头像外形框.可视 ＝ 真
        .否则

        .如果结束


    .如果结束

.否则

.如果结束


.子程序 _头像动画框_物体左键被按下
.参数 物体标识值, 整数型

头像外形框.可视 ＝ 假
演员头像显示 ＝ “”

.子程序 _缩略图演员标签_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 菜单标题, 文本型
.局部变量 子菜单, 类_菜单
.局部变量 子菜单标题, 文本型

.如果 (取数组成员数 (演员三围数组) ＞ 0)
    分割数组 ＝ 分割文本 (文本_替换 (缩略图演员标签.标题, , , , “演员：”, “”), “/”, )
    .如果 (取数组成员数 (分割数组) ＞ 0)

        .计次循环首 (取数组成员数 (分割数组), i)
            .如果 (演员头像显示 ＝ 分割数组 [i])
                跳出循环 ()
            .否则

            .如果结束

            .如果 (i ＝ 取数组成员数 (分割数组))
                加载演员头像 (分割数组 [1])
            .否则

            .如果结束

        .计次循环尾 ()

    .否则

    .如果结束

.否则

.如果结束





.子程序 _标签超级按钮0_获得焦点



.子程序 _窗口_下拉列表_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

可视设置 ()

.子程序 _缩略图动画框_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

可视设置 ()

.子程序 _缩略图演员标签_滚轮被滚动, 逻辑型
.参数 滚动距离, 整数型
.参数 功能键状态, 整数型
.局部变量 分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 菜单标题, 文本型
.局部变量 子菜单, 类_菜单
.局部变量 子菜单标题, 文本型

.如果 (取数组成员数 (演员三围数组) ＞ 0)
    分割数组 ＝ 分割文本 (文本_替换 (缩略图演员标签.标题, , , , “演员：”, “”), “/”, )
    .如果 (取数组成员数 (分割数组) ＞ 0)
        .计次循环首 (取数组成员数 (分割数组), i)
            .如果 (演员头像显示 ＝ 分割数组 [i])
                .如果 (i ＋ 1 ≤ 取数组成员数 (分割数组))
                    加载演员头像 (分割数组 [i ＋ 1])
                .否则
                    加载演员头像 (分割数组 [1])
                .如果结束
                跳出循环 ()
            .否则

            .如果结束

        .计次循环尾 ()
    .否则

    .如果结束

.否则

.如果结束




.子程序 _缩略图简介编辑框_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

可视设置 ()

.子程序 _缩略图日期标签_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

可视设置 ()


.子程序 _更新网盘2超级按钮_被单击

打开指定网址 (“https://pan.baidu.com/s/18lblWut1Elz_AScsDFiwzw”)

.子程序 爬女优名
.局部变量 r, 文本型
.局部变量 i, 整数型
.局部变量 文件名, 文本型
.局部变量 临时分割文本, 文本型, , "0"

' 调试输出 (编码_Utf8到Ansi (编码_编码转换对象 (到字节集 (编码_URL解码 (“https://av-help.memo.wiki/d/AV%bd%f7%cd%a5%b0%ec%cd%f7%a1%a7%a4%de%285%29”)), #编码_EUC_JP, #编码_UTF_8)))
写出演员名 (“あ”, 12)
写出演员名 (“い”, 6)
写出演员名 (“う”, 2)
写出演员名 (“え”, 1)
写出演员名 (“お”, 5)
写出演员名 (“か”, 7)
写出演员名 (“き”, 4)
写出演员名 (“く”, 3)
写出演员名 (“け”, 1)
写出演员名 (“こ”, 4)
写出演员名 (“さ”, 8)
写出演员名 (“し”, 5)
写出演员名 (“す”, 3)
写出演员名 (“せ”, 2)
写出演员名 (“そ”, 1)
写出演员名 (“た”, 5)
写出演员名 (“ち”, 1)
写出演员名 (“つ”, 2)
写出演员名 (“て”, 1)
写出演员名 (“と”, 2)
写出演员名 (“な”, 6)
写出演员名 (“に”, 2)
' 写出演员名 (“ぬ”, 0)
写出演员名 (“ね”, 1)
写出演员名 (“の”, 1)
写出演员名 (“は”, 5)
写出演员名 (“ひ”, 3)
写出演员名 (“ふ”, 3)
写出演员名 (“へ”, 1)
写出演员名 (“ほ”, 3)
写出演员名 (“ま”, 5)
写出演员名 (“み”, 8)
写出演员名 (“む”, 1)
写出演员名 (“め”, 1)
写出演员名 (“も”, 3)
写出演员名 (“や”, 2)
写出演员名 (“ゆ”, 2)
写出演员名 (“よ”, 2)
写出演员名 (“ら”, 1)
写出演员名 (“り”, 1)
写出演员名 (“る”, 1)
写出演员名 (“れ”, 1)
写出演员名 (“ろ”, 1)
写出演员名 (“わ”, 1)

.子程序 写出演员名
.参数 文件名, 文本型
.参数 k, 整数型
.局部变量 r, 文本型
.局部变量 i, 整数型

.计次循环首 (k, i)
    .如果 (i ≠ 1)
        r ＝ 网页_访问S (“https://av-help.memo.wiki/d/AV” ＋ 编码_URL编码 (到文本 (编码_编码转换对象 (编码_Ansi到Utf8 (“女優一覧：” ＋ 文件名 ＋ “(” ＋ 到文本 (i) ＋ “)”), #编码_UTF_8, #编码_EUC_JP))))
        写到文件 (根目录 ＋ 文件名 ＋ 到文本 (i) ＋ “.txt”, 到字节集 (r))

    .否则
        r ＝ 网页_访问S (“https://av-help.memo.wiki/d/AV” ＋ 编码_URL编码 (到文本 (编码_编码转换对象 (编码_Ansi到Utf8 (“女優一覧：” ＋ 文件名), #编码_UTF_8, #编码_EUC_JP))))
        写到文件 (根目录 ＋ 文件名 ＋ 到文本 (i) ＋ “.txt”, 到字节集 (r))

    .如果结束

.计次循环尾 ()



.子程序 子程序2
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 文本, 文本型
.局部变量 正则, 正则表达式类
.局部变量 k, 整数型
.局部变量 演员名, 文本型, , "0"
.局部变量 头像图, 文本型, , "0"
.局部变量 写出文本, 文本型

文件_枚举_升级版 (“C:\Users\Administrator\Desktop\新建文件夹”, “txt”, 临时数组, 0, 假, 假)
.计次循环首 (取数组成员数 (临时数组), i)
    文本 ＝ 到文本 (读入文件 (临时数组 [i]))
    正则.创建 (#演员姓名, 文本)
    .计次循环首 (正则.取匹配数量 (), k)
        加入成员 (演员名, 文本_取出中间文本 (正则.取匹配文本 (k), #演员姓名头, #演员姓名尾))
    .计次循环尾 ()
    正则.创建 (#头像图, 文本)
    .计次循环首 (正则.取匹配数量 (), k)
        加入成员 (头像图, 文本_取出中间文本 (正则.取匹配文本 (k), #头像图头, #头像图尾))
    .计次循环尾 ()
.计次循环尾 ()
.计次循环首 (取数组成员数 (演员名), k)
    .如果 (k ＝ 1)
        写出文本 ＝ 演员名 [k] ＋ “|” ＋ 头像图 [k]
    .否则
        写出文本 ＝ 写出文本 ＋ #换行符 ＋ 演员名 [k] ＋ “|” ＋ 头像图 [k]
    .如果结束

.计次循环尾 ()
写到文件 (根目录 ＋ “写出头像文本.txt”, 到字节集 (写出文本))


.子程序 子程序3
.局部变量 临时分割, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 临时分割2, 文本型, , "0"
.局部变量 x, 字节集

临时分割 ＝ 分割文本 (到文本 (读入文件 (“C:\Users\Administrator\Desktop\写出头像文本.txt”)), #换行符, )
.计次循环首 (取数组成员数 (临时分割), i)
    临时分割2 ＝ 分割文本 (临时分割 [i], “|”, )
    x ＝ HTTP读文件 (临时分割2 [2])
    .如果 (取字节集长度 (x) ＞ 1000)
        写到文件 (“C:\Users\Administrator\Desktop\头像\” ＋ 临时分割2 [1] ＋ “.jpg”, x)
    .否则

    .如果结束

.计次循环尾 ()

.子程序 删除文件小于4的文件夹
.局部变量 文件数, 整数型
.局部变量 i, 整数型
.局部变量 分割数, 文本型, , "0"
.局部变量 j_文件夹数组, 文本型, , "0"
.局部变量 文件夹数组, 文本型, , "0"

禁止 ()
取耗时 (1)
文件数 ＝ 文件_枚举_升级版 (“F:\封面2”, , 文件夹数组, 0, 真, 真)
.计次循环首 (取数组成员数 (文件夹数组), i)
    ' log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (文件夹数组)))
    .' 如果 (文件_取扩展名 (文件夹数组 [i]) ＝ “.jpg”)
        .' 如果 (到整数 (文件_取尺寸 (文件夹数组 [i])) ＜ 3100)
            ' 文件_删除 (文件夹数组 [i])
        .否则

        .如果结束

    .否则

    .如果结束
    log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (文件夹数组)))
    分割数 ＝ 分割文本 (文件夹数组 [i], “\”, )
    .如果 (取数组成员数 (分割数) ＝ 5)
        文件_枚举_升级版 (文件夹数组 [i], “jpg|nfo”, j_文件夹数组, 0, , 真)
        .如果 (取数组成员数 (j_文件夹数组) ≤ 1)
            删除目录 (文件夹数组 [i])

        .否则

        .如果结束
        清除数组 (j_文件夹数组)
    .否则

    .如果结束

.计次循环尾 ()
取禁 ()
log (“删除文件小于4的文件夹完成，” ＋ 取耗时 (2))


.子程序 移动文件夹
.局部变量 文件数, 整数型
.局部变量 i, 整数型
.局部变量 分割数, 文本型, , "0"
.局部变量 j_文件夹数组, 文本型, , "0"
.局部变量 文件夹数组, 文本型, , "0"
.局部变量 临时分割, 文本型, , "0"
.局部变量 临时分割2, 文本型, , "0"
.局部变量 k, 整数型

禁止 ()
取耗时 (1)
.计次循环首 (20, k)
    清除数组 (文件夹数组)
    文件数 ＝ 文件_枚举_升级版 (“F:\素人\” ＋ 到文本 (k), , 文件夹数组, 0, 真, 假)
    .计次循环首 (取数组成员数 (文件夹数组), i)
        log (到文本 (i) ＋ “/” ＋ 到文本 (取数组成员数 (文件夹数组)))
        分割数 ＝ 分割文本 (文件夹数组 [i], “\”, )
        .如果 (取数组成员数 (分割数) ＝ 4)
            临时分割 ＝ 分割文本 (分割数 [4], “ ”, )
            临时分割2 ＝ 分割文本 (临时分割 [2], “-”, )
            .如果 (文件是否存在 (“F:\素人\” ＋ 取文本左边 (分割数 [4], 4)) ≠ 真)
                创建目录 (“F:\素人\” ＋ 取文本左边 (分割数 [4], 4))
            .否则

            .如果结束

            .如果 (文件是否存在 (“F:\素人\” ＋ 取文本左边 (分割数 [4], 4) ＋ “\” ＋ 临时分割2 [1]) ≠ 真)
                创建目录 (“F:\素人\” ＋ 取文本左边 (分割数 [4], 4) ＋ “\” ＋ 临时分割2 [1])
            .否则

            .如果结束


            文件更名 (文件夹数组 [i], “F:\素人\” ＋ 取文本左边 (分割数 [4], 4) ＋ “\” ＋ 临时分割2 [1] ＋ “\” ＋ 分割数 [4])
        .否则

        .如果结束

    .计次循环尾 ()

.计次循环尾 ()
取禁 ()
log (“删除文件小于4的文件夹完成，” ＋ 取耗时 (2))


.子程序 _磁力高级表格_鼠标右键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

弹出菜单 (复制, , )

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

.如果真 (设置外形框1.可视 ＝ 真)
    置剪辑板文本 (磁力高级表格.取数据 (磁力高级表格.取光标行号 (), 磁力高级表格.取光标列号 ()))
.如果真结束

.如果真 (表格外形框.可视 ＝ 真)
    .如果 (色花超级列表框.可视 ＝ 真)
        剪辑板_置文本 (文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<种子>”, “</种子>”))


    .否则

    .如果结束
    .如果 (色花超级列表框2.可视 ＝ 真)
        剪辑板_置文本 (文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<种子>”, “</种子>”))
    .否则

    .如果结束

.如果真结束






.子程序 获取搜索磁力
.局部变量 i, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 磁力文本, 文本型
.局部变量 k, 整数型
.局部变量 磁力文本分割, 文本型, , "0"
.局部变量 写出磁力, 文本型, , "0"
.局部变量 番号id, 文本型

禁止 ()
.如果 (取数组成员数 (搜索) ＞ 0)
    .计次循环首 (取数组成员数 (搜索), k)
        番号id ＝ 文本_取出中间文本 (搜索 [k].nfo, “<id>”, “<id>”, , 真)
        清除数组 (临时数组)
        文件_枚举_关键词 (文件_取目录 (搜索 [k].文件), “txt”, “Torrent”, 临时数组, 0, 假, 假)
        .如果 (取数组成员数 (临时数组) ＞ 0)
            .计次循环首 (取数组成员数 (临时数组), i)
                文件_取文件名 (临时数组 [i])
                .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “Torrent”, , 真) ≠ -1)
                    磁力文本 ＝ 编码_Utf8到Ansi (读入文件 (临时数组 [i]))
                    .如果 (磁力文本 ≠ “”)
                        磁力文本分割 ＝ 分割文本 (磁力文本, #换行符, )
                        .计次循环首 (取数组成员数 (磁力文本分割), i)
                            .如果 (只获取高清选择框.选中 ＝ 真)
                                .如果 (只获取字幕选择框.选中 ＝ 真)
                                    .如果 (文本_寻找文本 (磁力文本分割 [i], “非高清”) ＝ -1)
                                        .如果 (文本_寻找文本 (磁力文本分割 [i], “非字幕”) ＝ -1)
                                            加入成员 (写出磁力, 番号id ＋ “|” ＋ 磁力文本分割 [i])
                                        .否则

                                        .如果结束

                                    .否则

                                    .如果结束

                                .否则
                                    .如果 (文本_寻找文本 (磁力文本分割 [i], “非高清”) ＝ -1)
                                        加入成员 (写出磁力, 番号id ＋ “|” ＋ 磁力文本分割 [i])
                                    .否则

                                    .如果结束

                                .如果结束

                            .否则
                                .如果 (只获取字幕选择框.选中 ＝ 真)
                                    .如果 (文本_寻找文本 (磁力文本分割 [i], “非字幕”) ＝ -1)
                                        加入成员 (写出磁力, 番号id ＋ “|” ＋ 磁力文本分割 [i])
                                    .否则

                                    .如果结束


                                .否则
                                    加入成员 (写出磁力, 番号id ＋ “|” ＋ 磁力文本分割 [i])
                                .如果结束

                            .如果结束



                        .计次循环尾 ()
                    .否则

                    .如果结束

                .否则

                .如果结束

            .计次循环尾 ()
        .否则

        .如果结束

    .计次循环尾 ()
    写到文本 (写出磁力, , 根目录 ＋ “临时磁力文本.txt”)
    执行 (, 根目录 ＋ “临时写出磁力文本.txt”, , , )
    取禁 ()
    log (“批量读取磁力到剪辑板完成。”)
.否则

    取禁 ()
    log (“未找到搜索结果。”)
.如果结束





.子程序 _获取搜索结果磁力按钮_被单击

.如果 (搜索状态 ＝ 真)
    线程_启动 (&获取搜索磁力)
.否则
    log (“还未进行搜索。”)
.如果结束


.子程序 加载本地色花文本包

.如果 (取数组成员数 (色花行数组) ≤ 0)
    .如果 (文件是否存在 (根目录 ＋ “资源\色花文本包.txt”) ＝ 真)
        线程_启动 (&读入色花文本)
    .否则
        表格提示.可视 ＝ 假
        log (“请检查是否已下载文本包并放在” ＋ 根目录 ＋ “资源\色花文本包.txt目录下。”)
    .如果结束


.否则
    log (“加载列表完成。”)
.如果结束




.子程序 读入色花文本
.局部变量 i, 整数型
.局部变量 表项索引, 整数型
.局部变量 信息, 文本型
.局部变量 类别, 文本型

表格提示.可视 ＝ 假
log (“正在初次加载列表，预计耗时10秒左右请耐心等待...”)
取耗时 (1)
禁止 ()
色花超级列表框.禁止 ＝ 假
色花超级列表框.可视 ＝ 假
清除数组 (色花行数组)
色花行数组 ＝ 分割文本 (到文本 (读入文件 (根目录 ＋ “资源\色花文本包.txt”)), #换行符, )
色花超级列表框.全部删除 ()
.计次循环首 (取数组成员数 (色花行数组), i)
    表项索引 ＝ 色花超级列表框.插入表项 (, , , , , )
    色花超级列表框.置标题 (表项索引, 0, 到文本 (i))
    类别 ＝ 文本_取出中间文本 (色花行数组 [i], “<类别>”, “</类别>”)
    .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
        取色花信息 (1, 色花行数组 [i], 表项索引)
    .否则
        取色花信息 (2, 色花行数组 [i], 表项索引)
    .如果结束

.计次循环尾 ()
取禁 ()
色花超级列表框.可视 ＝ 真
表格提示.可视 ＝ 真
色花复制磁力级按钮.可视 ＝ 真
log (“加载列表完成，” ＋ 取耗时 (2))

.子程序 取色花信息
.参数 类别, 整数型
.参数 文本, 文本型
.参数 表项, 整数型
.局部变量 演员名, 文本型
.局部变量 大小, 文本型
.局部变量 番号, 文本型
.局部变量 厂商, 文本型
.局部变量 时长, 文本型
.局部变量 日期, 文本型
.局部变量 系列, 文本型
.局部变量 发行, 文本型
.局部变量 风格, 文本型
.局部变量 时间, 文本型
.局部变量 种子, 文本型
.局部变量 题目, 文本型
.局部变量 i, 文本型
.局部变量 类目, 文本型

.如果真 (类别 ＝ 1)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    色花超级列表框.置标题 (表项, 1, 类目)
    色花超级列表框.置标题 (表项, 2, 题目)
    色花超级列表框.置标题 (表项, 3, 演员名)
    色花超级列表框.置标题 (表项, 4, 大小)
.如果真结束

.如果真 (类别 ＝ 2)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    色花超级列表框.置标题 (表项, 1, 类目)
    色花超级列表框.置标题 (表项, 2, 题目)
    色花超级列表框.置标题 (表项, 3, 演员名)
    色花超级列表框.置标题 (表项, 4, 大小)
.如果真结束

.如果真 (类别 ＝ 3)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    色花超级列表框2.置标题 (表项, 1, 类目)
    色花超级列表框2.置标题 (表项, 2, 题目)
    色花超级列表框2.置标题 (表项, 3, 演员名)
    色花超级列表框2.置标题 (表项, 4, 大小)


.如果真结束

.如果真 (类别 ＝ 4)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    色花超级列表框2.置标题 (表项, 1, 类目)
    色花超级列表框2.置标题 (表项, 2, 题目)
    色花超级列表框2.置标题 (表项, 3, 演员名)
    色花超级列表框2.置标题 (表项, 4, 大小)

.如果真结束


.如果真 (类别 ＝ 5)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    番号 ＝ 文本_取出中间文本 (文本, “<番号>”, “</番号>”)
    厂商 ＝ 文本_取出中间文本 (文本, “<厂商>”, “</厂商>”)
    时长 ＝ 文本_取出中间文本 (文本, “<收录时间>”, “</收录时间>”)
    日期 ＝ 文本_取出中间文本 (文本, “<配信开始日>”, “</配信开始日>”)
    系列 ＝ 文本_取出中间文本 (文本, “<系列>”, “</系列>”)
    发行 ＝ 文本_取出中间文本 (文本, “<发行商>”, “</发行商>”)
    风格 ＝ 文本_取出中间文本 (文本, “<风格>”, “</风格>”)
    时间 ＝ 文本_取出中间文本 (文本, “<时间>”, “</时间>”)
    种子 ＝ 文本_取出中间文本 (文本, “<种子>”, “</种子>”)
    色花缩略图磁力编辑框.内容 ＝ 种子
    色花缩略图磁力编辑框1.内容 ＝ “类别:” ＋ 类目 ＋ #换行符 ＋ “标题:” ＋ 题目 ＋ #换行符 ＋ “演员：” ＋ 演员名 ＋ #换行符 ＋ “番号：” ＋ 番号 ＋ #换行符 ＋ “厂商：” ＋ 厂商 ＋ #换行符 ＋ “发行：” ＋ 发行 ＋ #换行符 ＋ “系列：” ＋ 系列 ＋ #换行符 ＋ “风格：” ＋ 风格 ＋ #换行符 ＋ “日期：” ＋ 日期 ＋ #换行符 ＋ “时长：” ＋ 时长 ＋ #换行符 ＋ “大小：” ＋ 大小
.如果真结束

.如果真 (类别 ＝ 6)
    类目 ＝ 文本_取出中间文本 (文本, “<类别>”, “</类别>”)
    题目 ＝ 文本_取出中间文本 (文本, “<片名>”, “</片名>”)
    演员名 ＝ 文本_取出中间文本 (文本, “<女优>”, “</女优>”)
    大小 ＝ 文本_取出中间文本 (文本, “<大小>”, “</大小>”)
    时间 ＝ 文本_取出中间文本 (文本, “<时间>”, “</时间>”)
    种子 ＝ 文本_取出中间文本 (文本, “<种子>”, “</种子>”)
    色花缩略图磁力编辑框.内容 ＝ 种子
    色花缩略图磁力编辑框1.内容 ＝ “类别:” ＋ 类目 ＋ #换行符 ＋ “标题:” ＋ 题目 ＋ #换行符 ＋ “演员：” ＋ 演员名 ＋ #换行符 ＋ “大小：” ＋ 大小 ＋ #换行符 ＋ “时间：” ＋ 时间
.如果真结束




.子程序 色花搜索
.局部变量 关键词, 文本型
.局部变量 i, 整数型
.局部变量 表项索引, 整数型
.局部变量 类别, 文本型

禁止 ()
取耗时 (1)
色花超级列表框2.可视 ＝ 假
关键词 ＝ 搜索编辑框.内容
清除数组 (色花搜索行数组)
.计次循环首 (取数组成员数 (色花行数组), i)
    .如果 (文本_寻找文本 (到大写 (色花行数组 [i]), 到大写 (关键词), , 真) ≠ -1)
        加入成员 (色花搜索行数组, 色花行数组 [i])
    .否则

    .如果结束

.计次循环尾 ()
色花超级列表框2.全部删除 ()
.计次循环首 (取数组成员数 (色花搜索行数组), i)
    表项索引 ＝ 色花超级列表框2.插入表项 (, , , , , )
    色花超级列表框2.置标题 (表项索引, 0, 到文本 (i))
    类别 ＝ 文本_取出中间文本 (色花搜索行数组 [i], “<类别>”, “</类别>”)
    .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
        取色花信息 (3, 色花搜索行数组 [i], 表项索引)
    .否则
        取色花信息 (4, 色花搜索行数组 [i], 表项索引)
    .如果结束

.计次循环尾 ()
色花超级列表框.可视 ＝ 假
色花超级列表框2.可视 ＝ 真
取禁 ()
log (“列表搜索完成，” ＋ 取耗时 (2))

.子程序 _色花超级列表框_当前表项被改变
.局部变量 类别, 文本型
.局部变量 种子, 文本型

.如果 (色花超级列表框.可视 ＝ 真)
    种子 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<种子>”, “</种子>”)
    .如果 (关闭置剪贴板选择框.选中 ＝ 假)
        剪辑板_置文本 (种子)
    .否则

    .如果结束

    .如果 (色花缩略图分组框.可视 ＝ 真)
        类别 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<类别>”, “</类别>”)
        .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
            取色花信息 (5, 色花行数组 [色花超级列表框.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .否则
            取色花信息 (6, 色花行数组 [色花超级列表框.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .如果结束

    .否则
        .如果 (关闭置剪贴板选择框.选中 ＝ 假)
            log (“磁力复制到剪贴板：” ＋ 种子)

        .否则

        .如果结束

    .如果结束





.否则

.如果结束


.子程序 _色花超级列表框2_当前表项被改变
.局部变量 类别, 文本型
.局部变量 种子, 文本型

.如果 (色花超级列表框2.可视 ＝ 真)
    种子 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<种子>”, “</种子>”)
    .如果 (关闭置剪贴板选择框.选中 ＝ 假)
        剪辑板_置文本 (种子)
    .否则

    .如果结束

    .如果 (色花缩略图分组框.可视 ＝ 真)
        类别 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<类别>”, “</类别>”)
        .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
            取色花信息 (5, 色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .否则
            取色花信息 (6, 色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .如果结束


    .否则
        .如果 (关闭置剪贴板选择框.选中 ＝ 假)
            log (“磁力复制到剪贴板：” ＋ 种子)

        .否则

        .如果结束

    .如果结束




.否则

.如果结束



.子程序 _色花复制磁力按钮_被单击
.局部变量 磁力, 文本型

.如果 (色花超级列表框.可视 ＝ 真)
    .如果 (取数组成员数 (色花行数组) ≠ 0)
        磁力 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<种子>”, “</种子>”)
        置剪辑板文本 (磁力)
        log (“已复制磁力:” ＋ 磁力)
    .否则
        log (“未加载本地文本包，请先点击按钮加载。”)
    .如果结束

.否则
    .如果 (色花超级列表框2.可视 ＝ 真)
        .如果 (取数组成员数 (色花搜索行数组) ≠ 0)
            磁力 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<种子>”, “</种子>”)
            置剪辑板文本 (磁力)
            log (“已复制磁力:” ＋ 磁力)
        .否则
            log (“未加载本地文本包，请先点击按钮加载。”)
        .如果结束

    .否则

    .如果结束

.如果结束


.子程序 _色花复制磁力按钮2_被单击
.局部变量 磁力, 文本型

.如果 (色花超级列表框.可视 ＝ 真)
    .如果 (取数组成员数 (色花行数组) ≠ 0)
        磁力 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<种子>”, “</种子>”)
        置剪辑板文本 (磁力)
        log (“已复制磁力:” ＋ 磁力)
    .否则
        log (“未加载本地文本包，请先点击按钮加载。”)
    .如果结束

.否则
    .如果 (色花超级列表框2.可视 ＝ 真)
        .如果 (取数组成员数 (色花搜索行数组) ≠ 0)
            磁力 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<种子>”, “</种子>”)
            置剪辑板文本 (磁力)
            log (“已复制磁力:” ＋ 磁力)
        .否则
            log (“未加载本地文本包，请先点击按钮加载。”)
        .如果结束

    .否则

    .如果结束

.如果结束



.子程序 色花查看图片

log (“正在加载图片...”)
.如果 (色花超级列表框.可视 ＝ 真)
    .如果 (取数组成员数 (色花行数组) ≠ 0)
        .如果 (色花超级列表框.现行选中项 ＋ 1 ≤ 取数组成员数 (色花行数组))
            线程_启动 (&色花加载图片)
        .否则
            log (“到列表尾了。”)
        .如果结束

    .否则
        log (“未加载本地文本包，请先点击按钮加载。”)

    .如果结束

.否则
    .如果 (色花超级列表框2.可视 ＝ 真)
        .如果 (取数组成员数 (色花搜索行数组) ≠ 0)
            .如果 (色花超级列表框2.现行选中项 ＋ 1 ≤ 取数组成员数 (色花搜索行数组))
                线程_启动 (&色花加载图片)
            .否则
                log (“到列表尾了。”)
            .如果结束

        .否则
            log (“列表内没有搜索结果。”)

        .如果结束

    .否则

    .如果结束

.如果结束





.子程序 色花加载图片
.局部变量 图片, 字节集
.局部变量 图片链接, 文本型
.局部变量 文件名, 文本型
.局部变量 i, 整数型

图片链接 ＝ “”
.如果 (色花超级列表框.可视 ＝ 真)
    .如果 (取数组成员数 (色花行数组) ≠ 0)
        .如果 (文件是否存在 (文本_删右边 (SeHua图片包路径, 1)) ＝ 真)
            文件名 ＝ “thread-” ＋ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<网页>”, “</网页>”)
            .计次循环首 (3, i)
                .如果 (文件是否存在 (SeHua图片包路径 ＋ “有码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                    文件名 ＝ SeHua图片包路径 ＋ “有码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                    跳出循环 ()
                .否则
                    .如果 (文件是否存在 (SeHua图片包路径 ＋ “中字\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                        文件名 ＝ SeHua图片包路径 ＋ “中字\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                        跳出循环 ()
                    .否则
                        .如果 (文件是否存在 (SeHua图片包路径 ＋ “无码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                            文件名 ＝ SeHua图片包路径 ＋ “无码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                            跳出循环 ()
                        .否则
                            .如果 (文件是否存在 (SeHua图片包路径 ＋ “国产\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                文件名 ＝ SeHua图片包路径 ＋ “国产\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                跳出循环 ()
                            .否则
                                .如果 (文件是否存在 (SeHua图片包路径 ＋ “欧美\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                    文件名 ＝ SeHua图片包路径 ＋ “欧美\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                    跳出循环 ()
                                .否则
                                    .如果 (文件是否存在 (SeHua图片包路径 ＋ “素人\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                        文件名 ＝ SeHua图片包路径 ＋ “素人\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                        跳出循环 ()
                                    .否则
                                        .如果 (i ＝ 3)
                                            文件名 ＝ “空”
                                        .否则

                                        .如果结束

                                    .如果结束

                                .如果结束

                            .如果结束

                        .如果结束

                    .如果结束

                .如果结束

            .计次循环尾 ()
        .否则
            文件名 ＝ “空”
        .如果结束

        .如果 (文件名 ＝ “空”)
            图片链接 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<预览>http://pics.dmm.co.jp/digital/video/”, “pl.jpg</预览>”)
            .如果 (图片链接 ＝ “”)
                图片链接 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<预览>”, “</预览>”)
                .如果 (文本_寻找文本 (图片链接, “www.shttupian.com”, , 真) ≠ -1 或 文本_寻找文本 (图片链接, “djsndtupian”, , 真) ≠ -1)
                    图片链接 ＝ “”
                .否则

                .如果结束

            .否则
                图片链接 ＝ “http://pics.dmm.co.jp/digital/video/” ＋ 图片链接 ＋ “pl.jpg”
            .如果结束
            .如果 (图片链接 ≠ “”)
                图片 ＝ HTTP读文件 (图片链接)
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
                色花缩略图动画框.置图片 (色花缩略图动画框标识, 图片, )
                log (“加载网络图片完成。”)
            .否则
                log (“此影片没有图片。”)
            .如果结束


        .否则
            图片 ＝ 读入文件 (文件名)
            图片 ＝ 图片_缩放_透明 (图片, 800, 540)
            色花缩略图动画框.置图片 (色花缩略图动画框标识, 图片, )
            log (“加载本地图片完成。”)


        .如果结束

    .否则
        log (“未加载本地文本包，请先点击按钮加载。”)
    .如果结束

.否则
    .如果 (色花超级列表框2.可视 ＝ 真)
        .如果 (取数组成员数 (色花搜索行数组) ≠ 0)
            .如果 (文件是否存在 (文本_删右边 (SeHua图片包路径, 1)) ＝ 真)
                文件名 ＝ “thread-” ＋ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<网页>”, “</网页>”)
                .计次循环首 (3, i)
                    .如果 (文件是否存在 (SeHua图片包路径 ＋ “有码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                        文件名 ＝ SeHua图片包路径 ＋ “有码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                        跳出循环 ()
                    .否则
                        .如果 (文件是否存在 (SeHua图片包路径 ＋ “中字\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                            文件名 ＝ SeHua图片包路径 ＋ “中字\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                            跳出循环 ()
                        .否则
                            .如果 (文件是否存在 (SeHua图片包路径 ＋ “无码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                文件名 ＝ SeHua图片包路径 ＋ “无码\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                跳出循环 ()
                            .否则
                                .如果 (文件是否存在 (SeHua图片包路径 ＋ “国产\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                    文件名 ＝ SeHua图片包路径 ＋ “国产\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                    跳出循环 ()
                                .否则
                                    .如果 (文件是否存在 (SeHua图片包路径 ＋ “欧美\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                        文件名 ＝ SeHua图片包路径 ＋ “欧美\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                        跳出循环 ()
                                    .否则
                                        .如果 (文件是否存在 (SeHua图片包路径 ＋ “素人\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”) ＝ 真)
                                            文件名 ＝ SeHua图片包路径 ＋ “素人\” ＋ 文件名 ＋ “[” ＋ 到文本 (i) ＋ “].jpg”
                                            跳出循环 ()
                                        .否则
                                            .如果 (i ＝ 3)
                                                文件名 ＝ “空”
                                            .否则

                                            .如果结束

                                        .如果结束

                                    .如果结束

                                .如果结束

                            .如果结束

                        .如果结束

                    .如果结束

                .计次循环尾 ()






            .否则
                文件名 ＝ “空”
            .如果结束

            .如果 (文件名 ＝ “空”)
                图片链接 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<预览>http://pics.dmm.co.jp/digital/video/”, “pl.jpg</预览>”)
                .如果 (图片链接 ＝ “”)
                    图片链接 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<预览>”, “</预览>”)
                    .如果 (文本_寻找文本 (图片链接, “www.shttupian.com”, , 真) ≠ -1 或 文本_寻找文本 (图片链接, “djsndtupian”, , 真) ≠ -1)
                        图片链接 ＝ “”
                    .否则

                    .如果结束

                .否则
                    图片链接 ＝ “http://pics.dmm.co.jp/digital/video/” ＋ 图片链接 ＋ “pl.jpg”
                .如果结束
                .如果 (图片链接 ≠ “”)
                    图片 ＝ HTTP读文件 (图片链接)
                    图片 ＝ 图片_缩放_透明 (图片, 800, 540)
                    色花缩略图动画框.置图片 (色花缩略图动画框标识, 图片, )
                    log (“加载网络图片完成。”)
                .否则
                    log (“此影片没有图片。”)
                .如果结束

            .否则
                图片 ＝ 读入文件 (文件名)
                图片 ＝ 图片_缩放_透明 (图片, 800, 540)
                色花缩略图动画框.置图片 (色花缩略图动画框标识, 图片, )
                log (“加载本地图片完成。”)


            .如果结束

        .否则
            log (“未加载本地文本包，请先点击按钮加载。”)
        .如果结束

    .否则

    .如果结束

.如果结束


.子程序 _色花缩略图动画框_物体左键被按下
.参数 物体标识值, 整数型

色花缩略图分组框.可视 ＝ 假

.子程序 _色花超级列表框_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

色花超级列表框.获取焦点 ()

.子程序 _色花超级列表框2_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

色花超级列表框2.获取焦点 ()

.子程序 _表格提示_被单击

信息提示 (1)

.子程序 信息提示
.参数 项, 整数型

.如果 (项 ＝ 1)
    信息框_z (“【色花列表使用帮助】”, #色花信息提示, “”, “”, )
.否则

.如果结束

.如果 (项 ＝ 2)
    .如果 (搜索状态 ＝ 假)
        取视频信息 (影片 [封面子项].文件)
    .否则
        取视频信息 (搜索 [搜索封面子项].文件)
    .如果结束

.否则

.如果结束

.如果 (项 ＝ 3)
    信息框_z (“【ffmpeg使用帮助】”, #ffmpeg提示, “”, “”, )
.否则

.如果结束

.如果 (项 ＝ 4)
    信息框_z (“【目录使用帮助】”, #目录提示, “”, “”, )
.否则

.如果结束

.如果 (项 ＝ 5)
    信息框_z (“【刮削使用帮助】”, #刮削提示, “”, “”, )
.否则

.如果结束





.子程序 _信息提示关闭_被单击

信息提示外形框.可视 ＝ 假
信息提示编辑框.滚动条 ＝ 0

.子程序 _色花超级列表框_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

列表框双击 ()

.子程序 _色花超级列表框2_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

列表框双击 ()

.子程序 列表框双击
.局部变量 类别, 文本型
.局部变量 种子, 文本型


.如果 (色花缩略图分组框.可视 ＝ 假)
    .如果 (_启动窗口.宽度 ≠ 1830)
        _启动窗口.宽度 ＝ 1830
        _启动窗口.高度 ＝ 1020
    .否则

    .如果结束

    色花缩略图分组框.可视 ＝ 真
    .如果 (色花超级列表框.可视 ＝ 真)
        种子 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<种子>”, “</种子>”)
        ' log (“磁力复制到剪贴板：” ＋ 种子)
        .如果 (关闭置剪贴板选择框.选中 ＝ 假)
            剪辑板_置文本 (种子)
        .否则

        .如果结束
        类别 ＝ 文本_取出中间文本 (色花行数组 [色花超级列表框.现行选中项 ＋ 1], “<类别>”, “</类别>”)
        .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
            取色花信息 (5, 色花行数组 [色花超级列表框.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .否则
            取色花信息 (6, 色花行数组 [色花超级列表框.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .如果结束


    .否则

    .如果结束

    .如果 (色花超级列表框2.可视 ＝ 真)
        种子 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<种子>”, “</种子>”)
        ' log (“磁力复制到剪贴板：” ＋ 种子)
        .如果 (关闭置剪贴板选择框.选中 ＝ 假)
            剪辑板_置文本 (种子)
        .否则

        .如果结束
        类别 ＝ 文本_取出中间文本 (色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], “<类别>”, “</类别>”)
        .如果 (类别 ＝ “素人” 或 类别 ＝ “有码”)
            取色花信息 (5, 色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .否则
            取色花信息 (6, 色花搜索行数组 [色花超级列表框2.现行选中项 ＋ 1], 0)
            程序_延时 (取随机数 (100, 300))
            色花查看图片 ()
        .如果结束


    .否则

    .如果结束


.否则
    色花缩略图分组框.可视 ＝ 假
    .如果 (_启动窗口.宽度 ≠ 1230)
        _启动窗口.宽度 ＝ 1230
        _启动窗口.高度 ＝ 720
    .否则

    .如果结束



.如果结束


.子程序 _影片信息按钮_被单击

.如果 (文件是否存在 (取运行目录 () ＋ “\MediaInfo.dll”) ＝ 真)
    信息提示 (2)
.否则
    log (“缺少MediaInfo.dll,请将MediaInfo.dll与javgo程序放在同一个文件夹内。”)
.如果结束



.子程序 _搜索编辑框_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 i, 整数型

.如果 (搜索记录高级表格.可视 ＝ 假)
    .计次循环首 (30, i)
        搜索记录高级表格.置数据 (i － 1, 0, 1, 文本_取出中间文本 (搜索历史记录, “<” ＋ 到文本 (i) ＋ “>”, “<” ＋ 到文本 (i) ＋ “>”))
    .计次循环尾 ()
    搜索记录高级表格.置光标 (0, 0)
    搜索记录高级表格.置光标 (-1, -1)
    搜索记录高级表格.可视 ＝ 真
.否则

.如果结束


.子程序 _搜索图形按钮_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

搜索记录高级表格.可视 ＝ 假

.子程序 可视设置


.如果 (头像外形框.可视 ＝ 真)
    头像外形框.可视 ＝ 假
    演员头像显示 ＝ “”
.否则

.如果结束

.如果真 (搜索记录高级表格.可视 ＝ 真)
    搜索记录高级表格.可视 ＝ 假
.如果真结束

.如果真 (下拉高级表格.可视 ＝ 真)
    下拉高级表格.可视 ＝ 假
.如果真结束



.子程序 _顶部横幅外形框_鼠标位置被移动, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

可视设置 ()

.子程序 _搜索记录高级表格_被单击
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.局部变量 行号, 整数型
.局部变量 i, 整数型

行号 ＝ 搜索记录高级表格.取光标行号 () ＋ 1
搜索编辑框.内容 ＝ 文本_取出中间文本 (搜索历史记录, “<” ＋ 到文本 (行号) ＋ “>”, “<” ＋ 到文本 (行号) ＋ “>”)
搜索记录高级表格.可视 ＝ 假


.子程序 _配置环境变量按钮_被单击
.局部变量 环境变量, 文本型

.如果 (文件是否存在 (取特定目录 (9) ＋ “ffmpeg\ffmpeg.exe”) ＝ 真)
    环境变量 ＝ 环境.读环境变量 (真, “PATH”)
    .如果 (环境变量 ＝ #环境变量空)
        环境.写环境变量 (真, “PATH”, 取特定目录 (9) ＋ “ffmpeg;”)
    .否则
        .如果真 (文本_寻找文本 (环境变量, 取特定目录 (9) ＋ “ffmpeg;”, , 真) ＝ -1)
            .如果 (取文本右边 (环境变量, 1) ＝ “;”)
                环境.写环境变量 (真, “PATH”, 环境变量 ＋ 取特定目录 (9) ＋ “ffmpeg;”)
            .否则
                环境.写环境变量 (真, “PATH”, 环境变量 ＋ “;” ＋ 取特定目录 (9) ＋ “ffmpeg;”)
            .如果结束

        .如果真结束

    .如果结束

.否则
    .如果 (文件是否存在 (根目录 ＋ “资源\ffmpeg.exe”) ＝ 真)
        .如果真 (文件是否存在 (取特定目录 (9) ＋ “ffmpeg”) ＝ 假)
            创建目录 (取特定目录 (9) ＋ “ffmpeg”)
        .如果真结束
        .如果真 (文件是否存在 (取特定目录 (9) ＋ “ffmpeg”) ＝ 真)
            文件_复制 (根目录 ＋ “资源\ffmpeg.exe”, 取特定目录 (9) ＋ “ffmpeg\ffmpeg.exe”)
        .如果真结束
        .如果 (文件是否存在 (取特定目录 (9) ＋ “ffmpeg\ffmpeg.exe”) ＝ 真)
            环境变量 ＝ 环境.读环境变量 (真, “PATH”)
            .如果 (环境变量 ＝ #环境变量空)
                环境.写环境变量 (真, “PATH”, 取特定目录 (9) ＋ “ffmpeg;”)
            .否则
                .如果真 (文本_寻找文本 (环境变量, 取特定目录 (9) ＋ “ffmpeg;”, , 真) ＝ -1)
                    .如果 (取文本右边 (环境变量, 1) ＝ “;”)
                        环境.写环境变量 (真, “PATH”, 环境变量 ＋ 取特定目录 (9) ＋ “ffmpeg;”)
                    .否则
                        环境.写环境变量 (真, “PATH”, 环境变量 ＋ “;” ＋ 取特定目录 (9) ＋ “ffmpeg;”)
                    .如果结束

                .如果真结束

            .如果结束

        .否则

        .如果结束


    .否则
        log (“<data\资源>目录下没有ffmpeg.exe文件，请下载后放到文件夹内。”)
    .如果结束

.如果结束

环境变量 ＝ 环境.读环境变量 (真, “PATH”)
.如果 (文本_寻找文本 (环境变量, 取特定目录 (9) ＋ “ffmpeg;”, , 真) ＝ -1)
    配置环境变量按钮.标题 ＝ “配置环境失败”
.否则
    配置环境变量按钮.标题 ＝ “配置环境成功”

.如果结束


.子程序 _裁剪视频按钮_被单击
.局部变量 输出文件名, 文本型

裁剪视频 ()

.子程序 裁剪视频

.如果 (配置环境变量按钮.标题 ＝ “配置环境成功”)
    取耗时 (1)
    禁止 ()
    log (“开始剪切广告，请等待...,”)
    .如果 (裁剪广告外形框.可视 ＝ 真)
        取DOS返回文本1 (“ffmpeg -ss ” ＋ 起始时间编辑框.内容 ＋ “ -to ” ＋ 结束时间编辑框.内容 ＋ “ -accurate_seek -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [1], “to10un”) ＋ #引号 ＋ “ -codec copy -avoid_negative_ts 1 -y ” ＋ #引号 ＋ 编码_U编码转换 (文件_取目录 (接收文件数组 [1]) ＋ 文件_取文件名 (接收文件数组 [1]) ＋ “-裁剪001” ＋ 文件_取扩展名 (接收文件数组 [1]), “to10un”) ＋ #引号, &子程序_显示)
        裁剪广告外形框.可视 ＝ 假
        log (“去除广告完成,” ＋ 取耗时 (2))
    .否则
        取DOS返回文本1 (“ffmpeg -ss ” ＋ 起始编辑框.内容 ＋ “ -to ” ＋ 结束编辑框.内容 ＋ “ -accurate_seek -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [1], “to10un”) ＋ #引号 ＋ “ -codec copy -avoid_negative_ts 1 -y ” ＋ #引号 ＋ 编码_U编码转换 (文件_取目录 (接收文件数组 [1]) ＋ 文件_取文件名 (接收文件数组 [1]) ＋ “-裁剪001” ＋ 文件_取扩展名 (接收文件数组 [1]), “to10un”) ＋ #引号, &子程序_显示)
        log (“去除广告完成,” ＋ 取耗时 (2))

    .如果结束
    取禁 ()

.否则
    log (“请先在其他功能-ffmpeg-内配置环境变量。”)
.如果结束


.子程序 子程序_显示, 逻辑型
.参数 参_显示信息, 文本型

编辑框1.加入文本 (参_显示信息, #换行符)
返回 (假)

.子程序 生成视频预览图
.局部变量 输出文件名, 文本型
.局部变量 时间, 文本型
.局部变量 总时间, 整数型
.局部变量 i, 整数型
.局部变量 k, 整数型

.如果 (配置环境变量按钮.标题 ＝ “配置环境成功”)
    取耗时 (1)
    log (“正在生成预览图，请等待...。”)
    禁止 ()
    .如果 (取数组成员数 (接收文件数组) ＞ 0)
        .计次循环首 (取数组成员数 (接收文件数组), k)
            .如果真 (圆形进度外形框.可视 ＝ 假)
                圆形进度外形框.可视 ＝ 真
                LOGO图形按钮.可视 ＝ 假
            .如果真结束
            进度窗口 (到整数 (k ÷ 取数组成员数 (接收文件数组) × 100))

            时间 ＝ 文本_取出中间文本 (取DOS返回文本1 (“ffmpeg -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [k], “to10un”) ＋ #引号, &子程序_显示), “Duration: ”, “, start”)
            总时间 ＝ 到整数 (取文本左边 (时间, 2)) × 60 ＋ 到整数 (取文本中间 (时间, 4, 2))
            .计次循环首 (20, i)
                取DOS返回文本1 (“ffmpeg -ss ” ＋ 转时间格式 (到整数 (总时间 ÷ 21 × i)) ＋ “ -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [k], “to10un”) ＋ #引号 ＋ “ -f image2 -y -vframes 1 ” ＋ #引号 ＋ 编码_U编码转换 (文件_取目录 (接收文件数组 [k]) ＋ 文件_取文件名 (接收文件数组 [k]) ＋ “-00” ＋ 到文本 (i) ＋ “.jpg”, “to10un”) ＋ #引号, &子程序_显示)
            .计次循环尾 ()
        .计次循环尾 ()
        .如果真 (圆形进度外形框.可视 ＝ 真)
            圆形进度外形框.可视 ＝ 假
            LOGO图形按钮.可视 ＝ 真
        .如果真结束

        log (“生成预览图完成，” ＋ 取耗时 (2))
    .否则
        log (“生成预览图失败，未添加文件。”)
    .如果结束
    取禁 ()

.否则
    log (“请先在其他功能-ffmpeg-内配置环境变量。”)
.如果结束


.子程序 _视频截图按钮_被单击

生成视频预览图 ()

.子程序 转时间格式, 文本型
.参数 整数时间, 整数型
.局部变量 转换时间, 文本型

.如果 (整数时间 ÷ 60 ＝ 0)
    .如果 (整数时间 ＜ 10)
        转换时间 ＝ “00:0” ＋ 到文本 (整数时间) ＋ “:00”
    .否则
        转换时间 ＝ “00:” ＋ 到文本 (整数时间) ＋ “:00”
    .如果结束

.否则
    .如果 (到整数 (整数时间 ÷ 60) ＜ 10)
        .如果 (整数时间 － 到整数 (整数时间 ÷ 60) × 60 ＜ 10)
            转换时间 ＝ “0” ＋ 到文本 (到整数 (整数时间 ÷ 60)) ＋ “:0” ＋ 到文本 (整数时间 － 到整数 (整数时间 ÷ 60) × 60) ＋ “:00”
        .否则
            转换时间 ＝ “0” ＋ 到文本 (到整数 (整数时间 ÷ 60)) ＋ “:” ＋ 到文本 (整数时间 － 到整数 (整数时间 ÷ 60) × 60) ＋ “:00”
        .如果结束

    .否则
        .如果 (整数时间 － 到整数 (整数时间 ÷ 60) × 60 ＜ 10)
            转换时间 ＝ 到文本 (到整数 (整数时间 ÷ 60)) ＋ “:0” ＋ 到文本 (整数时间 － 到整数 (整数时间 ÷ 60) × 60) ＋ “:00”
        .否则
            转换时间 ＝ 到文本 (到整数 (整数时间 ÷ 60)) ＋ “:” ＋ 到文本 (整数时间 － 到整数 (整数时间 ÷ 60) × 60) ＋ “:00”
        .如果结束

    .如果结束

.如果结束
返回 (转换时间)

.子程序 _cmd命令编辑框_按下某键, 逻辑型
.参数 键代码, 整数型
.参数 功能键状态, 整数型
.局部变量 输出文本, 文本型

.如果 (键代码 ＝ 13)
    输出文本 ＝ 取DOS返回文本1 (cmd命令编辑框.内容, &子程序_显示)
.否则

.如果结束


.子程序 _执行命令按钮_被单击

取DOS返回文本1 (cmd命令编辑框.内容, &子程序_显示)



.子程序 _清空列表按钮_被单击

接收文件列表框.全部删除 ()
清除数组 (接收文件数组)

.子程序 _截预览图_被选择

清除数组 (接收文件数组)
.如果 (搜索状态 ＝ 假)
    加入成员 (接收文件数组, 影片 [封面子项].文件)
    生成视频预览图 ()
.否则
    加入成员 (接收文件数组, 搜索 [搜索封面子项].文件)
    生成视频预览图 ()

.如果结束




.子程序 _去除广告_被选择
.局部变量 时间, 文本型

裁剪广告外形框.可视 ＝ 真
清除数组 (接收文件数组)
.如果 (搜索状态 ＝ 假)
    加入成员 (接收文件数组, 影片 [封面子项].文件)
.否则
    加入成员 (接收文件数组, 搜索 [搜索封面子项].文件)
.如果结束
时间 ＝ 文本_取出中间文本 (取DOS返回文本1 (“ffmpeg -i ” ＋ #引号 ＋ 编码_U编码转换 (接收文件数组 [1], “to10un”) ＋ #引号, &子程序_显示), “Duration: ”, “, start”)
结束时间编辑框.内容 ＝ 取文本左边 (时间, 2) ＋ “:” ＋ 取文本中间 (时间, 4, 2) ＋ “:” ＋ 取文本中间 (时间, 7, 2)


.子程序 _开始裁剪广告按钮_被单击

裁剪视频 ()

.子程序 _裁剪广告按钮_被单击

裁剪广告外形框.可视 ＝ 假

.子程序 _合并视频按钮_被单击

合并视频 ()

.子程序 合并视频
.局部变量 输出文件名, 文本型
.局部变量 时间, 文本型
.局部变量 总时间, 整数型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 写出的文本, 文本型

.如果 (配置环境变量按钮.标题 ＝ “配置环境成功”)
    取耗时 (1)
    log (“正在合并视频，请等待...。”)
    禁止 ()
    .如果 (取数组成员数 (接收文件数组) ＞ 0)
        .计次循环首 (取数组成员数 (接收文件数组), k)
            .如果 (k ＝ 1)
                写出的文本 ＝ “file '” ＋ 接收文件数组 [1] ＋ “'”
            .否则
                写出的文本 ＝ 写出的文本 ＋ #换行符 ＋ “file '” ＋ 接收文件数组 [k] ＋ “'”
            .如果结束

        .计次循环尾 ()
        写到文件 (根目录 ＋ “图片\filelist.txt”, 到字节集 (写出的文本))
        取DOS返回文本1 (“ffmpeg -f concat -safe 0 -i ” ＋ #引号 ＋ 编码_U编码转换 (根目录 ＋ “图片\filelist.txt”, “to10un”) ＋ #引号 ＋ “ -c copy ” ＋ #引号 ＋ 编码_U编码转换 (文件_取目录 (接收文件数组 [1]) ＋ 文件_取文件名 (接收文件数组 [1]) ＋ “-合并001” ＋ 文件_取扩展名 (接收文件数组 [1]), “to10un”) ＋ #引号 ＋ “ -y”, &子程序_显示)

        log (“合并视频完成，” ＋ 取耗时 (2))
    .否则
        log (“合并视频失败，未添加文件。”)
    .如果结束
    取禁 ()

.否则
    log (“请先在其他功能-ffmpeg-内配置环境变量。”)
.如果结束


.子程序 _ffmpeg提示_被单击

信息提示 (3)

.子程序 _目录提示_被单击

信息提示 (4)

.子程序 _色花超级列表框_右键单击表项

弹出菜单 (复制, , )

.子程序 _色花超级列表框2_右键单击表项

弹出菜单 (复制, , )

.子程序 _刷新所有目录按钮_被单击
.局部变量 i, 整数型

禁止 ()
目录刷新状态 ＝ 真
封面项 ＝ 0
加载索引 (“所有影片”)

.计次循环首 (取数组成员数 (目录数组), i)
    .如果 (取文本右边 (目录数组 [i], 5) ≠ “%.txt”)
        .如果 (取文本右边 (目录数组 [i], 5) ≠ “#.txt”)
            生成索引 (文本_取出中间文本 (编码_Utf8到Ansi (读入文件 (目录数组 [i])), “<目录路径>”, “</目录路径>”), 真)
        .否则

        .如果结束

    .否则

    .如果结束

.计次循环尾 ()


目录刷新状态 ＝ 假
取禁 ()


.子程序 本地刮削
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 刮削数组, 文本型, , "0"
.局部变量 文件数, 整数型
.局部变量 路径, 文本型
.局部变量 文件名, 文本型
.局部变量 分割, 文本型, , "0"
.局部变量 分割2, 文本型, , "0"
.局部变量 刮削文件数组, 文本型, , "0"
.局部变量 番号, 文本型
.局部变量 完成数, 整数型
.局部变量 位置序号, 整数型
.局部变量 路径2, 文本型
.局部变量 路径3, 文本型
.局部变量 写出文件路径, 文本型

禁止 ()
取耗时 (1)
路径 ＝ 目录_浏览 ()
清除数组 (刮削文件数组)
清除数组 (刮削文件番号)
.如果 (路径 ≠ “”)
    .如果 (文件_是否存在 (本地刮削编辑框.内容) ＝ 真)
        log (“加载封面目录索引”)
        .如果 (取数组成员数 (本地刮削分割) ＝ 0)
            本地刮削分割 ＝ 分割文本 (编码_Utf8到Ansi (读入文件 (本地刮削编辑框.内容)), #换行符, )
        .否则

        .如果结束
        .计次循环首 (取数组成员数 (本地刮削分割), i)
            分割2 ＝ 分割文本 (本地刮削分割 [i], “|”, )
            加入成员 (刮削文件数组, 文件_取目录 (分割2 [1]))
            .如果 (取数组成员数 (分割2) ＞ 1)
                加入成员 (刮削文件番号, 文本_到大写 (文本_取出中间文本 (本地刮削分割 [i], “<id>”, “<id>”, , 真)))
            .否则
                加入成员 (刮削文件番号, “空”)
            .如果结束

        .计次循环尾 ()
        文件_枚举_升级版 (路径, #视频格式, 刮削数组, 0, 假, 真)
        .计次循环首 (取数组成员数 (刮削数组), k)
            log (到文本 (k) ＋ “/” ＋ 到文本 (取数组成员数 (刮削数组)))
            文件名 ＝ 文本_到大写 (文件_取文件名 (刮削数组 [k]))
            .如果真 (取文本右边 (文件名, 2) ＝ “-C”)
                文件名 ＝ 文本_删右边 (文件名, 2)
            .如果真结束

            位置序号 ＝ 取所在位置 (文件名)
            .如果 (位置序号 ≠ 0)
                路径2 ＝ 路径 ＋ 取上层文件夹名 (刮削文件数组 [位置序号])
                创建目录 (路径2)
                目录_复制 (文本_删右边 (刮削文件数组 [位置序号], 1), 路径2)
                路径3 ＝ 文件_取目录 (刮削数组 [k]) ＋ 取上层文件夹名 (刮削文件数组 [位置序号]) ＋ 文件_取扩展名 (刮削数组 [k])
                文件_改名 (刮削数组 [k], 路径3)
                写出文件路径 ＝ 路径2 ＋ “\” ＋ 取上层文件夹名 (刮削文件数组 [位置序号]) ＋ 文件_取扩展名 (刮削数组 [k])
                .如果 (文件_是否存在 (写出文件路径) ＝ 真)

                    .如果 (文件_取大小 (写出文件路径) ＝ 0)
                        文件_删除 (写出文件路径)
                    .否则

                    .如果结束

                .否则

                .如果结束
                文件_移动 (路径3, 路径2 ＋ “\” ＋ 取上层文件夹名 (刮削文件数组 [位置序号]) ＋ 文件_取扩展名 (刮削数组 [k]))
            .否则

            .如果结束

        .计次循环尾 ()
        log (“刮削完成，” ＋ 取耗时 (2))
    .否则
        log (“没有找到封面目录索引文件，请填入正确路径。>”)
    .如果结束

.否则
    log (“请选择正确的路径”)
.如果结束
取禁 ()



.子程序 取所在位置, 整数型
.参数 内容, 文本型
.局部变量 i, 整数型

.计次循环首 (取数组成员数 (刮削文件番号), i)
    .如果真 (内容 ＝ 刮削文件番号 [i])
        返回 (i)
    .如果真结束

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


.子程序 取上层文件夹名, 文本型
.参数 路径, 文本型
.局部变量 临时分割文本, 文本型, , "0"

临时分割文本 ＝ 分割文本 (路径, “\”, )
返回 (临时分割文本 [取数组成员数 (临时分割文本)])

.子程序 _本地刮削按钮_被单击

线程_启动 (&本地刮削)


.子程序 子程序4
.局部变量 局_信息, WIN32_FIND_DATA
.局部变量 句柄啊, 整数型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型

' 文件_枚举_升级版2 (“D:\1\”, “mp4”, 临时数组, 0, 假, 真)
.' 计次循环首 (取数组成员数 (临时数组), i)
    ' 调试输出 (临时数组 [i] ＋ “A”)
.' 计次循环尾 ()
句柄啊 ＝ FindFirstFileW (编码_Ansi到Unicode (“Y:\*”, ), 局_信息)
.循环判断首 ()

.循环判断尾 (FindNextFileW (句柄啊, 局_信息) ≠ 0)
FindClose (句柄啊)


.子程序 文件_枚举_升级版2, 整数型, , 提供一个目录,获取目录下指定格式文件,成功返回获取到的数量,失败返回0
.参数 欲寻找的目录, 文本型, 可空, 提供一个目录,比如 “c:” 为空则搜索程序运行的目录
.参数 欲寻找的文件名, 文本型, 可空, 提供一个或多个扩展名,多个扩展名请用"|" 隔开,扩展名的点可加可不加,比如: ".jpg|exe|png|.e" 留空则获取全部搜索到的文件
.参数 文件数组名, 文本型, 参考 可空 数组, 提供一个文本型的数组变量,接受结果
.参数 路径格式, 整数型, 可空, 0为获取完整路径,比如"c:\123.txt" 1为获取文件名,含扩展名,比如"123.txt" 2为文件名,不含扩展名 比如"123" 默认为0,获取完整路径
.参数 是否添加目录, 逻辑型, 可空, 为真时,搜索到的目录也加入到文件数组,默认为假,不加入目录
.参数 是否包含子目录, 逻辑型, 可空, 为真则子目录下文件也搜索,默认为假,不搜索子目录
.局部变量 局_搜索文件, 文本型
.局部变量 局_扩展名, 文本型, , "0"
.局部变量 局_搜到文件, 文本型
.局部变量 局_加入的文件, 文本型
.局部变量 i, 整数型
.局部变量 局_信息, WIN32_FIND_DATA
.局部变量 句柄啊, 整数型

.如果真 (欲寻找的目录 ＝ “”)
    欲寻找的目录 ＝ 取运行目录 ()
.如果真结束
.如果真 (取文本右边 (欲寻找的目录, 1) ≠ “\”)
    欲寻找的目录 ＝ 欲寻找的目录 ＋ “\”
.如果真结束
句柄啊 ＝ FindFirstFileW (编码_Ansi到Unicode (欲寻找的目录 ＋ “*.MP4”, ), 局_信息)
局_搜索文件 ＝ 编码_Unicode到Ansi (到字节集 (局_信息.cFileName))

.判断循环首 (局_搜索文件 ≠ “”)
    处理事件 ()
    .判断开始 (欲寻找的文件名 ＝ “*.*” 或 欲寻找的文件名 ＝ “.*” 或 欲寻找的文件名 ＝ “*”)
        局_搜到文件 ＝ 局_搜索文件
    .判断 (是否为空 (欲寻找的文件名) ＝ 假 且 欲寻找的文件名 ≠ “”)
        局_扩展名 ＝ 分割文本 (欲寻找的文件名, “|”, )
        .计次循环首 (取数组成员数 (局_扩展名), i)
            .如果真 (取文本左边 (局_扩展名 [i], 1) ≠ “.”)
                局_扩展名 [i] ＝ “.” ＋ 局_扩展名 [i]
            .如果真结束
            .如果真 (到小写 (局_扩展名 [i]) ＝ 到小写 (取文本右边 (局_搜索文件, 取文本长度 (局_扩展名 [i]))))
                局_搜到文件 ＝ 局_搜索文件
                跳出循环 ()
            .如果真结束

        .计次循环尾 ()
    .默认
        局_搜到文件 ＝ 局_搜索文件
    .判断结束

    .如果真 (局_搜到文件 ≠ “”)
        .判断开始 (路径格式 ＝ 0)
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件
        .判断 (路径格式 ＝ 1)
            局_加入的文件 ＝ 局_搜到文件
        .判断 (路径格式 ＝ 2)
            局_加入的文件 ＝ 取文本左边 (局_搜到文件, 倒找文本 (局_搜到文件, “.”, , 假) － 1)
        .默认
            局_加入的文件 ＝ 欲寻找的目录 ＋ 局_搜到文件  ' 其他情况都返回全路径
        .判断结束
        加入成员 (文件数组名, 局_加入的文件)
    .如果真结束
    局_搜到文件 ＝ “”
    局_搜索文件 ＝ 寻找文件 (, )
.判断循环尾 ()

.如果真 (是否添加目录 或 是否包含子目录)
    句柄啊 ＝ FindFirstFileW (编码_Ansi到Unicode (欲寻找的目录, ), 局_信息)
    局_搜索文件 ＝ 编码_Unicode到Ansi (到字节集 (局_信息.cFileName))

    .判断循环首 (局_搜索文件 ≠ “”)
        .如果真 (取文本左边 (局_搜索文件, 1) ≠ “.”)
            .如果真 (是否添加目录)
                加入成员 (文件数组名, 欲寻找的目录 ＋ 局_搜索文件)
            .如果真结束
            .如果真 (是否包含子目录)
                文件_枚举_升级版2 (欲寻找的目录 ＋ 局_搜索文件, 欲寻找的文件名, 文件数组名, 路径格式, 是否添加目录, 是否包含子目录)  ' 递归
            .如果真结束

        .如果真结束
        局_搜索文件 ＝ 寻找文件 (, #子目录)
    .判断循环尾 ()
    FindClose (句柄啊)
.如果真结束
返回 (取数组成员数 (文件数组名))


.子程序 处理函数_希尔_自定义_影片, 整数型, , 只有处理类型为3的时候需要返回正确的值，其他时候可返回任意值。请注意：本函数的执行效率直接影响排序效率，避免加入多余代码
.参数 处理类型, 整数型, , 0:索引2的值覆盖索引1的值 1.保存索引1值到临时变量 2.将临时变量还原至索引1 3.临时变量与索引1的值比较(临时变量大于索引1的值返回1，等于返回0，小于返回-1)
.参数 索引1, 整数型, , 索引从1开始
.参数 索引2, 整数型, , 索引从1开始
.参数 自定义参数, 整数型
.局部变量 临时变量, 影片数组, 静态, , 静态一定要勾选，否则此数据会丢失。本变量的数据类型根据自己的需要修改

.判断开始 (处理类型 ＝ 0)  ' 索引2的值覆盖索引1的值
    影片 [索引1] ＝ 影片 [索引2]
.判断 (处理类型 ＝ 1)  ' 保存索引1值到临时变量
    临时变量 ＝ 影片 [索引1]
.判断 (处理类型 ＝ 2)  ' 将临时变量还原至索引1
    影片 [索引1] ＝ 临时变量
.判断 (处理类型 ＝ 3)  ' 临时变量与索引1的值比较(临时变量大于索引1的值返回1，等于返回0，小于-1)
    .判断开始 (临时变量.整数 ＞ 影片 [索引1].整数)  ' 临时变量大于索引1的值返回1
        返回 (1)
    .判断 (临时变量.整数 ＝ 影片 [索引1].整数)  ' 临时变量等于索引1的值返回0
        返回 (0)
    .判断 (临时变量.整数 ＜ 影片 [索引1].整数)  ' 临时变量小于索引1的值返回-1
        返回 (-1)
    .默认
        返回 (-1)  ' 默认比较结果
    .判断结束

.默认

.判断结束
返回 (0)  ' 其他返回任意值


.子程序 处理函数_希尔_自定义_影片2, 整数型, , 只有处理类型为3的时候需要返回正确的值，其他时候可返回任意值。请注意：本函数的执行效率直接影响排序效率，避免加入多余代码
.参数 处理类型, 整数型, , 0:索引2的值覆盖索引1的值 1.保存索引1值到临时变量 2.将临时变量还原至索引1 3.临时变量与索引1的值比较(临时变量大于索引1的值返回1，等于返回0，小于返回-1)
.参数 索引1, 整数型, , 索引从1开始
.参数 索引2, 整数型, , 索引从1开始
.参数 自定义参数, 整数型
.局部变量 临时变量, 影片数组, 静态, , 静态一定要勾选，否则此数据会丢失。本变量的数据类型根据自己的需要修改

.判断开始 (处理类型 ＝ 0)  ' 索引2的值覆盖索引1的值
    影片 [索引1] ＝ 影片 [索引2]
.判断 (处理类型 ＝ 1)  ' 保存索引1值到临时变量
    临时变量 ＝ 影片 [索引1]
.判断 (处理类型 ＝ 2)  ' 将临时变量还原至索引1
    影片 [索引1] ＝ 临时变量
.判断 (处理类型 ＝ 3)  ' 临时变量与索引1的值比较(临时变量大于索引1的值返回1，等于返回0，小于-1)
    .判断开始 (临时变量.时间 ＞ 影片 [索引1].时间)  ' 临时变量大于索引1的值返回1
        返回 (1)
    .判断 (临时变量.时间 ＝ 影片 [索引1].时间)  ' 临时变量等于索引1的值返回0
        返回 (0)
    .判断 (临时变量.时间 ＜ 影片 [索引1].时间)  ' 临时变量小于索引1的值返回-1
        返回 (-1)
    .默认
        返回 (-1)  ' 默认比较结果
    .判断结束

.默认

.判断结束
返回 (0)  ' 其他返回任意值


.子程序 开场动画1
.参数 y, 双精度小数型
.参数 百分比, 双精度小数型
.局部变量 缓动透明度, 整数型
.局部变量 i, 整数型

缓动透明度 ＝ 240 × 百分比 ÷ 100
LOGO图形按钮.顶边 ＝ y ＋ 8  ' <!!!>
LOGO标签.顶边 ＝ y ＋ 8
封面分组框.顶边 ＝ y ＋ 55
搜索外形框.顶边 ＝ y ＋ 61
下拉图形按钮2.顶边 ＝ y ＋ 112
下拉图形按钮.顶边 ＝ y ＋ 112
_竖线.顶边 ＝ y ＋ 60
温馨提示.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 30
左箭头.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 35
右箭头.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 35
页数标签.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 32
窗口_大小控制.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 20
竖线_标签3.顶边 ＝ y ＋ 188
竖线_标签1.顶边 ＝ y ＋ 108
标签_分割线.顶边 ＝ y ＋ 窗口_下拉列表.高度 － 40
代理.顶边 ＝ y ＋ 16
帮助.顶边 ＝ y ＋ 16
设置2.顶边 ＝ y ＋ 16
设置.顶边 ＝ y ＋ 16
截图.顶边 ＝ y ＋ 16
最大化.顶边 ＝ y ＋ 16
最小化.顶边 ＝ y ＋ 16
关闭.顶边 ＝ y ＋ 16
.计次循环首 (10, i)
    文件夹超级按钮数组 [i].顶边 ＝ y ＋ 85 ＋ 55 × (i － 0)
    文件夹图形按钮数组 [i].顶边 ＝ y ＋ 95 ＋ 55 × (i － 0)
.计次循环尾 ()
.如果 (缓动可视状态 ＝ 假)
    缓动可视状态 ＝ 真
    .计次循环首 (10, i)
        文件夹超级按钮数组 [i].可视 ＝ 真
        文件夹图形按钮数组 [i].可视 ＝ 真
    .计次循环尾 ()
    LOGO图形按钮.可视 ＝ 真
    LOGO标签.可视 ＝ 真
    搜索外形框.可视 ＝ 真
    下拉图形按钮2.可视 ＝ 真
    下拉图形按钮.可视 ＝ 真
    封面分组框.可视 ＝ 真
    ' 竖线_标签3.可视 ＝ 真
    ' _竖线.可视 ＝ 真
    ' 竖线_标签1.可视 ＝ 真
    标签_分割线.可视 ＝ 真
    窗口_大小控制.可视 ＝ 真
    温馨提示.可视 ＝ 真
    右箭头.可视 ＝ 真
    左箭头.可视 ＝ 真
    页数标签.可视 ＝ 真
    代理.可视 ＝ 真
    帮助.可视 ＝ 真
    设置2.可视 ＝ 真
    设置.可视 ＝ 真
    截图.可视 ＝ 真
    最大化.可视 ＝ 真
    最小化.可视 ＝ 真
    关闭.可视 ＝ 真

.否则

.如果结束




.子程序 进度窗口
.参数 角度
.局部变量 i, 整数型
.局部变量 hDC
.局部变量 Graphics, GP缓存图形
.局部变量 Brush, GP纯色画刷
.局部变量 默认矩形, 矩形L
.局部变量 进度矩形, 矩形L
.局部变量 g_time, 日期时间型
.局部变量 文本矩形, 矩形F



延迟 (7)  ' 高精度等待延迟

' -------------------------------------- 置外形
默认矩形 ＝ 制矩形L (0, 0, 置宽度, 置高度)
进度矩形 ＝ 制矩形L (0, 0, 默认矩形.宽度, 默认矩形.高度)  ' 秒
' -------------------------------------- 创建背景色及图形
hDC ＝ GetDC (句柄)
Graphics.创建 (宽度, 高度)
Graphics.置平滑模式 (#平滑模式_最佳质量)
Graphics.置文本渲染模式 (#文本渲染模式_ClearType文本和hinting技术)
Graphics.清除 (RGB到ARGB (取颜色值 (42, 42, 49)))
' -------------------------------------- 画圆形
画弧形 (Graphics.取指针 (), 进度矩形, RGB到ARGB (#银白, 180), RGB到ARGB (取颜色值 (0, 224, 128), ), -90, 角度 × 3.6)
' 画弧形 (Graphics.取指针 (), 进度矩形, RGB到ARGB (#银白, 180), RGB到ARGB (取颜色值 (240, 209, 52), ), -90, 角度 × 3.6)
' -------------------------------------- 画中间文本
Brush.创建 (RGB到ARGB (取颜色值 (0, 224, 128), ))
' Brush.创建 (RGB到ARGB (取颜色值 (240, 209, 52), ))
文本矩形 ＝ 制矩形F (默认矩形.左边, 默认矩形.顶边, 默认矩形.宽度, 默认矩形.高度)
' -------------------------------------- 画进度数字
Graphics.画文本 (到文本 (角度) ＋ “%”, 字体, Brush, 文本矩形, 文本格式)
' -------------------------------------- 复制动画
Graphics.复制到DC (hDC)
Graphics.销毁 ()
Brush.销毁 ()
ReleaseDC (句柄, hDC)


.子程序 画弧形
.参数 图形指针, 整数型
.参数 外矩形, 矩形L
.参数 底弧颜色
.参数 顶弧颜色
.参数 开始角度
.参数 结束角度
.局部变量 brush, GP纯色画刷
.局部变量 矩形_内, 矩形L
.局部变量 矩形_外, 矩形L

矩形_外 ＝ 外矩形
矩形_内 ＝ 制矩形L (矩形_外.左边 ＋ 3, 矩形_外.顶边 ＋ 3, 矩形_外.宽度 － 6, 矩形_外.高度 － 6)

brush.创建 (底弧颜色)
GdipFillEllipseI (图形指针, brush.取指针 (), 矩形_内.左边, 矩形_内.顶边, 矩形_内.宽度, 矩形_内.高度)  ' 填充椭圆
brush.置颜色 (RGB到ARGB (取颜色值 (42, 42, 49)))
GdipFillEllipseI (图形指针, brush.取指针 (), 矩形_内.左边 ＋ 3, 矩形_内.顶边 ＋ 3, 矩形_内.宽度 － 6, 矩形_内.高度 － 6)  ' 填充椭圆

brush.置颜色 (顶弧颜色)
GdipFillPieI (图形指针, brush.取指针 (), 矩形_外.左边 ＋ 3, 矩形_外.顶边 ＋ 3, 矩形_外.宽度 － 6, 矩形_外.高度 － 6, 开始角度, 结束角度)  ' 填充饼

brush.置颜色 (RGB到ARGB (取颜色值 (42, 42, 49)))
GdipFillEllipseI (图形指针, brush.取指针 (), 矩形_外.左边 ＋ 9, 矩形_外.顶边 ＋ 9, 矩形_外.宽度 － 18, 矩形_外.高度 － 18)  ' 填充饼

brush.销毁 ()

.子程序 _图片拼接按钮_被单击
.局部变量 输出文件名, 文本型
.局部变量 时间, 文本型
.局部变量 总时间, 整数型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 图片字节集数组, 字节集, , "0"
.局部变量 图片, 字节集
.局部变量 图片宽度, 整数型
.局部变量 图片高度, 整数型
.局部变量 剪辑板文件, 文本型, , "1"
.局部变量 临时数组, 文本型, , "0"
.局部变量 文件名, 文本型


取耗时 (1)
log (“正在生成拼图，请等待...。”)
禁止 ()
.如果 (取数组成员数 (接收文件数组) ＞ 0)
    图片 ＝ 读入文件 (接收文件数组 [1])
    图片宽度 ＝ 图片_取宽度 (图片)
    .计次循环首 (取数组成员数 (接收文件数组), k)
        图片 ＝ 读入文件 (接收文件数组 [k])
        图片 ＝ 图片_缩放_透明 (图片, 图片宽度, 到整数 (图片宽度 ÷ 图片_取宽度 (图片) × 图片_取高度 (图片)))
        加入成员 (图片字节集数组, 图片_到24位图 (图片))
    .计次循环尾 ()
    .计次循环首 (取数组成员数 (接收文件数组) － 1, k)
        .如果 (k ＝ 1)
            图片 ＝ 图片合并 (图片字节集数组 [k], 图片字节集数组 [k ＋ 1])
        .否则
            图片 ＝ 图片合并 (图片, 图片字节集数组 [k ＋ 1])
        .如果结束

    .计次循环尾 ()

    文件_枚举_升级版 (根目录 ＋ “图片”, “jpg”, 临时数组, 0, , )

    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            .如果 (文本_寻找文本 (文件_取文件名 (临时数组 [i]), “临时拼图”) ≠ -1)
                文件_删除 (临时数组 [i])
            .否则

            .如果结束

        .计次循环尾 ()
    .否则

    .如果结束
    文件名 ＝ 根目录 ＋ “图片\临时拼图_” ＋ 到文本 (取现行时间 ()) ＋ “.jpg”
    写到文件 (文件名, 图片_转换Ex (图片, 2))
    剪辑板文件 [1] ＝ 文件名
    剪辑板_置文件 (剪辑板文件)
    log (“生成纵向拼图完成已复制到剪贴板，” ＋ 取耗时 (2))
.否则
    log (“生成纵向拼图失败，未添加文件。”)
.如果结束
取禁 ()


.子程序 图片合并, 字节集
.参数 img1, 字节集
.参数 img2, 字节集
.局部变量 位图1, 位图
.局部变量 位图2, 位图
.局部变量 位图3, 位图

位图1.载入数据 (img1)
位图2.载入数据 (img2)
位图3.创建 (位图1.取宽度 (), 位图1.取高度 () ＋ 位图2.取高度 (), 位图1.取位深度 (), )
位图1.复制到 (0, 0, 位图1.取宽度 (), 位图1.取高度 (), 位图3, 0, 0, )
位图2.复制到 (0, 0, 位图2.取宽度 (), 位图2.取高度 (), 位图3, 0, 位图1.取高度 (), )
返回 (位图3.取位图数据 ())

.子程序 子程序x
.局部变量 番号, 文本型
.局部变量 正则, 正则表达式类
.局部变量 r, 文本型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 网址, 文本型
.局部变量 番号数组, 文本型, , "0"

.计次循环首 (685, i)

    .如果真 (圆形进度外形框.可视 ＝ 假)
        圆形进度外形框.可视 ＝ 真
        LOGO图形按钮.可视 ＝ 假
    .如果真结束
    进度窗口 (到整数 (i ÷ 648 × 100))

    r ＝ 编码_Utf8到Ansi (网页_访问 (“http://www.playno1.com/portal.php?mod=list&catid=78&page=” ＋ 到文本 (i), , , #剑大cookies, , , , , , “127.0.0.1:1080”, ))
    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “您進入的網址有誤”) ＝ -1)
            正则.创建 (#剑大, r)
            .计次循环首 (正则.取匹配数量 (), k)
                番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (k), “<a href=” ＋ #引号, #引号 ＋ “ class=” ＋ #引号 ＋ “xi2” ＋ #引号 ＋ “>”)

                加入成员 (番号数组, 番号)
            .计次循环尾 ()
        .否则

        .如果结束

    .否则

    .如果结束

.计次循环尾 ()
.如果真 (圆形进度外形框.可视 ＝ 真)
    圆形进度外形框.可视 ＝ 假
    LOGO图形按钮.可视 ＝ 真
.如果真结束
写到文本 (番号数组, , “文章.TXT”, , )


.子程序 _浏览器关闭按钮_被单击

影片刮削分组框.可视 ＝ 假

.子程序 _代理选择框_被单击

.如果 (代理选择框.选中 ＝ 真)
    代理IP ＝ 代理编辑框.内容
    代理.点燃图片 ＝ #代理普通
    代理.正常图片 ＝ #代理点燃
.否则
    代理IP ＝ “”
    代理.点燃图片 ＝ #代理点燃
    代理.正常图片 ＝ #代理普通
.如果结束




.子程序 _开始刮削按钮_被单击

线程_启动 (&影片刮削)

.子程序 影片刮削
.局部变量 路径, 文本型
.局部变量 临时数组, 文本型, , "0"
.局部变量 i, 整数型

禁止 ()
取耗时 (1)
刮削javbus编辑框.内容 ＝ 是否有下划线 (刮削javbus编辑框.内容)
刮削jav321编辑框.内容 ＝ 是否有下划线 (刮削jav321编辑框.内容)
log (“开始刮削影片。”)
刮削日志 (“开始刮削影片。”)
清除数组 (刮削影片路径)
路径 ＝ 目录_浏览 (“影片刮削”)
' 路径 ＝ “F:\1”
.如果 (路径 ≠ “”)
    .如果 (刮削子文件夹选择框.选中 ＝ 真)
        文件_枚举_升级版 (路径, #视频格式, 临时数组, 0, 假, 真)
    .否则
        文件_枚举_升级版 (路径, #视频格式, 临时数组, 0, 假, 假)
    .如果结束

    .如果 (取数组成员数 (临时数组) ＞ 0)
        .计次循环首 (取数组成员数 (临时数组), i)
            加入成员 (刮削影片路径, 临时数组 [i])
        .计次循环尾 ()
        刮削日志 (“找到” ＋ 到文本 (取数组成员数 (临时数组)) ＋ “部影片”)
        开始爬取 ()
    .否则
        取禁 ()
        log (“未找到视频文件。”)
        刮削日志 (“未找到视频文件。”)

    .如果结束

.否则
    取禁 ()
    log (“请选择正确的文件夹。”)
    刮削日志 (“请选择正确的文件夹。”)

.如果结束


.子程序 开始爬取
.局部变量 爬取总数量, 整数型, , , 这里不太严谨，因为随时都有多个线程在执行，有可能后几个线程浪费掉，不过无所谓啦，反正一千多条才浪费几个线程
.局部变量 i, 整数型

.如果 (刮削javdb选择框.选中 ＝ 真)
    总线程 ＝ 1
.否则
    总线程 ＝ 到整数 (刮削线程数编辑框.内容)
.如果结束

爬虫线程池.创建 (总线程, 假, 10)  ' 我把插入列表框的部分全部注释了，如果打开记得把第二个假 参数 改为真
爬取总数量 ＝ 取数组成员数 (刮削影片路径)
总爬取量 ＝ 取数组成员数 (刮削影片路径)

.判断循环首 (真)
    ' 进度百分比标签.标题 ＝ “进度：” ＋ 到文本 (到整数 (当前完成位置 ÷ 取数组成员数 (文本组) × 100)) ＋ “%”

    .如果 (当前抓取位置 ≥ 爬取总数量)  ' 为什么大于可以看下上面的变量注释
        .如果 (当前完成位置 ≥ 爬取总数量)
            ' 进度百分比标签.标题 ＝ “进度：” ＋ 到文本 (到整数 (当前完成位置 ÷ 取数组成员数 (文本组) × 100)) ＋ “%”

            跳出循环 ()

        .否则

        .如果结束


    .否则
        .如果真 (总线程 ＞ 线程数量)
            .如果 (刮削javbus选择框.选中 ＝ 真)
                爬虫线程池.投递任务 (&bus刮削, )
            .否则
                .如果 (刮削jav321选择框.选中 ＝ 真)
                    爬虫线程池.投递任务 (&jav321刮削, )
                .否则
                    .如果 (刮削library选择框.选中 ＝ 真)
                        爬虫线程池.投递任务 (&library刮削, )
                    .否则
                        .如果 (刮削javdb选择框.选中 ＝ 真)
                            爬虫线程池.投递任务 (&javdb刮削, )
                        .否则

                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

        .如果真结束
        延迟 (100)
        处理事件 ()  ' 避免界面假死

    .如果结束


    ' 线程进度标签.标题 ＝ “完成：” ＋ 到文本 (当前完成位置) ＋ “|线程：” ＋ 到文本 (线程数量)
.判断循环尾 ()

当前抓取位置 ＝ 0
当前完成位置 ＝ 0
log (“刮削影片完成。” ＋ 取耗时 (2))
取禁 ()

.子程序 bus刮削
.局部变量 正则, 正则表达式类
.局部变量 id, 整数型
.局部变量 r, 文本型
.局部变量 图片, 字节集
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 a, 整数型, , "2"
.局部变量 题目, 文本型
.局部变量 封面, 文本型
.局部变量 号番, 文本型
.局部变量 网址数组, 文本型, , "0"
.局部变量 发行日期, 文本型
.局部变量 长度, 文本型
.局部变量 导演, 文本型
.局部变量 导演分割, 文本型, , "99"
.局部变量 制作商, 文本型
.局部变量 制作商分割, 文本型, , "99"
.局部变量 发行商, 文本型
.局部变量 发行商分割, 文本型, , "99"
.局部变量 系列, 文本型
.局部变量 系列分割, 文本型, , "99"
.局部变量 演员, 文本型, , "9999"
.局部变量 演员分割, 文本型, , "99"
.局部变量 演员累加, 文本型
.局部变量 类别, 文本型, , "9999"
.局部变量 类别分割, 文本型, , "99"
.局部变量 类别累加, 文本型
.局部变量 标签累加, 文本型
.局部变量 nfo文本, 文本型
.局部变量 系别, 文本型, , "999"
.局部变量 路径, 文本型
.局部变量 文件数, 文本型, , "0"
.局部变量 图片号, 整数型
.局部变量 磁力链接, 文本型
.局部变量 封面2, 文本型
.局部变量 二封面, 文本型
.局部变量 根路径, 文本型
.局部变量 宽, 整数型
.局部变量 高, 整数型
.局部变量 网址, 文本型
.局部变量 番号, 文本型
.局部变量 简介, 文本型
.局部变量 文件名, 文本型
.局部变量 过滤字符, 文本型, , "0"
.局部变量 临时文本, 文本型
.局部变量 预览图网址, 文本型, , "0"
.局部变量 临时文件名, 文本型, , "0"
.局部变量 影片文件夹名, 文本型
.局部变量 影片文件名, 文本型
.局部变量 演员名字, 文本型
.局部变量 翻译结果, 文本型
.局部变量 刮削状态, 逻辑型

增加一个线程 ()
许可_位置.进入 ()  ' 修改一下当前进行到的位置
当前抓取位置 ＝ 当前抓取位置 ＋ 1
id ＝ 当前抓取位置  ' 拿到自己应该处理的位置，然后存到局部变量里面
刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ 刮削影片路径 [id])
许可_位置.退出 ()
刮削状态 ＝ 假

文件名 ＝ 文件_取文件名 (刮削影片路径 [id])
.如果 (到大写 (取文本右边 (文件名, 2)) ＝ “-C”)
    文件名 ＝ 文本_删右边 (文件名, 2)
.否则

.如果结束
.如果 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “无码”)
    文件名 ＝ 文本_替换 (文件名, , , , “ ”, “”, )
.否则
    文件名 ＝ 文本_替换 (文件名, , , , “ ”, “”, “_”, “-”)

.如果结束
过滤字符 ＝ 分割文本 (过滤字符串编辑框.内容, “/”, )
.计次循环首 (取数组成员数 (过滤字符), i)
    文件名 ＝ 文本_替换 (文件名, , , , 过滤字符 [i], “”)
.计次循环尾 ()
.如果真 (正则番号选择框.选中)
    文件名 ＝ 文件名正则番号 (文件名)
.如果真结束
.如果 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “欧美”)
    r ＝ 网页_访问S (“https://www.javbus.one/search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)
.否则
    .如果 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “无码”)
        r ＝ 网页_访问S (刮削javbus编辑框.内容 ＋ “uncensored/search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)
        写到文件 (根目录 ＋ “写出网页.txt”, 到字节集 (r))
    .否则
        r ＝ 网页_访问S (刮削javbus编辑框.内容 ＋ “search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)
    .如果结束

.如果结束

.如果 (取文本长度 (r) ＞ 500)
    .如果 (文本_寻找文本 (r, “您進入的網址有誤”) ＝ -1)
        正则.创建 (#页面番号, r)
        .计次循环首 (正则.取匹配数量 (), i)
            番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<date>”, “</date> / <date>”)
            .如果 (到大写 (番号) ≠ 到大写 (文件名))
                网址 ＝ “空”
            .否则
                正则.创建 (#番号网址, r)
                网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #番号网址头, #番号网址尾)
                跳出循环 ()
            .如果结束

        .计次循环尾 ()


    .否则

    .如果结束

.否则

.如果结束

.如果 (网址 ≠ “空”)
    .如果 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “欧美”)
        r ＝ 网页_访问S (网址, , , , , , , , , , 代理IP, , , 超时时间)
    .否则
        r ＝ 网页_访问S (网址, , , , , , , , , , 代理IP, , , 超时时间)
    .如果结束
    根路径 ＝ 文件_取目录 (刮削影片路径 [id])
    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “沒有您要的結果！”) ＝ -1)
            .如果 (文本_寻找文本 (r, “您進入的網址有誤”) ＝ -1)
                磁力链接 ＝ 刮削获取磁力链接 (r)
                正则.创建 (#标题, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    题目 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<h3>”, “</h3>”)
                .计次循环尾 ()
                .如果 (题目 ＝ “”)
                    正则.创建 (#标题2, 到文本 (r))
                    .计次循环首 (正则.取匹配数量 (), i)
                        题目 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<h3>”, “</h3>”)
                    .计次循环尾 ()
                .否则

                .如果结束


                封面 ＝ “”
                正则.创建 (#封面网址, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    封面 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #封面头, #封面尾) ＋ “_b.jpg”
                    .如果真 (文本_取出中间文本 (正则.取匹配文本 (i), #封面头, #封面尾) ≠ “”)
                        跳出循环 ()
                    .如果真结束
                    ' 二封面 ＝ “https://images.javbus.one/thumb/” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #封面头2, #封面尾) ＋ “.jpg”
                .计次循环尾 ()

                .如果 (封面 ＝ “”)
                    正则.创建 (#封面网址2, 到文本 (r))
                    .计次循环首 (正则.取匹配数量 (), i)
                        封面 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #封面头, #封面尾2) ＋ “pl.jpg”
                    .计次循环尾 ()
                .否则

                .如果结束

                正则.创建 (#番号, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    号番 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #番号头, “</span>”)
                .计次循环尾 ()

                正则.创建 (#发行日期, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    发行日期 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “發行日期:</span> ”, “</p>”)
                .计次循环尾 ()

                正则.创建 (#长度, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    长度 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “長度:</span>”, “分鐘</p>”)
                .计次循环尾 ()

                正则.创建 (#导演, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    导演 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #导演头, “</a></p>”)
                .计次循环尾 ()

                正则.创建 (#制作商, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    制作商 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #制作商头, “</a>”)
                .计次循环尾 ()

                正则.创建 (#发行商, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    发行商 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #发行商头, “</a>”)
                .计次循环尾 ()

                正则.创建 (#系列, 到文本 (r))
                .计次循环首 (正则.取匹配数量 (), i)
                    系列 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #系列头, “</a>”)
                .计次循环尾 ()

                .如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “有码”)
                    正则.创建 (#预览图有码, 到文本 (r))
                .如果真结束

                .如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “无码”)
                    正则.创建 (#预览图无码, 到文本 (r))
                .如果真结束

                .如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “欧美”)
                    正则.创建 (#预览图欧美, 到文本 (r))
                .如果真结束

                .计次循环首 (正则.取匹配数量 (), i)
                    临时文本 ＝ 正则.取匹配文本 (i)
                    .如果 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “有码”)
                        .如果 (文本_寻找文本 (文本_取出中间文本 (临时文本, “video/”, “.jpg”), “jp”, , 真) ≠ -1)
                            加入成员 (预览图网址, 临时文本)
                        .否则

                        .如果结束

                    .否则
                        加入成员 (预览图网址, 临时文本)
                    .如果结束


                .计次循环尾 ()


                正则.创建 (#演员, 到文本 (r))
                .如果 (正则.取匹配数量 () ≠ 0)
                    .计次循环首 (正则.取匹配数量 (), i)
                        演员 [i] ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #演员头, “</div>”)
                        演员 [i] ＝ 文本_取出中间文本 (演员 [i], #系列头, “</a>”)
                        .如果 (演员 [i] ≠ “”)
                            演员累加 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ 演员 [i] ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符 ＋ 演员累加
                            演员名字 ＝ 演员名字 ＋ 演员 [i] ＋ “ ”
                        .否则
                            演员累加 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
                        .如果结束

                    .计次循环尾 ()

                .否则
                    演员累加 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
                .如果结束

                正则.创建 (#类别, 到文本 (r))
                .如果 (正则.取匹配数量 () ≠ 0)
                    .计次循环首 (正则.取匹配数量 (), i)
                        类别 [i] ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #类别头, “</span>”)
                        类别 [i] ＝ 文本_取出中间文本 (类别 [i], #系列头, “</a>”)


                        .如果 (类别 [i] ≠ “”)
                            类别累加 ＝ “  <genre>” ＋ 类别 [i] ＋ “</genre>” ＋ #换行符 ＋ 类别累加
                            标签累加 ＝ “  <tag>” ＋ 类别 [i] ＋ “</tag>” ＋ #换行符 ＋ 标签累加

                        .否则
                            类别累加 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                            标签累加 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符
                        .如果结束

                    .计次循环尾 ()

                .否则
                    类别累加 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                    标签累加 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符

                .如果结束


                .如果 (自定义刮削名称选择框.选中 ＝ 真)
                    清除数组 (临时文件名)
                    临时文件名 ＝ 分割文本 (自定义文件夹名编辑框.内容, “+”, )
                    .计次循环首 (取数组成员数 (临时文件名), i)

                    .计次循环尾 ()
                    .计次循环首 (取数组成员数 (临时文件名), i)
                        .如果真 (临时文件名 [i] ＝ “日期”)
                            .如果 (取文本长度 (发行日期) ＞ 1)
                                影片文件夹名 ＝ 影片文件夹名 ＋ 发行日期 ＋ “ ”
                            .否则

                            .如果结束

                        .如果真结束

                        .如果真 (临时文件名 [i] ＝ “番号”)
                            .如果 (取文本长度 (号番) ＞ 1)
                                影片文件夹名 ＝ 影片文件夹名 ＋ 号番 ＋ “ ”
                            .否则

                            .如果结束

                        .如果真结束

                        .如果真 (临时文件名 [i] ＝ “演员”)
                            .如果 (取文本长度 (演员名字) ＞ 1)
                                .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                    演员名字 ＝ 文本_删右边 (演员名字, 1)
                                .否则

                                .如果结束
                                影片文件夹名 ＝ 影片文件夹名 ＋ “[” ＋ 演员名字 ＋ “] ”
                            .否则

                            .如果结束

                        .如果真结束
                        .如果真 (临时文件名 [i] ＝ “标题”)
                            .如果 (取文本长度 (题目) ＞ 1)
                                .如果 (取文本长度 (题目) ＞ 100)
                                    题目 ＝ gb_取左边文本 (题目, 标题字数)

                                .否则

                                .如果结束
                                影片文件夹名 ＝ 影片文件夹名 ＋ 题目 ＋ “ ”

                            .否则

                            .如果结束

                        .如果真结束

                    .计次循环尾 ()
                    清除数组 (临时文件名)

                    临时文件名 ＝ 分割文本 (自定义影片名编辑框.内容, “+”, )
                    .计次循环首 (取数组成员数 (临时文件名), i)

                    .计次循环尾 ()
                    .计次循环首 (取数组成员数 (临时文件名), i)
                        .如果真 (临时文件名 [i] ＝ “日期”)
                            .如果 (取文本长度 (发行日期) ＞ 1)
                                影片文件名 ＝ 影片文件名 ＋ 发行日期 ＋ “ ”
                            .否则

                            .如果结束

                        .如果真结束

                        .如果真 (临时文件名 [i] ＝ “番号”)
                            .如果 (取文本长度 (号番) ＞ 1)
                                影片文件名 ＝ 影片文件名 ＋ 号番 ＋ “ ”
                            .否则

                            .如果结束

                        .如果真结束

                        .如果真 (临时文件名 [i] ＝ “演员”)
                            .如果 (取文本长度 (演员名字) ＞ 1)
                                .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                    演员名字 ＝ 文本_删右边 (演员名字, 1)
                                .否则

                                .如果结束
                                影片文件名 ＝ 影片文件名 ＋ “[” ＋ 演员名字 ＋ “] ”
                            .否则

                            .如果结束

                        .如果真结束
                        .如果真 (临时文件名 [i] ＝ “标题”)
                            .如果 (取文本长度 (题目) ＞ 1)
                                .如果 (取文本长度 (题目) ＞ 100)
                                    题目 ＝ gb_取左边文本 (题目, 标题字数)
                                .否则

                                .如果结束
                                影片文件名 ＝ 影片文件名 ＋ 题目 ＋ “ ”



                            .否则

                            .如果结束

                        .如果真结束

                    .计次循环尾 ()


                .否则
                    影片文件夹名 ＝ 发行日期 ＋ “ ” ＋ 番号
                    影片文件名 ＝ 发行日期 ＋ “ ” ＋ 番号
                .如果结束

                .如果 (取文本右边 (影片文件夹名, 1) ＝ “ ”)
                    影片文件夹名 ＝ 文本_删右边 (影片文件夹名, 1)
                .否则

                .如果结束

                .如果 (取文本右边 (影片文件名, 1) ＝ “ ”)
                    影片文件名 ＝ 文本_删右边 (影片文件名, 1)
                .否则

                .如果结束

                影片文件夹名 ＝ 删特殊字符 (影片文件夹名)

                影片文件名 ＝ 删特殊字符 (影片文件名)
                影片文件夹名 ＝ 文本_替换 (影片文件夹名, , , , #换行符, “”, 字符 (10), “”, 字符 (0), “”, #长空格, “”, 字符 (13), “”)
                影片文件名 ＝ 文本_替换 (影片文件名, , , , #换行符, “”, 字符 (10), “”, 字符 (0), “”, #长空格, “”, 字符 (13), “”)

                图片 ＝ 网页_访问_对象 (封面, , , , , , , , , , 代理IP, 10)
                .如果 (取字节集长度 (图片) ＞ 2000)

                    .如果 (文件是否存在 (根路径 ＋ “\” ＋ 影片文件夹名) ＝ 假)
                        创建目录 (根路径 ＋ “\” ＋ 影片文件夹名)
                    .否则

                    .如果结束
                    路径 ＝ 根路径 ＋ “\” ＋ 影片文件夹名


                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”) ≠ 真)
                        写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”, 图片)
                        .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”) ≠ 真)
                            批量裁剪封面 (1, 路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”)
                            ' 图片号 ＝ 载入图片 (图片)
                            ' 宽 ＝ 画板.取图片宽度 (图片号)
                            ' 高 ＝ 画板.取图片高度 (图片号)
                            ' 图片 ＝ 图片_取图片区域 (图片_到24位图 (图片), 宽 ÷ 2 ＋ 20, 0, 高 ÷ 27 × 19, 高)
                            ' 写到文件 (路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “-poster.jpg”, 图片_转换Ex (图片, 2))
                            ' 卸载图片 (图片号)
                        .否则

                        .如果结束

                        文件_改名 (刮削影片路径 [id], 文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                        文件_移动 (文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]), 路径 ＋ “\” ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))

                        .如果 (下载预览图选择框.选中 ＝ 真)

                            .如果 (取数组成员数 (预览图网址) ＞ 0)
                                .计次循环首 (取数组成员数 (预览图网址), i)
                                    图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                    .如果 (取字节集长度 (图片) ＞ 10000)
                                        .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图”) ＝ 假)
                                            创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图”)
                                        .否则

                                        .如果结束
                                        写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图\” ＋ 号番 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                    .否则
                                        图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                        .如果 (取字节集长度 (图片) ＞ 10000)
                                            .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图”) ＝ 假)
                                                创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图”)
                                            .否则

                                            .如果结束
                                            写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 号番 ＋ “\” ＋ 号番 ＋ “-预览图\” ＋ 号番 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)

                                        .否则

                                        .如果结束

                                    .如果结束

                                .计次循环尾 ()
                            .否则

                            .如果结束

                        .否则

                        .如果结束



                        .如果 (刮削获取简介选择框.选中 ＝ 真)
                            简介 ＝ dmm简介 (文件名)
                            .如果真 (简介 ＝ “”)
                                简介 ＝ dmm简介 (文件名)
                            .如果真结束


                            .如果 (百度翻译选择框.选中 ＝ 真)
                                翻译结果 ＝ 百度翻译 (简介)
                                .如果 (翻译结果 ≠ “失败”)
                                    简介 ＝ 翻译结果

                                .否则

                                .如果结束

                            .否则
                                .如果 (谷歌翻译选择框.选中 ＝ 真)
                                    翻译结果 ＝ 谷歌翻译 (简介)
                                    .如果 (翻译结果 ≠ “”)
                                        简介 ＝ 翻译结果

                                    .否则

                                    .如果结束

                                .否则
                                    .如果 (必应翻译选择框.选中 ＝ 真)
                                        翻译结果 ＝ 必应翻译 (简介)
                                        .如果 (翻译结果 ≠ “”)
                                            简介 ＝ 翻译结果

                                        .否则

                                        .如果结束

                                    .否则

                                    .如果结束

                                .如果结束

                            .如果结束


                        .否则

                        .如果结束



                        nfo文本 ＝ 文本_替换 (#NFO, , , , “标题”, 发行日期 ＋ “ ” ＋ 题目, “时间”, 发行日期, “番号”, 号番, “时长”, 长度, “年份”, 取文本左边 (发行日期, 4))
                        nfo文本 ＝ 文本_替换 (nfo文本, , , , “发商”, 发行商, “系列”, 系列, “  <genre>类别</genre>”, 类别累加, “  <tag>标签</tag>”, 标签累加, “演员”, 演员累加)
                        nfo文本 ＝ 文本_替换 (nfo文本, , , , “厂商”, 制作商, “导演”, 导演, “简介”, 简介)


                        写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “.nfo”, 编码_Ansi到Utf8 (nfo文本))
                        .如果 (刮削磁力选择框.选中 ＝ 真)
                            .如果 (取文本长度 (磁力链接) ＞ 20)
                                写到文件 (路径 ＋ “\” ＋ 号番 ＋ “_Torrent.txt”, 编码_Ansi到Utf8 (磁力链接))
                            .否则

                            .如果结束


                        .否则

                        .如果结束
                        刮削状态 ＝ 真
                    .否则

                    .如果结束

                .否则

                .如果结束




            .否则

            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束





.否则

.如果结束


路径 ＝ “”
许可_完成.进入 ()  ' 修改一下当前进行到的位置
当前完成位置 ＝ 当前完成位置 ＋ 1
总爬取量 ＝ 总爬取量 － 1
.如果 (网址 ≠ “空”)
    .如果 (刮削状态 ＝ 真)
        刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削完成：” ＋ 刮削影片路径 [id])
    .否则
        刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削失败：” ＋ 刮削影片路径 [id])
    .如果结束

.否则
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削失败，未查询到此影片：” ＋ 刮削影片路径 [id])
.如果结束

许可_完成.退出 ()
减少一个线程 ()


.子程序 刮削获取磁力链接, 文本型
.参数 文本, 文本型
.局部变量 正则, 正则表达式类
.局部变量 gid, 文本型
.局部变量 uc, 文本型
.局部变量 img, 文本型
.局部变量 磁力, 文本型
.局部变量 i, 整数型
.局部变量 磁力数组, 文本型, , "0"
.局部变量 临时文本, 文本型
.局部变量 写出文本, 文本型
.局部变量 k, 整数型
.局部变量 临时文本1, 文本型
.局部变量 番号, 文本型

正则.创建 (#gid, 文本)
gid ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var gid = ”, “;”)
正则.创建 (#uc, 文本)
uc ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var uc = ”, “;”)
正则.创建 (#img, 文本)
img ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “var img = '”, “';”)
.如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “有码”)
    磁力 ＝ 编码_Utf8到Ansi (网页_访问_对象 (刮削javbus编辑框.内容 ＋ “ajax/uncledatoolsbyajax.php?gid=” ＋ gid ＋ “&lang=zh&img=” ＋ img ＋ “&uc=0&floor=567”, , , , , , , , , , 代理IP, 超时时间))
.如果真结束

.如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “无码”)
    磁力 ＝ 编码_Utf8到Ansi (网页_访问_对象 (刮削javbus编辑框.内容 ＋ “ajax/uncledatoolsbyajax.php?gid=” ＋ gid ＋ “&lang=zh&img=” ＋ img ＋ “&uc=1&floor=567”, , , , , , , , , , 代理IP, 超时时间))
.如果真结束

.如果真 (刮削bus组合框.取项目文本 (刮削bus组合框.现行选中项) ＝ “欧美”)
    磁力 ＝ 编码_Utf8到Ansi (网页_访问_对象 (“https://www.javbus.one/” ＋ “ajax/uncledatoolsbyajax.php?gid=” ＋ gid ＋ “&lang=zh&img=” ＋ img ＋ “&uc=0&floor=567”, , , , , , , , , , 代理IP, 超时时间))
.如果真结束





清除数组 (磁力数组)
正则.创建 (#磁力, 磁力)
.计次循环首 (正则.取匹配数量 (), i)
    加入成员 (磁力数组, 正则.取匹配文本 (i))
.计次循环尾 ()

.计次循环首 (取数组成员数 (磁力数组), i)
    正则.创建 (“>” ＋ #换行符 ＋ “.+</a>”, 磁力数组 [i])
    .计次循环首 (正则.取匹配数量 (), k)
        .如果真 (k ＝ 1)
            .如果 (文本_寻找文本 (刮削文本替换换行符 (正则.取匹配文本 (k)), “class”, , 真) ≠ -1)
                临时文本1 ＝ 文本_取出中间文本 (刮削文本替换换行符 (正则.取匹配文本 (k)), “>”, “<aclass”)

            .否则
                临时文本1 ＝ 文本_取出中间文本 (刮削文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”)

            .如果结束

        .如果真结束

        .如果真 (k ＝ 2)
            临时文本1 ＝ 临时文本1 ＋ “|” ＋ 文本_取出中间文本 (刮削文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”)

        .如果真结束
        .如果真 (k ＝ 3)
            临时文本1 ＝ 临时文本1 ＋ “|” ＋ 文本_取出中间文本 (刮削文本替换换行符 (正则.取匹配文本 (k)), “>”, “</a>”) ＋ “|”

        .如果真结束

    .计次循环尾 ()





    正则.创建 (#磁力链接, 磁力数组 [i])
    临时文本 ＝ “magnet:?” ＋ 编码_URL解码 (文本_取出中间文本 (磁力数组 [i], “magnet:?”, “','”), 真)
    .如果 (文本_寻找文本 (磁力数组 [i], “高清”) ≠ -1)
        临时文本 ＝ 临时文本 ＋ “|高清”
    .否则
        临时文本 ＝ 临时文本 ＋ “|非高清”
    .如果结束
    .如果 (文本_寻找文本 (磁力数组 [i], “字幕”) ≠ -1)
        临时文本 ＝ 临时文本 ＋ “|字幕”
    .否则
        临时文本 ＝ 临时文本 ＋ “|非字幕”
    .如果结束




    .如果 (i ＝ 1)
        写出文本 ＝ 临时文本1 ＋ 临时文本
    .否则
        写出文本 ＝ 写出文本 ＋ #换行符 ＋ 临时文本1 ＋ 临时文本
    .如果结束

.计次循环尾 ()
返回 (写出文本)


.子程序 dmm简介, 文本型
.参数 番号, 文本型
.局部变量 简介文本, 文本型
.局部变量 正则, 正则表达式类
.局部变量 r, 文本型
.局部变量 简介链接网页, 文本型

r ＝ 网页_访问S (“https://www.arzon.jp/itemlist.html?t=&m=all&s=&q=” ＋ 番号, , , #cookies2, , , , , , , 代理IP, , , 超时时间)
.如果 (取文本长度 (r) ＞ 500)
    .如果 (文本_寻找文本 (r, “年齢認証</span>&nbsp;&nbsp;:&nbsp;&nbsp;あなたは１８歳以上ですか？”) ＝ -1)
        .如果 (文本_寻找文本 (r, “で検索に一致する作品はありませんでした。”) ＝ -1)
            正则.创建 (#简介链接, r)
            简介链接网页 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), #简介链接头, #简介链接尾)
            r ＝ 网页_访问S (“https://www.arzon.jp/” ＋ 简介链接网页, , , #cookies2, , , , , , , 代理IP, , , 超时时间)
            .如果 (取文本长度 (r) ＞ 500)
                正则.创建 (#匹配简介, r)
                正则.创建 (#匹配简介2, 正则.取匹配文本 (1))
                简介文本 ＝ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (1)), “<h2>作品紹介</h2>”, “</div>”)
            .否则

            .如果结束

        .否则

        .如果结束

    .否则
        正则.创建 (#验证链接, r)
        r ＝ 网页_访问S (“https://www.arzon.jp” ＋ 文本_取出中间文本 (正则.取匹配文本 (1), #验证链接1, #验证链接2), , , #cookies2, , , , , , , 代理IP, , , 超时时间)
        .如果 (取文本长度 (r) ＞ 500)
            .如果 (文本_寻找文本 (r, “年齢認証</span>&nbsp;&nbsp;:&nbsp;&nbsp;あなたは１８歳以上ですか？”) ＝ -1)
                .如果 (文本_寻找文本 (r, “で検索に一致する作品はありませんでした。”) ＝ -1)
                    正则.创建 (#简介链接, r)
                    简介链接网页 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), #简介链接头, #简介链接尾)
                    r ＝ 网页_访问S (“https://www.arzon.jp/” ＋ 简介链接网页, , , #cookies2, , , , , , , 代理IP, , , 超时时间)
                    .如果 (取文本长度 (r) ＞ 500)
                        正则.创建 (#匹配简介, r)
                        正则.创建 (#匹配简介2, 正则.取匹配文本 (1))
                        简介文本 ＝ 文本_取出中间文本 (文本替换换行符 (正则.取匹配文本 (1)), “<h2>作品紹介</h2>”, “</div>”)

                    .否则

                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束

    .如果结束

.否则


.如果结束
返回 (简介文本)

.子程序 刮削文本替换换行符, 文本型
.参数 文本, 文本型

文本 ＝ 文本_替换 (文本, , , , #换行符, “”, 字符 (10), “”, 字符 (0), “”, “ ”, “”, #长空格, “”)
文本 ＝ 文本_替换 (文本, , , , “|”, “”, 字符 (13), “”)
返回 (文本)

.子程序 增加一个线程, , , 记录当前有多少个线程在执行

许可_线程总数.进入 ()
线程数量 ＝ 线程数量 ＋ 1
许可_线程总数.退出 ()


.子程序 减少一个线程, , , 记录当前有多少个线程在执行

许可_线程总数.进入 ()
线程数量 ＝ 线程数量 － 1
许可_线程总数.退出 ()

.子程序 刮削日志
.参数 文本, 文本型

刮削运行编辑框.加入文本 (文本, #换行符)

.子程序 _生成mp4按钮_被单击

线程_启动 (&生成mp4)

.子程序 生成mp4
.局部变量 文本, 文本型
.局部变量 分割文本, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 路径, 文本型

禁止 ()
取耗时 (1)
路径 ＝ 目录_浏览 ()
.如果 (路径 ≠ “”)
    文本 ＝ 到文本 (读入文件 (路径 ＋ “\番号.txt”))
    分割文本 ＝ 分割文本 (文本, #换行符, )
    .计次循环首 (取数组成员数 (分割文本), i)
        .如果 (文件是否存在 (路径 ＋ “\” ＋ 分割文本 [i] ＋ “.mp4”) ＝ 假)
            写到文件 (路径 ＋ “\” ＋ 分割文本 [i] ＋ “.mp4”, 到字节集 (“”))
        .否则

        .如果结束

    .计次循环尾 ()
.否则

.如果结束
取禁 ()
log (“生成MP4完成，” ＋ 取耗时 (2))


.子程序 _保存配置按钮_被单击

批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_编辑框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_组合框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)

.子程序 _bus有码_被选择

.如果 (搜索状态 ＝ 假)
    下载预览图 (封面子项, 假, 1)
.否则
    下载预览图 (搜索封面子项, 真, 1)
.如果结束



.子程序 _bus无码_被选择

.如果 (搜索状态 ＝ 假)
    下载预览图 (封面子项, 假, 2)
.否则
    下载预览图 (搜索封面子项, 真, 2)
.如果结束


.子程序 _bus欧美_被选择

.如果 (搜索状态 ＝ 假)
    下载预览图 (封面子项, 假, 3)
.否则
    下载预览图 (搜索封面子项, 真, 3)
.如果结束



.子程序 下载预览图
.参数 项, 整数型
.参数 是否搜索, 逻辑型
.参数 类型, 整数型
.局部变量 正则, 正则表达式类
.局部变量 r, 文本型
.局部变量 文件名, 文本型
.局部变量 临时文本, 文本型
.局部变量 i, 整数型
.局部变量 预览图网址, 文本型, , "0"
.局部变量 图片, 字节集
.局部变量 路径, 文本型
.局部变量 网址, 文本型
.局部变量 番号, 文本型
.局部变量 返回协议头, 文本型

禁止 ()
取耗时 (1)
.如果 (是否搜索 ＝ 假)
    文件名 ＝ 影片 [项].番号
    路径 ＝ 文件_取目录 (影片 [项].文件)
.否则
    文件名 ＝ 搜索 [项].番号
    路径 ＝ 文件_取目录 (搜索 [项].文件)
.如果结束
.如果 (路径 ≠ “”)
    log (“正在下载” ＋ 文件名 ＋ “预览图”)
    .如果 (类型 ＜ 4)
        .如果 (类型 ＝ 3)
            r ＝ 网页_访问S (“https://www.javbus.one/search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)

        .否则
            .如果 (类型 ＝ 2)
                r ＝ 网页_访问S (bus网址 ＋ “uncensored/search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)
            .否则
                r ＝ 网页_访问S (bus网址 ＋ “search/” ＋ 文件名, , , #buscookies, , , , , , , 代理IP, , , 超时时间)
            .如果结束

        .如果结束

        .如果 (取文本长度 (r) ＞ 500)
            .如果 (文本_寻找文本 (r, “您進入的網址有誤”) ＝ -1)
                正则.创建 (#番号网址, r)
                .计次循环首 (正则.取匹配数量 (), i)
                    网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), #番号网址头, #番号网址尾)

                .计次循环尾 ()
                正则.创建 (#页面番号, r)
                .计次循环首 (正则.取匹配数量 (), i)
                    番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “<date>”, “</date> / <date>”)
                .计次循环尾 ()
                .如果 (到大写 (番号) ≠ 到大写 (文件名))
                    网址 ＝ “空”
                .否则

                .如果结束

            .否则
                log (“未搜索到此影片。”)
            .如果结束

        .否则
            log (“搜索番号失败，请重新尝试。”)
        .如果结束

        .如果 (网址 ≠ “空”)
            .如果 (类型 ＝ 3)
                r ＝ 网页_访问S (网址, , , , , , , , , , 代理IP, , , 超时时间)
            .否则
                r ＝ 网页_访问S (网址, , , , , , , , , , 代理IP, , , 超时时间)
            .如果结束


            .如果真 (类型 ＝ 1)
                正则.创建 (#预览图有码, 到文本 (r))
            .如果真结束

            .如果真 (类型 ＝ 2)
                正则.创建 (#预览图无码, 到文本 (r))
            .如果真结束

            .如果真 (类型 ＝ 3)
                正则.创建 (#预览图欧美, 到文本 (r))
            .如果真结束


            .计次循环首 (正则.取匹配数量 (), i)
                临时文本 ＝ 正则.取匹配文本 (i)
                .如果 (类型 ＝ 1)
                    .如果 (文本_寻找文本 (文本_取出中间文本 (临时文本, “video/”, “.jpg”), “jp”, , 真) ≠ -1)
                        加入成员 (预览图网址, 临时文本)

                    .否则

                    .如果结束

                .否则
                    加入成员 (预览图网址, 临时文本)
                .如果结束


            .计次循环尾 ()



            .如果 (取数组成员数 (预览图网址) ＞ 0)
                log (“正在下载” ＋ 文件名 ＋ “预览图，共” ＋ 到文本 (取数组成员数 (预览图网址)) ＋ “张”)
                .计次循环首 (取数组成员数 (预览图网址), i)
                    .如果真 (圆形进度外形框.可视 ＝ 假)
                        圆形进度外形框.可视 ＝ 真
                        LOGO图形按钮.可视 ＝ 假
                    .如果真结束
                    进度窗口 (到整数 (i ÷ 取数组成员数 (预览图网址) × 100))
                    log (“正在下载” ＋ 文件名 ＋ “预览图第” ＋ 到文本 (i) ＋ “张，共” ＋ 到文本 (取数组成员数 (预览图网址)) ＋ “张”)

                    图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                    .如果 (取字节集长度 (图片) ＞ 10000)
                        .如果 (文件是否存在 (路径 ＋ 文件名 ＋ “-预览图”) ＝ 假)
                            创建目录 (路径 ＋ 文件名 ＋ “-预览图”)
                        .否则

                        .如果结束
                        写到文件 (路径 ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                    .否则
                        图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                        .如果 (取字节集长度 (图片) ＞ 10000)
                            .如果 (文件是否存在 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”) ＝ 假)
                                创建目录 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”)
                            .否则

                            .如果结束
                            写到文件 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)

                        .否则

                        .如果结束

                    .如果结束

                .计次循环尾 ()
                .如果真 (圆形进度外形框.可视 ＝ 真)
                    圆形进度外形框.可视 ＝ 假
                    LOGO图形按钮.可视 ＝ 真
                .如果真结束
                log (“下载预览图完成，” ＋ 取耗时 (2))
            .否则
                log (“未获取到预览图网址，请重试。”)
            .如果结束




        .否则
            log (“未获取到影片番号网址，请重试。”)
        .如果结束

    .否则

    .如果结束

    .如果 (类型 ＝ 4)
        r ＝ 网页_访问S (“https://www.jav321.com/search”, 1, “sn=” ＋ 文件名, , , , , , , , 代理IP, , , 超时时间)
        .如果 (取文本长度 (r) ＞ 500)
            .如果 (文本_寻找文本 (r, “抱歉，未找到您要找的AV。”) ＝ -1)
                正则.创建 (#jav321图片, 到文本 (r))
                .如果 (正则.取匹配数量 () ≠ 0)
                    .计次循环首 (正则.取匹配数量 (), i)
                        加入成员 (预览图网址, 文本_取出中间文本 (正则.取匹配文本 (i), #jav321图片头, #jav321图片尾, , 真))
                    .计次循环尾 ()

                .否则
                    正则.创建 (#预览图321, 到文本 (r))
                    .计次循环首 (正则.取匹配数量 (), i)
                        .如果 (文本_寻找文本 (文本_取出中间文本 (正则.取匹配文本 (i), #预览图321头, #预览图321尾, , 真), “pf_o1_”) ＝ -1)
                            .如果 (文本_寻找文本 (文本_取出中间文本 (正则.取匹配文本 (i), #预览图321头, #预览图321尾, , 真), “digital/video”) ＝ -1)
                                加入成员 (预览图网址, 文本_取出中间文本 (正则.取匹配文本 (i), #预览图321头, #预览图321尾, , 真) ＋ “.jpg”)
                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .计次循环尾 ()
                .如果结束

                .如果 (取数组成员数 (预览图网址) ＞ 0)
                    log (“正在下载” ＋ 文件名 ＋ “预览图，共” ＋ 到文本 (取数组成员数 (预览图网址)) ＋ “张”)
                    .计次循环首 (取数组成员数 (预览图网址), i)
                        .如果真 (圆形进度外形框.可视 ＝ 假)
                            圆形进度外形框.可视 ＝ 真
                            LOGO图形按钮.可视 ＝ 假
                        .如果真结束
                        进度窗口 (到整数 (i ÷ 取数组成员数 (预览图网址) × 100))
                        log (“正在下载” ＋ 文件名 ＋ “预览图第” ＋ 到文本 (i) ＋ “张，共” ＋ 到文本 (取数组成员数 (预览图网址)) ＋ “张”)
                        .如果 (i ≠ 1)
                            图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                            .如果 (取字节集长度 (图片) ＞ 10000)
                                .如果 (文件是否存在 (路径 ＋ 文件名 ＋ “-预览图”) ＝ 假)
                                    创建目录 (路径 ＋ 文件名 ＋ “-预览图”)
                                .否则

                                .如果结束
                                写到文件 (路径 ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)
                            .否则
                                图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                .如果 (取字节集长度 (图片) ＞ 10000)
                                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”) ＝ 假)
                                        创建目录 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”)
                                    .否则

                                    .如果结束
                                    写到文件 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)

                                .否则

                                .如果结束

                            .如果结束

                        .否则

                        .如果结束

                    .计次循环尾 ()
                    .如果真 (圆形进度外形框.可视 ＝ 真)
                        圆形进度外形框.可视 ＝ 假
                        LOGO图形按钮.可视 ＝ 真
                    .如果真结束
                    log (“下载预览图完成，” ＋ 取耗时 (2))
                .否则
                    log (“未获取到预览图网址，请重试。”)
                .如果结束



            .否则
                log (“抱歉，未找到您要找的影片，请确认番号是否正确或者321是否有此影片。”)
            .如果结束

        .否则
            log (“无法打开网页，请先在<影片刮削>界面勾选代理并测试是否可连接。”)
        .如果结束

    .否则

    .如果结束

    .如果 (类型 ＝ 5)

        r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
        .如果 (取文本长度 (r) ＞ 500)

        .否则
            r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
        .如果结束

        .如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
            正则.创建 (#db取番号, r)
            .计次循环首 (正则.取匹配数量 (), i)
                番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “番號: ”, “ / 發布時間: ”)
                .如果 (到大写 (番号) ≠ 到大写 (文件名))
                    网址 ＝ “空”
                .否则
                    正则.创建 (#db取网页码, r)
                    网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “uid” ＋ #引号 ＋ “:” ＋ #引号, #引号)
                    跳出循环 ()
                .如果结束

            .计次循环尾 ()
        .否则

        .如果结束

        .如果 (网址 ≠ “空”)
            r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
            .如果 (取文本长度 (r) ＞ 500)

            .否则
                r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))

            .如果结束

            .如果 (取文本长度 (r) ＞ 500)
                .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
                    正则.创建 (#db预览图, 到文本 (r))
                    .计次循环首 (正则.取匹配数量 (), i)
                        加入成员 (预览图网址, 文本_取出中间文本 (正则.取匹配文本 (i), “tile-item” ＋ #引号 ＋ “ href=” ＋ #引号, #引号 ＋ “ data-fancybox”, , 真))
                    .计次循环尾 ()
                    .如果 (取数组成员数 (预览图网址) ＞ 0)
                        .计次循环首 (取数组成员数 (预览图网址), i)
                            .如果真 (圆形进度外形框.可视 ＝ 假)
                                圆形进度外形框.可视 ＝ 真
                                LOGO图形按钮.可视 ＝ 假
                            .如果真结束
                            进度窗口 (到整数 (i ÷ 取数组成员数 (预览图网址) × 100))
                            log (“正在下载” ＋ 文件名 ＋ “预览图第” ＋ 到文本 (i) ＋ “张，共” ＋ 到文本 (取数组成员数 (预览图网址)) ＋ “张”)
                            图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                            .如果 (取字节集长度 (图片) ＞ 1000)
                                .如果 (文件是否存在 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”) ＝ 假)
                                    创建目录 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”)
                                .否则

                                .如果结束
                                写到文件 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                            .否则
                                图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                .如果 (取字节集长度 (图片) ＞ 1000)
                                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”) ＝ 假)
                                        创建目录 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图”)
                                    .否则

                                    .如果结束
                                    写到文件 (路径 ＋ “\” ＋ 文件名 ＋ “-预览图\” ＋ 文件名 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                .否则

                                .如果结束

                            .如果结束

                        .计次循环尾 ()
                        .如果真 (圆形进度外形框.可视 ＝ 真)
                            圆形进度外形框.可视 ＝ 假
                            LOGO图形按钮.可视 ＝ 真
                        .如果真结束
                        log (“下载预览图完成，” ＋ 取耗时 (2))
                    .否则
                        log (“未获取到预览图网址，请重试。”)
                    .如果结束



                .否则

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束

    .否则

    .如果结束

.否则
    log (“未获取到影片路径，下载预览图失败。”)
.如果结束
取禁 ()


.子程序 _jav321_被选择

.如果 (搜索状态 ＝ 假)
    下载预览图 (封面子项, 假, 4)
.否则
    下载预览图 (搜索封面子项, 真, 4)
.如果结束


.子程序 _测试按钮_被单击
.局部变量 r, 文本型

r ＝ 网页_访问S (“https://www.jav321.com/search”, 1, “sn=AAA222222”, , , , , , , , 代理IP, , , 超时时间)
.如果 (文本_寻找文本 (r, “抱歉，未找到您要找的AV。”) ≠ -1)
    log (“代理连接成功。”)
.否则
    log (“代理连接失败，请重新检查ip和端口是否正确。”)
.如果结束


.子程序 _超时时间编辑框_内容被改变

.如果 (到整数 (超时时间编辑框.内容) ＜ 10)
    超时时间 ＝ 10
.否则
    .如果 (到整数 (超时时间编辑框.内容) ＞ 60)
        超时时间 ＝ 60
    .否则
        到整数 (超时时间编辑框.内容)
    .如果结束

.如果结束


.子程序 jav321刮削
.局部变量 id, 整数型
.局部变量 正则, 正则表达式类
.局部变量 正则2, 正则表达式类
.局部变量 r, 文本型
.局部变量 题目, 文本型
.局部变量 网址, 文本型
.局部变量 下载, 文本型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 女优名, 文本型
.局部变量 女优名组, 文本型, , "0"
.局部变量 番号, 文本型
.局部变量 片商组, 文本型, , "0"
.局部变量 标签组, 文本型, , "0"
.局部变量 播放时长组, 文本型, , "0"
.局部变量 赞组, 文本型, , "0"
.局部变量 系列组, 文本型, , "0"
.局部变量 写出文本, 文本型
.局部变量 临时文本, 文本型
.局部变量 文件名, 文本型
.局部变量 过滤字符, 文本型, , "0"
.局部变量 预览图网址, 文本型, , "0"
.局部变量 影片标题, 文本型
.局部变量 发行商, 文本型
.局部变量 发行日期, 文本型
.局部变量 影片时长, 文本型
.局部变量 点赞数, 文本型
.局部变量 评分, 文本型
.局部变量 系列, 文本型
.局部变量 简介, 文本型
.局部变量 演员名, 文本型
.局部变量 类别, 文本型
.局部变量 标签影片, 文本型
.局部变量 nfo文本, 文本型
.局部变量 根路径, 文本型
.局部变量 路径, 文本型
.局部变量 宽, 整数型
.局部变量 图片号, 整数型
.局部变量 高, 整数型
.局部变量 图片, 字节集
.局部变量 临时图片网址, 文本型
.局部变量 网址临时分割, 文本型, , "0"
.局部变量 影片短网址, 文本型
.局部变量 影片文件名, 文本型
.局部变量 影片文件夹名, 文本型
.局部变量 临时文件名, 文本型, , "0"
.局部变量 演员名字, 文本型
.局部变量 翻译结果, 文本型
.局部变量 刮削状态, 逻辑型

增加一个线程 ()
许可_位置.进入 ()  ' 修改一下当前进行到的位置
当前抓取位置 ＝ 当前抓取位置 ＋ 1
id ＝ 当前抓取位置  ' 拿到自己应该处理的位置，然后存到局部变量里面
刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ 刮削影片路径 [id])
许可_位置.退出 ()
刮削状态 ＝ 假
.如果 (刮削jav321选择框.选中 ＝ 真)
    .如果 (代理选择框.选中 ＝ 假)
        代理选择框.选中 ＝ 真
        代理IP ＝ 代理编辑框.内容
        代理.点燃图片 ＝ #代理普通
        代理.正常图片 ＝ #代理点燃

    .否则

    .如果结束

.否则

.如果结束

文件名 ＝ 文件_取文件名 (刮削影片路径 [id])
.如果 (到大写 (取文本右边 (文件名, 2)) ＝ “-C”)
    文件名 ＝ 文本_删右边 (文件名, 2)
.否则

.如果结束
文件名 ＝ 文本_替换 (文件名, , , , “ ”, “”, “_”, “-”)
过滤字符 ＝ 分割文本 (过滤字符串编辑框.内容, “/”, )
.计次循环首 (取数组成员数 (过滤字符), i)
    文件名 ＝ 文本_替换 (文件名, , , , 过滤字符 [i], “”)
.计次循环尾 ()
.如果真 (正则番号选择框.选中)
    文件名 ＝ 文件名正则番号 (文件名)
.如果真结束
r ＝ 网页_访问S (“https://www.jav321.com/search”, 1, “sn=” ＋ 文件名, , , , , , , , 代理IP, , , 超时时间)
.如果 (取文本长度 (r) ＞ 500)

.否则
    r ＝ 网页_访问S (“https://www.jav321.com/search”, 1, “sn=” ＋ 文件名, , , , , , , , 代理IP, , , 超时时间)
.如果结束

.如果 (取文本长度 (r) ＞ 500)
    .如果 (文本_寻找文本 (r, “抱歉，未找到您要找的AV。”) ＝ -1)
        根路径 ＝ 文件_取目录 (刮削影片路径 [id])
        正则.创建 (#jav321内容, 到文本 (r))
        .计次循环首 (正则.取匹配数量 (), i)
            题目 ＝ 正则.取匹配文本 (i)
        .计次循环尾 ()

        正则.创建 (#jav321网址, 到文本 (r))
        .计次循环首 (正则.取匹配数量 (), i)
            网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #jav321网址头, #jav321网址尾, , 真)
        .计次循环尾 ()
        网址临时分割 ＝ 分割文本 (网址, “/”, )
        影片短网址 ＝ 网址临时分割 [取数组成员数 (网址临时分割)]

        正则.创建 (#jav321标题, 题目)
        .计次循环首 (正则.取匹配数量 (), i)
            影片标题 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #jav321标题头, “<small>”, , 真)
        .计次循环尾 ()

        正则.创建 (#jav321女优, 题目)
        .计次循环首 (正则.取匹配数量 (), i)
            女优名 ＝ 正则.取匹配文本 (i)
        .计次循环尾 ()

        文本_取中间_批量 (女优名, #jav321女优头, “</a>”, 女优名组)
        .如果 (取数组成员数 (女优名组) ≠ 0)
            .计次循环首 (取数组成员数 (女优名组), i)
                .如果 (女优名组 [i] ≠ “”)
                    演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ 女优名组 [i] ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符 ＋ 演员名
                    演员名字 ＝ 演员名字 ＋ 女优名组 [i] ＋ “ ”
                .否则
                    演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
                .如果结束

            .计次循环尾 ()
        .否则
            演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
        .如果结束

        正则.创建 (#jav321番号啊, 题目)
        .计次循环首 (正则.取匹配数量 (), i)
            番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “番号</b>: ”, “<br><b>发行日期”, , 真)
        .计次循环尾 ()


        文本_取中间_批量 (题目, “片商”, “/a><br><b>”, 片商组)
        .计次循环首 (取数组成员数 (片商组), i)
            发行商 ＝ 文本_取出中间文本 (片商组 [i], #jav321女优头, “<”, , 真)
        .计次循环尾 ()

        文本_取中间_批量 (文本_取出中间文本 (题目, “标签”, “/a><br><b>”, , 真), #jav321女优头, “<”, 标签组)
        .如果 (取数组成员数 (标签组) ≠ 0)
            .计次循环首 (取数组成员数 (标签组), i)
                .如果 (标签组 [i] ≠ “”)
                    类别 ＝ “  <genre>” ＋ 标签组 [i] ＋ “</genre>” ＋ #换行符 ＋ 类别
                    标签影片 ＝ “  <tag>” ＋ 标签组 [i] ＋ “</tag>” ＋ #换行符 ＋ 标签影片
                .否则
                    类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                    标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符
                .如果结束

            .计次循环尾 ()
        .否则
            类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
            标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符
        .如果结束






        发行日期 ＝ 文本_取出中间文本 (题目, “发行日期</b>: ”, “<br><b>播放时长”, , 真)



        文本_取中间_批量 (题目, “播放时长</b>: ”, “<br>”, 播放时长组)
        .计次循环首 (取数组成员数 (播放时长组), i)
            影片时长 ＝ 播放时长组 [i]
        .计次循环尾 ()


        文本_取中间_批量 (题目, “赞</b>: ”, “<br><b>”, 赞组)
        .计次循环首 (取数组成员数 (赞组), i)
            点赞数 ＝ 赞组 [i]
        .计次循环尾 ()


        正则.创建 (#jav321评分, 到文本 (r))
        .计次循环首 (正则.取匹配数量 (), i)
            评分 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #jav321评分头, #jav321评分尾, , 真)
        .计次循环尾 ()


        正则.创建 (#jav321系列, 到文本 (r))
        .计次循环首 (正则.取匹配数量 (), i)
            系列 ＝ 文本_取出中间文本 (文本_取出中间文本 (正则.取匹配文本 (i), #jav321系列头, “/a>”, , 真), “>”, “<”, , 真)
        .计次循环尾 ()


        正则.创建 (#jav321简介, 题目)
        .计次循环首 (正则.取匹配数量 (), i)
            临时文本 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #jav321简介头, #jav321简介尾, , 真)
            .如果 (文本_取出中间文本 (临时文本, #jav321简介头, “<”, , 真) ＝ “”)
                简介 ＝ 文本替换换行符 (临时文本)
            .否则
                简介 ＝ 文本替换换行符 (文本_取出中间文本 (临时文本, #jav321简介头, “<”, , 真))
            .如果结束

        .计次循环尾 ()
        .如果 (文本_寻找文本 (简介, “col-md-12”, , 真) ≠ -1)
            简介 ＝ “”
        .否则

        .如果结束
        .如果 (百度翻译选择框.选中 ＝ 真)
            翻译结果 ＝ 百度翻译 (简介)
            .如果 (翻译结果 ≠ “失败”)
                简介 ＝ 翻译结果

            .否则

            .如果结束

        .否则
            .如果 (谷歌翻译选择框.选中 ＝ 真)
                翻译结果 ＝ 谷歌翻译 (简介)
                .如果 (翻译结果 ≠ “”)
                    简介 ＝ 翻译结果

                .否则

                .如果结束

            .否则
                .如果 (必应翻译选择框.选中 ＝ 真)
                    翻译结果 ＝ 必应翻译 (简介)
                    .如果 (翻译结果 ≠ “”)
                        简介 ＝ 翻译结果

                    .否则

                    .如果结束

                .否则

                .如果结束

            .如果结束

        .如果结束



        ' 正则.创建 (#jav321下载, 到文本 (r))
        .' 计次循环首 (正则.取匹配数量 (), i)
            ' 下载 ＝ 正则.取匹配文本 (i)
            ' 正则2.创建 (#jav321下载文件名, 下载)
            .' 计次循环首 (正则2.取匹配数量 (), k)
                ' 写出文本 ＝ 写出文本 ＋ “<文件名>” ＋ 文本_取出中间文本 (正则2.取匹配文本 (k), “<tr><td>”, “</td><td>”, , 真) ＋ “</文件名>”
            .' 计次循环尾 ()
            ' 正则2.创建 (#jav321下载大小, 下载)
            .' 计次循环首 (正则2.取匹配数量 (), k)
                ' 写出文本 ＝ 写出文本 ＋ “<大小>” ＋ 文本_取出中间文本 (正则2.取匹配文本 (k), “</td><td>”, “</td><td><a href”, , 真) ＋ “</大小>”
            .' 计次循环尾 ()
            ' 正则2.创建 (#jav321下载链接, 下载)
            .' 计次循环首 (正则2.取匹配数量 (), k)
                ' 写出文本 ＝ 写出文本 ＋ “<链接>” ＋ 文本_取出中间文本 (正则2.取匹配文本 (k), #jav321下载链接头, “下载”, , 真) ＋ “</链接>”
            .' 计次循环尾 ()
            ' 写出文本 ＝ 写出文本 ＋ “○”

        .' 计次循环尾 ()


        ' 正则.创建 (#jav321图片, 到文本 (r))
        .' 计次循环首 (正则.取匹配数量 (), i)
            ' 写出文本 ＝ 写出文本 ＋ “<图片>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #jav321图片头, #jav321图片尾, , 真) ＋ “</图片>”
        .' 计次循环尾 ()


        ' 正则.创建 (#jav321图片, 到文本 (r))
        .' 如果 (正则.取匹配数量 () ≠ 0)
            .' 计次循环首 (正则.取匹配数量 (), i)
                ' 加入成员 (预览图网址, 文本_取出中间文本 (正则.取匹配文本 (i), #jav321图片头, #jav321图片尾, , 真))

            .' 计次循环尾 ()
        .否则

        .如果结束


        正则.创建 (#预览图321, 到文本 (r))
        .计次循环首 (正则.取匹配数量 (), i)
            临时图片网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), #预览图321头, #预览图321尾, , 真)
            .如果 (文本_寻找文本 (临时图片网址, “pf_o1_”) ＝ -1)
                .如果 (文本_寻找文本 (临时图片网址, 影片短网址) ≠ -1)
                    .如果 (取文本右边 (临时图片网址, 2) ≠ “ps”)
                        加入成员 (预览图网址, 临时图片网址 ＋ “.jpg”)
                    .否则

                    .如果结束

                .否则

                .如果结束



            .否则
                .如果 (i ＝ 1)
                    .如果 (文本_寻找文本 (临时图片网址, 影片短网址) ≠ -1)
                        加入成员 (预览图网址, 临时图片网址 ＋ “.jpg”)

                    .否则

                    .如果结束

                .否则

                .如果结束

            .如果结束





        .计次循环尾 ()

        .如果 (自定义刮削名称选择框.选中 ＝ 真)
            清除数组 (临时文件名)
            临时文件名 ＝ 分割文本 (自定义文件夹名编辑框.内容, “+”, )
            .计次循环首 (取数组成员数 (临时文件名), i)
                .如果真 (临时文件名 [i] ＝ “日期”)
                    .如果 (取文本长度 (发行日期) ＞ 1)
                        影片文件夹名 ＝ 影片文件夹名 ＋ 发行日期 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

                .如果真 (临时文件名 [i] ＝ “番号”)
                    .如果 (取文本长度 (番号) ＞ 1)
                        影片文件夹名 ＝ 影片文件夹名 ＋ 番号 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

                .如果真 (临时文件名 [i] ＝ “演员”)
                    .如果 (取文本长度 (演员名字) ＞ 1)
                        .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                            演员名字 ＝ 文本_删右边 (演员名字, 1)
                        .否则

                        .如果结束
                        影片文件夹名 ＝ 影片文件夹名 ＋ “[” ＋ 演员名字 ＋ “] ”
                    .否则

                    .如果结束

                .如果真结束
                .如果真 (临时文件名 [i] ＝ “标题”)
                    .如果 (取文本长度 (影片标题) ＞ 1)
                        .如果 (取文本长度 (影片标题) ＞ 100)
                            影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                        .否则

                        .如果结束
                        影片文件夹名 ＝ 影片文件夹名 ＋ 影片标题 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

            .计次循环尾 ()

            清除数组 (临时文件名)

            临时文件名 ＝ 分割文本 (自定义影片名编辑框.内容, “+”, )
            .计次循环首 (取数组成员数 (临时文件名), i)
                .如果真 (临时文件名 [i] ＝ “日期”)
                    .如果 (取文本长度 (发行日期) ＞ 1)
                        影片文件名 ＝ 影片文件名 ＋ 发行日期 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

                .如果真 (临时文件名 [i] ＝ “番号”)
                    .如果 (取文本长度 (番号) ＞ 1)
                        影片文件名 ＝ 影片文件名 ＋ 番号 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

                .如果真 (临时文件名 [i] ＝ “演员”)
                    .如果 (取文本长度 (演员名字) ＞ 1)
                        .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                            演员名字 ＝ 文本_删右边 (演员名字, 1)
                        .否则

                        .如果结束
                        影片文件名 ＝ 影片文件名 ＋ “[” ＋ 演员名字 ＋ “] ”
                    .否则

                    .如果结束

                .如果真结束
                .如果真 (临时文件名 [i] ＝ “标题”)
                    .如果 (取文本长度 (影片标题) ＞ 1)
                        .如果 (取文本长度 (影片标题) ＞ 100)
                            影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                        .否则

                        .如果结束
                        影片文件名 ＝ 影片文件名 ＋ 影片标题 ＋ “ ”
                    .否则

                    .如果结束

                .如果真结束

            .计次循环尾 ()


        .否则
            影片文件夹名 ＝ 发行日期 ＋ “ ” ＋ 番号
            影片文件名 ＝ 发行日期 ＋ “ ” ＋ 番号
        .如果结束

        .如果 (取文本右边 (影片文件夹名, 1) ＝ “ ”)
            影片文件夹名 ＝ 文本_删右边 (影片文件夹名, 1)
        .否则

        .如果结束

        .如果 (取文本右边 (影片文件名, 1) ＝ “ ”)
            影片文件名 ＝ 文本_删右边 (影片文件名, 1)
        .否则

        .如果结束

        影片文件夹名 ＝ 删特殊字符 (影片文件夹名)
        影片文件名 ＝ 删特殊字符 (影片文件名)

        .如果 (取数组成员数 (预览图网址) ＞ 0)
            .如果 (取数组成员数 (预览图网址) ＞ 1)
                .如果 (文本_寻找文本 (预览图网址 [1], “pf_o1_”) ＝ -1)
                    图片 ＝ 网页_访问_对象 (预览图网址 [1], , , , , , , , , , 代理IP, 10)
                    .如果 (取字节集长度 (图片) ＝ 2732)
                        图片 ＝ 网页_访问_对象 (预览图网址 [2], , , , , , , , , , 代理IP, 10)
                    .否则

                    .如果结束

                .否则
                    图片 ＝ 网页_访问_对象 (预览图网址 [2], , , , , , , , , , 代理IP, 10)
                .如果结束

            .否则
                图片 ＝ 网页_访问_对象 (预览图网址 [1], , , , , , , , , , 代理IP, 10)
            .如果结束

            .如果 (取字节集长度 (图片) ＞ 2000)
                .如果 (文件是否存在 (根路径 ＋ “\” ＋ 影片文件夹名) ＝ 假)
                    创建目录 (根路径 ＋ “\” ＋ 影片文件夹名)
                .否则

                .如果结束
                路径 ＝ 根路径 ＋ “\” ＋ 影片文件夹名

                .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”) ≠ 真)
                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”, 图片)
                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”) ≠ 真)
                        批量裁剪封面 (1, 路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”)
                    .否则

                    .如果结束

                    nfo文本 ＝ 文本_替换 (#NFO, , , , “标题”, 发行日期 ＋ “ ” ＋ 影片标题, “时间”, 发行日期, “番号”, 番号, “时长”, 影片时长, “年份”, 取文本左边 (发行日期, 4))
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “发商”, 发行商, “系列”, 系列, “  <genre>类别</genre>”, 类别, “  <tag>标签</tag>”, 标签影片, “演员”, 演员名)
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “厂商”, “”, “导演”, “”, “简介”, 简介)

                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “.nfo”, 编码_Ansi到Utf8 (nfo文本))

                    文件_改名 (刮削影片路径 [id], 文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                    文件_移动 (文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]), 路径 ＋ “\” ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))

                    刮削状态 ＝ 真
                    .如果 (下载预览图选择框.选中 ＝ 真)
                        .如果 (取数组成员数 (预览图网址) ＞ 0)
                            .计次循环首 (取数组成员数 (预览图网址), i)
                                .如果 (文本_寻找文本 (预览图网址 [1], “pf_o1_”) ≠ -1)
                                    .如果 (i ≠ 1)
                                        .如果 (i ≠ 2)
                                            图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                            .如果 (取字节集长度 (图片) ＞ 10000)
                                                .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                    创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                                .否则

                                                .如果结束
                                                写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)
                                            .否则
                                                图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                                .如果 (取字节集长度 (图片) ＞ 10000)
                                                    .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                        创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                                    .否则

                                                    .如果结束
                                                    写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)

                                                .否则

                                                .如果结束

                                            .如果结束

                                        .否则

                                        .如果结束

                                    .否则
                                        图片 ＝ 网页_访问_对象 (预览图网址 [1], , , , , , , , , , 代理IP, 超时时间)
                                        .如果 (取字节集长度 (图片) ＞ 10000)
                                            .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                            .否则

                                            .如果结束
                                            写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”, 图片)
                                        .否则
                                            图片 ＝ 网页_访问_对象 (预览图网址 [1], , , , , , , , , , 代理IP, 超时时间)
                                            .如果 (取字节集长度 (图片) ＞ 10000)
                                                .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                    创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                                .否则

                                                .如果结束
                                                写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”, 图片)
                                            .否则

                                            .如果结束

                                        .如果结束

                                    .如果结束

                                .否则
                                    .如果 (i ≠ 1)
                                        图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                        .如果 (取字节集长度 (图片) ＞ 10000)
                                            .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                            .否则

                                            .如果结束
                                            写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)
                                        .否则
                                            图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                            .如果 (取字节集长度 (图片) ＞ 10000)
                                                .如果 (文件是否存在 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                                    创建目录 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                                .否则

                                                .如果结束
                                                写到文件 (根路径 ＋ “\” ＋ 发行日期 ＋ “ ” ＋ 番号 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-321预览图” ＋ 到文本 (i － 1) ＋ “.jpg”, 图片)

                                            .否则

                                            .如果结束

                                        .如果结束

                                    .否则

                                    .如果结束

                                .如果结束



                            .计次循环尾 ()






                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束

        .否则

        .如果结束

    .否则
        刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “请检查文件名中番号是否正确。”)
    .如果结束

.否则
    刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未获取到网页，请测试代理是否勾选或连接，如果代理正常请重新尝试刮削。”)
.如果结束

许可_完成.进入 ()  ' 修改一下当前进行到的位置
当前完成位置 ＝ 当前完成位置 ＋ 1
总爬取量 ＝ 总爬取量 － 1
.如果 (刮削状态 ＝ 真)
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削完成：” ＋ 刮削影片路径 [id])
.否则
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削失败：” ＋ 刮削影片路径 [id])
.如果结束
许可_完成.退出 ()
减少一个线程 ()

.子程序 _刮削提示_被单击

信息提示 (5)


.子程序 _翻译按钮_被单击
.局部变量 翻译结果, 文本型

.如果 (百度翻译选择框.选中 ＝ 真)
    翻译结果 ＝ 百度翻译 (缩略图简介编辑框.内容)
    .如果 (翻译结果 ≠ “失败”)
        缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
    .否则

    .如果结束
    程序_延时 (1000)
    翻译结果 ＝ 百度翻译 (缩略图标题编辑框.内容)
    .如果 (翻译结果 ≠ “失败”)
        缩略图标题编辑框.内容 ＝ 翻译结果
    .否则

    .如果结束


.否则
    .如果 (谷歌翻译选择框.选中 ＝ 真)
        翻译结果 ＝ 谷歌翻译 (缩略图简介编辑框.内容)
        .如果 (翻译结果 ≠ “”)
            缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
        .否则

        .如果结束
        翻译结果 ＝ 谷歌翻译 (缩略图标题编辑框.内容)
        .如果 (翻译结果 ≠ “”)
            缩略图标题编辑框.内容 ＝ 翻译结果
        .否则

        .如果结束

    .否则
        .如果 (必应翻译选择框.选中 ＝ 真)
            翻译结果 ＝ 必应翻译 (缩略图简介编辑框.内容)
            .如果 (翻译结果 ≠ “”)
                缩略图简介编辑框.内容 ＝ “    ” ＋ 翻译结果
            .否则

            .如果结束
            翻译结果 ＝ 必应翻译 (缩略图标题编辑框.内容)
            .如果 (翻译结果 ≠ “”)
                缩略图标题编辑框.内容 ＝ 翻译结果
            .否则

            .如果结束

        .否则

        .如果结束

    .如果结束

.如果结束


.子程序 _设置2_被单击

.如果 (程序设置外形框.可视 ＝ 真)
    程序设置外形框.可视 ＝ 假
.否则
    程序设置外形框.可视 ＝ 真
.如果结束


.子程序 _程序设置关闭按钮_被单击

程序设置外形框.可视 ＝ 假

.子程序 _缩略图番号编辑框_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果 (搜索状态 ＝ 假)
    搜索编辑框.内容 ＝ 影片 [封面子项].番号
    置剪辑板文本 (搜索编辑框.内容)
.否则
    搜索编辑框.内容 ＝ 搜索 [搜索封面子项].番号
    置剪辑板文本 (搜索编辑框.内容)
.如果结束


.子程序 library刮削
.局部变量 id, 整数型
.局部变量 正则, 正则表达式类
.局部变量 正则2, 正则表达式类
.局部变量 r, 文本型
.局部变量 题目, 文本型
.局部变量 网址, 文本型
.局部变量 下载, 文本型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 女优名, 文本型
.局部变量 女优名组, 文本型, , "0"
.局部变量 番号, 文本型
.局部变量 片商组, 文本型, , "0"
.局部变量 标签组, 文本型, , "0"
.局部变量 播放时长组, 文本型, , "0"
.局部变量 赞组, 文本型, , "0"
.局部变量 系列组, 文本型, , "0"
.局部变量 写出文本, 文本型
.局部变量 临时文本, 文本型
.局部变量 文件名, 文本型
.局部变量 过滤字符, 文本型, , "0"
.局部变量 预览图网址, 文本型, , "0"
.局部变量 影片标题, 文本型
.局部变量 发行商, 文本型
.局部变量 发行日期, 文本型
.局部变量 影片时长, 文本型
.局部变量 点赞数, 文本型
.局部变量 评分, 文本型
.局部变量 系列, 文本型
.局部变量 简介, 文本型
.局部变量 演员名, 文本型
.局部变量 类别, 文本型
.局部变量 标签影片, 文本型
.局部变量 nfo文本, 文本型
.局部变量 根路径, 文本型
.局部变量 路径, 文本型
.局部变量 宽, 整数型
.局部变量 图片号, 整数型
.局部变量 高, 整数型
.局部变量 图片, 字节集
.局部变量 临时图片网址, 文本型
.局部变量 网址临时分割, 文本型, , "0"
.局部变量 影片短网址, 文本型
.局部变量 影片文件名, 文本型
.局部变量 影片文件夹名, 文本型
.局部变量 临时文件名, 文本型, , "0"
.局部变量 演员名字, 文本型
.局部变量 翻译结果, 文本型
.局部变量 刮削状态, 逻辑型
.局部变量 片商, 文本型
.局部变量 封面, 文本型
.局部变量 评论, 文本型
.局部变量 临时评论, 文本型

增加一个线程 ()
许可_位置.进入 ()  ' 修改一下当前进行到的位置
当前抓取位置 ＝ 当前抓取位置 ＋ 1
id ＝ 当前抓取位置  ' 拿到自己应该处理的位置，然后存到局部变量里面
刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ 刮削影片路径 [id])
许可_位置.退出 ()
刮削状态 ＝ 假

文件名 ＝ 文件_取文件名 (刮削影片路径 [id])
.如果 (到大写 (取文本右边 (文件名, 2)) ＝ “-C”)
    文件名 ＝ 文本_删右边 (文件名, 2)
.否则

.如果结束
文件名 ＝ 文本_替换 (文件名, , , , “ ”, “”, “_”, “-”)
过滤字符 ＝ 分割文本 (过滤字符串编辑框.内容, “/”, )
.计次循环首 (取数组成员数 (过滤字符), i)
    文件名 ＝ 文本_替换 (文件名, , , , 过滤字符 [i], “”)
.计次循环尾 ()
.如果真 (正则番号选择框.选中)
    文件名 ＝ 文件名正则番号 (文件名)
.如果真结束
r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/vl_searchbyid.php?keyword=” ＋ 文件名, , , , , , , , , , 代理IP, , , 超时时间)
.如果 (取文本长度 (r) ＞ 500)

.否则
    r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/vl_searchbyid.php?keyword=” ＋ 文件名, , , , , , , , , , 代理IP, , , 超时时间)
.如果结束


.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ≠ -1)
    正则.创建 (#lib取网页番号, r)
    .计次循环首 (正则.取匹配数量 (), i)
        番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “class=” ＋ #引号 ＋ “id” ＋ #引号 ＋ “>”, “</div>”)
        .如果 (到大写 (番号) ≠ 到大写 (文件名))
            网址 ＝ “空”
        .否则
            正则.创建 (#lib取网页, r)
            网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<a href=” ＋ #引号 ＋ “./?v=”, #引号 ＋ “ title=”)
            跳出循环 ()
        .如果结束

    .计次循环尾 ()
.否则

.如果结束

.如果 (网址 ≠ “”)
    .如果 (网址 ≠ “空”)
        r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/?v=” ＋ 网址, , , , , , , , , , 代理IP, , , 超时时间)
        .如果 (取文本长度 (r) ＞ 500)

        .否则
            r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/?v=” ＋ 网址, , , , , , , , , , 代理IP, , , 超时时间)
        .如果结束

    .否则
        刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未在网站搜索到此番号。”)
    .如果结束

.否则

.如果结束
.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
            根路径 ＝ 文件_取目录 (刮削影片路径 [id])
            正则.创建 (#lib标题, r)
            .计次循环首 (正则.取匹配数量 (), i)
                影片标题 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “rel='bookmark' >”, “</a></h3>”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib网址, r)
            .计次循环首 (正则.取匹配数量 (), i)
                网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “videoid = ” ＋ #引号, #引号 ＋ “;”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib封面, r)
            .计次循环首 (正则.取匹配数量 (), i)
                封面 ＝ “http:” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #lib封面头, #lib封面尾, , 真)
            .计次循环尾 ()

            正则.创建 (#lib番号, r)
            .计次循环首 (正则.取匹配数量 (), i)
                番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “text” ＋ #引号 ＋ “>”, “</td>”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib制作商, r)
            .计次循环首 (正则.取匹配数量 (), i)
                发行商 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “tag” ＋ #引号 ＋ “>”, “<”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib片商, r)
            .计次循环首 (正则.取匹配数量 (), i)
                片商 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “tag” ＋ #引号 ＋ “>”, “<”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib发行日期, r)
            .计次循环首 (正则.取匹配数量 (), i)
                发行日期 ＝ 正则.取匹配文本 (1)
            .计次循环尾 ()

            正则.创建 (#lib影片时长, r)
            .计次循环首 (正则.取匹配数量 (), i)
                影片时长 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “text” ＋ #引号 ＋ “>”, “</span>”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib评分, r)
            .计次循环首 (正则.取匹配数量 (), i)
                评分 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “score” ＋ #引号 ＋ “>(”, “)<”, , 真)
            .计次循环尾 ()

            正则.创建 (#lib评论, r)
            .计次循环首 (正则.取匹配数量 (), i)
                临时评论 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “hidden” ＋ #引号 ＋ “>”, “</textarea>”, , 真)
                .如果 (文本_寻找文本 (临时评论, “點擊進入下載”) ＝ -1)
                    .如果 (文本_寻找文本 (临时评论, “点击进入下载资源”) ＝ -1)
                        .如果 (文本_寻找文本 (临时评论, “点击进入下载”) ＝ -1)
                            .如果 (文本_寻找文本 (临时评论, “.mp4”) ＝ -1)
                                .如果 (文本_寻找文本 (临时评论, “http”) ＝ -1)
                                    .如果 (文本_寻找文本 (临时评论, “color”) ＝ -1)
                                        .如果 (文本_寻找文本 (临时评论, “img”) ＝ -1)
                                            临时评论 ＝ 文本_替换 (临时评论, , , , “[/quote]”, “”, “[quote:]”, “”)
                                            临时评论 ＝ 文本_替换 (临时评论, , , , 文本_取出中间文本 (临时评论, “[quote”, “:]”), “”)
                                            评论 ＝ 评论 ＋ “评论” ＋ 到文本 (i) ＋ “:” ＋ 刮削文本替换换行符 (临时评论) ＋ “。”

                                        .否则

                                        .如果结束

                                    .否则

                                    .如果结束

                                .否则

                                .如果结束

                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .计次循环尾 ()

            .如果 (评分 ≠ “”)
                类别 ＝ “  <genre>” ＋ “评分:” ＋ 评分 ＋ “</genre>” ＋ #换行符
                标签影片 ＝ “  <tag>” ＋ “评分:” ＋ 评分 ＋ “</tag>” ＋ #换行符

            .否则

            .如果结束

            正则.创建 (#lib演员, r)
            .如果 (正则.取匹配数量 () ≠ 0)
                .计次循环首 (正则.取匹配数量 (), i)
                    .如果 (正则.取匹配文本 (i) ≠ “”)
                        演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), “tag” ＋ #引号 ＋ “>”, “<”, , 真) ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符 ＋ 演员名
                        演员名字 ＝ 演员名字 ＋ 文本_取出中间文本 (正则.取匹配文本 (i), “tag” ＋ #引号 ＋ “>”, “<”, , 真) ＋ “ ”
                    .否则
                        演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
                    .如果结束

                .计次循环尾 ()

            .否则
                演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
            .如果结束

            正则.创建 (#lib标签, r)
            .如果 (正则.取匹配数量 () ≠ 0)
                .计次循环首 (正则.取匹配数量 (), i)
                    .如果 (正则.取匹配文本 (i) ≠ “”)
                        类别 ＝ “  <genre>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), “tag” ＋ #引号 ＋ “>”, “<”, , 真) ＋ “</genre>” ＋ #换行符 ＋ 类别
                        标签影片 ＝ “  <tag>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), “tag” ＋ #引号 ＋ “>”, “<”, , 真) ＋ “</tag>” ＋ #换行符 ＋ 标签影片
                    .否则
                        类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                        标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符
                    .如果结束

                .计次循环尾 ()

            .否则
                类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符

            .如果结束

            .如果 (刮削获取简介选择框.选中 ＝ 真)
                简介 ＝ dmm简介 (文件名)
                .如果真 (简介 ＝ “”)
                    简介 ＝ dmm简介 (文件名)
                .如果真结束


                .如果 (百度翻译选择框.选中 ＝ 真)
                    翻译结果 ＝ 百度翻译 (简介)
                    .如果 (翻译结果 ≠ “失败”)
                        简介 ＝ 翻译结果

                    .否则

                    .如果结束

                .否则
                    .如果 (谷歌翻译选择框.选中 ＝ 真)
                        翻译结果 ＝ 谷歌翻译 (简介)
                        .如果 (翻译结果 ≠ “”)
                            简介 ＝ 翻译结果

                        .否则

                        .如果结束

                    .否则
                        .如果 (必应翻译选择框.选中 ＝ 真)
                            翻译结果 ＝ 必应翻译 (简介)
                            .如果 (翻译结果 ≠ “”)
                                简介 ＝ 翻译结果

                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .如果结束

                .如果结束

            .否则

            .如果结束

            .如果 (保存评论选择框.选中 ＝ 真)
                简介 ＝ 简介 ＋ “//【精彩影评】” ＋ 评论
            .否则

            .如果结束

            ' 调试输出 (影片标题)
            ' 调试输出 (网址)
            ' 调试输出 (演员名字)
            ' 调试输出 (番号)
            ' 调试输出 (发行商)
            ' 调试输出 (片商)
            ' 调试输出 (发行日期)
            ' 调试输出 (影片时长)
            ' 调试输出 (评分)
            ' 调试输出 (简介)



            正则.创建 (#lib预览图, 到文本 (r))
            .计次循环首 (正则.取匹配数量 (), i)
                加入成员 (预览图网址, “http:” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #lib预览图头, #lib预览图尾, , 真))
            .计次循环尾 ()

            .如果 (自定义刮削名称选择框.选中 ＝ 真)
                清除数组 (临时文件名)
                临时文件名 ＝ 分割文本 (自定义文件夹名编辑框.内容, “+”, )
                .计次循环首 (取数组成员数 (临时文件名), i)
                    .如果真 (临时文件名 [i] ＝ “日期”)
                        .如果 (取文本长度 (发行日期) ＞ 1)
                            影片文件夹名 ＝ 影片文件夹名 ＋ 发行日期 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “番号”)
                        .如果 (取文本长度 (番号) ＞ 1)
                            影片文件夹名 ＝ 影片文件夹名 ＋ 番号 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “演员”)
                        .如果 (取文本长度 (演员名字) ＞ 1)
                            .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                演员名字 ＝ 文本_删右边 (演员名字, 1)
                            .否则

                            .如果结束
                            影片文件夹名 ＝ 影片文件夹名 ＋ “[” ＋ 演员名字 ＋ “] ”
                        .否则

                        .如果结束

                    .如果真结束
                    .如果真 (临时文件名 [i] ＝ “标题”)
                        .如果 (取文本长度 (影片标题) ＞ 1)
                            .如果 (取文本长度 (影片标题) ＞ 100)
                                影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                            .否则

                            .如果结束
                            影片文件夹名 ＝ 影片文件夹名 ＋ 影片标题 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                .计次循环尾 ()

                清除数组 (临时文件名)

                临时文件名 ＝ 分割文本 (自定义影片名编辑框.内容, “+”, )
                .计次循环首 (取数组成员数 (临时文件名), i)
                    .如果真 (临时文件名 [i] ＝ “日期”)
                        .如果 (取文本长度 (发行日期) ＞ 1)
                            影片文件名 ＝ 影片文件名 ＋ 发行日期 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “番号”)
                        .如果 (取文本长度 (番号) ＞ 1)
                            影片文件名 ＝ 影片文件名 ＋ 番号 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “演员”)
                        .如果 (取文本长度 (演员名字) ＞ 1)
                            .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                演员名字 ＝ 文本_删右边 (演员名字, 1)
                            .否则

                            .如果结束
                            影片文件名 ＝ 影片文件名 ＋ “[” ＋ 演员名字 ＋ “] ”
                        .否则

                        .如果结束

                    .如果真结束
                    .如果真 (临时文件名 [i] ＝ “标题”)
                        .如果 (取文本长度 (影片标题) ＞ 1)
                            .如果 (取文本长度 (影片标题) ＞ 100)
                                影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                            .否则

                            .如果结束
                            影片文件名 ＝ 影片文件名 ＋ 影片标题 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                .计次循环尾 ()


            .否则
                影片文件夹名 ＝ 发行日期 ＋ “ ” ＋ 番号
                影片文件名 ＝ 发行日期 ＋ “ ” ＋ 番号
            .如果结束

            .如果 (取文本右边 (影片文件夹名, 1) ＝ “ ”)
                影片文件夹名 ＝ 文本_删右边 (影片文件夹名, 1)
            .否则

            .如果结束

            .如果 (取文本右边 (影片文件名, 1) ＝ “ ”)
                影片文件名 ＝ 文本_删右边 (影片文件名, 1)
            .否则

            .如果结束

            影片文件夹名 ＝ 删特殊字符 (影片文件夹名)
            影片文件名 ＝ 删特殊字符 (影片文件名)

            图片 ＝ 网页_访问_对象 (封面, , , , , , , , , , 代理IP, 超时时间)
            .如果 (取字节集长度 (图片) ＞ 2000)
                .如果 (文件是否存在 (根路径 ＋ 影片文件夹名) ＝ 假)
                    创建目录 (根路径 ＋ 影片文件夹名)
                .否则

                .如果结束
                路径 ＝ 根路径 ＋ 影片文件夹名
                .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”) ≠ 真)
                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”, 图片)
                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”) ≠ 真)
                        批量裁剪封面 (1, 路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”)
                    .否则

                    .如果结束

                    nfo文本 ＝ 文本_替换 (#NFO, , , , “标题”, 发行日期 ＋ “ ” ＋ 影片标题, “时间”, 发行日期, “番号”, 番号, “时长”, 影片时长, “年份”, 取文本左边 (发行日期, 4))
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “发商”, 发行商, “系列”, 系列, “  <genre>类别</genre>”, 类别, “  <tag>标签</tag>”, 标签影片, “演员”, 演员名)
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “厂商”, 片商, “导演”, “”, “简介”, 简介)
                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “.nfo”, 编码_Ansi到Utf8 (nfo文本))

                    文件_改名 (刮削影片路径 [id], 文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                    文件_移动 (文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]), 路径 ＋ “\” ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                    刮削状态 ＝ 真
                    .如果 (下载预览图选择框.选中 ＝ 真)
                        .如果 (取数组成员数 (预览图网址) ＞ 0)
                            .计次循环首 (取数组成员数 (预览图网址), i)
                                图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                .如果 (取字节集长度 (图片) ＞ 1000)
                                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                        创建目录 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                    .否则

                                    .如果结束
                                    写到文件 (路径 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                .否则
                                    图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                    .如果 (取字节集长度 (图片) ＞ 1000)
                                        .如果 (文件是否存在 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                            创建目录 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                        .否则

                                        .如果结束
                                        写到文件 (路径 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                    .否则

                                    .如果结束

                                .如果结束

                            .计次循环尾 ()






                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束



        .否则
            刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “请检查文件名中番号是否正确。”)
        .如果结束

    .否则
        刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未获取到网页，请测试代理是否勾选或连接，如果代理正常请重新尝试刮削。”)
    .如果结束


.否则
    刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未获取到番号所在的网页，请检查后重新尝试。”)
.如果结束


许可_完成.进入 ()  ' 修改一下当前进行到的位置
当前完成位置 ＝ 当前完成位置 ＋ 1
总爬取量 ＝ 总爬取量 － 1
.如果 (刮削状态 ＝ 真)
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削完成：” ＋ 刮削影片路径 [id])
.否则
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削失败：” ＋ 刮削影片路径 [id])
.如果结束
许可_完成.退出 ()
减少一个线程 ()

.子程序 _浏览播放器路径按钮_被单击
.局部变量 路径, 文本型

路径 ＝ 目录_浏览 (“选择指定播放器”, 真)
播放器编辑框.内容 ＝ 路径
批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_编辑框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_组合框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)


.子程序 _设置播放器选择框_被单击

批量_选择框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_编辑框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)
批量_组合框_保存配置 (窗口_下拉列表, 根目录 ＋ “配置\组件配置.ini”)



.子程序 播放视频
.参数 路径, 文本型

.如果 (设置播放器选择框.选中 ＝ 真)
    运行 (播放器编辑框.内容 ＋ “ ” ＋ 路径, 假, )
.否则
    执行 (, 路径, , , )
.如果结束


.子程序 javdb刮削
.局部变量 id, 整数型
.局部变量 正则, 正则表达式类
.局部变量 正则2, 正则表达式类
.局部变量 r, 文本型
.局部变量 题目, 文本型
.局部变量 网址, 文本型
.局部变量 下载, 文本型
.局部变量 i, 整数型
.局部变量 k, 整数型
.局部变量 女优名, 文本型
.局部变量 女优名组, 文本型, , "0"
.局部变量 番号, 文本型
.局部变量 片商组, 文本型, , "0"
.局部变量 标签组, 文本型, , "0"
.局部变量 播放时长组, 文本型, , "0"
.局部变量 赞组, 文本型, , "0"
.局部变量 系列组, 文本型, , "0"
.局部变量 写出文本, 文本型
.局部变量 临时文本, 文本型
.局部变量 文件名, 文本型
.局部变量 过滤字符, 文本型, , "0"
.局部变量 预览图网址, 文本型, , "0"
.局部变量 影片标题, 文本型
.局部变量 发行商, 文本型
.局部变量 发行日期, 文本型
.局部变量 影片时长, 文本型
.局部变量 点赞数, 文本型
.局部变量 评分, 文本型
.局部变量 系列, 文本型
.局部变量 简介, 文本型
.局部变量 演员名, 文本型
.局部变量 类别, 文本型
.局部变量 标签影片, 文本型
.局部变量 nfo文本, 文本型
.局部变量 根路径, 文本型
.局部变量 路径, 文本型
.局部变量 宽, 整数型
.局部变量 图片号, 整数型
.局部变量 高, 整数型
.局部变量 图片, 字节集
.局部变量 临时图片网址, 文本型
.局部变量 网址临时分割, 文本型, , "0"
.局部变量 影片短网址, 文本型
.局部变量 影片文件名, 文本型
.局部变量 影片文件夹名, 文本型
.局部变量 临时文件名, 文本型, , "0"
.局部变量 演员名字, 文本型
.局部变量 翻译结果, 文本型
.局部变量 刮削状态, 逻辑型
.局部变量 片商, 文本型
.局部变量 封面, 文本型
.局部变量 评论, 文本型
.局部变量 临时评论, 文本型

增加一个线程 ()
许可_位置.进入 ()  ' 修改一下当前进行到的位置
当前抓取位置 ＝ 当前抓取位置 ＋ 1
id ＝ 当前抓取位置  ' 拿到自己应该处理的位置，然后存到局部变量里面
刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ 刮削影片路径 [id])
许可_位置.退出 ()
刮削状态 ＝ 假

文件名 ＝ 文件_取文件名 (刮削影片路径 [id])
.如果 (到大写 (取文本右边 (文件名, 2)) ＝ “-C”)
    文件名 ＝ 文本_删右边 (文件名, 2)
.否则

.如果结束
文件名 ＝ 文本_替换 (文件名, , , , “ ”, “”, “_”, “-”)
过滤字符 ＝ 分割文本 (过滤字符串编辑框.内容, “/”, )
.计次循环首 (取数组成员数 (过滤字符), i)
    文件名 ＝ 文本_替换 (文件名, , , , 过滤字符 [i], “”)
.计次循环尾 ()
.如果真 (正则番号选择框.选中)
    文件名 ＝ 文件名正则番号 (文件名)
.如果真结束


r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
.如果 (取文本长度 (r) ＞ 500)

.否则
    r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
.如果结束

.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
    正则.创建 (#db取番号, r)
    .计次循环首 (正则.取匹配数量 (), i)
        番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “番號: ”, “ / 發布時間: ”)
        .如果 (到大写 (番号) ≠ 到大写 (文件名))
            网址 ＝ “空”
        .否则
            正则.创建 (#db取网页码, r)
            网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “uid” ＋ #引号 ＋ “:” ＋ #引号, #引号)
            跳出循环 ()
        .如果结束

    .计次循环尾 ()
.否则

.如果结束

.如果 (网址 ≠ “空”)
    r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
    .如果 (取文本长度 (r) ＞ 500)

    .否则
        r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
    .如果结束

    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
            根路径 ＝ 文件_取目录 (刮削影片路径 [id])
            正则.创建 (#db标题, r)
            .计次循环首 (正则.取匹配数量 (), i)
                影片标题 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<strong>”, “</strong>”, , 真)
            .计次循环尾 ()
            ' 正则.创建 (#lib网址, r)
            .' 计次循环首 (正则.取匹配数量 (), i)
                ' 网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “videoid = ” ＋ #引号, #引号 ＋ “;”, , 真)
            .' 计次循环尾 ()

            正则.创建 (#db封面, r)
            .计次循环首 (正则.取匹配数量 (), i)
                封面 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “img src=” ＋ #引号, #引号 ＋ “ class=”, , 真)
            .计次循环尾 ()

            正则.创建 (#db番号, r)
            .计次循环首 (正则.取匹配数量 (), i)
                番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “複製番號” ＋ #引号 ＋ “ data-clipboard-text=” ＋ #引号, #引号 ＋ “>”, , 真)
            .计次循环尾 ()

            正则.创建 (#db片商, r)
            .计次循环首 (正则.取匹配数量 (), i)
                发行商 ＝ 文本_取出中间文本 (文本_取出中间文本 (正则.取匹配文本 (1), #db片商头, “</span>”, , 真), #引号 ＋ “>”, “</a>”, , 真)
            .计次循环尾 ()


            ' 正则.创建 (#lib片商, r)
            .' 计次循环首 (正则.取匹配数量 (), i)
                ' 片商 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “tag” ＋ #引号 ＋ “>”, “<”, , 真)
            .' 计次循环尾 ()

            正则.创建 (#db日期, r)
            .计次循环首 (正则.取匹配数量 (), i)
                发行日期 ＝ 正则.取匹配文本 (1)
            .计次循环尾 ()
            正则.创建 (#db时长, r)
            .计次循环首 (正则.取匹配数量 (), i)
                影片时长 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “value” ＋ #引号 ＋ “>”, “ 分鍾”, , 真)
            .计次循环尾 ()

            ' 正则.创建 (#lib评分, r)
            .' 计次循环首 (正则.取匹配数量 (), i)
                ' 评分 ＝ 文本_取出中间文本 (正则.取匹配文本 (1), “score” ＋ #引号 ＋ “>(”, “)<”, , 真)
            .' 计次循环尾 ()

            ' 正则.创建 (#lib评论, r)
            .' 计次循环首 (正则.取匹配数量 (), i)
                ' 临时评论 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “hidden” ＋ #引号 ＋ “>”, “</textarea>”, , 真)
                .' 如果 (文本_寻找文本 (临时评论, “點擊進入下載”) ＝ -1)
                    .' 如果 (文本_寻找文本 (临时评论, “点击进入下载资源”) ＝ -1)
                        .' 如果 (文本_寻找文本 (临时评论, “点击进入下载”) ＝ -1)
                            .' 如果 (文本_寻找文本 (临时评论, “.mp4”) ＝ -1)
                                .' 如果 (文本_寻找文本 (临时评论, “http”) ＝ -1)
                                    .' 如果 (文本_寻找文本 (临时评论, “color”) ＝ -1)
                                        .' 如果 (文本_寻找文本 (临时评论, “img”) ＝ -1)
                                            ' 临时评论 ＝ 文本_替换 (临时评论, , , , “[/quote]”, “”, “[quote:]”, “”)
                                            ' 临时评论 ＝ 文本_替换 (临时评论, , , , 文本_取出中间文本 (临时评论, “[quote”, “:]”), “”)
                                            ' 评论 ＝ 评论 ＋ “评论” ＋ 到文本 (i) ＋ “:” ＋ 刮削文本替换换行符 (临时评论) ＋ “。”

                                        .否则

                                        .如果结束

                                    .否则

                                    .如果结束

                                .否则

                                .如果结束

                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .' 计次循环尾 ()

            .' 如果 (评分 ≠ “”)
                ' 类别 ＝ “  <genre>” ＋ “评分:” ＋ 评分 ＋ “</genre>” ＋ #换行符
                ' 标签影片 ＝ “  <tag>” ＋ “评分:” ＋ 评分 ＋ “</tag>” ＋ #换行符

            .否则

            .如果结束



            正则.创建 (#db演员, r)
            演员名 ＝ 正则.取匹配文本 (1)
            正则.创建 (#db演员2, 演员名)
            .如果 (正则.取匹配数量 () ≠ 0)
                演员名 ＝ “”
                .计次循环首 (正则.取匹配数量 (), i)
                    .如果 (正则.取匹配文本 (i) ≠ “”)
                        演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #引号 ＋ “>”, “</a>”, , 真) ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符 ＋ 演员名
                        演员名字 ＝ 演员名字 ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #引号 ＋ “>”, “</a>”, , 真) ＋ “ ”
                    .否则
                        演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
                    .如果结束

                .计次循环尾 ()

            .否则
                演员名 ＝ “  <actor>” ＋ #换行符 ＋ “    <name>” ＋ “无演员信息” ＋ “</name>” ＋ #换行符 ＋ “    <type>Actor</type>” ＋ #换行符 ＋ “  </actor>” ＋ #换行符
            .如果结束
            正则.创建 (#db标签, r)
            类别 ＝ 正则.取匹配文本 (1)
            正则.创建 (#db演员2, 类别)
            .如果 (正则.取匹配数量 () ≠ 0)
                类别 ＝ “”
                .计次循环首 (正则.取匹配数量 (), i)
                    .如果 (正则.取匹配文本 (i) ≠ “”)
                        类别 ＝ “  <genre>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #引号 ＋ “>”, “</a>”, , 真) ＋ “</genre>” ＋ #换行符 ＋ 类别
                        标签影片 ＝ “  <tag>” ＋ 文本_取出中间文本 (正则.取匹配文本 (i), #引号 ＋ “>”, “</a>”, , 真) ＋ “</tag>” ＋ #换行符 ＋ 标签影片
                    .否则
                        类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                        标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符
                    .如果结束

                .计次循环尾 ()

            .否则
                类别 ＝ “  <genre>” ＋ “无类别” ＋ “</genre>” ＋ #换行符
                标签影片 ＝ “  <tag>” ＋ “无标签” ＋ “</tag>” ＋ #换行符

            .如果结束

            .如果 (刮削获取简介选择框.选中 ＝ 真)
                简介 ＝ dmm简介 (文件名)
                .如果真 (简介 ＝ “”)
                    简介 ＝ dmm简介 (文件名)
                .如果真结束


                .如果 (百度翻译选择框.选中 ＝ 真)
                    翻译结果 ＝ 百度翻译 (简介)
                    .如果 (翻译结果 ≠ “失败”)
                        简介 ＝ 翻译结果

                    .否则

                    .如果结束

                .否则
                    .如果 (谷歌翻译选择框.选中 ＝ 真)
                        翻译结果 ＝ 谷歌翻译 (简介)
                        .如果 (翻译结果 ≠ “”)
                            简介 ＝ 翻译结果

                        .否则

                        .如果结束

                    .否则
                        .如果 (必应翻译选择框.选中 ＝ 真)
                            翻译结果 ＝ 必应翻译 (简介)
                            .如果 (翻译结果 ≠ “”)
                                简介 ＝ 翻译结果

                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .如果结束

                .如果结束

            .否则

            .如果结束

            ' 调试输出 (封面)
            ' 调试输出 (影片标题)
            ' 调试输出 (番号)
            ' 调试输出 (发行商)
            ' 调试输出 (发行日期)
            ' 调试输出 (影片时长)
            ' 调试输出 (演员名)
            ' 调试输出 (演员名字)
            ' 调试输出 (类别)
            ' 调试输出 (标签影片)

            正则.创建 (#db预览图, 到文本 (r))
            .计次循环首 (正则.取匹配数量 (), i)
                加入成员 (预览图网址, 文本_取出中间文本 (正则.取匹配文本 (i), “tile-item” ＋ #引号 ＋ “ href=” ＋ #引号, #引号 ＋ “ data-fancybox”, , 真))
            .计次循环尾 ()

            .如果 (自定义刮削名称选择框.选中 ＝ 真)
                清除数组 (临时文件名)
                临时文件名 ＝ 分割文本 (自定义文件夹名编辑框.内容, “+”, )
                .计次循环首 (取数组成员数 (临时文件名), i)
                    .如果真 (临时文件名 [i] ＝ “日期”)
                        .如果 (取文本长度 (发行日期) ＞ 1)
                            影片文件夹名 ＝ 影片文件夹名 ＋ 发行日期 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “番号”)
                        .如果 (取文本长度 (番号) ＞ 1)
                            影片文件夹名 ＝ 影片文件夹名 ＋ 番号 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “演员”)
                        .如果 (取文本长度 (演员名字) ＞ 1)
                            .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                演员名字 ＝ 文本_删右边 (演员名字, 1)
                            .否则

                            .如果结束
                            影片文件夹名 ＝ 影片文件夹名 ＋ “[” ＋ 演员名字 ＋ “] ”
                        .否则

                        .如果结束

                    .如果真结束
                    .如果真 (临时文件名 [i] ＝ “标题”)
                        .如果 (取文本长度 (影片标题) ＞ 1)
                            .如果 (取文本长度 (影片标题) ＞ 100)
                                影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                            .否则

                            .如果结束
                            影片文件夹名 ＝ 影片文件夹名 ＋ 影片标题 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                .计次循环尾 ()

                清除数组 (临时文件名)

                临时文件名 ＝ 分割文本 (自定义影片名编辑框.内容, “+”, )
                .计次循环首 (取数组成员数 (临时文件名), i)
                    .如果真 (临时文件名 [i] ＝ “日期”)
                        .如果 (取文本长度 (发行日期) ＞ 1)
                            影片文件名 ＝ 影片文件名 ＋ 发行日期 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “番号”)
                        .如果 (取文本长度 (番号) ＞ 1)
                            影片文件名 ＝ 影片文件名 ＋ 番号 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                    .如果真 (临时文件名 [i] ＝ “演员”)
                        .如果 (取文本长度 (演员名字) ＞ 1)
                            .如果 (取文本右边 (演员名字, 1) ＝ “ ”)
                                演员名字 ＝ 文本_删右边 (演员名字, 1)
                            .否则

                            .如果结束
                            影片文件名 ＝ 影片文件名 ＋ “[” ＋ 演员名字 ＋ “] ”
                        .否则

                        .如果结束

                    .如果真结束
                    .如果真 (临时文件名 [i] ＝ “标题”)
                        .如果 (取文本长度 (影片标题) ＞ 1)
                            .如果 (取文本长度 (影片标题) ＞ 100)
                                影片标题 ＝ gb_取左边文本 (影片标题, 标题字数)
                            .否则

                            .如果结束
                            影片文件名 ＝ 影片文件名 ＋ 影片标题 ＋ “ ”
                        .否则

                        .如果结束

                    .如果真结束

                .计次循环尾 ()


            .否则
                影片文件夹名 ＝ 发行日期 ＋ “ ” ＋ 番号
                影片文件名 ＝ 发行日期 ＋ “ ” ＋ 番号
            .如果结束

            .如果 (取文本右边 (影片文件夹名, 1) ＝ “ ”)
                影片文件夹名 ＝ 文本_删右边 (影片文件夹名, 1)
            .否则

            .如果结束

            .如果 (取文本右边 (影片文件名, 1) ＝ “ ”)
                影片文件名 ＝ 文本_删右边 (影片文件名, 1)
            .否则

            .如果结束

            影片文件夹名 ＝ 删特殊字符 (影片文件夹名)
            影片文件名 ＝ 删特殊字符 (影片文件名)

            图片 ＝ 网页_访问_对象 (封面, , , , , , , , , , 代理IP, 超时时间)
            .如果 (取字节集长度 (图片) ＞ 10000)
                .如果 (文件是否存在 (根路径 ＋ 影片文件夹名) ＝ 假)
                    创建目录 (根路径 ＋ 影片文件夹名)
                .否则

                .如果结束
                路径 ＝ 根路径 ＋ 影片文件夹名
                .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”) ≠ 真)
                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”, 图片)
                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 影片文件名 ＋ “-poster.jpg”) ≠ 真)
                        批量裁剪封面 (1, 路径 ＋ “\” ＋ 影片文件名 ＋ “-fanart.jpg”)
                    .否则

                    .如果结束

                    nfo文本 ＝ 文本_替换 (#NFO, , , , “标题”, 发行日期 ＋ “ ” ＋ 影片标题, “时间”, 发行日期, “番号”, 番号, “时长”, 影片时长, “年份”, 取文本左边 (发行日期, 4))
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “发商”, 发行商, “系列”, 系列, “  <genre>类别</genre>”, 类别, “  <tag>标签</tag>”, 标签影片, “演员”, 演员名)
                    nfo文本 ＝ 文本_替换 (nfo文本, , , , “厂商”, 片商, “导演”, “”, “简介”, 简介)
                    写到文件 (路径 ＋ “\” ＋ 影片文件名 ＋ “.nfo”, 编码_Ansi到Utf8 (nfo文本))

                    文件_改名 (刮削影片路径 [id], 文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                    文件_移动 (文件_取目录 (刮削影片路径 [id]) ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]), 路径 ＋ “\” ＋ 影片文件名 ＋ 文件_取扩展名 (刮削影片路径 [id]))
                    刮削状态 ＝ 真
                    .如果 (下载预览图选择框.选中 ＝ 真)
                        .如果 (取数组成员数 (预览图网址) ＞ 0)
                            .计次循环首 (取数组成员数 (预览图网址), i)
                                图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                .如果 (取字节集长度 (图片) ＞ 1000)
                                    .如果 (文件是否存在 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                        创建目录 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                    .否则

                                    .如果结束
                                    写到文件 (路径 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                .否则
                                    图片 ＝ 网页_访问_对象 (预览图网址 [i], , , , , , , , , , 代理IP, 超时时间)
                                    .如果 (取字节集长度 (图片) ＞ 1000)
                                        .如果 (文件是否存在 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”) ＝ 假)
                                            创建目录 (路径 ＋ “\” ＋ 番号 ＋ “-预览图”)
                                        .否则

                                        .如果结束
                                        写到文件 (路径 ＋ “\” ＋ 番号 ＋ “-预览图\” ＋ 番号 ＋ “-bus预览图” ＋ 到文本 (i) ＋ “.jpg”, 图片)
                                    .否则

                                    .如果结束

                                .如果结束

                            .计次循环尾 ()






                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .否则

            .如果结束



        .否则
            刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “请检查文件名中番号是否正确。”)
        .如果结束

    .否则
        刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未获取到网页，请测试代理是否勾选或连接，如果代理正常请重新尝试刮削。”)
    .如果结束

.否则
    刮削日志 (“正在刮削第” ＋ 到文本 (id) ＋ “个：” ＋ “未在网站搜索到此番号。”)
.如果结束

许可_完成.进入 ()  ' 修改一下当前进行到的位置
当前完成位置 ＝ 当前完成位置 ＋ 1
总爬取量 ＝ 总爬取量 － 1
.如果 (刮削状态 ＝ 真)
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削完成：” ＋ 刮削影片路径 [id])
.否则
    刮削日志 (“第” ＋ 到文本 (id) ＋ “个刮削失败：” ＋ 刮削影片路径 [id])
.如果结束
许可_完成.退出 ()
减少一个线程 ()

.子程序 写出网页
.参数 网页, 文本型

写到文件 (根目录 ＋ “写出网页.txt”, 到字节集 (网页))
执行 (, 根目录 ＋ “写出网页.txt”, , , )

.子程序 删特殊字符, 文本型
.参数 文本, 文本型

文本 ＝ 文本_替换 (文本, , , , “?”, “”, “\”, “”, “/”, “”, “:”, “”, “*”, “”)
文本 ＝ 文本_替换 (文本, , , , #引号, “”, “<”, “”, “>”, “”, “|”, “”, )
.如果 (取文本右边 (文本, 1) ＝ “ ”)
    文本 ＝ 文本_删右边 (文本, 1)
.否则

.如果结束
返回 (文本)

.子程序 _获取评论_被选择

log (“正在获取影片的评论，请稍等...”)
.如果 (搜索状态 ＝ 假)
    获取评论 (影片 [封面子项].番号, 1)
.否则
    获取评论 (搜索 [搜索封面子项].番号, 1)

.如果结束



.子程序 获取评论, 文本型
.参数 lib番号, 文本型
.参数 项, 整数型
.局部变量 r, 文本型
.局部变量 正则, 正则表达式类
.局部变量 番号, 文本型
.局部变量 i, 整数型
.局部变量 网址, 文本型
.局部变量 临时评论, 文本型
.局部变量 评论, 文本型
.局部变量 a, 整数型

r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/vl_searchbyid.php?keyword=” ＋ lib番号, , , , , , , , , , 代理IP, , , 超时时间)
.如果 (取文本长度 (r) ＞ 500)

.否则
    r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/vl_searchbyid.php?keyword=” ＋ lib番号, , , , , , , , , , 代理IP, , , 超时时间)
.如果结束

.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ≠ -1)
    正则.创建 (#lib取网页番号, r)
    .计次循环首 (正则.取匹配数量 (), i)
        番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “class=” ＋ #引号 ＋ “id” ＋ #引号 ＋ “>”, “</div>”)
        .如果 (到大写 (番号) ≠ 到大写 (lib番号))
            网址 ＝ “空”
        .否则
            正则.创建 (#lib取网页, r)
            网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<a href=” ＋ #引号 ＋ “./?v=”, #引号 ＋ “ title=”)
            跳出循环 ()
        .如果结束

    .计次循环尾 ()
.否则

.如果结束

.如果 (网址 ≠ “”)
    .如果 (网址 ≠ “空”)
        r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/?v=” ＋ 网址, , , , , , , , , , 代理IP, , , 超时时间)
        .如果 (取文本长度 (r) ＞ 500)

        .否则
            r ＝ 网页_访问S (刮削library编辑框.内容 ＋ “cn/?v=” ＋ 网址, , , , , , , , , , 代理IP, , , 超时时间)
        .如果结束

    .否则
        刮削日志 (“正在获取评论：” ＋ “未在网站搜索到此番号。”)
    .如果结束

.否则

.如果结束
.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
            正则.创建 (#lib评论, r)
            .计次循环首 (正则.取匹配数量 (), i)
                临时评论 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “hidden” ＋ #引号 ＋ “>”, “</textarea>”, , 真)
                .如果 (文本_寻找文本 (临时评论, “點擊進入下載”) ＝ -1)
                    .如果 (文本_寻找文本 (临时评论, “点击进入下载资源”) ＝ -1)
                        .如果 (文本_寻找文本 (临时评论, “点击进入下载”) ＝ -1)
                            .如果 (文本_寻找文本 (临时评论, “.mp4”) ＝ -1)
                                .如果 (文本_寻找文本 (临时评论, “http”) ＝ -1)
                                    .如果 (文本_寻找文本 (临时评论, “color”) ＝ -1)
                                        .如果 (文本_寻找文本 (临时评论, “img”) ＝ -1)
                                            临时评论 ＝ 文本_替换 (临时评论, , , , “[/quote]”, “”, “[quote:]”, “”)
                                            临时评论 ＝ 文本_替换 (临时评论, , , , 文本_取出中间文本 (临时评论, “[quote”, “:]”), “”)
                                            评论 ＝ 评论 ＋ “评论” ＋ 到文本 (i) ＋ “:” ＋ 刮削文本替换换行符 (临时评论) ＋ “。” ＋ #换行符
                                        .否则

                                        .如果结束

                                    .否则

                                    .如果结束

                                .否则

                                .如果结束

                            .否则

                            .如果结束

                        .否则

                        .如果结束

                    .否则

                    .如果结束

                .否则

                .如果结束

            .计次循环尾 ()

        .否则

        .如果结束

    .否则

    .如果结束

.否则

.如果结束

.如果 (评论 ≠ “”)
    ' 信息提示外形框.可视 ＝ 真
    ' 信息提示编辑框.滚动条 ＝ 2
    ' 信息提示 (6, “【” ＋ lib番号 ＋ “精彩影评】” ＋ #换行符 ＋ 评论)
    .如果 (项 ＝ 1)
        a ＝ 信息框_z (“【” ＋ lib番号 ＋ “精彩影评】”, 评论, “”, “”, )
    .否则

    .如果结束
    返回 (“【” ＋ lib番号 ＋ “精彩影评】” ＋ #换行符 ＋ 评论)
.否则
    log (“未获取到此影片的评论。”)
    返回 (“未获取到此影片的评论。”)
.如果结束


.子程序 _组件移动时钟_周期事件

.如果真 (缩略图移动状态)
    缩略图分组框.顶边 ＝ 取鼠标垂直位置 () － 窗口_下拉列表.顶边 － 20
    缩略图分组框.左边 ＝ 取鼠标水平位置 () － 窗口_下拉列表.左边 － 15
.如果真结束


.子程序 _缩略图移动_鼠标左键被按下, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果 (移动 ＝ 真)
    组件移动时钟.时钟周期 ＝ 0
    移动 ＝ 假
    缩略图移动状态 ＝ 假
.否则
    组件移动时钟.时钟周期 ＝ 1
    移动 ＝ 真
    缩略图移动状态 ＝ 真

.如果结束


.子程序 _缩略图移动_鼠标左键被放开, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型

.如果 (移动 ＝ 真)
    组件移动时钟.时钟周期 ＝ 0
    移动 ＝ 假
    缩略图移动状态 ＝ 假
.否则
    组件移动时钟.时钟周期 ＝ 1
    移动 ＝ 真
    缩略图移动状态 ＝ 真
.如果结束



.子程序 设置搜索项标题
.参数 文本, 文本型
.参数 文本2, 文本型

下拉图形按钮2.标题 ＝ 文本
搜索编辑框.内容 ＝ 文本2

.子程序 gb_取左边文本, 文本型
.参数 源文本, 文本型
.参数 数量, 整数型
.局部变量 逐字分割数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 返回值, 文本型

文本_逐字分割 (源文本, 逐字分割数组)
.如果 (取数组成员数 (逐字分割数组) ≥ 数量)
    .计次循环首 (数量, i)
        返回值 ＝ 返回值 ＋ 逐字分割数组 [i]
    .计次循环尾 ()
    返回 (返回值)
.否则
    返回 (源文本)
.如果结束


.子程序 取热键组合框文本

隐藏快捷键组合框文本 ＝ 隐藏快捷键组合框.取项目文本 (隐藏快捷键组合框.现行选中项)
搜索快捷键组合框文本 ＝ 搜索快捷键组合框.取项目文本 (搜索快捷键组合框.现行选中项)

.子程序 文件名正则番号, 文本型
.参数 文件名, 文本型
.局部变量 正则, 正则表达式类
.局部变量 番号, 文本型

番号 ＝ “”
正则.创建 (“T28[\-_]\d{3,4}”, 文件名)
.如果 (正则.取匹配数量 () ＞ 0)
    番号 ＝ 正则.取匹配文本 (1)
.否则
    正则.创建 (“1PONDO[\-_]\d{6}[\-_]\d{2,4}”, 文件名)
    .如果 (正则.取匹配数量 () ＞ 0)
        番号 ＝ 正则.取匹配文本 (1)
    .否则
        正则.创建 (“HEYZO[\-_]?\d{4}”, 文件名)
        .如果 (正则.取匹配数量 () ＞ 0)
            番号 ＝ 正则.取匹配文本 (1)
        .否则
            正则.创建 (“CARIB[\-_]\d{6}[\-_]\d{3}”, 文件名)
            .如果 (正则.取匹配数量 () ＞ 0)
                番号 ＝ 正则.取匹配文本 (1)
            .否则
                正则.创建 (“N[-_]\d{4}”, 文件名)
                .如果 (正则.取匹配数量 () ＞ 0)
                    番号 ＝ 正则.取匹配文本 (1)
                .否则
                    正则.创建 (“JUKUJO[-_]\d{4}”, 文件名)
                    .如果 (正则.取匹配数量 () ＞ 0)
                        番号 ＝ 正则.取匹配文本 (1)
                    .否则
                        正则.创建 (“[A-Z]{2,5}[-_]\d{3,5}”, 文件名)
                        .如果 (正则.取匹配数量 () ＞ 0)
                            番号 ＝ 正则.取匹配文本 (1)
                        .否则
                            正则.创建 (“\d{6}[\-_]\d{2,4}”, 文件名)
                            .如果 (正则.取匹配数量 () ＞ 0)
                                番号 ＝ 正则.取匹配文本 (1)
                            .否则
                                正则.创建 (“[A-Z]+\d{3,5}”, 文件名)
                                .如果 (正则.取匹配数量 () ＞ 0)
                                    番号 ＝ 正则.取匹配文本 (1)
                                .否则
                                    正则.创建 (“[A-Za-z]+[-_]?\d+”, 文件名)
                                    .如果 (正则.取匹配数量 () ＞ 0)
                                        番号 ＝ 正则.取匹配文本 (1)
                                    .否则
                                        正则.创建 (“”, 文件名)
                                        .如果 (正则.取匹配数量 () ＞ 0)
                                            番号 ＝ 正则.取匹配文本 (1)
                                        .否则
                                            正则.创建 (“\d+[-_]?\d+”, 文件名)
                                            .如果 (正则.取匹配数量 () ＞ 0)
                                                番号 ＝ 正则.取匹配文本 (1)
                                            .否则

                                            .如果结束

                                        .如果结束

                                    .如果结束

                                .如果结束

                            .如果结束

                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

        .如果结束

    .如果结束

.如果结束
.如果 (番号 ≠ “”)
    返回 (番号)
.否则
    返回 (“”)
.如果结束


.子程序 _javdb_被选择

.如果 (搜索状态 ＝ 假)
    下载预览图 (封面子项, 假, 5)
.否则
    下载预览图 (搜索封面子项, 真, 5)
.如果结束


.子程序 _db磁力_被选择

菜单磁力状态 ＝ 真
.如果 (搜索状态 ＝ 假)
    获取db磁力 (封面子项, 假)
.否则
    获取db磁力 (搜索封面子项, 真)
.如果结束


.子程序 获取db磁力
.参数 项, 整数型
.参数 是否搜索, 逻辑型
.局部变量 正则, 正则表达式类
.局部变量 r, 文本型
.局部变量 文件名, 文本型
.局部变量 临时文本, 文本型
.局部变量 i, 整数型
.局部变量 磁力数组, 文本型, , "0"
.局部变量 图片, 字节集
.局部变量 路径, 文本型
.局部变量 网址, 文本型
.局部变量 番号, 文本型
.局部变量 返回协议头, 文本型
.局部变量 db磁力链接, 文本型
.局部变量 db磁力文件, 文本型
.局部变量 db磁力高清, 文本型
.局部变量 db磁力字幕, 文本型
.局部变量 db磁力大小, 文本型
.局部变量 db磁力日期, 文本型
.局部变量 文本, 文本型
.局部变量 k, 整数型
.局部变量 分割文本, 文本型, , "0"

禁止 ()
取耗时 (1)
.如果 (是否搜索 ＝ 假)
    文件名 ＝ 影片 [项].番号
    路径 ＝ 文件_取目录 (影片 [项].文件)
.否则
    文件名 ＝ 搜索 [项].番号
    路径 ＝ 文件_取目录 (搜索 [项].文件)
.如果结束
.如果 (路径 ≠ “”)
    log (“正在获取” ＋ 文件名 ＋ “db磁力链接”)
    r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
    .如果 (取文本长度 (r) ＞ 500)

    .否则
        r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
    .如果结束

    .如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
        正则.创建 (#db取番号, r)
        .计次循环首 (正则.取匹配数量 (), i)
            番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “番號: ”, “ / 發布時間: ”)
            .如果 (到大写 (番号) ≠ 到大写 (文件名))
                网址 ＝ “空”
            .否则
                正则.创建 (#db取网页码, r)
                网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “uid” ＋ #引号 ＋ “:” ＋ #引号, #引号)
                跳出循环 ()
            .如果结束

        .计次循环尾 ()
    .否则

    .如果结束

    .如果 (网址 ≠ “空”)
        r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
        .如果 (取文本长度 (r) ＞ 500)

        .否则
            r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
        .如果结束
        .如果 (取文本长度 (r) ＞ 500)
            .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
                正则.创建 (#db磁力详情, 到文本 (r))
                .如果 (正则.取匹配数量 () ＞ 0)
                    .计次循环首 (正则.取匹配数量 (), i)
                        db磁力链接 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<a href=” ＋ #引号, #引号 ＋ “ title”, , 真)
                        db磁力文件 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<span>”, “</span><br/>”, , 真)
                        db磁力高清 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “tag is-primary is-small” ＋ #引号 ＋ “>”, “</span>”, , 真)
                        db磁力字幕 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “tag is-warning is-small” ＋ #引号 ＋ “>”, “</span>”, , 真)
                        db磁力大小 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “&nbsp;( ”, “B”, , 真)
                        db磁力日期 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “time” ＋ #引号 ＋ “>”, “</span></td>”, , 真)
                        ' 调试输出 (db磁力链接)
                        ' 调试输出 (db磁力文件)
                        ' 调试输出 (db磁力高清)
                        ' 调试输出 (db磁力字幕)
                        ' 调试输出 (db磁力大小 ＋ “B”)
                        ' 调试输出 (db磁力日期)
                        .如果 (i ＝ 1)
                            文本 ＝ 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕
                        .否则
                            文本 ＝ 文本 ＋ #换行符 ＋ 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕
                        .如果结束
                        加入成员 (磁力数组, 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕)
                    .计次循环尾 ()
                    置剪辑板文本 (文本)
                    磁力高级表格.清空数据 ()
                    磁力高级表格.置列宽 (0, 80)
                    磁力高级表格.置列宽 (1, 100)
                    磁力高级表格.置列宽 (2, 80)
                    磁力高级表格.置列宽 (3, 80)
                    磁力高级表格.置列宽 (4, 300)
                    磁力高级表格.置列宽 (5, 80)
                    磁力高级表格.置列宽 (6, 80)
                    磁力高级表格.置数据 (0, 0, 1, “番号”)
                    磁力高级表格.置数据 (0, 1, 1, “片名”)
                    磁力高级表格.置数据 (0, 2, 1, “大小”)
                    磁力高级表格.置数据 (0, 3, 1, “日期”)
                    磁力高级表格.置数据 (0, 4, 1, “磁力”)
                    磁力高级表格.置数据 (0, 5, 1, “分辨率”)
                    磁力高级表格.置数据 (0, 6, 1, “字幕”)
                    .如果 (搜索状态 ＝ 假)
                        写到文件 (文件_取目录 (影片 [项].文件) ＋ 文本_取出中间文本 (影片 [项].nfo, “<id>”, “<id>”) ＋ “_db_Torrent.txt”, 编码_Ansi到Utf8 (文本))
                    .否则
                        写到文件 (文件_取目录 (搜索 [项].文件) ＋ 文本_取出中间文本 (搜索 [项].nfo, “<id>”, “<id>”) ＋ “_db_Torrent.txt”, 编码_Ansi到Utf8 (文本))
                    .如果结束
                    .计次循环首 (取数组成员数 (磁力数组), i)
                        分割文本 ＝ 分割文本 (磁力数组 [i], “|”, )
                        .计次循环首 (取数组成员数 (分割文本), k)
                            磁力高级表格.置数据 (i, k － 1, 1, 分割文本 [k])
                        .计次循环尾 ()
                    .计次循环尾 ()
                    设置超级按钮 (1)
                    log (“磁力搜索完成。”)

                .否则
                    log (“未获取到此影片的磁力。”)
                .如果结束

            .否则
                log (“未搜索到此番号。”)
            .如果结束

        .否则
            log (“网页打开失败。”)
        .如果结束

    .否则
        log (“未搜索到此番号网址。”)
    .如果结束

.否则
    log (“路径不正确，请重新尝试。”)
.如果结束

取禁 ()




.子程序 获取db磁力2
.局部变量 正则, 正则表达式类
.局部变量 r, 文本型
.局部变量 文件名, 文本型
.局部变量 临时文本, 文本型
.局部变量 i, 整数型
.局部变量 磁力数组, 文本型, , "0"
.局部变量 图片, 字节集
.局部变量 路径, 文本型
.局部变量 网址, 文本型
.局部变量 番号, 文本型
.局部变量 返回协议头, 文本型
.局部变量 db磁力链接, 文本型
.局部变量 db磁力文件, 文本型
.局部变量 db磁力高清, 文本型
.局部变量 db磁力字幕, 文本型
.局部变量 db磁力大小, 文本型
.局部变量 db磁力日期, 文本型
.局部变量 文本, 文本型
.局部变量 k, 整数型
.局部变量 分割文本, 文本型, , "0"

禁止 ()
取耗时 (1)
文件名 ＝ 搜索编辑框.内容
log (“正在获取” ＋ 文件名 ＋ “db磁力链接”)
r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
.如果 (取文本长度 (r) ＞ 500)

.否则
    r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “videos/search_autocomplete.json?q=” ＋ 文件名 ＋ “&f=all”, , , , , , , , , 代理IP))
.如果结束

.如果 (文本_寻找文本 (r, “识别码搜寻结果”) ＝ -1)
    正则.创建 (#db取番号, r)
    .计次循环首 (正则.取匹配数量 (), i)
        番号 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “番號: ”, “ / 發布時間: ”)
        .如果 (到大写 (番号) ≠ 到大写 (文件名))
            网址 ＝ “空”
        .否则
            正则.创建 (#db取网页码, r)
            网址 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “uid” ＋ #引号 ＋ “:” ＋ #引号, #引号)
            跳出循环 ()
        .如果结束

    .计次循环尾 ()
.否则

.如果结束

.如果 (网址 ≠ “空”)
    r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
    .如果 (取文本长度 (r) ＞ 500)

    .否则
        r ＝ 编码_Utf8到Ansi (网页_访问 (刮削javdb编辑框.内容 ＋ “v/” ＋ 网址, , , , , , , , , 代理IP))
    .如果结束
    .如果 (取文本长度 (r) ＞ 500)
        .如果 (文本_寻找文本 (r, “以下为常见的搜寻错误:”) ＝ -1)
            正则.创建 (#db磁力详情, 到文本 (r))
            .如果 (正则.取匹配数量 () ＞ 0)
                .计次循环首 (正则.取匹配数量 (), i)
                    db磁力链接 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<a href=” ＋ #引号, #引号 ＋ “ title”, , 真)
                    db磁力文件 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “<span>”, “</span><br/>”, , 真)
                    db磁力高清 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “tag is-primary is-small” ＋ #引号 ＋ “>”, “</span>”, , 真)
                    db磁力字幕 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “tag is-warning is-small” ＋ #引号 ＋ “>”, “</span>”, , 真)
                    db磁力大小 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “&nbsp;( ”, “B”, , 真)
                    db磁力日期 ＝ 文本_取出中间文本 (正则.取匹配文本 (i), “time” ＋ #引号 ＋ “>”, “</span></td>”, , 真)
                    ' 调试输出 (db磁力链接)
                    ' 调试输出 (db磁力文件)
                    ' 调试输出 (db磁力高清)
                    ' 调试输出 (db磁力字幕)
                    ' 调试输出 (db磁力大小 ＋ “B”)
                    ' 调试输出 (db磁力日期)
                    .如果 (i ＝ 1)
                        文本 ＝ 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕
                    .否则
                        文本 ＝ 文本 ＋ #换行符 ＋ 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕
                    .如果结束
                    加入成员 (磁力数组, 番号 ＋ “|” ＋ db磁力文件 ＋ “|” ＋ db磁力大小 ＋ “|” ＋ db磁力日期 ＋ “|” ＋ db磁力链接 ＋ “|” ＋ db磁力高清 ＋ “|” ＋ db磁力字幕)
                .计次循环尾 ()
                置剪辑板文本 (文本)
                磁力高级表格.清空数据 ()
                磁力高级表格.置列宽 (0, 80)
                磁力高级表格.置列宽 (1, 100)
                磁力高级表格.置列宽 (2, 80)
                磁力高级表格.置列宽 (3, 80)
                磁力高级表格.置列宽 (4, 300)
                磁力高级表格.置列宽 (5, 80)
                磁力高级表格.置列宽 (6, 80)
                磁力高级表格.置数据 (0, 0, 1, “番号”)
                磁力高级表格.置数据 (0, 1, 1, “片名”)
                磁力高级表格.置数据 (0, 2, 1, “大小”)
                磁力高级表格.置数据 (0, 3, 1, “日期”)
                磁力高级表格.置数据 (0, 4, 1, “磁力”)
                磁力高级表格.置数据 (0, 5, 1, “分辨率”)
                磁力高级表格.置数据 (0, 6, 1, “字幕”)

                .计次循环首 (取数组成员数 (磁力数组), i)
                    分割文本 ＝ 分割文本 (磁力数组 [i], “|”, )
                    .计次循环首 (取数组成员数 (分割文本), k)
                        磁力高级表格.置数据 (i, k － 1, 1, 分割文本 [k])
                    .计次循环尾 ()
                .计次循环尾 ()
                设置超级按钮 (1)
                log (“磁力搜索完成。”)

            .否则
                log (“未获取到此影片的磁力。”)
            .如果结束

        .否则
            log (“未搜索到此番号。”)
        .如果结束

    .否则
        log (“网页打开失败。”)
    .如果结束

.否则
    log (“未搜索到此番号网址。”)
.如果结束
取禁 ()


.子程序 _色花复制磁力级按钮_被单击
.局部变量 i, 整数型
.局部变量 磁力文本, 文本型

.如果真 (表格外形框.可视 ＝ 真)
    .' 如果 (色花超级列表框.可视 ＝ 真)
        .' 计次循环首 (取数组成员数 (色花行数组), i)
            .' 如果 (i ＝ 1)
                ' 磁力文本 ＝ 文本_取出中间文本 (色花行数组 [i], “<种子>”, “</种子>”)
            .否则
                ' 磁力文本 ＝ 磁力文本 ＋ #换行符 ＋ 文本_取出中间文本 (色花行数组 [i], “<种子>”, “</种子>”)
            .如果结束

        .' 计次循环尾 ()
        ' 剪辑板_置文本 (磁力文本)
    .否则

    .如果结束

    .如果 (色花超级列表框2.可视 ＝ 真)
        .计次循环首 (取数组成员数 (色花搜索行数组), i)
            .如果 (i ＝ 1)
                磁力文本 ＝ 文本_取出中间文本 (色花搜索行数组 [i], “<种子>”, “</种子>”)
            .否则
                磁力文本 ＝ 磁力文本 ＋ #换行符 ＋ 文本_取出中间文本 (色花搜索行数组 [i], “<种子>”, “</种子>”)
            .如果结束

        .计次循环尾 ()
        剪辑板_置文本 (磁力文本)
        log (“已将此页磁力置剪贴板。”)
    .否则

    .如果结束

.如果真结束


.子程序 _下拉图形按钮2_滚轮被滚动, 逻辑型
.参数 滚动距离, 整数型
.参数 功能键状态, 整数型

.如果 (滚动距离 ＝ -1)
    .如果 (下拉图形按钮2.标题 ＝ “本地搜索”)
        下拉图形按钮2.标题 ＝ “db磁力搜索”
    .否则
        .如果 (下拉图形按钮2.标题 ＝ “db磁力搜索”)
            下拉图形按钮2.标题 ＝ “bus磁力搜索”
        .否则
            .如果 (下拉图形按钮2.标题 ＝ “bus磁力搜索”)
                下拉图形按钮2.标题 ＝ “bus番号搜索”
            .否则
                .如果 (下拉图形按钮2.标题 ＝ “bus番号搜索”)
                    下拉图形按钮2.标题 ＝ “bus模糊搜索”
                .否则
                    .如果 (下拉图形按钮2.标题 ＝ “bus模糊搜索”)
                        下拉图形按钮2.标题 ＝ “FC2番号搜索”
                    .否则
                        .如果 (下拉图形按钮2.标题 ＝ “FC2番号搜索”)
                            下拉图形按钮2.标题 ＝ “javdb搜索”
                        .否则
                            .如果 (下拉图形按钮2.标题 ＝ “wiki辞典搜索”)
                                下拉图形按钮2.标题 ＝ “javdb搜索”
                            .否则
                                .如果 (下拉图形按钮2.标题 ＝ “javdb搜索”)
                                    下拉图形按钮2.标题 ＝ “library搜索”
                                .否则
                                    .如果 (下拉图形按钮2.标题 ＝ “library搜索”)
                                        下拉图形按钮2.标题 ＝ “色花模糊搜索”
                                    .否则
                                        .如果 (下拉图形按钮2.标题 ＝ “色花模糊搜索”)
                                            下拉图形按钮2.标题 ＝ “jav321搜索”
                                        .否则

                                        .如果结束

                                    .如果结束

                                .如果结束

                            .如果结束

                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

        .如果结束

    .如果结束

.否则
    .如果 (下拉图形按钮2.标题 ＝ “db磁力搜索”)
        下拉图形按钮2.标题 ＝ “本地搜索”
    .否则
        .如果 (下拉图形按钮2.标题 ＝ “bus磁力搜索”)
            下拉图形按钮2.标题 ＝ “db磁力搜索”
        .否则
            .如果 (下拉图形按钮2.标题 ＝ “bus模糊搜索”)
                下拉图形按钮2.标题 ＝ “bus磁力搜索”
            .否则
                .如果 (下拉图形按钮2.标题 ＝ “FC2番号搜索”)
                    下拉图形按钮2.标题 ＝ “bus模糊搜索”
                .否则
                    .如果 (下拉图形按钮2.标题 ＝ “wiki辞典搜索”)
                        下拉图形按钮2.标题 ＝ “FC2番号搜索”
                    .否则
                        .如果 (下拉图形按钮2.标题 ＝ “javdb搜索”)
                            下拉图形按钮2.标题 ＝ “wiki辞典搜索”
                        .否则
                            .如果 (下拉图形按钮2.标题 ＝ “library搜索”)
                                下拉图形按钮2.标题 ＝ “javdb搜索”
                            .否则
                                .如果 (下拉图形按钮2.标题 ＝ “色花模糊搜索”)
                                    下拉图形按钮2.标题 ＝ “library搜索”
                                .否则
                                    .如果 (下拉图形按钮2.标题 ＝ “jav321搜索”)
                                        下拉图形按钮2.标题 ＝ “色花模糊搜索”
                                    .否则

                                    .如果结束

                                .如果结束

                            .如果结束

                        .如果结束

                    .如果结束

                .如果结束

            .如果结束

        .如果结束

    .如果结束

.如果结束


.子程序 _代理_被单击

.如果 (代理选择框.选中 ＝ 真)
    代理IP ＝ “”
    代理选择框.选中 ＝ 假
    代理.点燃图片 ＝ #代理点燃
    代理.正常图片 ＝ #代理普通
.否则
    代理IP ＝ 代理编辑框.内容
    代理选择框.选中 ＝ 真
    代理.点燃图片 ＝ #代理普通
    代理.正常图片 ＝ #代理点燃
.如果结束


.子程序 _帮助_被单击

.如果 (文件是否存在 (根目录 ＋ “资源\JavGo使用说明.chm”) ＝ 真)
    执行 (, 根目录 ＋ “资源\JavGo使用说明.chm”, , , )
.否则

.如果结束