# 0 22  (执行 (全) (0 1)) (0 0)
#!/usr/bin/python3 
# -*- coding:utf-8 -*-
#main.py author: Jacky.Shi distribute under General Public License v3 http://www.gnu.org/licenses/quick-guide-gplv3.html
#E-mail: 625052847@qq.com 
'''
一、安装环境
https://cloud.189.cn/web/share?code=yqyQ3ueQBZVr
密码：zbl4
来自
https://blog.csdn.net/qq_61032526/article/details/130501787

下载之后用winrar解压，再导入虚拟机VirtualBox，会生成一个48G的虚拟盘

二、导入原文件
启动虚拟机，将源文件包解压缩，将项目文件夹，复制到kivydev用户的一级目录test下面

三、启动终端
$ cd /home/kivydev/test/项目文件夹/

四、编译
$ kdpp go

# 22 6               (0 0 0 10)

手机标准构架
笈智通用方法



# 6 9      (执行 (0 2) (0 3) (0 4))                (0 0 0 331 112 15822 6702)

手机标准构架：
模块导入 from import
安卓类及模块
主程序类入口	__main__	
退出 QuitRun(self)



# 9 15 (执行 (0 3) (0 5) (0 6) (0 0))             (7 0 0 22 36 55 81 81)

界面操作方法
文件操作方法
计算相关方法
分页相关方法
分页格式方法
弹出框与推送框








# 15 21             (0 0 10645 7176 12397 10635 11060 11278 11159 12458 12809 10658 11306)

选中项统计 RowCount (self,mydic)
显示目录文件 RunUp (self)
字串行号 LineNow (self,string,i0)
顶行显示 FirstLine (self,myStr)
阅读执行模式切换 SetMode (self)
编辑框显示摘录 displayextract (self)
手动摘录 Extract (self)
文件搜索响应 To_Search (self):
专业搜索 SearchExp (self,ss) 区分‘、’分割的‘或条件’，及‘；’分割的‘与条件’
选中行汇总 SelectedList (self)
回看 OutPut（self）









# 21 13   (执行 (0 7) (0 0))               (16 0 7286)

打开库文件  openlabfile(self)











# 13 18             (38 6713 6380 6353 5664 5621 5549 6675 12894 8970 9021 7073)
分层拆解括号串 AltStr (self,slecstr,digit_num,expbnow) ('[起始行号]、[隐式通用关键词(如伤寒论'主之'表示方剂)]；[+之后行数]')起始默认为当前行，终止默认文件末
字串数、符分拆至五位列表	ArrangStr (self,lstr,symb)
检测计算符 Formular (self,string) 
算式串计算转化 strcacu (self,mystr)
获取浮点小数位 floatfmt (self,lstr)
检测字串是否实数 IsNumber (self,localstr)
浮点实数检测 IsFloat (self,localstr)
分离出表格数字 PickNum (self,string)
分解范围格式 PickRang (self,n,colstr,row)
确定表项 PickList (self,string,expbnow)
工程取整 EngInt (self,string)







# 18 25             (52 0 11039 11327 10652 11056 8212 11696 7725 7292 12294 11135 12254 11467 11114 9906)

判断括号成对 Listp (self,localstr)4243
当前索引摘录显示 EIDisp (self)
索引摘录 EIndex (self)
配对分割字串 psplit (self,string,p1,p2)
注释摘录 AutoE (self,string) 多项时尾项为‘；’时变量及赋值取为首项，否则取为末项
分页显示 ExpView (self,top,bot)#
分页综合前跳 forward (self)
分页综合回跳 backward (self)
本页格式行号 PageNow (self,MaxLine)
手动摘录 ExtractNow (self)
推送框显示 PopView (self,mymodel,n,string)
摘引文本显示 DispIndex (self,FilePath,IndexList):#FilePath母版文件，IndexList显示列表
运行本页代码 PageRun (self)
选行跳转 ForJump (self,Expbnow,Expitem):#当前页首行Expbnow,选择Expitem行前跳的处理










# 25 14             (71 0 9919 10227 11835 11790 11812)

@调出弹出框 PopList (self,string,expbnow) 末以'￥'结尾提取‘或条件’关键词；#结尾循环提取‘与条件’关键词；##结尾对文本进行种子法提取关键字
种子法提炼关键词 InduceKeyWord (self,ss) 输入文件Krule.txt中除黑名单
关键字行排队弹框 HuntPop (self,keystr) 包括‘或条件’、‘或条件’＋通用条件keystr、‘与条件’ 三层筛查可选
主程序换行 LineFeed (self,string,n)
主程序去换行 DeLineFeed (self,string,n)








# 14 26             (107 0 0 55 32 255 249 760 771 781 810 821 841 0 1120 1128 16 1096 1108)
安卓类及模块
弹出框 SRV类
主程序 MainApp (App,RV)
主窗口类MenuScreen (Screen) (RecycleDataViewBehavior,RecycleView)
阅读窗口类 ReadingScreen (Screen)
文本窗口类 TextScreen(Screen)
分级归类覆盖确认框 EditStatePopup1 (Popup)
世家覆盖确认框 EditStatePopup2 (Popup)
[子应用]覆盖确认框 EditStatePopup3 (Popup)
[子应用]创建确认框 EditStatePopup4 (Popup)
[子应用]改名确认框 EditStatePopup5 (Popup)
[主目录列表]删除最底行确认框 EditStatePopup6 (Popup)
弹出框 SRV (Popup)
可选列表 SelectableRecycleGridLayout(FocusBehavior, LayoutSelectionBehavior,RecycleGridLayout)
可选标签 SelectableLabel(RecycleDataViewBehavior, Label)
可选列表MyRV(RecycleView)
文件选择框(未实用) EditFileChooser(BoxLayout)
列表文件选择框(未实用) ListFileChooser(BoxLayout)








# 26 15             (0 0 966 986 1000 1023 1036 1047 1068)
弹出框 SRV类
弹出框变量声明
初始化入口 __init__(self, obj, **kwargs)
建立列表数据表模块 QtSetmodelp (self,Model)
显示列表模块 QtStandardItemModelp
其它初始化模块 init_othersp (self)
确认的模块 popok (self)
取消的模块 popno (self)







# 15 15             (27 1231 1231 1243 1250 1266 1275 1288)
可选列表MyRV类
初始化入口 __init__(self, **kwargs)
键盘关闭 _keyboard_closed(self)
键盘按下 _on_keyboard_down(self, keyboard, keycode, text, modifiers)
清空选择 clearAll(self)
下行选择 nextItem(self)
上行选择 prevItem(self)








# 15 22             (43 0 0 1277 1350 1363 305 1402 319 1578 522 10783 543 562 620 682 6998)

主对话框MenuScreen (Screen)模块：
主对话框MenuScreen (Screen)变量声明
入口初始化 __init__(self, **kwargs)
建立表数据 QtSetmodel (self,Model,n)
显示表数据 QtStandardItemModel(self)
读取目录文件 ReadMWLine (self,path,n)
其它初始化 init_others (self)
打开文件 myfileopen (self,slecstr,n)
换行模块 LineFeed (self,string,n)
消除换行 UnFeed (self)
中文当地时间 Ztime (self,n)
关键字初始化 KeyListInit (self,mypath,line)
默认伤寒论关键字 WKrule (self)
数字括号前缀倍数 DLFmt (self,mylist)
组建MenuScreen类 build (self)






# 22 12             (59 0 1939 0 70)

主程序类 声明MainApp (App,RV)
手机主程序模块
记账模块








# 12 69             (0 0 1968 1977 1985 2006 2014 2028 2035 6414 2086 2099 2114 2169 4627 2187 2350 2268 2041 13390 1993 13461 2152 13506 2021 13473 2220 2061 13484 13611 13516 13742 13755 13767 13780 13788 13851 14347 14464 14479 14664 13644 13707 13538 13582 15494 15200 15175 14962 14915 14752 14020 13955 13875 12861 12798 12744 12489 12341 12291 12196 12175 11174 11094 10979 7360 7294 7257 7223)
手机主程序模块：
分级归类覆盖确认弹出框 Pop1 (self)
世家覆盖确认弹出框 Pop2 (self)
[子应用]覆盖确认弹出框 Pop3 (self)
[子应用]创建确认弹出框 Pop4 (self)
[子应用]改名确认弹出框 Pop5 (self)
[主目录列表]删除最底行确认 Pop6 (self)
[合账贴]覆盖确认 Pop7 (self）
取消弹出框 dismiss_popup(self)
改写主目录 WriteOften (self)
改写世家文件 WriteAcc (self)
编辑框内容写入所选目录对应子应用 WriteTest (self)
创建子应用 CreateTest (self)
修改子应用 SubApp (self)
子应用改名 RenameTest (self)
删除主目录最末应用 DelTest (self)
返回主目录 UpdateMain (self)
密码运行子应用弹出框 pop8 (self)
密码运行确认 passok (self)
[子应用]密码覆盖弹出框 Pop3a (self)
密码覆盖确认 pass3aok (self)
密码覆盖子应用 WriteTesta (self)
密码覆盖取消 passno (self)
[子应用]密码改名弹出框 Pop5a (self)
密码改名确认 pass5aok (self)
密码改名子应用 RenameTesta (self)
密码显示子应用弹出框 pop9 (self)
密码显示确认 pass9ok (self)
rsa 加密二进制文件 rsa_encrypt_binfile (self,file_path,save_path,pub_key)
rsa 解密二进制文件 rsa_decrypt_binfile (self,file_path,save_path,pub_key)
阅读屏幕设置 ReadingSet (self)
主屏幕设置 MenuSet (self)
文本窗口放大字体 Enlarge (self)
文本窗口缩小字体 Minish (self)
弹出品鉴 PopComment (self,linenow)
段落格式编辑 PFormat (self)
链接格式编辑 JFormat (self)
增删行格式调整 PJAdjust (self):
执行增删行格式调整 PJList (self,mylist)
文本窗口[粘贴]PasteStrT (self)
编辑框加密 rsa_encrypt_textedit (self,pub_key)
编辑框加密操作 encrypt (self)
编辑框解密 rsa_decrypt_textedit (self,priv_key)
编辑框解密操作 decrypt (self)
提取列表框标题、序号PickMName (self,filename)
主目录多文件搜索SearchFile (self,lpath,ss)
笈文件格式判断JFileP (self,mylist)
步进试算StepCalcu (self,fstring,LessP)
变量代换AltPara (self,parastr)
文件表操作FData (self,strit,alti)
文本窗口清空ClearT (self)
主窗口光标翻页NxtCursor (self)
文本窗口光标翻页TopCursor (self)
文本窗口删选按钮CutStr1 (self)
文本窗口复制CopyStr2 (self)
文本窗口全复制CopyIn2 (self)
品鉴笔记评注撰写ToComment (self)
品鉴笔记评注显示ShowComment (self)
品鉴笔记评注加载LoadComment(self)
主窗口编辑框光标定位ELineNowM (self)
文本窗口编辑框光标定位ELineNow (self)
执行自测题评分GradeScore (self,FilePath,mylist,nitem)
自测题评分GetScore (self)
手动摘录ManualEx (self)
由行号获取文件名GetEFName (self,linenow)
由编辑框内容获取光标所在行号GetELine (self)
列表框定位文件页ToFileLine (self,filename,pline)
文本窗口内容定位TextScreenLine (self,string)

# 69 33           (13 0 0 2350 2369 2388 2402 2433 2450 2461 2588 2673 2693 2740 4166 4227 4342 4410 4432 4455 4476 4498 4537 5051 5084 5248 5276)
复制粘贴各模块
下为记账各模块：
重写程序启动 on_start(self)
秒表启停 start_stop(self)
秒表更新 Mb_update(self,n)
计算/秒表模式切换 ClearRun (self)
秒表重置 reset(self)
时钟更新 Clock_update(self,n)
编辑框文字查算 handle (self)
查算分派 myAccount (self,mystr1,Brch)
长文六字 GetPreStr (self,mystr)
类关键字展开 TopPlus (self,Toplist)
世家统计 CalcuAccount (self,mystr1,string,foretime,Brch)
时差计算 TimeLag (self,string)
确定统计开始时间 CatchFTime (self,mystr)
判断统计、计算模式 AccountP (self,mystr)
时间戳行判断 OnlyTP (self,mystr)
包含计算符判断 HvCacuWord (self,mystr)
包含数字判断 HvNumber (self,mystr)
包含时间量词判断 TimeP (self,mystr)
世家修改 ModiAccfile (self)
归类修改 ModiClass (self)
中文当地时间扩展 ZtimeZ (self,n)
分解括号手机版 AltStrm (self,slecstr,digit_num,expbnow)
提取尾数 GetHindNum (self,string)
提取尾数价格 GetHindPrice (self,string)







# 33 19             (0 0 12673 12689 12724 12783 12790 12846 12864 12900 13157)
下为复制粘贴各模块：
全复制 CopyIn (self)
内复制 BCopyIn (self)
复制 CopyStr (self)
删选 CutStr (self)
粘贴 PasteStr (self)
全粘贴 PasteOut (self)
合账贴 BPasteOut (self)
[合账贴]不覆盖模块 BPasteOutA (self)
[合账贴]覆盖模块 BPasteOutO (self)








'''
# 19 56             (321 0 0)

#v11，2023.7.11由于kivy对中文文件名支持的局限，修改加载文件名为英文名;
import sys,os,math ,time, random#20240625 datetime
import kivy
import base64#20240901,rsa 下四行加载导致手机闪退
#from Cryptodome import Random#20240901#202408302 pip install pycryptodomex -i https://pypi.tuna.tsinghua.edu.cn/simple/
#from Cryptodome.PublicKey import RSA#20240901#202408302
#from Cryptodome.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5#20240901#202408302
#from Cryptodome.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5#20240901#202408302公钥长度1024bit明文长度不超117byte(1024/8 -11 = 117 byte)
from kivy.uix.screenmanager import ScreenManager, Screen#20240904
from kivy.uix.image import Image

from kivy.core.clipboard import Clipboard #1011
from kivy import platform
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import BooleanProperty, ListProperty, ObjectProperty,NumericProperty, StringProperty
from kivy.lang import Builder
from kivy.uix.button import Button
from kivy.uix.behaviors import FocusBehavior
from kivy.uix.popup import Popup
from kivy.core.window import Window
from kivy.clock import Clock
from kivy.core.text import LabelBase
from kivy.uix.recycleboxlayout import RecycleBoxLayout
from kivy.uix.behaviors import FocusBehavior
from kivy.uix.button import ButtonBehavior
from kivy.clock import Clock
from kivy.core.text import LabelBase
from kivy.uix.recycleview import RecycleView
from kivy.uix.recycleview.layout import LayoutSelectionBehavior
from kivy.uix.recycleview.views import RecycleDataViewBehavior
from kivy.uix.recyclegridlayout import RecycleGridLayout

from tempfile import TemporaryFile,NamedTemporaryFile#20241005

#from kivy.config import Config#202410112解决字体新方案
#Config.set('kivy','default_font',['Xim-Sans-ShouXieTi-2.ttf','HarmonyOS_Sans_SC_Light.ttf','hy-bwxj.ttf','dedris-g3.ttf'])
from kivy.uix.label import Label

sys.setrecursionlimit(1500)#20230323为解决RecursionError进行系统设置


LabelBase.register(name='jzz',fn_regular='./fonts/HarmonyOS_Sans_SC_Light.ttf')#202410112解决字体之前方案#202503274	'./fonts/Qomolangma-Subtitle.ttf'发行简化
LabelBase.register(name='jzj',fn_regular='./fonts/hy-bwxj.ttf')#20240914解决字体之前方案发行简化
LabelBase.register(name='jzh',fn_regular='./fonts/HarmonyOS_Sans_SC_Light.ttf')#20240914解决字体之前方案；202410112尝试失败,fn_bold='./fonts/'发行简化
LabelBase.register(name='jzx',fn_regular='./fonts/HarmonyOS_Sans_SC_Light.ttf')#20240914解决字体之前方案
#202503274	'./#LabelBase.register(name='jzx',fn_regular='./fonts/jx.ttf')








# 56 5             (219 0 255)

class TextScreen (Screen):#文本窗口
    pass
		
		
# 5 71               (276 0)
class ReadingScreen (Screen):#阅读窗口
#class RV (RecycleDataViewBehavior,RecycleView):
#	print("\n进入阅读窗口之ReadingScreen类")
	Ignore=0 #兼容如意软件变量，此版因为考虑python及C等编程语言模式，数字括号设为第2，3位，如意是第1，2位
	PicSize=600
	FormatShow=False
	IdxFrom=2
	AppendP=False#v0.991新增，判断摘录的追加模式，还是插入模式（改为默认），这是次较大的变动
#	KeyWordStr=""#v0.987新增
#	KeyWordStr2=""#v0.987新增
#	IndexLogFile="IndexLog.txt"
#	LastKey=""
#	noun=[]
#	Adverb=[]
#	Verb=[]
#	Verb1=[]#v0.986新增
	KeyTitle="笈智关键字"
	FFname=""
	CheckedRow=[]
	Doing=1#0414v0.992
#	RedoList=[]
	fileName_choose=""#全局变量
	Expdic={}
	Rundic={}
	ExpMode=False
	AutoMode=False
	ViewList=[]
	Expitem=-1
	Expbnow=0
	Expfnow=0
	Expbackstep=0
	Expforestep=0
	FullStep=0
	lViewList=0
	MyOutput=""
	CheckedRow=[]
	JustNum=-1
	mystr=""
	PosFound=-1
	numt1=["","","","",""]
	numt1id=[0,0,0,0,0]
	fmt=3
	PMark='♦'
	JMark='♥'
	promptstr1="特殊字符：&图像⌇续行♦分页♥链接"
	OftenFiles="oftenfiles.set"#目录文件名
	FruitFile="Fruit.txt"#搜索结果文件名
	IndexFile="Fruit.idx"#搜索结果索引文件名
	KruleFile="Krule.txt"#关键词解析词源文件名
	KwdFile="Kwd.txt"		#文本框排除法解析关键词追加的结果文件
	_startPos = None
	_endPos = None
	_isTracking = False
	Model =[]
	#LineChars = 18
	active = BooleanProperty()
	OmniState = False
	UnLineFeed = False
	Writen = 2
	prompstr="笈智中医kv1.0，修身齐家治平，人工智能即兴"# 吴名,2024.1QQ625052847顶行（本行）为输入行，双击后可输入关键字，点[搜索]按钮可进行内容搜索，'与条件'关键字由';'分割，'或条件'由空格或'、'分割，精确数字匹配在第一个字输入'｀'。点中顶行，再勾选顶行，可勾选全页，再勾选一次可取消全选；点[摘录]按钮，勾选内容会显示到右栏；点[计算]按钮可计算点中行算式，结果显示在顶行。20030611注释即软件，软件即注释，用活好典籍，笈智当第一  本款为图形界面v1.0p版，希望老少朋友们喜欢，家有爱编程萌宝的可用来仿作编程哦，本软件是人工智能的平民化定义。勾选本行，可显示注释行，本软件可广泛应用于医学、工程、编程、法律、教育、行政等领域，。本软件是自由软件，遵循GPL v3.0许可，详见http://www.gnu.org/licenses/quick-guide-gplv3.html，您可以带源代码再发布（包括要求有偿），但没有担保。" 
	data_items = ListProperty([])
	col1 = ListProperty(["?", "?"])
	col2 = ListProperty(["?", "?"])








# 71 12

	def __init__(self, **kwargs):
		super(ReadingScreen, self).__init__(**kwargs)#RV
#		MainApp.LineChars = int((Window.width-360)/540)+30#20240221 3 
		#20240829适配青春版720-16dp6.09吋-4 self.LineChars 1080-18dp6.67吋-8#20250403
#		print("\t进入阅读模式窗口，宽度为(",Window.width,")字高30，行字数(",MainApp.LineChars,")")#20240829self. 1025(",self.menu_screen.ids.RV_List.font_size,")
		self.cwd = os.getcwd() # 获取当前程序文件位置
		self.init_others()#界面的其它初始化，包括文件方法等
		self.QtSetmodel(self.Model,0)#get_states()



# 12 19   

	def QtSetmodel (self,Model,n):#get_states(self):
		lM=len(Model)
		rows = []# [(1, 'Test1'), (2, 'Test2'), (3, 'Test3'), (4, 'Test4')]
		for j in range(lM): 
		#	print(j+1)
			rows.append(Model[j])#linc)
		i = n#0731 0
		self.data_items=[]
		for row in rows:
			self.data_items.append([row,i])#[row[0],  i])
#			print(row[0],  i)
			i += 1
		self.col2=self.QtStandardItemModel()#update()
		return self.col2
#		self.refresh_from_data()#0707



# 19 13             (308 0)

	def QtStandardItemModel(self):#update(self):
		#20240807self.col2 = [{'selected':False,'Name': x[0], 'key': 'Name', 'font_name':'jz','height':(len( str(x[0]) ) // self.LineChars + 1)*80,'text': str(x[1])} for x in self.data_items]#0125 + 1)*50
		col2=[]#20240807
		for x in self.data_items:
			locheight=(len( str(x[0]) ) // MainApp.LineChars + 1)*80#20240829self
			col2.append({'selected':False,'Name': x[0], 'key': 'Name', 'font_name':'jzh','height':locheight,'text': str(x[1])})
		self.col2 = col2
#		print(self.col2)
		return col2



# 13 26            (328 0)
	
	def init_others (self):#界面的其它初始化，包括文件方法等
#		print("\t阅读窗口进入其它初始化模块 init_others，初始化界面、文件、方法等")
		#20240807if(SelectableLabel.selectedItem == None):
		if(isinstance(SelectableLabel.selectedItem,int)):#20240807
#			print("\t\t阅读窗口准备打开文件self.fileName_choose[",self.fileName_choose,"]")
			if(os.path.isfile(self.fileName_choose)):#0710
				self.myfileopen(self.fileName_choose,1)#0706
		else:
#			print("\t\t阅读窗口模块 init_others，未选中时")
			mypath=os.path.join(os.getcwd(),"src/FirstRun.txt")#202408262
#			print("\t\t首次运行时间文件名[",mypath,"]")
			if(not os.path.isfile(mypath)):
				localtime=MainApp.ZtimeZ(self,0)
#				print("\t\t\t首次运行当地时间为：",localtime)
				fh=open(mypath,mode='w+t',encoding='UTF-8')
				if fh:
					fh.write(localtime)
					fh.close
				
			self.myfileopen(self.OftenFiles,1)#0706





# 26 175

	def myfileopen (self,slecstr,n): #文件打开准备20230203
		print("\n进入myfileopen->功能(",n,")，新开文件名[",slecstr,"]")
	#	localtime=self.Ztime(0)
	#	print("当地时间为：",localtime)
		KFP=False#打开关键字文件判断
		FKP=False#文件中是否自带关键字判断
		LineScope=50#关键字不超过50行，若有需要可修改此数字
		mypath=os.path.join(os.getcwd(),self.KruleFile)#读取文件Krule.txt中的名词、前缀、后缀、单字白名单
		if(os.path.isfile(mypath)):
			fh=open(mypath,mode='r+t',encoding='UTF-8')
			if fh:
				fh.close
				self.KeyListInit(mypath,0)
				KFP=True
		if(slecstr.strip()):		
			if(slecstr.find(self.OftenFiles)<=0):#如果不是第一次打开，或不是回主页界面操作
				fh=open(slecstr,mode='r+t',encoding='UTF-8')
				if fh:
					fh.seek(0)
					data=fh.read()
					print("\t阅读窗口完成打开文件->",slecstr)
					fh.close()
					mylist = data.split("\n")
					lm=len(mylist)
					i1=0
					for i in range(lm-1,0,-1):
						if(i1<LineScope):
							if(mylist[i].find(self.KeyTitle)>=0):#发现“笈智关键字”字串
								line=i
#								print("\t\tmyfileopen 模块倒查至(",i,")行，发现笈智关键字格式")
								self.KeyListInit(slecstr,line)
								FKP=True
								break
						else:
#							print("\t\tmyfileopen 模块倒查至(",i,")行，已至边界行数(",LineScope,")，未发现笈智关键字格式")
							break
						i1+=1
		if((not KFP) and (not FKP)):
			self.WKrule()
		ExpMode=False
		mypath=os.path.join(os.getcwd(),self.OftenFiles)
		fh=False
		if(slecstr.strip()):		
			fh=open(slecstr,mode='a+t',encoding='UTF-8')
			self.KeyWordStr=""#0225v0.981
			self.KVWordStr2=""#0225v0.981
#			print("\t全局变量关键词清空")
		else:
			if(n==2):
				if(not self.fileName_choose.strip()):
					print("\t首次打开……")
					self.fileName_choose=mypath#v0.60-
		if fh:
			fh.seek(0)
			data=fh.read()
#			print("完成打开文件[",slecstr,"]")#20250718内容100～500字为[",data[100:500],"]
			fh.close()
			mylist = data.split("\n")
			print("阅读窗口Myfileopen打开时的表前15～20项",mylist[15:20])
			self.Ignore=self.DLFmt(mylist)#v0.89 0406
			lie=mylist[0].split()
			lcol=len(lie)
			if(lcol>=2):
				if(lie[self.Ignore+1][-1]=='0' and lie[self.Ignore+2].isdigit()):
					self.ExpMode=True
					self.ViewList=mylist
					self.lViewList=len(mylist)
					self.Expbackstep=0
					self.Expforestep=int(lie[self.Ignore+2])
					self.Expbnow=0#V0.75
					self.Expfnow=0
#					print("\t\t",slecstr,"判断",self.ExpMode,"为专用模式文件！")
#					print("\t\t阅读窗口文件初打开，回跳行号(",self.Expbnow,")回跳步长(",self.Expbackstep,")前跳行号(",self.Expfnow,")前跳步长(",self.Expforestep,")忽略词数(",self.Ignore+1,")")		
				else:
					self.ExpMode=False
					print("\t\t阅读窗口『",slecstr,"』判断为非专用模式文件！")
			else:
				self.ExpMode=False
				self.ViewList=mylist#20230307
				self.lViewList=len(mylist)#20230307
				print("\t\t阅读窗口『",slecstr,"』判断为非专用模式文件！")#ViewList[0]为：",self.ViewList[0]20230307
			i=0
			i1=0#格式行
			if not self.ExpMode:#非专用文件
#				print("\n\t阅读窗口非专用文件格式状态")
				for task in mylist:
					#print("i=",i,",i1=",i1)
					if(self.fileName_choose==mypath):#当打开oftenfiles.set文件时
			#			print("\n\t选择文件为[",self.fileName_choose,"]比较常用文件[",mypath,"]，结果相同")
						if(i % 2 == 0):
							if(task):#20240823
								lstr= task.split()[0]#20240823
						else:
							lstr = ""
						item = lstr #0711 task #KV0611  QStandardItem(task)
					elif(self.fileName_choose.strip()):	
						item = task
					else:
			#			print("\n\t选择文件为[",self.fileName_choose,"]比较常用文件[",mypath,"]，结果不同")
						if(i % 2 == 0):
							if(task):#20240823
								lstr= task.split()[0]#20240823
						else:
							lstr = ""
						item = lstr #0711 task #KV0611  QStandardItem(task)
					if i == 0 :#首页首项显示提示
						model=[] #KV0611 model.clear()
			#			if (not self.fileName_choose.strip()):
						item1 = self.prompstr #KV0611 QStandardItem(self.prompstr)
						model.append(item1) #KV0611 appendRow(item1)
						model.append(item) #KV0611 appendRow(item)
					else:
						if(self.fileName_choose==mypath):#打开oftenfiles.set设置文件时
							if(item.strip()):
								model.append(item)#appendRow(item)
#								print("[",item,"]加入主目录列表")
							else:
								print("本项[",item,"]未放入主目录列表")
#							model.append(item) #KV0611 appendRow(item)
						elif(self.fileName_choose.strip()):	
							model.append(item) #KV0611 appendRow(item)
						else:
							if(item.strip()):
								model.append(item)#appendRow(item)
					i=i+1
			else:#Expert mode专用文件
				for task in mylist:
					if(self.fileName_choose==mypath):#打开oftenfiles.set设置文件时
						lstr=os.path.split(task)[1]#取文件的名
						item =lstr #KV0611  QStandardItem(lstr)
					else:	
						if(i==i1):#v0.73打开其它文件时，格式空置显示
							if self.FormatShow:
								item = self.ViewList[i] #KV0611  QStandardItem(self.ViewList[i])
							else:
								item = ""#QStandardItem("")
						else:
							item = task #QStandardItem(task)
					if i == 0 :
						item1 = self.prompstr #QStandardItem(self.prompstr)
						model=[] #.clear()
						model.append(item1)#.appendRow(item1)#兼容模式首页多此一行
						if(i==i1):#v0.73格式行
							if(i<self.lViewList-2):
								lie=mylist[i1].split()
								if(self.Ignore+2<len(lie)):
									i1=i+int(lie[self.Ignore+2])+1#定位下一个格式行
#									print("\t兼容首页当前格式行i=",i,",下一个格式行i1=",i1)
						model.append(item)#appendRow(item)
					else:#i!=0兼容模式非首页首项
						#20240807model=[] 
						if(i==i1):#v0.73
							if(i<self.lViewList-2):
								lie=mylist[i1].split()
								if(self.Ignore+2<len(lie)):
									if(lie[self.Ignore+2].isdigit()):
										i1=i+int(lie[self.Ignore+2])+1
										#print("\t当前格式行i=",i,",下一个格式行i1=",i1)
									else:
										print("\t当前行i=",i,"非格式行错误，请予以修正")
						model.append(item)#appendRow(item)
					i=i+1
		if(model):
			if(n==1):
				modelt = []
				for item in model:
					modelt.append(self.LineFeed(item,MainApp.LineChars))#20240829self
				self.Model=modelt
				self.QtSetmodel(self.Model,0)#get_states()
		self.CheckedRow=[]#v0.76清空多选项表
		return self.Model#0707



# 175 20             (369 0)

	def LineFeed (self,string,n):
		ls=len(string)
		ln = n
		if(ls<n):
			strt = string
		else:
			strt = ""
			for i in range(0,ls,n):
				if(ls-i > n):
					strt += string[i:ln]+'\n'
					ln += n
				else:
					strt += string[i:]
#				print("Linefeed string[",strt,"]")	
#		print("Linefeed string is [",strt,"]")
		return strt		
			


# 20 18              (545 0)

	def Ztime (self,n):#电脑中文当地时间，n为整数，0为年月时分秒，1为年月时分，2为月日时分，3为日时分，4为时分
		timet=time.localtime(time.time())
		if(n==0):
			localtime=time.strftime("%Y-%m-%d-%H:%M:%S",timet)
		elif(n==1):
			localtime=time.strftime("%Y-%m-%d-%H:%M",timet)
		elif(n==2):
			localtime=time.strftime("%m-%d-%H:%M",timet)
		elif(n==3):
			localtime=time.strftime("%d-%H:%M",timet)
		elif(n==4):
			localtime=time.strftime("%H:%M%",timet)
#		self.LocalTime=localtime
	#	print("\t\t当地时间为：",localtime)
		return localtime


# 18 57              (566 0)

	
	def KeyListInit (self,mypath,line):#关键字初始化，从文件某行开始读入赋值
		#mypath=os.path.join(os.getcwd(),self.KruleFile)#读取文件Krule.txt中的名词、前缀、后缀、单字白名单
		fh=open(mypath,mode='r',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()
#			print("完成打开文件->",mypath)
			fh.close()
			mylist = data.split("\n")
			lm=len(mylist)
			strt=""
			cn=0
			Adverb=[]
			noun=[]
			Verb=[]
			Verb1=[]
			for i1 in range(line+1,lm):
				PassP=True
#				print(i1,"行内容[",mylist[i1],"]")
				if(len(mylist[i1])>0):
					if(mylist[i1][0]=='#'):
						if(len(strt)>0):
							if(cn==1):
								list1=strt.split()
								strt=""
							elif(cn==2):
								list2=strt.split()
								noun.append(list1)
								noun.append(list2)
#								print("\t\tnoun表为：",noun)
								strt=""
							elif(cn==3):
								Adverb=strt.split()
								strt=""
#								print("\t\tAdverb表为：",Adverb)
							elif(cn==4):
								Verb=strt.split()
								strt=""
#								print("\t\tVerb表为：",Verb)
							elif(cn==5):
								Verb1=strt.split()
								strt=""
#								print("\t\tVerb1表为：",Verb1)
						cn+=1
						PassP=False
					if PassP:
						strt+=mylist[i1]
#						print("\t\t联结字串成为[",strt,"]")#结束读取文件Krule.txt中的名词、前缀、后缀、单字白名单
			self.Adverb=Adverb
			self.noun=noun
			self.Verb=Verb
			self.Verb1=Verb1



# 57 61              (585 0)

	def WKrule (self):#如果没有关键字文件，默认从伤寒论关键字，创建该文件##v0.997 0426   
		noun=[['脉', '风', '热', '表', '里', '汗', '头', '面', '目', '口', '鼻', '咽','喉', '身', '体', '项', '背', '腰', '胸', '胁', '膈', '心', '腹', '脐', '脚', '手', '足', '脾', '胃', '肠', '针', '利', '疟', '胁', '饥', '水', '饮', '气', '血', '荣', '卫', '昼', '夜', '寸', '关', '尺', '衣', '床', '食', '噫', '眠', '睡', '静', '谐', '矢', '喘', '疮', '声', '语', '脓', '漏', '精', '色', '产', '经', '妇', '劳', '痉'], ['太阳', '膀胱', '四肢', '小便', '大便', '阳明', '骨节', '清谷', '日晡', '潮热', '骨节', '奔豚', '手足','妊娠']] 
		Adverb= ['不', '无', '有', '未', '可', '多', '少', '大', '小', '嗜', '喜', '恶', '怕', '发', '自', '捻', '摸', '谵', '得', '干', '似', '欲', '结', '潮', '昏', '半', '遂', '乍', '或', '在', '能', '谵', '必', '入', '即', '饮', '善', '而', '唾', '冲', '生', '时', '切', '失'] 
		Verb= ['浮', '弦', '涩', '弱', '微', '细', '缓', '紧', '洪', '大', '促', '迟', '沉', '滑', '短', '出', '臭', '吐', '厥', '逆', '鸣', '痛', '疼', '强', '咳', '漏', '难', '屈', '伸', '痒', '烦', '躁', '引', '寒', '如', '伤', '挛', '急', '温', '伸', '止', '胀', '满', '卧', '轻', '重', '解', '渴', '噎', '呕', '瞑', '衄', '悸', '和', '清', '往', '来', '眩', '懊', '恼', '窒', '结', '溏', '挛', '疟', '言', '动', '燥', '淋', '疮', '苦', '哕', '鞕', '惊', '狂', '灼', '中', '烂', '发', '扰', '竭', '数', '则枯', '利', '冷', '痞', '几', '安', '赤', '彻', '度', '虚', '实', '黄', '休', '上', '下', '反', '仁', '黑'] 
		Verb1=['苦','哕','咳', '呕', '吐', '烦', '渴', '噎', '窒', '漏', '淋', '瞑', '衄', '悸', '下', '利', '重', '眩', '鸣']
		Exclud=['，', '。', '；', '、', '：', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '日', '则', '以', '此', '必', '之', '了', '者', '也', '而', '于', '甚', '或', '和', '与', '并', '反', '不', '可', '宜', '故', '未', '再', '无', '难', '前', '后', '去', '更', '名', '为', '传', '得', '色', '方', '法', '加', '攻', '其', '复', '煮', '取', '症', '调', '以', '愈', '治', '针', '误', '在', '滓', '亦', '何', '仍', '坏', '用', '几', '衣', '服', '作', '家', '至', '曰', '草', '桂', '枝', '姜', '枣', '愈', '治', '药', '液', '枯', '酒', '客', '附', '子', '升', '两', '斤', '证', '已', '若', '被', '汤', '闻', '主', '欲', '解', '半', '夏', '承', '虎', '麻', '人', '皮', '太', '明', '甘', '伤', '旦', '（', '）', '(', ')', 'n', '\\n', '苓', '散', '卷', '忄', '吴', '所', '蒿', '理', '假', '令', '卫', '当', '归', '猪', '连', '芩', '尺', '中', '寸', '关', '自', '少', '桃', '仁', '消', '谷', '时', '茯', '术', '因', '朴', '邪', '枳', '翁', '龙', '牡', '泽', '嘿', '桔', '梗', '本', '芪', '葛', '根', '阿', '胶', '刺', '泻', '豆', '知', '犯', '杏', '仁', '久', '须', '茱', '茵', '救', '陈', '令', '乌', '是', '因', '致', '先', '刺', '柴', '胡', '汁', '蜜', '煎', '虽', '愦', '但', '文', '蛤', '乍', '真', '武', '荣', '禹', '熏', '余', '粮', '见', '陷', '雷', '合', '地', '石', '膏', '青', '从', '凡', '血', '分', '医', '瓜', '蒂', '期', '门', '悉', '津', '行', '除', '栝', '蒌', '建', '诸', '言', '属', '浆', '灸', '病', '辛', '死', '参', '脏', '芍', '今', '栀', '乃', '过', '丸', '问', '还', '彻', '厚', '辨', '续', '罢', '豉', '萸', '使', '师', '蛎', '丑', '橘', '枚', '斗', '柏']
		self.noun=noun
		self.Adverb=Adverb
		self.Verb=Verb
		self.Verb1=Verb1
		mypath=os.path.join(os.getcwd(),self.KruleFile)#名词、前缀、后缀、单字白名单写入文件Krule.txt中的
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			lm=len(noun[0])
			fh.write("#笈智关键字"+"\n")
			fh.write("#单字名词"+"\n")
			for i in range(lm-1):
				fh.write(noun[0][i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(noun[0][lm-1]+"\n")
			lm=len(noun[1])
			fh.write("#双字名词"+"\n")
			for i in range(lm-1):
				fh.write(noun[1][i]+"  ")
				if(i%20==15):
					fh.write("\n")
			fh.write(noun[1][lm-1]+"\n")
			lm=len(Adverb)
			fh.write("#前缀"+"\n")
			for i in range(lm-1):
				fh.write(Adverb[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Adverb[lm-1]+"\n")
			lm=len(Verb)
			fh.write("#后缀"+"\n")
			for i in range(lm-1):
				fh.write(Verb[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Verb[lm-1]+"\n")
			lm=len(Verb1)
			fh.write("#单字后缀白名单"+"\n")
			for i in range(lm-1):
				fh.write(Verb1[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Verb1[lm-1]+"\n")
			lm=len(Exclud)
			fh.write("#关键字黑名单"+"\n")
			for i in range(lm-1):
				fh.write(Exclud[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Exclud[lm-1]+"\n")
			fh.close



# 61 22              (643 0)

	def DLFmt (self,mylist):#数字括号前缀项位数，设定全局变量Ignore #0421
		print("进入数字括号之词序号获取模块")
		Ignore=0 
#		mylist=datastr.split('\n')
		lie=mylist[0].split()
		ll=len(lie)
		if(ll>=2):
			print("\t首行转成(",ll,")词列表：\t",lie)
			i1=0
			for lstr in lie:#判断数字括号格式项序号
				if(i1<=ll-1):
					if(lstr[-1]=='0'):
						print("\t\t(",i1,")词之末符[",lstr[-1],"]为0，初判为数字括号所在词")
						if(lie[i1+1].isdigit()):
							Ignore=i1-1#self.Ignore=i1-1 20230406
							print("\t\t\t其后(",i1+1,")词为数字，确认为数字括号格式词，序号Ignore为(",Ignore,")")
							break
				i1+=1
		return Ignore


# 22  10             (764)

class EditStatePopup1 (Popup):
#	print("\n进入EditStatePopup1类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup1, self).__init__(**kwargs)



# 10 9               (787 0 0)

class EditStatePopup2 (Popup):
#	print("\n进入EditStatePopup2类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup2, self).__init__(**kwargs)


# 9 28                 (798 0 0)

class EditStatePopup3 (Popup):
#	print("\n进入EditStatePopup3类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup3, self).__init__(**kwargs)



class EditStatePopup3a (Popup):
#	print("\n进入EditStatePopup3a类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup3a, self).__init__(**kwargs)



class EditStatePopup3b (Popup):
#	print("\n进入EditStatePopup3b类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup3b, self).__init__(**kwargs)



# 28 10                 (808 0 0)

class EditStatePopup4 (Popup):#0123
#	print("\n进入EditStatePopup4类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup4, self).__init__(**kwargs)



# 10 19                     (837 0 0)

class EditStatePopup5 (Popup):#0124
#	print("\n进入EditStatePopup5类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup5, self).__init__(**kwargs)



class EditStatePopup5a (Popup):#0124
#	print("\n进入EditStatePopup5a类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup5a, self).__init__(**kwargs)



# 19 140             (848 0 0)

class EditStatePopup6 (Popup):#0124
#	print("\n进入EditStatePopup6类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup6, self).__init__(**kwargs)




class EditStatePopup7 (Popup):#20240719
#	print("\n进入EditStatePopup7类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup7, self).__init__(**kwargs)



class EditStatePopup8 (Popup):#20240729
#	print("\n进入EditStatePopup8类，密码输入弹出框")
	popinfo = ""#20240914
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup8, self).__init__(**kwargs)
#		print("\t密码输入弹出框EditStatePopup8类中的提示文字为[",self.popinfo,"]")#20240914
		if(self.popinfo):
			self.ids.Pop8_Info.text = self.popinfo
			self.ids.Pass_Edit.focus = True#20241009
#			print("\t\t显示消息")
		else:
			print("\t\t显示默认消息")



class EditStatePopup8a (Popup):#20240914
#	print("\n进入EditStatePopup8a类，消息提示弹出框")
	popinfo = ""
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup8a, self).__init__(**kwargs)
#		print("\t消息提示弹出框EditStatePopup8a类中的消息文字为[",self.popinfo,"]")
		if(self.popinfo):
			self.ids.Pop8a_Edit.text = self.popinfo
#			print("\t\t显示消息")
		else:
			print("\t\t显示默认消息")



class EditStatePopup8b (Popup):#20240926
#	print("\n进入EditStatePopup8b类，文本内容密码输入弹出框")
	popinfo = ""
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup8b, self).__init__(**kwargs)
#		print("\t密码输入弹出框EditStatePopup8b类中的提示文字为[",self.popinfo,"]")#20240914
		if(self.popinfo):
			self.ids.Pop8b_Info.text = self.popinfo
#			print("\t\t显示消息")
		else:
			print("\t\t显示默认消息")



class EditStatePopup9 (Popup):#20240729
#	print("\n进入EditStatePopup9类")
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup9, self).__init__(**kwargs)



class EditStatePopup10 (Popup):#202409062
#	print("\n进入图像弹出框EditStatePopup10类")
	popath = ""#"loading.png"
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup10, self).__init__(**kwargs)
		if(self.popath):#20241011
			popath = os.path.join(os.getcwd(),"pic",self.popath)#20240907#202409182"src"
#			print("\t图像弹出框EditStatePopup10类中的图像路径为[",popath,"]")
			if(os.path.isfile(popath)):
#				print("\t\t已找到该图像文件")
				self.ids.PopImage.source = popath
				print("\t\t显示图像")



class EditStatePopup11 (Popup):#20240908#20240909
#	print("\n进入EditStatePopup11类")
	poptext = "[确定]后将清空主编辑框，以显示品鉴，你确定吗？"
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup11, self).__init__(**kwargs)
		self.ids.Pop_Edit.text = self.poptext#Pop11_Info
#		print("\tEditStatePopup11类显示文字[",self.poptext,"]")
		


class EditStatePopup11b (Popup):#202409082确认保存品鉴弹出框
#	print("\n进入EditStatePopup11b类")
	poptext = "准备将主编辑框内容保存为品鉴，你确定吗？"
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(EditStatePopup11b, self).__init__(**kwargs)
		self.ids.Popb_Edit.text = self.poptext#Pop11_Info
#		print("\tEditStatePopup11b类显示文字[",self.poptext,"]")
		


class Test_Image (Popup):#202409062
#	print("\n进入图像显示框TestImage类")
	popath = "loading.jpg"#"src/.png"
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	def __init__(self, obj, **kwargs):
		super(Test_Image, self).__init__(**kwargs)
		popath = os.path.join(os.getcwd(),"pic",self.popath)#202409182"src"
#		print("\t图像显示框Test_Image类中的图像路径初设置为[",self.popath,"]，更新为[",popath,"]")
		if(os.path.isfile(popath)):
#			print("\t\t已找到该图像文件")
			self.ids.TestImage.source = popath
			#background_image = Image(source=self.popath)
			print("\t\t显示图像")
	






# 140 19             (841 0 0)

class SRV (Popup):#(RecycleDataViewBehavior,RecycleView):#
#	print("\n进入SRV类")
	data_items = ListProperty([])
	popcol = ListProperty(["?", "?"])
	Model = ['Test1','Test2','Test3','Test4'] #[]#
	Sline = 0
	Preline = 0 
	Stext = ""
	Title = "弹出框标题"
	Prompt = "弹出框提示"
	EditText = "修改本编辑框内容优先采用"







# 19 13             (982 0 0)

	def __init__(self, obj, **kwargs):
		super(SRV, self).__init__(**kwargs)
		self.cwd = os.getcwd() # 获取当前程序文件位置
		self.init_othersp()#界面的其它初始化，包括文件方法等
		self.QtSetmodelp(self.Model)#get_states()







# 13 22             (1002 0 0)

	def QtSetmodelp (self,Model):#get_states(self):
		lM=len(Model)
		rows = []
		for j in range(lM): 
		#	print(j+1)
			rows.append(Model[j])#linc)
		i = 0
		self.data_items=[]
		for row in rows:
			self.data_items.append([row,i])#[row[0],  i])
#			print(row[0],  i)
			i += 1
		self.popcol=self.QtStandardItemModelp()#update()
		return self.popcol







# 22 12             (1016 0 0)

	def QtStandardItemModelp (self):#update(self):
		self.popcol = [{'selected':False,'Name': x[0], 'key': 'Name', 'font_name':'jzh','text': str(x[1])} for x in self.data_items]
		print(self.popcol)
		return self.popcol







# 12 10             (1039 0 0)

	def init_othersp (self):#界面的其它初始化，包括文件方法等
		print("SRV进入初始化模块 init_others，初始化界面、文件、方法等")







# 10 20             (1052 0 0)

	def popok (self):
		print("\n模块popok中，弹出框，选择了(",self.Sline,")行，内容为[",self.Stext,"]",MainApp.ZtimeZ(self,6))
		self.EditText = self.Stext
		self.ids['Pop_Edit'].text = self.Stext
		MainApp.ok = True #0725
		mytext=self.ids['Pop_Edit'].text
		print("\n弹出框之编辑框内容为[",mytext,"]")
		if(mytext != self.Stext):
			self.Stext=mytext
			self.Sline = -1
		print("\n模块popok中，弹出框确认，选择了(",self.Sline,")行，内容为[",self.Stext,"]")
		self.dismiss()#root







# 20 11             (1063 0 0)

	def popno (self):
#		print("\n弹出框已取消，清空弹出框文件pop.txt")
		self.dismiss()#root







# 11 11             (1111 0 0)

class EditFileChooser(BoxLayout):
	load = ObjectProperty(None)
	cancel = ObjectProperty(None)







# 11 11             (1123 0 0)

class ListFileChooser(BoxLayout):
	load = ObjectProperty(None)
	cancel = ObjectProperty(None)







# 11 7             (1135 0 0)

class SelectableRecycleGridLayout(FocusBehavior, LayoutSelectionBehavior,
								  RecycleGridLayout):
	''' Adds selection and focus behaviour to the view. '''



# 7 20             (1147 0 0)

class SelectableLabel(RecycleDataViewBehavior, Label):
	''' Add selection support to the Label '''
#	print("\n进入SelectableLabel类")
	selected = BooleanProperty(False)
	selectable = BooleanProperty(True)
	rv_data = ObjectProperty(None)
	start_point = NumericProperty(0)
	col_data = ListProperty(["?", "?"])
	index = NumericProperty(0)
	selectedItem=None
	SelectedLines = []#202504020








# 20 11 (0 0)

	def __init__(self, **kwargs):
		super(SelectableLabel, self).__init__(**kwargs)
		Clock.schedule_interval(self.update, .0005)







# 11 9 (0 0)

	def update(self, *args):
		self.text = self.rv_data[self.index][self.key]






# 9 12 (0 0)

	def refresh_view_attrs(self, rv, index, data):
		''' Catch and handle the view changes '''
		self.index = index
		return super(SelectableLabel, self).refresh_view_attrs(rv, index, data)







# 12 14 (0 0)

	def on_touch_down(self, touch):
		''' Add selection on touch down '''
		if super(SelectableLabel, self).on_touch_down(touch):
			return True
		if self.collide_point(*touch.pos) and self.selectable:
			return self.parent.select_with_touch(self.index, touch)







# 14 63 (0 0)

	def apply_selection(self, rv, index, is_selected):
		self.selected = is_selected
		rv.data[index]['selected']=self.selected#0714
		self.rv_data = rv.data
		#下为增加的多选项功能#from RV8
		if is_selected:
	#		print("选中项转到第(",index,")项，内容为","{0}".format(rv.data[index]))#selection changed to 
#			print("选中项转到第(",index,")项")#selection changed to 
			self.index = index
			self.col_data[0] = self.rv_data[self.index]["Name"]
			self.col_data[1] = self.rv_data[self.index]["text"]#0731
			SelectableLabel.selectedItem = self.index
			if(str(self.index) not in self.SelectedLines):#20250420
				self.SelectedLines.append(str(self.index))
				print("\tSelectableLabel可选标签类的选中表SelectedLines",self.SelectedLines)
			
			print("\n\tSelectableLabel选中界面第(",SelectableLabel.selectedItem,")项内容\n『",self.col_data[0],"』")
			mypath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
			if(MenuScreen.fileName_choose=='' or MenuScreen.fileName_choose==mypath):#0714
				print("检测SelectableLabel位于主级目录层，所在文件名MenuScreen.fileName_choose=[",MenuScreen.fileName_choose,"]")
				if(self.index>0):#20240129
					SRV.Stext = self.col_data[0]#20240129
			else:
				print("检测SelectableLabel位于主目录的次级文件层，所在文件名MenuScreen.fileName_choose=[",MenuScreen.fileName_choose,"]")
				print("模块SelectableLabel检测：",MainApp.PickListP,"在PickList模块中",MainApp.ZtimeZ(self,6))
				SRV.Sline = self.col_data[1]#0731 self.index
				SRV.Stext = self.col_data[0]
				SRV.Preline = int(SRV.Sline)-self.index#0918
				print("\tselectableLabel赋值SRV，点中(",self.index,")行，为本页总序号(",SRV.Sline,")行，界面从(",SRV.Preline,")行开始显示，内容\n『",SRV.Stext,"』")
				if(MenuScreen.OmniState):#0925运行模式时，点顶行时将系统当前文件名设为主目录文件
					print("[运行/阅读]开关(",MenuScreen.OmniState,")判断SRV.Sline是否字符(",isinstance(SRV.Sline,str),")")#整数(",isinstance(SRV.Sline,int),")")
					if(SRV.Sline=='0'):#0830self.index==0):
						print("\tselectableLabel点中本页顶行时，准备打开目录文件[",mypath,"]")
						MenuScreen.fileName_choose= mypath
				else:#0724 if(self.index>0):
					print("\t阅读模式时，selectableLabel类点中(",self.index,")行","内容[",self.col_data[0],"]")
					if(SRV.Stext.find("#")>=0 and SRV.Stext.find(".")>=0):#202409062图像格式设置为&开头，后跟空格
						print("\t\t发现选中行有图像链接符#")
						strt = MainApp.DeLineFeed(self,SRV.Stext,MainApp.LineChars)
						pict = strt.split("#")[1].split()[0]
						#popath = os.path.join(os.getcwd(),"src",pict)
						print("\t\t\t图像文件名为[",pict,"]")#文件名[",popath,"]
						EditStatePopup10.popath = pict#popath#20240907
						MainApp.Pop10(self)
#					print("\t\tselectableLabel类中全局品鉴表『",MainApp.CommentL," 』")#MenuScreen.Comments)#20240908
			#		if MenuScreen.Comments:#20240908
					if(MainApp.CommentL):
						linenow = MenuScreen.Expbnow+int(SRV.Sline)
						MainApp.PopComment(self,linenow)#20240923为节省代码尝试将编码模块化
		else:#20250420
			for id in range(len(self.SelectedLines)):
				if(self.SelectedLines[id]==str(self.index)):
					self.SelectedLines.pop(id)
					print("\tSelectableLabel可选标签类的选中表SelectedLines",self.SelectedLines)
					break







# 63 11             (1183 0 0)
		
class MyRV(RecycleView):
#	print("\n进入MyRV类")
	def __init__(self, **kwargs):
		super(MyRV, self).__init__(**kwargs)
		self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
		self._keyboard.bind(on_key_down=self._on_keyboard_down)
		self.selectedItem = -1



# 11 6              (1247 0)

	def _keyboard_closed (self):
		pass



# 6 15              (1259 0 0)

	def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
		if keycode[1] == 'down':
			self.clearAll()
			self.nextItem()
			print('down')
		elif keycode[1] == 'up':
			self.clearAll()
			self.prevItem()
			print("up")
		#elif keycode[1] == 'e' and len(modifiers) > 0 and modifiers[0] == 'ctrl':
		#	self.view_adapter.views[self.selectedItem].on_press()



# 15 8              (1266 0 0)

	def clearAll(self):
		if (self.selectedItem > -1):
			for i in range(len(self.view_adapter.views) - 1):
				self.view_adapter.views[self.selectedItem].selected = 0



# 8 12             (1282 0 0)

	def nextItem(self):
		if self.selectedItem < len(self.view_adapter.views) - 1:
			self.selectedItem += 1
		else:
			self.selectedItem = 0
		self.view_adapter.views[self.selectedItem].selected = 1
		#print(self.selectedItem)
		#print("第[",self.selectedItem,"]项已选中")



# 12 11             (1291 0 0)

	def prevItem(self):
		if self.selectedItem > 0:
			self.selectedItem -= 1
		else:
			self.selectedItem = len(self.view_adapter.views) - 1
		self.view_adapter.views[self.selectedItem].selected = 1
		print("第[",self.selectedItem,"]项已选中")



# 11 72            (1288 0 0)

class MenuScreen (Screen):
#class RV (RecycleDataViewBehavior,RecycleView):
#	print("\n进入RV主屏类")
	Ignore=0 #兼容如意软件变量，此版因为考虑python及C等编程语言模式，数字括号设为第2，3位，如意是第1，2位
	PicSize=600
	FormatShow=False
	IdxFrom=2
	AppendP=False#v0.991新增，判断摘录的追加模式，还是插入模式（改为默认），这是次较大的变动
#	KeyWordStr=""#v0.987新增
#	KeyWordStr2=""#v0.987新增
#	IndexLogFile="IndexLog.txt"
#	LastKey=""
#	noun=[]
#	Adverb=[]
#	Verb=[]
#	Verb1=[]#v0.986新增
	KeyTitle="笈智关键字"
	FFname=""
	CheckedRow=[]
	Doing=1#0414v0.992
#	RedoList=[]
	fileName_choose=""#全局变量
	Expdic={}
	Rundic={}
	ExpMode=False
	AutoMode=False
	ViewList=[]
	Expitem=-1
	Expbnow=0
	Expfnow=0
	Expbackstep=0
	Expforestep=0
	FullStep=0
	lViewList=0
	MyOutput=""
	CheckedRow=[]
	JustNum=-1
	mystr=""
	PosFound=-1
	numt1=["","","","",""]
	numt1id=[0,0,0,0,0]
	fmt=3
	PMark='♦'
	JMark='♥'
	promptstr1="特殊字符：&图像⌇续行♦分页♥链接"
	OftenFiles="oftenfiles.set"#目录文件名
	FruitFile="Fruit.txt"#搜索结果文件名
	IndexFile="Fruit.idx"#搜索结果索引文件名
	KruleFile="Krule.txt"#关键词解析词源文件名
	KwdFile="Kwd.txt"		#文本框排除法解析关键词追加的结果文件
	_startPos = None
	_endPos = None
	_isTracking = False
	Model =[]
	#LineChars = 18
	active = BooleanProperty()
	OmniState = False
	UnLineFeed = False
	Writen = 2
	prompstr="修身齐家治平   人工智能即兴      笈智中医kv1.0"#吴名,QQ群869383706,©GPLv3，更新下载至‘Ubuntu中文论坛’网-‘软件推荐’板块# 吴名,2024.1QQ625052847顶行（本行）为输入行，双击后可输入关键字，点[搜索]按钮可进行内容搜索，'与条件'关键字由';'分割，'或条件'由空格或'、'分割，精确数字匹配在第一个字输入'｀'。点中顶行，再勾选顶行，可勾选全页，再勾选一次可取消全选；点[摘录]按钮，勾选内容会显示到右栏；点[计算]按钮可计算点中行算式，结果显示在顶行。20030611注释即软件，软件即注释，用活好典籍，笈智当第一  本款为图形界面v1.0p版，希望老少朋友们喜欢，家有爱编程萌宝的可用来仿作编程哦，本软件是人工智能的平民化定义。勾选本行，可显示注释行，本软件可广泛应用于医学、工程、编程、法律、教育、行政等领域，。本软件是自由软件，遵循GPL v3.0许可，详见http://www.gnu.org/licenses/quick-guide-gplv3.html，您可以带源代码再发布（包括要求有偿），但没有担保。" 
	data_items = ListProperty([])
	col1 = ListProperty(["?", "?"])
	col2 = ListProperty(["?", "?"])
	Comments = False#202409083	20250406None #
	






# 72 12            (1300 0 0)

	def __init__(self, **kwargs):
		super(MenuScreen, self).__init__(**kwargs)#RV
		MainApp.LineChars = int((Window.width-360)/540)+15#20240221 3 #20240829适配青春版720-16dp6.09吋-4 self.LineChars 1080-18dp6.67吋-8
		
#		print("进入主程序窗口，宽度为(",Window.width,")字高30，行字数(",MainApp.LineChars,")")#20240829self. 1025(",self.menu_screen.ids.RV_List.font_size,")
		self.cwd = os.getcwd() # 获取当前程序文件位置
		self.init_others()#界面的其它初始化，包括文件方法等
		self.InitFontSize()#202503263
		self.QtSetmodel(self.Model,0)#get_states()


# 12 19                  (1373 0 0)

	def QtSetmodel (self,Model,n):#get_states(self):
		lM=len(Model)
		rows = []# [(1, 'Test1'), (2, 'Test2'), (3, 'Test3'), (4, 'Test4')]
		for j in range(lM): 
		#	print(j+1)
			rows.append(Model[j])#linc)
		i = n#0731 0
		self.data_items=[]
		for row in rows:
			self.data_items.append([row,i])#[row[0],  i])
#			print(row[0],  i)
			i += 1
		self.col2=self.QtStandardItemModel()#update()
		return self.col2
#		self.refresh_from_data()#0707



# 19 18             (1467 0 0)

	def QtStandardItemModel(self):#update(self):
		#20240807self.col2 = [{'selected':False,'Name': x[0], 'key': 'Name', 'font_name':'jz','height':(len( str(x[0]) ) // self.LineChars + 1)*80,'text': str(x[1])} for x in self.data_items]#0125 + 1)*50
		col2=[]#20240807
		for x in self.data_items:
			if(len( str(x[0]) ) < MainApp.LineChars):#202409292
				locheight = 70
			#20241006elif(len( str(x[0]) ) <= MainApp.LineChars*5):
			#20241006	locheight=(len( str(x[0]) ) // MainApp.LineChars+ 1)*50#202409292 
			else:
				locheight=(len( str(x[0]) ) // MainApp.LineChars+ 1)*50#202409292 + 1)*80#20241006)*40
			col2.append({'selected':False,'Name': x[0], 'key': 'Name', 'font_name':'jzh','height':locheight,'text': str(x[1])})
		self.col2 = col2
#		print(self.col2)
		return col2



# 18 123              (1406 0 0)

	def ReadMWLine (self,path,n):#
		print("\n进入读取目录文件模块ReadMWLine，目录文件[",path,"]读入第(",n,")行")#此n已为文件实际行号
		Nname = ""#主页列表名
		linestr = ""#列表对应文件名
		strt =  ""#20241012
		linestr = ""#20241012
		linelist = []
		if(os.path.isfile(path)):
			ld1=os.path.getsize(path)#文件大小
			if(ld1>0):
				fh=open(path,mode='r+t',encoding='UTF-8')
				if fh:
					fh.seek(0)
					data=fh.read()#20241012[:-1]
#					print("\t\t读取目录文件模块ReadMWLine完成打开文件->")#20241011,path)
					fh.close()
					mylist = data.split("\n")
#					print("\t\t转换为主目录名称列表")#为：20241011,mylist)#0123
					if(n<len(mylist)):
						if(n>0):
							Fname =mylist[n].split()[0]#202409272调出文件名称
							Escores = 1.0e5 
							if(len(mylist[n].split())>1):
								Escores = int(mylist[n].split()[1])#202409272调出菜单名称后一项学分
							strt =mylist[n-1]#调出菜单名称
							strtl = strt.split()#20240823列表名称行密码判断,先转为列表
							print("\t\t\t选中",strtl,"行，次行链接文件[",Fname,"]")
							if(len(strtl)>1):#当文件行有两词以上时，表示有密码
								MainApp.PassWdText = strtl[1]
								MainApp.MenuName   = strtl[0]#202408262#202409272设置文件名第二项为学分
								MainApp.PassFile = Fname#20241008#20241013因绕过密码机制撤消全局赋值MainApp.MenuFile
								ClosePeriod = None #20240828"0"
								ExpirePeriod =  None #20240828"0"
								if(len(strtl)>2):#202408262#当文件行三词以上时，表示时间窗口功能，可能有封闭期（正整数）或有效期(负整数）限制
									PeriodP = False#时间限制判断
									if(strtl[2][0]=="-"):#202408262第三词为负数时，
										timet = MainApp.TimeLag(self,strtl[2][1:])#20240914 
										if(timet >= 0):#20240914当时间量>0表示有效期
											ExpirePeriod = timet#20240914 strtl[2][1:]
											PeriodP = True
											print("\t\t\t\t有效时长为(",ClosePeriod,")",PeriodP)
									else:
										timet = MainApp.TimeLag(self,strtl[2])#20240914 
										if(timet >= 0):#20240914#第三词时间量>0时，表示有封闭期
											ClosePeriod = timet#20240914 strtl[2]
											PeriodP = True
											print("\t\t\t\t封闭时长为(",ClosePeriod,")秒,封闭判断：",PeriodP)
										
									if(PeriodP):#202408262有时间限制判断
										mypath=os.path.join(os.getcwd(),"src/FirstRun.txt")
										print("\t\t\t首次运行时间文件名[",mypath,"]")
										if(os.path.isfile(mypath)):
											fh=open(mypath,mode='r+t',encoding='UTF-8')
											if fh:
												fh.seek(0)
												booktime=fh.read()#读入文件作为记录时20240828[:-1] 
												print("\t\t\t\t首次运行当地时间记录为[",booktime,"]")
												fh.close
												booktime=time.mktime(time.strptime(booktime,"%Y年%m月%d日%H时%M分%S秒"))
												print("\t\t\t\t转换为时间值(",booktime,")")
												nowtime = time.time()#当前时间值
												if(ClosePeriod >= 0): #20240828!= "0"
													if(Escores > 0):#202409272当发现有等效学分时
														Utime = round(timet/Escores,1)											
													tscore = self.Tscore()
													mtime = round(Utime*tscore)
													ClosePeriod -= mtime
													print("\t\t\t\t\t学分当量时间(",Utime,")秒，总学分(",tscore,")，相当于实际时间(",mtime,")秒，扣除后得到封闭时长为(",ClosePeriod,")秒")
													closetime = ClosePeriod#20240914int(ClosePeriod)*86400
													print("\t\t\t\t\t期限(",strtl[2],")，时间值为(",closetime,")")#20240914
													if(nowtime > booktime+closetime):#如果现在时间在封闭期以外，正常执行
														print("\t\t\t\t\t\t已通过封闭期")
														#20240914linestr = mylist[n]
														days = int((nowtime-booktime-closetime)/86400) #202409272
														if(len(strtl)==3):#当为三项，已满足时间授权，正常继续#20240914
															linestr = Fname#20240927mylist[n]
														elif(len(strtl)>3):#当超过三项，虽已满足时间授权，仍须密码验证#20240914
															if(strtl[2].isdigit()):
																popinfo = "密码时间双许可"+strtl[2]+"天生效，您已关注"+str(days)+"天（总学分"+str(tscore)+"，已抵扣"+str(round(mtime/86400))+"天）\n"#20241011EditStatePopup8.
															else:
																popinfo = "密码时间双许可"+strtl[2]+"生效，您已关注"+str(days)+"天（总学分"+str(tscore)+"，已抵扣"+str(round(mtime/86400))+"天）\n"#20241011EditStatePopup8.
															EditStatePopup8.popinfo = strtl[3]+"\n本许可需要同时满足授权与时间：\n"+popinfo+"若已得授权，请在下框正确输入密码"
															self.Pop8()#密码弹出框
															linestr = MainApp.MenuFile#20241008
													else:#20240914
														print("未过封闭期")
														days = (booktime+closetime-nowtime)//86400
														if(strtl[2].isdigit()):
															EditStatePopup8a.popinfo = "时间许可"+strtl[2]+"天后生效，还剩"+str(days)+"天（总学分"+str(tscore)+"，已抵扣"+str(round(mtime/86400))+"天）\n"
														else:
															EditStatePopup8a.popinfo = "时间许可"+strtl[2]+"后生效，还剩"+str(days)+"天（总学分"+str(tscore)+"，已抵扣"+str(round(mtime/86400))+"天）\n"
														print(EditStatePopup8a.popinfo)
														self.Pop8a()#弹出消息
														
												elif(ExpirePeriod>=0):  #20240828!= "0" 
													print("有效时长为(",ExpirePeriod,")不为0")
													closetime = ExpirePeriod#20240914int(ExpirePeriod)*86400
													print("期限(",strtl[2][1:],")，时间值为(",closetime,")")#20240914
													if(nowtime < booktime+closetime):#如果现在时间有效期以内，正常执行
														print("尚在有效期")
														linestr = Fname#20240927mylist[n]	
													else:	#20240914								
														print("已过有效期")
														days = int((nowtime-booktime-closetime)/86400) 
														if(strtl[2][1:].isdigit()):
															EditStatePopup8a.popinfo = "有效期为"+strtl[2][1:]+"天，已超过("+str(days)+")天，欢迎惠顾"
														else:
															EditStatePopup8a.popinfo = "有效期为"+strtl[2][1:]+"，已超过("+str(days)+")天，欢迎惠顾"
														print(EditStatePopup8a.popinfo)
														#self.Pop8a()#弹出消息
														
								elif(len(strtl)==2):#20240914#当为二项，需输入密码 or (len(strtl)>3):或三项以上#20241008恢复
									self.Pop8()#密码限制功能
							else:	
								linestr = Fname#20240927mylist[n]
		linelist.append(strt)
		linelist.append(linestr)
		print("\t模块ReadMWLine返回：",linelist,"\n")
		return linelist #20240925改返列表 linestr



# 123 51            (1506 0)
	
	def init_others(self):#界面的其它初始化，包括文件方法等
		print("主屏类进入其它初始化模块 init_others，初始化界面、文件、方法等")#RV
		if(isinstance(SelectableLabel.selectedItem,int)):#20240807
			print("\t主屏窗口准备打开文件self.fileName_choose[",self.fileName_choose,"]")#20250420RV
			if(os.path.isfile(self.fileName_choose)):#0710
				self.myfileopen(self.fileName_choose,1)#0706
		else:
			print("主屏模块 init_others，未选中时")#RV
			mypath=os.path.join(os.getcwd(),"src/FirstRun.txt")#202408262
#			print("\t\t\t首次运行时间文件名[",mypath,"]")
			if(not os.path.isfile(mypath)):
				localtime=MainApp.ZtimeZ(self,0)
#				print("首次运行当地时间为：",localtime)
				fh=open(mypath,mode='w+t',encoding='UTF-8')
				if fh:
					fh.write(localtime)
					fh.close
				
			self.myfileopen(self.OftenFiles,1)#0706







	def InitFontSize(self):#202503263__init__(self, **kwargs):
#		super(MenuScreen, self).__init__(**kwargs)#RV
		path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)#202503263
		with open(path,mode='r+t',encoding='UTF-8') as f:#202503263读取上次的文本高度设置
			data = f.read()
			dlist = data.split("\n")
			ld = len(dlist)
			dsp = dlist[1].split()
#			fs = self.text_screen.ids.Enlarge_Edit.font_size
#			print("\tRunup中检测当前文本窗口字高(",fs,")")
			if(len(dsp)>1):#探测设置文件的第二行是否多词
				txthi = dsp[1]#读取设置文件的第二词
				self.texthi = int(txthi)#20250326
				print("\t\t文本字高取为设置文件第二行第二词(",txthi,")")
#				self.text_screen.ids.Enlarge_Edit.font_size = int(txthi)
				self.ids.Text_Edit.font_size = int(txthi)#menu_screen.








# 51 188             (1549 0 0)

	def myfileopen (self,slecstr,n): #主屏文件打开准备20230203
		print("\n进入主屏myfileopen->",n,"新开文件名： ",slecstr)
	#	localtime=self.Ztime(0)
	#	print("当地时间为：",localtime)
		KFP=False#打开关键字文件判断
		FKP=False#文件中是否自带关键字判断
		LineScope=50#关键字不超过50行，若有需要可修改此数字
		mypath=os.path.join(os.getcwd(),self.KruleFile)#读取文件Krule.txt中的名词、前缀、后缀、单字白名单
		if(os.path.isfile(mypath)):
			fh=open(mypath,mode='r+t',encoding='UTF-8')
			if fh:
				fh.close
				self.KeyListInit(mypath,0)
				KFP=True
		if(slecstr.strip()):		
			if(slecstr.find(self.OftenFiles)<=0):#如果不是第一次打开，或不是回主页界面操作
				fh=open(slecstr,mode='r+t',encoding='UTF-8')
				if fh:
					fh.seek(0)
					data=fh.read()
					print("\t完成打开文件->",slecstr)
					fh.close()
					mylist = data.split("\n")
					lm=len(mylist)
					i1=0
					for i in range(lm-1,0,-1):
						if(i1<LineScope):
							if(mylist[i].find(self.KeyTitle)>=0):#发现“笈智关键字”字串
								line=i
#								print("\t\tmyfileopen 模块倒查至(",i,")行，发现笈智关键字格式")
								self.KeyListInit(slecstr,line)
								FKP=True
								break
						else:
#							print("\t\tmyfileopen 模块倒查至(",i,")行，已至边界行数(",LineScope,")，未发现笈智关键字格式")
							break
						i1+=1
		if((not KFP) and (not FKP)):
			self.WKrule()
		ExpMode=False
		mypath=os.path.join(os.getcwd(),self.OftenFiles)#准备打开主页文件
		fh=False
		if(slecstr.strip()):		
			fh=open(slecstr,mode='a+t',encoding='UTF-8')
			self.KeyWordStr=""#0225v0.981
			self.KVWordStr2=""#0225v0.981
#			print("\t全局变量关键词清空")
		else:
			if(n==2):
				if(not self.fileName_choose.strip()):
					print("\t首次打开……")
					self.fileName_choose=mypath#v0.60-

		if fh:
			fh.seek(0)
			data=fh.read()
			print("完成打开文件[",slecstr,"]")#20240718内容100～500字为[",data[100:500],"]
			fh.close()
			mylist = data.split("\n")
			if(len(mylist[-1])==0):#20250420
				mylist.pop()
				
			if(data.find('"密码')>=0):
				MainApp.CPassP = True
			print("主窗Myfileopen打开时，表的前5项",mylist[:5])#20250420		15～20	[15:20]
			self.Ignore=self.DLFmt(mylist)#v0.89 0406
			lie=mylist[0].split()
			lcol=len(lie)
			if(lcol>=2):
				if(lie[self.Ignore+1][-1]=='0' and lie[self.Ignore+2].isdigit()):
					self.ExpMode=True
					self.lViewList=len(mylist)
					self.ViewList=mylist
					self.Expbackstep=0
					self.Expforestep=int(lie[self.Ignore+2])
					self.Expbnow=0#V0.75
					self.Expfnow=0
					print("\t",slecstr,"判断",self.ExpMode,"为专用模式文件！")
					print("\t主屏文件初打开，回跳行号(",self.Expbnow,")回跳步长(",self.Expbackstep,")前跳行号(",self.Expfnow,")前跳步长(",self.Expforestep,")忽略词数(",self.Ignore+1,")")#202504232改rv为主屏
				else:
					self.ExpMode=False
					print("\t",slecstr,"判断为非专用模式文件！")
			else:
				self.ExpMode=False
				self.ViewList=mylist#20230307
				self.lViewList=len(mylist)#20230307
				print("\t「",slecstr,"」为非专用模式文件！共(",self.lViewList,")行，末二行为:",mylist[-2:])#ViewList[0]为：",self.ViewList[0]20230307


			i=0
			i1=0#格式行
			if not self.ExpMode:#非专用文件
				print("\n\t操作主窗口非专用文件格式")
				for task in mylist:
					#print("i=",i,",i1=",i1)
					if(self.fileName_choose==mypath or self.fileName_choose==""):#当打开oftenfiles.set文件时
			#			print("\n\t选择文件为[",self.fileName_choose,"]比较常用文件[",mypath,"]，结果相同")
						lstr = ""#20250420
						if(i % 2 == 0):
							if(task):#20240823
								lstr= task.split()[0]#20240823
#						else:#20250420
#							lstr = ""
						item = lstr #0711 task #KV0611  QStandardItem(task)
					elif(self.fileName_choose.strip()):	
						item = task
#					else:#20250420
			#			print("\n\t选择文件为[",self.fileName_choose,"]比较常用文件[",mypath,"]，结果不同")
#						if(i % 2 == 0):
#							if(task):#20240823
#								lstr= task.split()[0]#20240823
#						else:
#							lstr = ""
#						item = lstr #0711 task #KV0611  QStandardItem(task)
					if i == 0 :
						model=[] #KV0611 model.clear()
			#			if (not self.fileName_choose.strip()):
						item1 = self.prompstr #KV0611 QStandardItem(self.prompstr)
						model.append(item1) #KV0611 appendRow(item1)
#						print("i=0时[",item1,"]提示加入主目录列表")#20250420
						model.append(item) #KV0611 appendRow(item)
#						print("i=0时[",item,"]加入主目录列表")#20250420
					else:
						if(self.fileName_choose==mypath):#打开oftenfiles.set设置文件时
							if(item.strip()):
								model.append(item)#appendRow(item)
#								print("[",item,"]加入主目录列表")#20250420
#							else:#20250420
#								print("本项[",item,"]未放入主目录列表")

#							model.append(item) #KV0611 appendRow(item)
						elif(self.fileName_choose.strip()):	
							model.append(item) #KV0611 appendRow(item)
						else:
							if(item.strip()):
								model.append(item)#appendRow(item)
					i=i+1
			else:#Expert mode专用文件
				for task in mylist:
					if(self.fileName_choose==mypath):#打开oftenfiles.set设置文件时
						lstr=os.path.split(task)[1]#取文件的名
						item =lstr #KV0611  QStandardItem(lstr)
					else:	
						if(i==i1):#v0.73打开其它文件时，格式空置显示
							if self.FormatShow:
								item = self.ViewList[i] #KV0611  QStandardItem(self.ViewList[i])
							else:
								item = ""#QStandardItem("")
						else:
							item = task #QStandardItem(task)
					if i == 0 :#首页首项显示提示
						item1 = self.prompstr #QStandardItem(self.prompstr)
						model=[] #.clear()
						model.append(item1)#.appendRow(item1)#兼容模式首页多此一行
						if(i==i1):#v0.73格式行
							if(i<self.lViewList-2):
								lie=mylist[i1].split()
								if(self.Ignore+2<len(lie)):
									i1=i+int(lie[self.Ignore+2])+1#定位下一个格式行
#									print("\t兼容首页当前格式行i=",i,",下一个格式行i1=",i1)
						model.append(item)#appendRow(item)
					else:#i!=0兼容模式非首页首项
						#20240807model=[] 
						if(i==i1):#v0.73
							if(i<self.lViewList-2):
								lie=mylist[i1].split()
								if(self.Ignore+2<len(lie)):
									if(lie[self.Ignore+2].isdigit()):
										i1=i+int(lie[self.Ignore+2])+1
										#print("\t当前格式行i=",i,",下一个格式行i1=",i1)
									else:
										print("\t当前行i=",i,"非格式行错误，请予以修正")
						model.append(item)#appendRow(item)
					i=i+1
		if(model):
			if(n==1):#为清空时重新打开，测试注销此行，下减一档
				modelt = []
				for item in model:
					modelt.append(self.LineFeed(item,MainApp.LineChars))#20240829self
				self.Model=modelt
				self.QtSetmodel(self.Model,0)#get_states()
				
		self.CheckedRow=[]#v0.76清空多选项表
		return self.Model#0707



# 188 20             (1682 0 0)

	def LineFeed (self,string,n):
		ls=len(string)
		ln = n
		if(ls<n):
			strt = string
		else:
			strt = ""
			for i in range(0,ls,n):
				if(ls-i > n):
					strt += string[i:ln]+'\n'
					ln += n
				else:
					strt += string[i:]
#				print("Linefeed string[",strt,"]")	
#		print("Linefeed string is [",strt,"]")
		return strt		
			


# 20 18           (1871 0 0)

	def Ztime (self,n):#电脑中文当地时间，n为整数，0为年月时分秒，1为年月时分，2为月日时分，3为日时分，4为时分
		timet=time.localtime(time.time())
		if(n==0):
			localtime=time.strftime("%Y-%m-%d-%H:%M:%S",timet)
		elif(n==1):
			localtime=time.strftime("%Y-%m-%d-%H:%M",timet)
		elif(n==2):
			localtime=time.strftime("%m-%d-%H:%M",timet)
		elif(n==3):
			localtime=time.strftime("%d-%H:%M",timet)
		elif(n==4):
			localtime=time.strftime("%H:%M%",timet)
#		self.LocalTime=localtime
	#	print("\t\t当地时间为：",localtime)
		return localtime


# 18 57            (1892 0 0)

	
	def KeyListInit (self,mypath,line):#关键字初始化，从文件某行开始读入赋值
		#mypath=os.path.join(os.getcwd(),self.KruleFile)#读取文件Krule.txt中的名词、前缀、后缀、单字白名单
		fh=open(mypath,mode='r',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()
#			print("完成打开文件->",mypath)
			fh.close()
			mylist = data.split("\n")
			lm=len(mylist)
			strt=""
			cn=0
			Adverb=[]
			noun=[]
			Verb=[]
			Verb1=[]
			for i1 in range(line+1,lm):
				PassP=True
#				print(i1,"行内容[",mylist[i1],"]")
				if(len(mylist[i1])>0):
					if(mylist[i1][0]=='#'):
						if(len(strt)>0):
							if(cn==1):
								list1=strt.split()
								strt=""
							elif(cn==2):
								list2=strt.split()
								noun.append(list1)
								noun.append(list2)
#								print("\t\tnoun表为：",noun)
								strt=""
							elif(cn==3):
								Adverb=strt.split()
								strt=""
#								print("\t\tAdverb表为：",Adverb)
							elif(cn==4):
								Verb=strt.split()
								strt=""
#								print("\t\tVerb表为：",Verb)
							elif(cn==5):
								Verb1=strt.split()
								strt=""
#								print("\t\tVerb1表为：",Verb1)
						cn+=1
						PassP=False
					if PassP:
						strt+=mylist[i1]
#						print("\t\t联结字串成为[",strt,"]")#结束读取文件Krule.txt中的名词、前缀、后缀、单字白名单
			self.Adverb=Adverb
			self.noun=noun
			self.Verb=Verb
			self.Verb1=Verb1



# 57 61           (1911 0 0)

	def WKrule (self):#如果没有关键字文件，默认从伤寒论关键字，创建该文件##v0.997 0426   
		noun=[['脉', '风', '热', '表', '里', '汗', '头', '面', '目', '口', '鼻', '咽','喉', '身', '体', '项', '背', '腰', '胸', '胁', '膈', '心', '腹', '脐', '脚', '手', '足', '脾', '胃', '肠', '针', '利', '疟', '胁', '饥', '水', '饮', '气', '血', '荣', '卫', '昼', '夜', '寸', '关', '尺', '衣', '床', '食', '噫', '眠', '睡', '静', '谐', '矢', '喘', '疮', '声', '语', '脓', '漏', '精', '色', '产', '经', '妇', '劳', '痉'], ['太阳', '膀胱', '四肢', '小便', '大便', '阳明', '骨节', '清谷', '日晡', '潮热', '骨节', '奔豚', '手足','妊娠']] 
		Adverb= ['不', '无', '有', '未', '可', '多', '少', '大', '小', '嗜', '喜', '恶', '怕', '发', '自', '捻', '摸', '谵', '得', '干', '似', '欲', '结', '潮', '昏', '半', '遂', '乍', '或', '在', '能', '谵', '必', '入', '即', '饮', '善', '而', '唾', '冲', '生', '时', '切', '失'] 
		Verb= ['浮', '弦', '涩', '弱', '微', '细', '缓', '紧', '洪', '大', '促', '迟', '沉', '滑', '短', '出', '臭', '吐', '厥', '逆', '鸣', '痛', '疼', '强', '咳', '漏', '难', '屈', '伸', '痒', '烦', '躁', '引', '寒', '如', '伤', '挛', '急', '温', '伸', '止', '胀', '满', '卧', '轻', '重', '解', '渴', '噎', '呕', '瞑', '衄', '悸', '和', '清', '往', '来', '眩', '懊', '恼', '窒', '结', '溏', '挛', '疟', '言', '动', '燥', '淋', '疮', '苦', '哕', '鞕', '惊', '狂', '灼', '中', '烂', '发', '扰', '竭', '数', '则枯', '利', '冷', '痞', '几', '安', '赤', '彻', '度', '虚', '实', '黄', '休', '上', '下', '反', '仁', '黑'] 
		Verb1=['苦','哕','咳', '呕', '吐', '烦', '渴', '噎', '窒', '漏', '淋', '瞑', '衄', '悸', '下', '利', '重', '眩', '鸣']
		Exclud=['，', '。', '；', '、', '：', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '日', '则', '以', '此', '必', '之', '了', '者', '也', '而', '于', '甚', '或', '和', '与', '并', '反', '不', '可', '宜', '故', '未', '再', '无', '难', '前', '后', '去', '更', '名', '为', '传', '得', '色', '方', '法', '加', '攻', '其', '复', '煮', '取', '症', '调', '以', '愈', '治', '针', '误', '在', '滓', '亦', '何', '仍', '坏', '用', '几', '衣', '服', '作', '家', '至', '曰', '草', '桂', '枝', '姜', '枣', '愈', '治', '药', '液', '枯', '酒', '客', '附', '子', '升', '两', '斤', '证', '已', '若', '被', '汤', '闻', '主', '欲', '解', '半', '夏', '承', '虎', '麻', '人', '皮', '太', '明', '甘', '伤', '旦', '（', '）', '(', ')', 'n', '\\n', '苓', '散', '卷', '忄', '吴', '所', '蒿', '理', '假', '令', '卫', '当', '归', '猪', '连', '芩', '尺', '中', '寸', '关', '自', '少', '桃', '仁', '消', '谷', '时', '茯', '术', '因', '朴', '邪', '枳', '翁', '龙', '牡', '泽', '嘿', '桔', '梗', '本', '芪', '葛', '根', '阿', '胶', '刺', '泻', '豆', '知', '犯', '杏', '仁', '久', '须', '茱', '茵', '救', '陈', '令', '乌', '是', '因', '致', '先', '刺', '柴', '胡', '汁', '蜜', '煎', '虽', '愦', '但', '文', '蛤', '乍', '真', '武', '荣', '禹', '熏', '余', '粮', '见', '陷', '雷', '合', '地', '石', '膏', '青', '从', '凡', '血', '分', '医', '瓜', '蒂', '期', '门', '悉', '津', '行', '除', '栝', '蒌', '建', '诸', '言', '属', '浆', '灸', '病', '辛', '死', '参', '脏', '芍', '今', '栀', '乃', '过', '丸', '问', '还', '彻', '厚', '辨', '续', '罢', '豉', '萸', '使', '师', '蛎', '丑', '橘', '枚', '斗', '柏']
		self.noun=noun
		self.Adverb=Adverb
		self.Verb=Verb
		self.Verb1=Verb1
		mypath=os.path.join(os.getcwd(),self.KruleFile)#名词、前缀、后缀、单字白名单写入文件Krule.txt中的
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			lm=len(noun[0])
			fh.write("#笈智关键字"+"\n")
			fh.write("#单字名词"+"\n")
			for i in range(lm-1):
				fh.write(noun[0][i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(noun[0][lm-1]+"\n")
			lm=len(noun[1])
			fh.write("#双字名词"+"\n")
			for i in range(lm-1):
				fh.write(noun[1][i]+"  ")
				if(i%20==15):
					fh.write("\n")
			fh.write(noun[1][lm-1]+"\n")
			lm=len(Adverb)
			fh.write("#前缀"+"\n")
			for i in range(lm-1):
				fh.write(Adverb[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Adverb[lm-1]+"\n")
			lm=len(Verb)
			fh.write("#后缀"+"\n")
			for i in range(lm-1):
				fh.write(Verb[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Verb[lm-1]+"\n")
			lm=len(Verb1)
			fh.write("#单字后缀白名单"+"\n")
			for i in range(lm-1):
				fh.write(Verb1[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Verb1[lm-1]+"\n")
			lm=len(Exclud)
			fh.write("#关键字黑名单"+"\n")
			for i in range(lm-1):
				fh.write(Exclud[i]+"  ")
				if(i%20==19):
					fh.write("\n")
			fh.write(Exclud[lm-1]+"\n")
			fh.close



# 61 24                    (1969 0 0)

	def DLFmt (self,mylist):#数字括号前缀项位数，设定全局变量Ignore #0421
		print("进入数字括号‘首词序号’获取模块DLFmt")
		Ignore=0 
#		mylist=datastr.split('\n')
		if(len(mylist)>0):#2025034013
			lie=mylist[0].split()
			ll=len(lie)
			if(ll>=2):
#				print("\t首行转成(",ll,")词列表：\t",lie)
				i1=0
				for lstr in lie:#判断数字括号格式项序号
					if(i1<=ll-1):
						if(lstr[-1]=='0'):
#							print("\t\t(",i1,")词之末符[",lstr[-1],"]为0，初判为数字括号所在词")
							if(lie[i1+1].isdigit()):
								Ignore=i1-1#self.Ignore=i1-1 20230406
								print("\t\t\t其后(",i1+1,")词为数字，确认为数字括号格式词，序号Ignore为(",Ignore,")")
								break
					i1+=1
		return Ignore



# 24 98                    (1927 0 0)

class MainApp (App):#主程序,RV KeyWordStr Adverb
	CacuMode= True
	Mb_started = False # 秒表启动状态
	Mb_seconds = 0 # 当前秒表秒数
	popup1 = None
	popup2 = None
	PopListDlg = None
	title = "Jzkv"
	FFname = ""
	QtMessageOk = False
	selectedItem = -1
	rslist = []
#	Sline = 0
#	Stext = ""
	GetStr = False
	GetAttr =  False
	PickListP = False
	HuntPopP = False
	ok = 0#0904False
	numList =[]#0724
	PickListNum = 0
	RunModel=""
	MainPara = ""
	PopP = False
	LoopP = False
	LoopOn = False#20240905 True
	InduceKP = False
	nLoop = 0	
	KVWordStr=""#0902
	KVWordStr2=""#0902
	KeyWord2p = False#0924或条件关键词判断
	IndexLogFile="IndexLog.txt"
	LastKey=""
	noun=[]
	Adverb=[]
	Verb=[]
	Verb1=[]#v0.986新增
	PosFound=-1
	MainPage = -1#0911
	OnFeed=True#0914
	CopyFrom = -1#20240612
	AccountStr = ""#202406181首行字符
	NAStr = 0#202406181记账编辑框字符数
	PInsertP = False #20240729合账贴时是否增加编辑行备注
	Line_str = ""#20240729
	PassWdText = ""#20240823
	PassFile = ""#20241013密码框转输文件名
	MenuFile = ""#20240823
	MenuName = ""#20240911
	NameKey = "题"#20240925
	tiP=False#20241207菜单名中含“题判断”
	
	LineChars = 18 #20240829
	CheckedRow = None#20240902
	MainPrompt = ""#20240905
#	Comments = None #False#20240908
	CommentL = []#20240908
	CPassP = False #20240926
	PMark='♢'#20241005
	JMark='♡'#20241005
	FontBold = False #202410112
	

	MenuLine = -1 #20250115记录之前选中菜单行
	FDataList = [] #20250120管道文件输入的数据表
	FDataP = False #20250120管道文件输入判断
	NFData = 0 		#20250120管道文件输入位置
	texthi = 40 #202503263


	
	
	
	
	def InitFontSize(self):#202503263__init__(self, **kwargs):
#		super(MenuScreen, self).__init__(**kwargs)#RV
		path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)#202503263
		with open(path,mode='r+t',encoding='UTF-8') as f:#202503263读取上次的文本高度设置
			data = f.read()
			dlist = data.split("\n")
			ld = len(dlist)
			dsp = dlist[1].split()
#			fs = self.text_screen.ids.Enlarge_Edit.font_size
#			print("\tRunup中检测当前文本窗口字高(",fs,")")
			if(len(dsp)>1):#探测设置文件的第二行是否多词
				txthi = dsp[1]#读取设置文件的第二词
				self.texthi = int(txthi)#20250326
				print("\t\t文本字高取为设置文件第二行第二词(",txthi,")")
				self.text_screen.ids.Enlarge_Edit.font_size = int(txthi)
				self.menu_screen.ids.Text_Edit.font_size = int(txthi)






	
# 98 8            (1939 0 0)
	
	def Pop1 (self):
		self.popup1 = EditStatePopup1(self)
		self.popup1.open()
		print("弹出框测试点",self.ZtimeZ(6))



# 8 7              (2038 0 0)

	def Pop2 (self):
		self.popup2 = EditStatePopup2(self)
		self.popup2.open()



# 7 7                 (2047 0 0)

	def Pop3 (self):
		self.popup3 = EditStatePopup3(self)
		self.popup3.open()



# 7 12                 (2055 0)

	def Pop3a (self):
		self.popup3a = EditStatePopup3a(self)
		self.popup3a.open()



	def Pop3b (self):
		self.popup3b = EditStatePopup3b(self)
		self.popup3b.open()


# 12 7                 (2063 0 0)

	def Pop4 (self):
		self.popup4 = EditStatePopup4(self)
		self.popup4.open()



# 7 6                     (2076 0 0)

	def Pop5 (self):
		self.popup5 = EditStatePopup5(self)
		self.popup5.open()


# 6 6                    (2084 0)
	def Pop5a (self):
		self.popup5a = EditStatePopup5a(self)
		self.popup5a.open()



# 6 6                     (2091 0 0)

	def Pop6 (self):
		self.popup6 = EditStatePopup6(self)
		self.popup6.open()


# 6 5                     (2098 0)

	def Pop7 (self):
		self.popup7 = EditStatePopup7(self)
		self.popup7.open()

# 5 19              (2105)

	def Pop8 (self,):#20240823密码运行弹出框
		self.popup8 = EditStatePopup8(self)
		self.popup8.open()
		#return self.MenuFile


	def Pop8a (self):#20240914消息弹出框
		self.popup8a = EditStatePopup8a(self)
		self.popup8a.open()



	def Pop8b (self):#20240926文本内容密码运行弹出框
		self.popup8b = EditStatePopup8b(self)
		self.popup8b.open()



# 19 24              (2111)
	def Pop9 (self):#20240823密码显示子应用弹出框
		self.popup9 = EditStatePopup9(self)
		self.popup9.open()
		return self.MenuFile


	def Pop10 (self):#202406显示图像弹出框
		popup10 = EditStatePopup10(self)
		popup10.open()
		


	def Pop11 (self):#202409073确认显示品鉴弹出框
		self.popup11 = EditStatePopup11(self)
		self.popup11.open()
		
		
		
	def Pop11b (self):#202409082确认保存品鉴弹出框
		self.popup11b = EditStatePopup11b(self)
		self.popup11b.open()
		
		
		
# 24 12                (2131 0 0)

	def WriteOften (self):
		mypath=os.path.join(os.getcwd(),"src/OftenWord.txt")
		mystr=  self.menu_screen.ids.Text_Edit.text
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			fh.write(mystr)#d3.5*0.5 q2*0.6 2
			fh.close
		self.popup1.dismiss()



# 12 14              (2156 0 0)

	def WriteAcc (self):
		mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			data = self.menu_screen.ids.Text_Edit.text
			data+= '\n'
			#print("读取编辑框内容[",data,"]")
			fh.write(data)#d3.5*0.5 q2*0.6 2
			fh.close
		self.popup2.dismiss()



# 14 37              (2169 0 0)

	def WriteTest (self):#0123 覆盖应用
		mypath=self.MenuFile#20250326
#		n= self.Writen
#		mypath=os.path.join(os.getcwd(),"src/Test"+str(n)+".txt")#0123
		#20240911*mypath = self.MenuFile#20241012
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			data = self.menu_screen.ids.Text_Edit.text
			#20241012data+= '\n'
			#print("读取编辑框内容[",data,"]")
			fh.write(data)#d3.5*0.5 q2*0.6 2
			fh.close
		else:
			self.menu_screen.ids.Line_Edit.text = "没有文件「"+mypath+"」"
		self.UpdateMain()
		self.popup3.dismiss()



	def WriteTestb (self):#20240831 解密覆盖应用
		print("进入解密覆盖应用模块")
		n= self.Writen
		tmpath=os.path.join(os.getcwd(),"src/Temp.txt")
		with open(tmpath,"r+t") as f :
			data = f.read()
		mypath=os.path.join(os.getcwd(),"src/Test"+str(n)+".txt")
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			print("读取临时中间文件内容[",data,"]")
			fh.write(data)
			fh.close
		self.UpdateMain()
		self.popup3b.dismiss()



# 37 16              (2184)

	def WriteTesta (self):#202408243 覆盖应用
		print("进入密码验证覆盖模块WriteTesta")
		#mypath=os.path.join(os.getcwd(),"src/Test1.txt")#0123
		n= self.Writen
		mypath=os.path.join(os.getcwd(),"src/Test"+str(n)+".txt")#0123
		print("准备覆盖[",mypath,"]")
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			data = self.menu_screen.ids.Text_Edit.text
			data+= '\n'
			#print("读取编辑框内容[",data,"]")
			fh.write(data)
			fh.close


# 16 17               (2222 0 0)

	def CreateTest (self):#0123 创建应用
		#mypath=os.path.join(os.getcwd(),"src/Test1.txt")#0123
		n= self.Writen
		mypath=os.path.join(os.getcwd(),"src/Test"+str(n)+".txt")#0123
		fh=open(mypath,mode='w+t',encoding='UTF-8')
		if fh:
			data = self.menu_screen.ids.Text_Edit.text
			data+= '\n'
			#print("读取编辑框内容[",data,"]")
			fh.write(data)#d3.5*0.5 q2*0.6 2
			fh.close
		self.UpdateMain()
		self.popup4.dismiss()



# 17 32                 (2239 0 0)

	def RenameTest (self):#0123 改名应用
		self.selectedItem=SelectableLabel.selectedItem 
		lnum=self.selectedItem
		if(isinstance(lnum,int)):#0124
			Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
			fh=open(Oftenpath,mode='r+t',encoding='UTF-8')
			if fh:
				fh.seek(0)
				data=fh.read()
				fh.close()
				flist= data.split("\n")
			nt=lnum*2-2
			mystr2=self.menu_screen.ids.Line_Edit.text #0123kv获取编辑行输入
			print("当前选中行号为(",lnum,")内容为[",mystr2,"]")
			flist[nt]=mystr2
			#print("\t常用文件内容列表成为：",flist)
			nft=len(flist)
			fho=open(Oftenpath,mode='w+t',encoding='UTF-8')
			if fho:
				flist1=[]
				for l in range(nft):
					fho.write(flist[l]+"\n")
					if(l%2==0):
						flist1.append(flist[l])
				fho.close()
			self.menu_screen.ids.Text_Edit.text = "改名完成"+self.menu_screen.ids.Text_Edit.text[2:]#20240830
			self.UpdateMain()
			self.popup5.dismiss()



# 32 47                 (2257)
	def RenameTesta (self):#202408243 改名应用a
		print("进入密码验证后改名模块RenameTesta")
		self.selectedItem=SelectableLabel.selectedItem 
		lnum=self.selectedItem
		if(isinstance(lnum,int)):#0124
			Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
			fh=open(Oftenpath,mode='r+t',encoding='UTF-8')
			if fh:
				fh.seek(0)
				data=fh.read()
				fh.close()
				flist= data.split("\n")
				flist.pop()
			nt=lnum*2-2
			mystr2=self.menu_screen.ids.Line_Edit.text #0123kv获取编辑行输入
			print("当前选中行号为(",lnum,")文件名将改为[",mystr2,"]")
			strl = flist[nt].split()#20240825
			str2l = mystr2.split()#20240825探测编辑行为多项时，按编辑行设置密码
			nl = len(strl)#20240826
			n2l = len(str2l)
			strt=str2l[0]
	#		print("\t\t(0)",strt,end="")
			for i in range(1,n2l):
				strt += " " +str2l[i]
	#			print("\t\t(",i,")",strt,end="")
			if(nl>n2l):#如果原设置词数较多，补足原设置，可能为保密时间、密钥类型，操作者不一定知晓或不希望知晓
				for i in range(n2l,nl):
					strt += " " +strl[i] 
	#				print("\t\t(",i,")",strt,end="")
	#		print("")
			flist[nt]=strt
			#print("\t常用文件内容列表成为：",flist)
			nft=len(flist)
			fho=open(Oftenpath,mode='w+t',encoding='UTF-8')
			if fho:
				flist1=[]
				for l in range(nft):#20240825nft-1
					fho.write(flist[l]+"\n")
					if(l%2==0):
						flist1.append(flist[l])
				fho.close()
			self.menu_screen.ids.Text_Edit.text = "密码改名完成"+self.menu_screen.ids.Text_Edit.text[2:]#20240830
			self.UpdateMain()
			#self.popup5.dismiss()



# 47 81              (2290 0 0)

	def UpdateMain (self):#0124
		print("\n进入UpdateMain 返回主目录模块")
		Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		fh=open(Oftenpath,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()[:-1]#20241006[:-1]
			fh.close()
			flist= data.split("\n")
			nft=len(flist)
			strt = "点非顶行（选功能）,再点[笈智]打开。点选中行,取消选中"#202409233修正回主目录时换行问题
			item1=self.LineFeed(strt,self.LineChars)
			flist1=[item1]#202409233
			print("\t主目录内容共(",nft,")行\t",end="")#20241006
			for l in range(nft):#20240825 nft-1#20241006nft-2#20241012
#				print("\t(",l,")",flist[l][:6],end="")#20241006
				if(l%2==0):
					strt = flist[l].split()[0]#20240923
					item1=self.LineFeed(strt,self.LineChars)#202409233
					flist1.append(item1)#202408242 flist[l]#202409233
			print("UpdateMain 返回主目录模块表末五项：",flist1[-5:])#202408242
			self.FirstLine("文件目录页")#0126
			self.menu_screen.ids.RV_List.data =  self.menu_screen.QtSetmodel(flist1,0)#20240903self, MenuScreen
			MenuScreen.fileName_choose = Oftenpath#0126
		MenuScreen.ExpMode=False#0126
		MenuScreen.AutoMode=False
		MenuScreen.ViewList=[]
		MenuScreen.Expitem=-1
		MenuScreen.Expbnow=0
		MenuScreen.Expfnow=0
		MenuScreen.Expbackstep=0
		MenuScreen.Expforestep=0
		MenuScreen.FullStep=0
		MenuScreen.lViewList=0
		MenuScreen.Expdic={}
		MenuScreen.Rundic={}
		MainApp.CommentL = []#202409092
		print("\tUpdateMain 更新MenuScreen.fileName_choose为[",MenuScreen.fileName_choose,"]")
		#20240807
		self.CacuMode= True
		self.Mb_started = False # 秒表启动状态
		self.Mb_seconds = 0 # 当前秒表秒数
		self.popup1 = None
		self.popup2 = None
		self.PopListDlg = None
		self.title = "Jzkv"
		self.FFname = ""
		self.QtMessageOk = False
		self.selectedItem = -1
		self.rslist = []
		self.GetStr = False
		self.GetAttr =  False
		self.PickListP = False
		self.HuntPopP = False
		self.ok = 0#0904False
		self.numList =[]#0724
		self.PickListNum = 0
		self.RunModel=""
		self.MainPara = ""
		self.PopP = False
		self.LoopP = False
		self.LoopOn = False#20240905 True
		self.InduceKP = False
		self.nLoop = 0	
		self.KVWordStr=""#0902
		self.KVWordStr2=""#0902
		self.KeyWord2p = False#0924或条件关键词判断
		self.IndexLogFile="IndexLog.txt"
		self.LastKey=""
		self.PosFound=-1
		self.MainPage = -1#0911
		self.OnFeed=True#0914
		self.CopyFrom = -1#20240612
		self.AccountStr = ""#202406181首行字符
		self.NAStr = 0#202406181记账编辑框字符数
		self.PInsertP = False #20240729合账贴时是否增加编辑行备注
		self.Line_str = ""#20240729



# 81 33              (2338 0 0)

	def DelTest (self):#0123 删除主目录最末应用
		Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		fh=open(Oftenpath,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()
			fh.close()
			flist= data[:-1].split("\n")
			print("准备扫尾的列表：",flist)
			lnum = len(flist)
			nt=int(lnum/2)-2
			flist.pop()
			flist.pop()
			print("扫尾后的列表：",flist)
			nft=len(flist)
			fho=open(Oftenpath,mode='w+t',encoding='UTF-8')
			if fho:
				for l in range(nft):
					fho.write(flist[l]+"\n")
				#202408252fho.write(flist[nft-1])
				fho.close()
			mypath=os.path.join(os.getcwd(),"src/Test"+str(nt)+".txt")#0123
			print("准备清空文件[",mypath,"]")
			fh=open(mypath,mode='w+t',encoding='UTF-8')
			if fh:
				fh.write("")#d3.5*0.5 q2*0.6 2
				fh.close()
			self.UpdateMain()
			self.popup6.dismiss()



# 33 18            (2350 0 0)

	# 重写程序启动的事件。1、程序启动后首先进入时间更新画面
	def on_start(self):
		#if self.Mb_started:
		Clock.schedule_interval(self.Mb_update,0)
		#else:
		Clock.schedule_interval(self.Clock_update,0)
		self.InitFontSize()#202503273
		self.menu_screen.ids.Text_Edit.font_size = self.texthi#0927 15#202503273
		self.menu_screen.ids.Line_Edit.font_size = self.texthi
		self.text_screen.ids.Enlarge_Edit.font_size = self.texthi#202503273

		print("MainApp启动显示行字数(",self.LineChars,")")#20250403





# 18 18           (2384 0 0)

	# 开始/停止。2、当按下启动按钮，开始秒表计数 秒表启停
	def start_stop(self):
		if not self.CacuMode:
			self.menu_screen.ids.handle.text = '>' if self.Mb_started else '>|'
			self.Mb_started = not self.Mb_started
		#	self.Mb_started = not self.Mb_started
	#		self. Mb_update(0)
		#	self.menu_screen.ids.handle.text = '>' if self.Mb_started else '>|'
		else:
			self.handle()







# 18 13           (2403 0 0)

	def Mb_update(self,n):#秒表更新
		# 如果秒表已启动，更新当前秒数
		#print("启动秒表")
		if self.Mb_started:
			self.Mb_seconds += n
			self.menu_screen.ids.handle.text = '>|' if self.Mb_started else '>'
			# 更新秒表
			m,s = divmod(self.Mb_seconds,60) # 返回一个包含商和余数的元组
			self.menu_screen.ids.Text_Edit.text = ("%02d: %02d.%02d" % (int(m),int(s),int(s*100%100)))



# 13 30             (2422 0 1927)

	def ClearRun (self):#计算/秒表模式切换
#		print("\t\t***进入ClearRun***")
		self.CacuMode = not self.CacuMode
		if(self.Mb_started):
			if self.CacuMode:
				self.menu_screen.ids.ClearRun.text ='X'
				self.menu_screen.ids.Text_Edit.text =''#0909'0'
				self.menu_screen.ids.Text_Edit.font_size = 150
				self.menu_screen.ids.file.text = '[color=#ffd900]世  家[/color]'#20250329帐  目
				#self.menu_screen.ids.file.font_size = 80
			else:
				self.menu_screen.ids.Text_Edit.font_size = 120
				self.menu_screen.ids.ClearRun.text =':'
				self.menu_screen.ids.handle.text ='>'
				self.reset()
		else:
			if self.CacuMode:
				self.menu_screen.ids.ClearRun.text ='+'
				self.menu_screen.ids.Text_Edit.text =''#0909'0'
				self.menu_screen.ids.Text_Edit.font_size = self.texthi#20250326340#0928 70
				self.menu_screen.ids.handle.text ='[color=#00ff00]＋[/color]' #0927'＋'
			else:
				self.menu_screen.ids.ClearRun.text ='X'
				self.menu_screen.ids.Text_Edit.font_size = 120
				self.reset()
		#print("计算模式[",self.CacuMode,"]，秒表启动状态[",self.Mb_started,"]")



# 30 16                 (2436 0 0)

	# 秒表重置
	def reset(self):
		if not self.CacuMode:
			if not self.Mb_started:
				self.menu_screen.ids.handle.text = '>'
				self.Mb_started = True
				self.menu_screen.ids.Text_Edit.text = time.strftime("%H:%M:%S")
			else:
				self.menu_screen.ids.handle.text = '>|'
				self.Mb_started = False
				self.Mb_seconds = 0
				self.menu_screen.ids.Text_Edit.text = time.strftime("%H:%M:%S")



# 16 10                (2467 0 0)

	def Clock_update (self,n):#时钟更新
		# 更新当前时间
		pass
#		self.menu_screen.ids.ClearRun.text = time.strftime("%H:%M:%S")
#20240901		self.menu_screen.ids.ClearRun.text = '[color=#ffd900]'+time.strftime("%Y%m%d-%H:%M:%S")+'[/color]'#20240615 %Y%m%d-
		self.menu_screen.ids.ClearRun.text =  '[color=#ffd900]'+time.strftime("%Y%m%d-%H:%M:%S")+'[/color]'#20240901



# 10 126  (2484 0 0)

	def handle (self):#编辑框文字查算
		print("\n进入查算模块handle")
		mystr=self.menu_screen.ids.Text_Edit.text #202503263获取编辑框输入 从后第三行前移至此
		if self.CacuMode and len(mystr)>0:
			len_inquire = 30	#20240929查询字串长度设为不超过16（两句七言诗）#20250504		
#			mystr=self.menu_screen.ids.Text_Edit.text #20240902kv获取编辑框输入
			mystr1 = mystr#假设字串为一行
		#	print("编辑框字串长为(",len(mystr),")")
			if(len(mystr)==9):#20240110
		#		print("编辑框字串长为9,‘:’为第(",mystr.find(':'),")位，‘.’为第(",mystr.find('.'),")位")
				if(mystr.find(':')==2 and mystr.find('.')==6):
		#			print("编辑框字串第2位为‘:’，第6位为‘.’，确定为秒表记录")
					mystr1='*'+mystr
			FileP=False
			if(self.TimeP(mystr.split('\n')[0])):#首行时间戳时表示帐目文件#20250318 .split('\n')[0]
				FileP = True
				print("首行字串含时间戳")
			if(len(mystr)>0):#202406194
				if(mystr[0]!='*'):#20240131过滤首字*。测试计算字串 3*sin2.000*cos3.000
					loc=mystr.find('=')#过滤计算式结果
					if(loc>=0 and (not FileP)):#先检查字串有无‘=’号，以确定其为计算式
						mystr1 = mystr[:loc-1]#返回'='前的算式 ，作为首行字串
						if(len(mystr1.split('\n'))>1 ):#202406192过滤考虑查询时出现的多行结果
							if(self.TimeP(mystr1.split('\n')[1].split()[0])):#202406193当第二行为时间戳时，#20250318时间戳行可能多项，取其第一项.split()[0]
								mystr1=mystr1.split('\n')[0]#202406192取第一行
								if(mystr1[0]==' '):#20240622
									print("mystr1[0]为空格")
					else:
						loc1=mystr.find('笈智总计：')#过滤查询结果
						if(loc1>=0 and (not FileP)):#20240606再检查字串有无‘笈智总计’，以确定其为查询式
							mystr1 = mystr[:loc-1]#返回‘笈智总计’前的算式，作为首行字串
							if(len(mystr1.split('\n'))>1 ):#20240622考虑查询时出现多行结果
								if(self.TimeP(mystr1.split('\n')[1])):#202406193当第二行为时间戳时
									mystr1=mystr1.split('\n')[0]#202406192取第一行
									print("‘笈智总计：’前第一行字串[",mystr1,"]")
									if(mystr1[0]==' '):#20240622
										print("mystr1[0]为空格")
			lm = len(mystr1)#20250318由第6 行移至此
			mystrt = mystr1#20240128将首行初值保存
			if(mystr1[0]==' '):#20240622
				print("mystr1[0]为空格")
			NewP = True#202406181防止重复操作
			print("\n\t获取首行(‘=’号或‘笈智总计’之前)字符串[",mystr1,"]，判断前全局首行字串[",self.AccountStr,"]字串总长(",self.NAStr,")更改判断：",NewP)
			if(mystr1 == self.AccountStr): #判断首行相同为重复
				NewP = False
			self.AccountStr = mystr1
			self.NAStr = len(self.AccountStr)
			print("\n\t获取首行(‘=’号或‘笈智总计’之前)字符串[",mystr1,"]，判断后全局首行字串[",self.AccountStr,"]字串总长(",self.NAStr,")更改判断：",NewP)
			mylist = []
			Toplist = []
			Top = ""
			Top0 = ""
			if(mystr1.strip()):
				mylist = mystr.split('\n')
			if(len(mylist)>0):
				Top= mylist[0]
			if(Top.strip()):
				Toplist = Top.split()
			if(len(Toplist)>0):
				Top0=Toplist[0]
			NumberP = True
			if(len(Top0)>0):#.strip()):
				NumberP=self.IsNumber(Toplist[0])
			fmt=self.floatfmt(mystrt)#20250504	Top	检测顶行（查询命令）的最大小数位
			if(fmt<0):
			
				fmt = 2#默认小数位为2 位
			
			if(mystr1.strip()):#顶行字串非空才计算#20240618增加#20250318 and NewP
				if(NewP):#20250318检测是否重复按[+]，下增一档
#					fmt=self.floatfmt(mystr1)#20250504
					if(mystr1[0]==' '):#20240622
						print("mystr1[0]为空格")
					if(not self.AccountP(mystr1)):#首行非年月日及正数时，为查询而非计算
						if(not FileP):#1220 FileP表示有时间戳，用于判断显示世家，故不计算
							if not NumberP:#不全是实数时
	#							print("所获取字串非数字，开始计算，小数位数为(",fmt,")位")#0605
								#1227mystr=mystr1+"\n= "+self.AltStrm(mystr1,fmt,1)
								#202406202if(mystr1[0]=='*'):#1227
								if(mystr1[0]=='*' or (not self.HvNumber(mystr1) )):#202406202增加无数字纯文本判断
									mystr=mystr1#20240128
								else:#1227
									mystr=mystr1+"\n= "+self.AltStrm(mystr1,fmt,1)
	#								print("\t计算结果为[",mystr,"]")	
								self.menu_screen.ids.Text_Edit.text = mystr#+"??"
								if(mystrt[-1]!=' '):#20240128如果首行末尾为空格，则只计算不记录
									localtime=self.ZtimeZ(0)#0927(6)
									mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
								#	print(mypath)
									fh=open(mypath,mode='a+t',encoding='UTF-8')
									if fh:
										fh.write(localtime+"\n")
										fh.write(mystr+"\n")#d3.5*0.5 q2*0.6 2
										fh.close
									self.menu_screen.ids.file.text = '[color=#ffd900]世  家[/color]'#20250329帐  目
								#self.menu_screen.ids.file.font_size = 80
							else:#1221 if(mystr1 != '0'):#se:#当只有数字及点号时，判断为手写日期格式，进行统计计算
								print("发现手写日期",Toplist[0])
								self.myAccount(mystr1,0)
					else:#统计
						if(len(mystr1)<= len_inquire):#20240929考虑阅读放大，限制查询字串长度为16，如遇例外可自行修改本模块开头设置
							self.myAccount(mystr1,0)
						else:
							self.texthi += 5
							self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503282
							self.menu_screen.ids.Line_Edit.font_size = self.texthi
							self.text_screen.ids.Enlarge_Edit.font_size = self.texthi
							self.menu_screen.ids.Text_Edit.text=mystr#20240929放大刷新
				else:#重复操作时#20240618#20250318else
					self.texthi += 5
					self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503282
					self.menu_screen.ids.Line_Edit.font_size = self.texthi
					self.text_screen.ids.Enlarge_Edit.font_size = self.texthi
					self.menu_screen.ids.Text_Edit.text=mystr#放大刷新











# 126 84  (2495 0 0)

	def myAccount (self,mystr1,Brch):#Brch=0对应于=计算操作，Brch=1对应显示统计过程  查算分派
		print("\n进入 myAccount 模块，笈智统计开始……输入参数字串[",mystr1[:20],"]是否显示统计过程标记(",Brch,")")#202406192
		mystr=self.menu_screen.ids.Text_Edit.text #__self__ #kv获取编辑框输入
		loc=mystr.find('笈智总计：')#防止之前操作干扰
		mystrL = mystr
		if(loc>=0):# and (not self.TimeP(mystr))):如果发现'笈智总计：'
			mystr1 = mystr[:loc-1]#只取'笈智总计：'之前内容#202406192考虑查询时内容较多
			if(len(mystr1.split('\n') )>1 ):#202406192考虑查询时出现多行结果
				mystr1=mystrL.split('\n')[0]#202406192取第一行
		mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
		fh=open(mypath,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			string = fh.read()
			fh.close#1221
		strlist = string.split('\n')#将纪录内容字串转化为表 
		foretime=time.mktime(time.strptime(strlist[0],"%Y年%m月%d日%H时%M分%S秒"))#1227先假设起始时间为首条记录
		mylist=mystr1.split('\n')#如果没有'笈智总计：'
		MItemP=False
		Toplist = mylist[0].split()
		Nitem=len(Toplist)
		Top0=Toplist[0]#20231230
		if(self.AccountP(mylist[0])):#2240701(mystr1)):#20240622从首行判断，当为查询命令时Toplist[0]
			MItemP = True
			print("\t\t编辑框顶行[",Top0,"]项数(",Nitem,")，CalcuAccount判断处理")#1221,多于一项
			#即累加第一个等号后相关数值，否则会统计全部数值，即累加第二个等号后的数值")
		if(not self.TimeP(mylist[0])):#2240701(mystr1)):#若非带时间戳的帐目内容时，表示统计命令
			print("\t\t内容非本应用标准记录格式，即非‘整数+年月日时分秒’，表示统计命令(否则覆盖纪录文件操作)")
			if(mystr1.find('.')<0):	#也不是2023.09.01手写日期格式		
				foretime=self.CatchFTime(mystr1)#计算统计时间点，然后统计之后的数值
			else:#是2023.09.01格式时
				if(self.IsNumber(Top0)):#20231229先判断是否为实数mystr1
					n1=Top0.find('.')
					if(Top0[:n1].isdigit()):#1227
						vn1=int(Top0[:n1])
					else:#1227
						vn1=1969
					upyear = time.localtime(time.time()).tm_year
					print("编辑框为(",vn1,")年，今年是(",upyear,")年")
					if(vn1>=1970 and vn1 <= int(upyear)):#以年份数字介于1970～今年判断是简化时间表达式XXXX.XX.XX
						foretime = time.mktime(time.strptime(Top0,"%Y.%m.%d"))
						print("手写时间转化为统计起点时间：",foretime)
					else:#1227
						foretime = time.mktime(time.strptime('1970.1.1',"%Y.%m.%d"))
						print("早于1970年手写日期，统计起点时间转化为1970.1.1：",foretime)
				else:#1229
					print("非数首项，转化为统计起点时间：",foretime)
			Sum = self.CalcuAccount(mystr1,'JzAccount.txt',foretime,Brch)# 5 苹果 5 荔枝data
		else:#对于标准记录，将第一个时间设定为统计起点
			print("\t发现标准记录，即‘整数+年月日时分秒’")	
			mylist=mystr1.split('\n')
			lm=len(mylist)
			for i in range(lm):
				if(self.TimeP(mylist[i])):
					foretime=time.mktime(time.strptime(mylist[i],"%Y年%m月%d日%H时%M分%S秒"))
					print("\t(",i,")行发现时间格式[",mylist[i],"]")
					break
			Sum = self.CalcuAccount("",mystr1,foretime,Brch)
		#self.menu_screen.ids.Text_Edit.font_size = 50
		#self.menu_screen.ids.Text_Edit.clear_widgets()#20231230
		#print("\t\t模块myAccount中 Sum:",Sum)
		if(len(str(Sum))>0):#202406202配合空点[列传]放大  判断变量为空not Sum
			if(isinstance(Sum,float)):
				print("\t\t笈智总计： ",Sum)
			elif(isinstance(Sum,list)):
				if(len(Sum)>0):
					print("\t\t模块myAccount中判断Sum非空，内容为 :",Sum[0])
			if(Brch==0):			
				self.menu_screen.ids.Text_Edit.text = mystr1+"\n笈智总计： "+str(round(Sum,2))
			else:
				Data = mystr1#20240717 + '\n'包、三十二度
				nl = len(Sum)
				if(nl>1):#202406302串联表文字，输出为长字串，方便在编辑框显示
					Data = mystr1 + '\n'#20240717
					for i in range(nl-1):#20240603
						if(len(Sum[i])>0):
							Data += Sum[i] + '\n'
					if(len(Sum[nl-1])>0):
						Data += Sum[nl-1]
				self.menu_screen.ids.Text_Edit.text = Data



# 84 19               (2622 0 0)

	def GetPreStr (self,mystr):#取数前六字符 长文六字
		#print("\t\t\t\t进入获取数前六字符模块")
		lm=len(mystr)
		prestr=mystr
		for i in range(lm):
			if(mystr[i].isdigit()):
				if(i>0):
					prestr=mystr[:i]
				else:
					prestr=""
				break
		if(len(prestr)>6):
			prestr = prestr[-6:]
		#print("\t\t\t\t数前六字符为[",prestr,"]")
		return prestr



# 19 46               (2707 0 0)

	def TopPlus (self,Toplist):#类关键字展开
		print("\t\t\t进入TopPlus模块！输入列表共",len(Toplist),"项，为：",Toplist)
		mypath=os.path.join(os.getcwd(),"src/OftenWord.txt")
		print("\t\t\t常用字文件名[",mypath,"]")
		if(os.path.exists(mypath)):
			ld1=os.path.getsize(mypath)#文件大小
			if(ld1>0):
				fh=open(mypath,mode='r+t',encoding='UTF-8')
				if fh:
					fh.seek(0)
					data=fh.read()
					fh.close
					loclist=data.split('\n')#分行成表
					nloc=len(loclist)#获取行数
					exitP = False#20240606
					hdrunl = []
					while not exitP:
						print("\t追踪查询表关键字\t",end="")#20240607
						for Titem in Toplist:#遍历查询关键字 如“食品”
							print("\t[",Titem,"]\t",end="")#追踪查询关键字表执行状态20240607(",i,")
							if(not self.IsNumber(Titem)):#略过数字，对非数字项进行判断，是否为类关键字
								for j in range(nloc):#遍历文件内各行
									#print("\t\t\t\t遍历归类文件(",j,")行",loclist[j],"\t")#追踪显示各行内容
									if(j not in hdrunl):
										if(loclist[j].find(Titem)>=0):#如果有某行未查找过，且发现类关键字
											sonloc=loclist[j].split()#将该行分列成表
											if len(sonloc)>0:#略过空行
												if(sonloc[0] == Titem):#0120如果首列是查询关键字sonloc[0].find(Titem)>=0
													#Toplist.pop(i)#删除类关键字，只留具体关键字
													nson=len(sonloc)#统计该行的词数量
													for k in range(1,nson):#将其余词追加入关键字表
														prestr=self.GetPreStr(sonloc[k])
														if(prestr.strip()):#筛选非空关键字
															Toplist.append(prestr)#关键字只取数之前六字
													nTop=len(Toplist)
													print("\t\t\t\t\t发现[",Titem,"]为常用文件行的首项，关键字列表扩展为(",nTop,")项的",Toplist)
													hdrunl.append(j)
									if(j==nloc-1):exitP=True
							else:#20240717
								exitP=True
								
		return Toplist



# 46 1425                      (2727 0 0)

	def CalcuAccount (self,mystr1,string,foretime,Brch):#世家统计20250316
		print("\n进入CalcuAccount世家统计计算或显示模块，指令格式字串[",mystr1,"]；内容字串[",string[:20],"]")#202406192
		daytime = 86400 #20240601
		nextime = time.time()#先假设终点时间为当前
		newftime= time.localtime(nextime)#20240603
		newstime= time.strftime("%Y.%m.%d",newftime)#0123
		nextime = time.mktime(time.strptime(newstime,"%Y.%m.%d"))+86399
		gtime = time.gmtime(nextime) #20240601
		newtime1 = nextime#20240601
		Sum = 0.0
		if(string=='JzAccount.txt'):
			mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
			fh=open(mypath,mode='r+t',encoding='UTF-8')
			if fh:
				fh.seek(0)
				string = fh.read()
				fh.close#1221
		strlist = string.split('\n')#将内容字串转化为表 
		#20240618newtime=time.mktime(time.strptime(strlist[0],"%Y年%m月%d日%H时%M分%S秒"))#1227先假设起始时间为首条记录
		str0=strlist[0].split()[0]#20240731.split()[0]
		if(self.TimeP(str0)):#判断为时间戳时，读取作为起始时间为首条记录
			newtime=time.mktime(time.strptime(str0,"%Y年%m月%d日%H时%M分%S秒"))
		else:#非时间戳时，表示非帐本文件，直接退出本模块计算
			return ""#202406202未 0.00
		loclist=[]
		nsl = len(strlist)#世家记录行数
		AccBeginP = False
		KeyWdP = False#有查询类关键词判断
		OnlyP = False
		Nitem=0
		Mitem = 0#202406212
		Nb=2#关键字起始位置
		ConP=False
		BoundP = False#0120首字母关键字‘#’绑定判断
		pricefmt=2#20240416
		if(mystr1.strip()):
			mylist= mystr1.split('\n')#指令格式字串的行表
			Toplist = mylist[0].split()#指令格式顶行的列表
			Top0=Toplist[0]#1221指令格式首词
			Toplist2 = []#20240607
			Nitem = len(Toplist)#指令格式词数
			if(Nitem == 1):#指令格式为单词
				print("\t指令格式为单词")
				if(Top0.isdigit()):#0927当只有一项数字时，假定第二项指令数字同首项#20240511Toplist[0]
					if(Top0!='0'):#1227
						Toplist.append(Top0)
					else:#首项为0时
						days=round((nextime-newtime)/86400)+1#1222math.ceil#int20240608round((nextime-newtime)/86400,0)
#						print("数字首项的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
						Toplist.append(str(days))
					#Toplist.append(Toplist[0])#1227
					Mitem = 2#指令格式单词转化为双词
				else:#1221当首项非纯数字时‘ 汽油1’ '60日' ‘£比优特’
					if(not Top0[0].isdigit()):#首字也非数字时
						KeyWdP = True#20240622
						days=int((nextime-newtime)/86400)+1#1222math.ceil
#						print("文字首项的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
						Toplist2.append(str(days))#202406212
						Toplist2.append(str(days))#202406212
	
						if(Top0[0]=='£' or Top0[0]=='#'):#20240622
							BoundP = True
							Top2=Top0[1:]
							Toplist2.append(Top2)
#							print("\t\t查询关键词首字为'£'或'#'符,顶行第三项去除符后为表{",Toplist2,"}")
						else:
							Toplist2.append(Top0)
							Top2=Top0#202407013
							print("\t\t查询关键词首字非'£'或'#'符时,追加顶行第三项成为表{",Toplist2,"}")
						if(not self.IsNumber(Top2)):#202407013
							Toplist1 = self.TopPlus(Toplist2)# 10 水果 10 中药
							Toplist2 = Toplist1
						Mitem = 3#指令格式纯文单词转化为三词
					else:#当首字为数字时
						if(Top0.find('.')<0):	#也不是2023.09.01的手写日期格式		#20240605 #小柴胡汤 ‘ 汽油1’ ‘£比优特’
							if(Top0.find('年')>=0 or Top0.find('月')>=0 or Top0.find('日')>=0 or Top0.find('天')>=0 or Top0.find('周')>=0 or Top0.find('季')>=0):#1231 1月
								days=int(self.TimeLag(Top0)/86400)+1#1228
#								print("综合单项的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
								Toplist2.append(str(days))#202406212
								Toplist2.append('0')
								Mitem = 2#指令格式纯文单词转化为二词
						elif(self.IsNumber(Top0)):#1229如果是手写日期格式，如2023.09.01时#20240630
							n1=Top0.find('.')
							vn1=int(Top0[:n1])
							upyear = time.localtime(time.time()).tm_year
#							print("编辑框为(",vn1,")年，今年是(",upyear,")年")
							if(vn1>=1970 and vn1 <= int(upyear)):#以年份数字介于1970～今年判断是简化时间表达式XXXX.XX.XX
								newtime = time.mktime(time.strptime(Toplist[0],"%Y.%m.%d"))
#								print("CalcuAccount转化为统计起点时间值：",newtime)
#							elif(vn1>1):#20240608
#								print("查询时间应在1970年后")
#								self.ui.textEdit_2.setText("查询时间应在1970年后")
						days=int((nextime-newtime)/86400)+1#20240511统计时间 +1
						Toplist2.append(str(days))#202406212
						Toplist2.append(str(days))#202406212
						Mitem = 2#指令格式纯文单词转化为二词
					Toplist=Toplist2
#				print("CalcuAccount统计时间值从(",newtime,")到(",nextime,")Toplist",Toplist)#20240608
			#	print("1-Nitem > 1,Toplist",Toplist)#20240608
				if(Mitem>0):#202406212统计判断
					ConP=True
			if(Nitem > 1):#判断顶行是多词时 10 苹果 荔枝  
				print("\t指令格式为多词")
				print("1-Nitem > 1,Toplist:",Toplist,"\nToplist2:")#20240608 '0 30 汽油'＊＊＊
				Top1 = Toplist[1]
				if(Top0.isdigit()):#20240607,8当只有一项正整数时，假定第二项指令数字同首项#20240511Toplist[0] '0 10'
					ConP=True#20230908统计判断
					if(Top0!='0'):#首词不为0，表示具体之前天数
						Toplist2.append(Top0)#20240608
						days=int(Top0)#202406212
					else:#首词为0时
						days=round((nextime-newtime)/86400)+1#1222math.ceil#int 86400,0
						print("当首项为数字时，统计时间值始于(",newtime,")")
						Toplist2.append(str(days))
					if(not Top1[0].isdigit() ):#判断为关键字。次词首字非数字，表示一定非日期，如 ‘0 汽油1’
						print("\t指令格式次词首字不为数字")
						KeyWdP = True#20240622有关键词查询
						Toplist2.append(str(days))#202406212关键词时次词应同首词时间量
#						print("\t\t查询顶行首词为数，命令项数(",Nitem,"),多于一，且第二项首字非数字，表示是关键字")
						if(Top1[0]=='£' or Top1[0]=='#'):#20240120#20240614 or Top1[0]=='#'
							BoundP = True
							Top1=Top1[1:]
							print("\t\t查询顶行第二项去除整体查询符#后为[",Top1,"]")
						if(Top0[0].isdigit()):#202503307
							Toplist2.append(Top1)#20240607
							lt = len(Toplist)#20250308
							if(lt>1):
								for itop in range(2,lt):
									Toplist2.append(Toplist[itop])
								
						print("\t关键词展开前为[",Toplist2,"]")
						Toplist1 = self.TopPlus(Toplist2)#20240607(Toplist)
						Mitem=len(Toplist1)
						Nb= 2 #20240607 1
						print("\t\t查询顶行项数(",Mitem,")Toplist1:",Toplist1)
						Toplist = Toplist2#202406212
					else:#第二项首字是数字时，表示（一）统计天数#20240612 或（二）数量，或（三）绝对时间'0 10'
						print("\t指令格式次词首字为数字")
						if(Top1=='0'):#20240121（一）统计天数
							timelag = nextime-newtime
							nextime = foretime + timelag #20240603
							Toplist2.append(str(days))#202406212 0 表示次词，为同首词的时间量
						else:#202406012(Top1.isdigit()):
							if(Top1.isdigit()):#2042406212'0 10'
								days=int(Top1)
								nextime = foretime + 86400*days
							elif(self.IsNumber(Top1) and Top1.find('.')>=0 ):#20240612如果是实数，表示（三）绝对时间格式
								n1=Top1.find('.')
								vn1=int(Top1[:n1])
								upyear = time.localtime(time.time()).tm_year
#								print("编辑框为(",vn1,")年，今年是(",upyear,")年")
								if(vn1>=1970 and vn1 <= int(upyear)):#以年份数字介于1970～今年判断是简化时间表达式XXXX.XX.XX
									nextime = time.mktime(time.strptime(Top1,"%Y.%m.%d"))+86399
#									print("CalcuAccount转化为统计终点时间值：",nextime)
#								elif(vn1>1):#20240608
#									print("查询时间应在1970年后")
#									self.ui.textEdit_2.setText("查询时间应在1970年后")
							else:#20240612非实数时，表示（二）数量
								timelag = self.TimeLag(Top1)
								#print("\t查询时长(",Top1,")天")
								strn=Top0.find('年')#20240601计算纪录起点与查询起点时差
								if(strn>=0):#发现有关键字‘年’
									numyear=self.GetHindNum(mystr1[0:strn])
					
									newtime1 = nextime - int(numyear)*daytime*363+1#0123 +1
									newgtime = time.gmtime(newtime1)
#									print("\t查询‘年’对应的号数为：",newgtime.tm_mday,end="")
									dlta1=newgtime.tm_mday-gtime.tm_mday
									while(newgtime.tm_mday != gtime.tm_mday):#1231 >
										newtime1 -= daytime
										newgtime = time.gmtime(newtime1)
#										print("\t匹配‘年’对应的号数：",newgtime.tm_mday,end="")
										dlta2=newgtime.tm_mday-gtime.tm_mday
										if(dlta2-dlta1>0):
											break
									newtime1 -= daytime#20240601
#									print("\t统计模块设定统计开始时间值(",newtime1,")，纪录开始时间值(",foretime,")，",end = "")
									timelag = timelag-foretime+newtime1
#								print("\t次词查询时长(",Top1,")天，统计时长(",timelag/86400,")天")
								nextime = foretime + timelag #20240603
								if(Top1.find('.')<0):	#如果第二词，不是手写日期格式，如2023.09.01，推测为数量	
									if(Top1.find('年')>=0 or Top1.find('月')>=0 or Top1.find('日')>=0 or Top1.find('天')>=0 or Top1.find('周')>=0 or Top1.find('季')>=0):#1231 1月		
										days=int(self.TimeLag(Top1)/86400)+1#1228
#										print("次词的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
									else:
										days=int((nextime-newtime)/86400)+1
#										print("次词的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
								else:#当为2023.09.01的手写日期格式时
									days=int((nextime-foretime)/86400)#20240511统计时间 +1
#									print("CalcuAccount统计时间值从(",foretime,")到(",nextime,")共(",days,")天")
							Toplist2.append(str(days))#20240622缩进一档 0 表示次词，为同首词的时间量
						Nb=2
#						print("查询顶行命令不少于二词，起点时间值为[",foretime,"]，->统计终点时间值为[",nextime,"]")
#						print("2-Nitem > 1,Toplist:",Toplist,",Toplist2:",Toplist2)#20240608
						if(Nitem > 2):#项数三项及以上，三项及以后为关键字
							#29249717下面退一档if(not Toplist[2][0].isdigit() ):#第三词首字非数字，表示是关键词‘2023.11.1 2024.4.1 汽油’ ‘苹果 梨 荔枝’
							KeyWdP = True#20240622
#							print("\t\t查询顶行项数(",Nitem,"),多于二",Toplist)#20240608，且第三项首字非数字：
							if(Toplist[2][0]=='£' or Toplist[2][0]=='#'):#20240120#20240614or Toplist[2][0]=='#'
								BoundP = True
								Top2=Toplist[2][1:]#202406212
								Toplist2.append(Top2)#202406212
								print("\t\t查询关键词首字为'£'或'#'符,顶行第三项去除符后为表{",Toplist2,"}")
								if(len(Toplist)>3):#20250309
									Toplist2.extend(Toplist[3:])#20250309
							else:
								Toplist2.extend(Toplist[2:])#20240621#20250309
#								Toplist2.append(Toplist[2])#20240621
								print("\t\t查询关键词首字非'£'或'#'符时,追加顶行第三项成为表{",Toplist2,"}")
							Toplist1 = self.TopPlus(Toplist2)# 10 水果 10 中药
							if(len(Toplist1)>0):#多文词时，作为关键词追加
								if(not Toplist1[0][0].isdigit()): 
									Toplist1.extend(Toplist[1:])
								elif(not Toplist1[1][0].isdigit()):
									Toplist1.extend(Toplist[2:])
							Mitem=len(Toplist1)
#							print("\t\t查询顶行项数(",Mitem,")",Toplist1)
							Toplist = Toplist1#202406212
#							print("3-Nitem > 2,Toplist:",Toplist)#20240608
				else:#1221当首项非正整数时 '60日 10 汽油' ‘60日 汽油7’‘2023.11.1 2024.4.1 汽油’ '60日 汽油' ‘苹果 梨 荔枝’
					print("\t\t\t当查询首项不是正整数时，可能是类似‘2025.03.29’的数字手写日期格式时")
					ConP=True
					if(Top0.find('.')>=0):	#202406212当为2023.09.01的手写日期格式时‘2023.11.1 2024.4.1 汽油’
						if(self.IsNumber(Top0)):#1229如果是实数
							n1=Top0.find('.')
							vn1=int(Top0[:n1])
							upyear = time.localtime(time.time()).tm_year
							print("查询首项关键词为(",vn1,")年，今年是(",upyear,")年")
							if(vn1>=1970 and vn1 <= int(upyear)):#以年份数字介于1970～今年判断是简化时间表达式XXXX.XX.XX
								newtime = time.mktime(time.strptime(Toplist[0],"%Y.%m.%d"))
								print("CalcuAccount转化为统计起点时间值：",newtime)
#							elif(vn1>1):#20240608
#								print("查询时间应在1970年后")
#								self.ui.textEdit_2.setText("查询时间应在1970年后")
						days=int((nextime-newtime)/86400)+1#20240511统计时间 +1
						print("CalcuAccount统计时间值从 ",newtime," 到 ",nextime)
						Toplist2.append(str(days))#202406212
					else:#202406212if(Top0.find('.')<0):	#也不是2023.09.01的手写日期格式		#20240605 #小柴胡汤 ‘ 汽油1’#20240608 '60日 汽油' '(60日) 10 汽油' ‘60日 汽油7’
						#‘苹果 梨 荔枝’
						if(Top0.find('年')>=0 or Top0.find('月')>=0 or Top0.find('日')>=0 or Top0.find('天')>=0 or Top0.find('周')>=0 or Top0.find('季')>=0):#1231 1月
							timelag=self.TimeLag(Top0)#20240622
							days=int(timelag/86400)+1#1228
							newtime =  nextime-timelag#20240622
#							print("首词非数字的查询中，首项的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
							Toplist2.append(str(days))#202406212
						else:# #小柴胡汤 ‘ 汽油1’ ‘苹果 梨 荔枝’
							KeyWdP = True#20240622
							days=int((nextime-newtime)/86400)+1#1222math.ceil
							print("文字首项的统计时间值从(",newtime,")到(",nextime,")共(",days,")天")
							Toplist2.append(str(days))#202406212
							Toplist2.append(str(days))#202406212
							Toplist2.extend(Toplist)#202406212
							Mitem = len(Toplist2)
							print("3A-Nitem > 1,(",Mitem,")项Toplist2:",Toplist2)#202406222
					if(not Top1[0].isdigit() ):#判断为关键字。第二项首字非数字，表示一定非日期，如 ‘0 汽油1’ ‘60日 汽油7’
						KeyWdP = True#20240622
						if(Top0[0].isdigit()):#202406222
							Toplist2.append(str(days))#202406212
							print("\t\t查询顶行首词非数字，命令项数(",Nitem,"),多于一，且第二项首字非数字，表示是关键字")
#						if(Top1[0]=='£' or Top1[0]=='#'):#20240120#20240614 or Top1[0]=='#'
#							BoundP = True
#							Top1=Top1[1:]
#							print("\t\t查询顶行首词手写日期格式，第二项去除整体查询符#后为[",Top1,"]")
#							if(Top0[0].isdigit()):
#								Toplist2.append(Top1)#202406212
#						else:
#							if(Top0[0].isdigit()):#202406222
#								Toplist2.append(Toplist[1])#202406212

						if(Top1[0]=='£' or Top1[0]=='#'):#202503292
							BoundP = True
							Top1=Top1[1:]
							print("\t\t查询顶行首词手写日期格式，第二项去除整体查询符#后为[",Top1,"]")
						if(Top0[0].isdigit()):#202503306
							Toplist2.append(Top1)
							lt = len(Toplist)
							if(lt>1):
								for itop in range(2,lt):
									Toplist2.append(Toplist[itop])
								
						print("3B-Nitem > 1,关键词展开前Toplist2:",Toplist2)
						Toplist1 = self.TopPlus(Toplist2)#20240607(Toplist)
						Mitem=len(Toplist1)
						Nb= 2 #20240607 1
						print("\t\t3B-Nitem > 2查询顶行项数(",Mitem,")Toplist1:",Toplist1)
					else:#第二项首字是数字时，表示是统计天数#202406212 或数量'60日 (10) 汽油'‘2023.11.1 2024.4.1 汽油’
						if(Top1=='0'):#20240121
							timelag = int(self.TimeLag(Top0))+86399#nextime-newtime
							nextime = foretime + timelag 
						else:#202406012(Top1[0].isdigit()):次词首字为数字，'60日 (10) 汽油'
							if(self.IsNumber(Top1)):#20240612如果是实数
								if(Top1.find('.')>=0 ):#202406212如果有'.'表示绝对时间格式‘2023.11.1 2024.4.1 汽油’
									n1=Top1.find('.')
									vn1=int(Top1[:n1])
									upyear = time.localtime(time.time()).tm_year
#									print("编辑框为(",vn1,")年，今年是(",upyear,")年")
									if(vn1>=1970 and vn1 <= int(upyear)):#以年份数字介于1970～今年判断是简化时间表达式XXXX.XX.XX
										nextime = time.mktime(time.strptime(Top1,"%Y.%m.%d"))+86399
#										print("CalcuAccount转化为统计终点时间值：",nextime)
#									elif(vn1>1):#20240608
#										print("查询时间应在1970年后")
#										self.ui.textEdit_2.setText("查询时间应在1970年后")
									days = int((nextime-newtime)/86400)+1
								else:#202406212表示数字
									nextime= foretime + int(Top1)*86400
									days = int(Top1)
							else:#20240612非实数时，表示数量
								timelag = self.TimeLag(Top1)
								#print("\t查询时长(",Top1,")天")
								strn=Top0.find('年')#20240601计算纪录起点与查询起点时差
								if(strn>=0):#发现有关键字‘年’
									numyear=self.GetHindNum(mystr1[0:strn])
					
									newtime1 = nextime - int(numyear)*daytime*363+1#0123 +1
									newgtime = time.gmtime(newtime1)
#									print("\t查询‘年’对应的号数为：",newgtime.tm_mday,end="")
									dlta1=newgtime.tm_mday-gtime.tm_mday
									while(newgtime.tm_mday != gtime.tm_mday):#1231 >
										newtime1 -= daytime
										newgtime = time.gmtime(newtime1)
#										print("\t匹配‘年’对应的号数：",newgtime.tm_mday,end="")
										dlta2=newgtime.tm_mday-gtime.tm_mday
										if(dlta2-dlta1>0):
											break
									newtime1 -= daytime#20240601
#									print("\t统计模块设定统计开始时间值(",newtime1,")，纪录开始时间值(",foretime,")，",end = "")
									timelag = timelag-foretime+newtime1
#								print("\t查询时长(",Top1,")天，统计时长(",timelag/86400,")天")
								nextime = foretime + timelag #20240603
							Toplist2.append(str(days))#202406212
#							print("－2-Nitem > 1,Toplist:",Toplist,",Toplist2:",Toplist2)#20240608
							if(Nitem > 2):#项数三项及以上，三项及之后为关键字
								#202407172下退一档f(not Toplist[2][0].isdigit() ):#第三词首字非数字，表示是关键词‘2023.11.1 2024.4.1 汽油’
								KeyWdP = True#20240622
#								print("\t\t查询顶行项数(",Nitem,"),多于二：",Toplist)#20240608且第三项首字非数字，
								if(Toplist[2][0]=='£' or Toplist[2][0]=='#'):#20240120#20240614or Toplist[2][0]=='#'
									BoundP = True
									Top2=Toplist[2][1:]#202406212
									Toplist2.append(Top2)#202406212
									print("\t\t查询关键词首字为'£'或'#'符,顶行第三项去除符后为表{",Toplist2,"}")
									if(len(Toplist)>3):#20250309
										Toplist2.extend(Toplist[3:])#20240621＃20250309append(Toplist[2])
								else:
									Toplist2.extend(Toplist[2:])#20240621#20250309append(Toplist[2])
#									print("\t\t查询关键词首字非'£'或'#'符时,追加顶行第三项成为表{",Toplist2,"}")
								Toplist1 = self.TopPlus(Toplist2)# 10 水果 10 中药
								if(len(Toplist1)>0):#多文词时，作为关键词追加
									if(not Toplist1[0][0].isdigit()): 
										Toplist1.extend(Toplist[1:])
									elif(not Toplist1[1][0].isdigit()):
										Toplist1.extend(Toplist[2:])
								Mitem=len(Toplist1)
								print("\t\t查询顶行项数(",Mitem,")",Toplist1)
								Toplist = Toplist1#202406212
								print("－3-Nitem > 1,Toplist:",Toplist)#20240608
						Nb=2
						print("查询顶行命令不少于二词，统计起点时间值为[",foretime,"]，->统计终点时间值为[",nextime,"]")
#					if(len(Toplist)<3):#202407172#202503292下行减一档
					Toplist = Toplist2
					print("4-Nitem > 1,Toplist:",Toplist)#20240608
		Mitem	=len(Toplist)		
		Toplist2 = []#202503092
		for j in range (Mitem):#扫描关键字项，确定是否有含有‘；’
			if(Toplist[j].find('；')>0):#202503092
				Tsl = Toplist[j].split('；')
				Toplist2.append(Tsl)
			else:
				Toplist2.append(Toplist[j])
		Toplist = Toplist2
		print("\n5-Nitem > 1,关键字共(",Mitem,")项，Toplist各表项:",Toplist)#20240608

		Boundmax = 2#round((Nitem-2)/2) #20240607
		RecordB = 0#202406223纪录开始行初值
		RecordE = nsl#202406223纪录结束行初值为最大行数
		Nrcd = 0#202406212选中纪录的编号初值
		KeypmP = False #20240623品名关键字判断
		pricemax = 0.00 #20240623最大单价、平均单价、最小单价
		pricelev = 0.00
		pricemin = 0.00
		Nprice = 0
#		if(Mitem==3):#20240623当查询列表只有三项时，表示只有品名关键字查询20250305
#			KeypmP = True 
		CommentLock = False#20240731时间戳后是否有备注判断，如果发现就锁定
		CommentP = False#20240731时间戳后是否有备注关键字判断
		Comment2P = False#202408023时间戳后是否有第二项
		Tmax = str0#20240731
		Tmin = str0#20240731
		#20250305如果查询关键词第三项是'＋'数字或'－'数字时，尝试统计不小于或不大于该数值的单项
		VcompareP = False#20250305数值比较判断
		VGEP = False#世家值大于等于查询值
		VBTP = False#202503082世家值小于等于查询值VLEP
		BoundV = False#202503083
		TopV2 = 0.0
		Sum = 0.0
		
		TopV1 = 0.0
		if(len(Toplist)>Nb):
			if(Toplist[Nb][0]=='-'):
				if(self.IsNumber(Toplist[Nb][1:])):
					VcompareP = True
#					VLEP = True#202503082
					TopV1 = round(float(Toplist[Nb][1:]),2)#第一项查询基准值
					print("\t\t\t查询第三项最大值为(",TopV1,")")
			elif(Toplist[Nb][0]=='+'):
				if(self.IsNumber(Toplist[Nb][1:])):
					VcompareP = True
					VGEP = True
					TopV1 = round(float(Toplist[Nb][1:]),2)
					print("\t\t\t查询第三项最小值为(",TopV1,")")
			if(len(Toplist)>Nb+1):#202503082
				if(Toplist[Nb+1][0]=='-'):
					if(self.IsNumber(Toplist[Nb+1][1:])):
						VcompareP = True
						VBTP = True#202503293区间值比较判断VLEP
						TopV2 = round(float(Toplist[Nb+1][1:]),2)#第二项查询基准值
						print("\t\t\t查询第四项最大值为(",TopV2,")")
					
		if(VcompareP):#202503302
			if BoundP:#202503083
				BoundV = True
			if(VBTP):#20250309
				if (Mitem>4):
					KeypmP = True
			else:
				if (Mitem>3):
					KeypmP = True
			
		print("\t\t\t查询项数转化为(",Mitem,")项；统计判断(",ConP,")；未小判断VGEP(",VGEP,")；区间值判断VBTP(",VBTP,")；\n\t\t\t数值判断VcompareP(",VcompareP,")整纪录判断BoundP(",BoundP,")；数值整纪录判断BoundV(",BoundV,")")#202503274

		if(ConP):
			loc = 0
			if(nsl>0):#如果存在世家记录
				RCalcuP = True#整条纪录统计标志#202407013
				for i in range (nsl):#遍历判断是否有符合备注搜索
					if(len(strlist[i])>0):#略过空项
						strls = strlist[i].split()#20240731转成表
						if(self.TimeP(strls[0])):#寻找判断表的首词符合本应用标准的时间格式
							if(KeyWdP):#20240731如果类关键字搜索
								if(not CommentLock):#备注还未锁定
									if(len(strls)>=2):#20240731当不少于两项时，才可能是时间戳与备注＃202503275	==2
										FT = -1#202503092
										for j1 in range (Nb,Mitem):#20240731扫描各项查询关键字，确定是否有含有备注关键字
											if(not isinstance(Toplist[j],list)):#202503092
												FT = strls[1].find(Toplist[j1])#寻找第二项是否包含关键词
#												print("\t\t扫描时间戳后备注FT=(",FT,")",end="")
												if(FT >= 0):
#													print("\t\t扫描查询关键字中发现备注[",Toplist[j1],"]锁定‘备注锁’")#202406212Toplist1[j],end=""
													CommentLock = True
				if(not VcompareP):
					if(CommentLock):#202503032
						if(Mitem==4):#20250305其余当查询列表只有三项时，表示只有品名关键字查询
							KeypmP = True 	#单品名查询判断					
							print("\t\t\t不带数值带备注查询时，单品名编号判断KeypmP(",KeypmP,")")		
					else:
						if(Mitem==3):#20250305其余当查询列表只有三项时，表示只有品名关键字查询
							KeypmP = True 
							print("\t\t\t带数值不带备注查询时，单品名编号判断KeypmP(",KeypmP,")")		
					
				for i in range (nsl):#对各项进行统计或显示过程 
					SecP = False#20250305当遇到时间戳时，是否重复统计判断，初始化
					BoundFP= False#20240605首字母关键字‘#’绑定下，次位关键字命中判断，用于“地点分店+名称+价格+数量”格式统计满足首字查询
					BoundM= False#20240605首字母关键字‘#’绑定下，多重关键字命中判断，用于中药查询时有两项以上命中时假定为匹配
					Commentstr = ""#20240801用于忽略备注关键字搜索结果
#					print("\t\t第(",i,")行[",strlist[i],"]")
					if(not AccBeginP and len(strlist[i])>0):#寻找统计开始时间
						strls = strlist[i].split()#20240731分割字串成表
						if(self.TimeP(strls[0])):#20240729 strlist[i]
#							print("\t\t发现时间格式行[",strlist[i],"]，",end="")
							timet=time.mktime(time.strptime(strls[0],"%Y年%m月%d日%H时%M分%S秒"))#20240731strlist[i].split()[0]
							if(timet >= foretime):
								if ((not KeypmP) and (not KeyWdP)):#20240623if not KeypmP:
									Nrcd +=1 #202406212
									Tmax = strls[0]#20240731strlist[i]#20240715
									Tmin = strls[0]#20240731strlist[i]#20240715
#								print("("+str(Nrcd)+") "+strlist[i])#202406223遍历统计点之后的时间格式行
#								print("当前记录时间[",timet,"]，进入统计开始时间[",foretime,"]")
#								print("\t\t遍历统计点后时间格式行[",strlist[i],"]，",end="")
								Timenx = strls[0]#20240731strlist[i]#202407182前移2行
								stritt = strlist[i]#20240801记录时间戳行备用
								if(Brch==1):
									if(not KeyWdP):
										loclist.append(strlist[i])
								AccBeginP = True#判断统计开始
							#else:#0927
							#	print("\t\t本段时间在统计点之前，故予忽略",timet)
					elif(AccBeginP and len(strlist[i])>0):#确定统计开始后进行累加#20240729else:
						strls = strlist[i].split()#20240731
						if(self.TimeP(strls[0])):#寻找本应用标准的时间格式行
#							SecP = False#20250305当遇到时间戳时，是否重复统计判断，初始化
							loc = 0
							if(len(strls)>=2):#202408023当只有时间戳与备注时＃202503275	==2
#								print("\t\t扫描时间行发现二词及以上，即有备注项")#202406212Toplist1[j]
								Comment2P = True#202408023
							else:#202408023
#								print("\t\t扫描时间行发现不是二词，假定为无备注项（如果有扩展三项需要可修改）")#202406212Toplist1[j]
								Comment2P = False
							#20240731if ((not KeypmP) and (not KeyWdP)):#20240623如果不是品名关键字，也非类关键字搜索
							if(KeyWdP):#20240731如果类关键字搜索
								if(len(strls)==2):#20240731当只有时间戳与备注时
									FT = -1#202503092
									for j1 in range (Nb,Mitem):#20240731扫描查询关键字项，确定是否有含有备注关键字
										if(not isinstance(Toplist[j],list)):#202503092
											FT = strls[1].find(Toplist[j1])
#											print("\t\t扫描时间戳后备注FT=(",FT,")",end="")
											if(FT >= 0):
#												print("\t\t扫描发现备注[",Toplist[j1],"]",end="")#202406212Toplist1[j]
												CommentP = True
												Commentstr = Toplist[j1]
									
							else:
								Nrcd +=1 #202406212品名搜索时，说明本记录符合要求，计数增一
#								print("普查("+str(Nrcd)+") "+strlist[i])#202406223遍历统计点之后的时间格式行
							timet=time.mktime(time.strptime(strls[0],"%Y年%m月%d日%H时%M分%S秒"))#20240731strlist[i].split()[0]
							if(timet > nextime):
								AccBeginP = False
#								print("时间超过统计终点时间[",nextime,"]，统计中止")
								break
							Timenx = strls[0]#20240731strlist[i]#202407182前移2行
							stritt = strlist[i]#20240801记录时间戳行备用
							RecordB = i+1#202406223本纪录原始始行初值
							RecordE = i+1#202406223本纪录原始末行初值
#							print("\t\t纪录[",Timenx,"]从(",RecordB,")行开始",end="")
							#print("\t行序号最大为(",nsl-1,")：",end="")#nsl=1717
							i2=i+1#202407013
							RCalcuP = True#整条纪录全部统计计算判断标志
							if(i2<nsl-1):
								if(len(strlist[i2])>0):
									if(strlist[i2][0]=='*'):
										RCalcuP = False#对‘*’开头的纪录，本纪录各行都不用统计，统计标志关闭
								for i2 in range(i+1,nsl):
							#		print("\t\t(",i2,")行",end="")
									if(len(strlist[i2])>0):
										if(self.TimeP(strlist[i2].split()[0])):#20240731strlist[i2] #20240803 strlist[i2][0]=='=' or 
											RecordE = i2-1#原始记录末行号20240804 -1
											break
							if(i2==nsl-1):
								RecordE = i2 
#								print("\n\t扫描行i2=(",i2,")到最后纪录行时nsl-1=(",nsl-1,")，设定为本纪录原始内容末行号")
#							print("\t\t到末(",RecordE,")行结束")
						if(len(strlist[i])==0):#20240624跳过空行
							continue
						if(strlist[i].find('=')>=0):#查找等号‘=’行，标记等号行序号
							loc +=1
						if(loc==0):
							OnlyP = True#每行单项纪录判断
							if(len(strlist[i].split())>1):
								OnlyP = False
								#print("\t\t\tloc=",loc,"[",strlist[i],"]行为空格分割的多项式")
						#202406223print("\t\t\t[",strlist[i],"]等号出现第(",loc,")次，本行‘单项式行’判断OnlyP：",OnlyP,"；‘存在关键词’判断KeyWdP：",KeyWdP)	
						#202407013print("\t纪录计算标志(",RCalcuP,")当前行i=(",i,")还不到最大行号nsl-1=(",nsl-1,")时，往后扫描……")
						if ((not CommentLock) and KeyWdP) or (KeyWdP and CommentLock and CommentP ):
						#如果类名查询时没有备注，或者类名查询时有备注且已锁定，对于多项纪录，搜索其子项，即第一等号后的关键字及数值，进行累加
						
							print("\t\t\t当类名查询时没有备注，或者类名查询时有备注且已锁定")#判断进入多项筛选分支
							if(loc == 0 and (not VcompareP)):#原始记录行#202503082当数值比较时略过原始记录行
#							if(loc == 0):#原始记录行
								print("\t\t\t\t进入loc==0原始记录，且没有数值比较分支")#202503292判断进入多项筛选分支

								FoundP=False#1229发现关键词初值
								Bound=0#0120符合关键词计数初值
								strt = ""
								print("\t\t\t\t[",strlist[i],"]行扫描(",Nb,")到(",Mitem-1,")项关键词或数值判断",Toplist[2:])#202406212Toplist1[j]
								FT = -1
								for j in range (Nb,Mitem):#初次扫描查询关键字项，确定是否有含有查询关键字
									if(len(Commentstr)>0):#有备注字串
										if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
											continue
									if(not isinstance(Toplist[j],list)):#202503092如果关键字不是表
									
										FT = strlist[i].find(Toplist[j])#202503275	Toplist[j].
									else:
										lt = len(Toplist[j])
										acci = 0
										for it in range(lt):
											if(strlist[i].find(Toplist[j][it])>=0):
												acci +=1
										if(lt == acci):
											FT = 3
										
								#	print("\t\t扫描FT=(",FT,")",end="")
									if(FT >= 0):#20240416 strlist[i].find(Toplist1[j]#20240610 and strlist[i][0]!= '*'
										print("\t\t扫描发现关键字[",Toplist[j],"]",end="")#202406212Toplist1[j]
										FoundP = True
										if BoundP:#20240416
											if(FT==0):#20240416如果首位发现关键词
												BoundFP = True#20240416
#												print("\t\t\t确定为#绑定，纪录以关键字开头")
											
										
								if FoundP:#对扫描确认，再进行精细统计
								#	if (not BoundP) or (BoundP and Bound >1):#0121 
									Sonlist = strlist[i].split()
									ls=len(Sonlist)
									FMItemP=False#20240606确认发现关键词判断
#									print("\n\t‘=’前(",i,")行各词遍历，",end="")
									for k in range(ls):#遍历纪录首行各词
										ExactP = False#20240715精准关键字判断，之后为词尾或实数时为真
										lSk = len(Sonlist[k])
		
#										print("\t第(",k,")词[",Sonlist[k],"]词长(",lSk,")，",end="")
										nSf = -1#202503092
										for j in range (Nb,Mitem):
											if(not isinstance(Toplist[j],list)):#202503092
												nSf = Sonlist[k].find(Toplist[j])
											else:#202503092
												lt = len(Toplist[j])
												acci = 0
												for it in range(lt):
													if(Sonlist[k].find(Toplist[j][it])>=0):
														acci +=1
												if(lt == acci):
													nSf = 3
																		
											if(nSf >=0):#本项扫描各关键字，确认存在时#202406212Toplist1[j]
												if(mystr1[-1]==' '):#20240715当查询关键字末尾为空格时，进行精准判断
													lTj=len(Toplist[j])
#													print("\t\t(",nSf,")位发现关键词[",Toplist[j],"]，词长(",lTj,")",end="")
													if(lSk==nSf+lTj):#到达词末，符合判断条件
#														print("\t\t词长(",lSk,")等于发现位置(",nSf,")+关键词长(",lTj,")精准判断：",ExactP,end="")
														ExactP = True
													elif (self.IsNumber(Sonlist[k][nSf+lTj])):#之后为数字也符合判断条件
														ExactP = True
#														print("\t\t发现位置(",nSf,")+关键词长(",lTj,")=(",nSf+lTj,")位，为数字，精准判断：",ExactP,end="")
														
												if(((mystr1[-1]==' ') and ExactP) or (mystr1[-1]!=' ')):#20240715下整体后退一档 (and (not ExactP))#豌豆 
													if(KeypmP):#品名判断时
														pricestr=self.GetHindPrice(Sonlist[k])#20240623
										#				print("\t\t提取价格数串为[",pricestr,"]")
														if(pricestr!="0"):#20240728(self.IsNumber(pricestr)):#菇莨 
															
															Nprice += 1
															if(pricemin<=0.01):#20240728 0.0
																pricemin = round(float(pricestr),2)
																Tmin = Timenx#20240715
															if(float(pricestr)>0.01):	#20240728 0.0
																if(float(pricestr)>pricemax):
																	pricemax = round(float(pricestr),2)
																	Tmax = Timenx#20240715
																elif(float(pricestr)<pricemin):
																	pricemin = round(float(pricestr),2)
																	Tmin = Timenx#20240715
																pricelev += float(pricestr)
														print("\t\t最大价格(",pricemax,")，最小价格(",pricemin,")，第(",Nprice,")次物价累计(",round(pricelev,2),")")
													FMItemP=True
													strt += Sonlist[k]+' '#将关键字所在词，组合成字串
													Bound += 1#20240605发现关键词计次
#													print("总共第(",Bound,")次发现关键字为[",Toplist[j],"]")#202406212Toplist1[j]
													if BoundP:#当绑定查询时
														if(Mitem>3):#20240605对于归类集合查询 #小柴胡汤 #小柴胡汤□
															if(Bound>=Boundmax):#0120如果二个以上含有绑定关键词 >=2#20240606设定数
																BoundM = True#20240416识别为‘绑定锁定行’判断
#																print("\t\t\t确定为#绑定，纪录含有二项以上查询关键字")
														else:#20240605对于单项查询
															if(Bound>0):#如果含有绑定关键词
																BoundM = True#20240416识别为‘绑定锁定行’判断  #柴胡  #比优特
#																print("\t\t\t确定为#绑定，纪录只含一项查询关键字")
														break
													else:#20240606非绑定查询
														if(Mitem>3):#20240606对于集合查询 小柴胡汤
															if(Bound>=Boundmax):#20240606如果发现关键词数，如果二个以上
																BoundM = True
#																print("\t\t\t非#绑定归类查询，纪录含有2项以上查询关键字，判断输出")
														else:#20240605对于单项查询 柴胡
															if(Bound>0):#如果含有绑定关键词
																BoundM = True#20240416如果发现关键词 
#																print("\t\t\t非#绑定品名查询，纪录只含1项查询关键字，判断为输出")
														break
									#if(Brch == 1 ):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作过程 #20240731
									if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作过程 #20240801 and CommentLock
										if ((FMItemP and (not BoundP)) or ((BoundM or BoundFP) and BoundP and FMItemP)):#20240609
											Nrcd +=1#20240623选中纪录计数
											loclist.append("("+str(Nrcd)+') '+stritt)#20240801记录时间戳行Timenx
											print("\n("+str(Nrcd)+') '+stritt)#20240801
											
											if(BoundP):#20240120
												#202406223loclist.append(strlist[i])
#												print("\n\t\t\t绑定查询时，输出整条纪录从(",RecordB,")行到(",RecordE,")行")#strlist[i],"]")
												for i2 in range(RecordB,RecordE):
													loclist.append(strlist[i2])
													print("\t\t\t",strlist[i2])
												print("\n")
											else:
												loclist.append(strt)#非绑定查询时，仅输出关键字子项
#												print("\n\t\t\t非绑定查询时，仅输出含查询关键字的词[",strt,"]")
#									print("(",i,")行非纯记事纪录，故整条纪录计算标志(",RCalcuP,")")#202407013
									if(not isinstance(Toplist[-1],list)):#202503092
										if(self.HvNumber(Toplist[-1].strip()) and (RCalcuP)):#1227含数字的关键字搜索时#202407013增加纪录计算标志
											#202407172if(BoundM  or BoundFP):#20240416如果是多项命中或首字命中
											if(BoundFP):#20240416如果是多项命中或首字命中#202407172
												for k in range(ls):
													sumstr=(self.strcacu(Sonlist[k],pricefmt)).strip()#20240416 小数位2，定义为变量,整行累计
													sumnum=self.GetHindNum(sumstr)
													print("\t\t(",k,")[",Sonlist[k],"]词值",sumnum,end="")
													Sum += float(sumnum)#strlist[i][1:])
												print("\n")
											elif BoundM:#202407172
												strtl = strt.split()#20240718
												sumstrt = ""
												lst = len(strtl)
												for l in range(lst):
													sumstr=(self.strcacu(strtl[l],pricefmt)).strip()#20240416 小数位2，定义为变量,整行累计	
													sumstrt += " "+sumstr
													sumnum=self.GetHindNum(sumstr)
													print("\t\t(",l,")项[",strtl[l],"]词值(",sumnum,")",end="")
													Sum += float(sumnum)#strlist[i][1:])
												sumstr = sumstrt
												print("\n")
											
											else:
												sumstr=(self.strcacu(strt,pricefmt)).strip()#20240416 小数位2，定义为变量
												sumnum=self.GetHindNum(sumstr)
							#					print("\t\t帐目首行，检测到查询命令末词有数字，且单项纪录:[",strt,"]=",sumstr,"(",sumnum,")")#1226
												Sum += float(sumnum)#strlist[i][1:])
											if(math.fabs(Sum)>0.1):#202407013
												print("\t\t笈智小计1： ",str(round(Sum,2)))
												loclist.append("="+sumstr)
												if(not mystr1[-1]==' '):#20240607#20240127mystr1[0]==' '
													loclist.append("\t笈智累计："+str(round(Sum,2)))
										#	loclist.append("\t笈智累计："+str(round(Sum,2)))#20240127
											SecP = True#20240114一次统计标记
							#				print("\tSecP1为",SecP,end="")#20240114
										#20240718print("\t\t笈智小计1： ",str(round(Sum,2)))
																
							if(loc == 1):#第一个等号行
								print("\t\t\t\t进入loc==1第一个等号行[",strlist[i],"]")#202503292判断进入多项筛选分支
								FoundP=False
								Bound=0#0120发现两项以上关键词初值
								strt = "= "
								print("\t\t\t\t纪录[",strlist[i][:10],"……]扫描关键字或数值判断(",Nb,")项到(",Mitem-1,")项",Toplist[2:4],"……")#202406212Toplist1[j]
								FT = -1#202503092
								SFT = 0 #202503292统计发现关键词的次数，如果有力备注项，须>=2
								for j in range (Nb,Mitem):#初次扫描对内容行遍历，确定是否有符合关键字项

									if(not isinstance(Toplist[j],list)):#202503092如果关键字不是表
									
										FT = strlist[i].find(Toplist[j])#202503275Toplist[j].
										if(FT >= 0):#202503292
											SFT +=1
															
											print("\t\t\t\t\t\t关键字不是表，纪录扫描发现含关键字[",Toplist[j],"]",end="")
									else:
										lt = len(Toplist[j])
										acci = 0
										for it in range(lt):
											if(strlist[i].find(Toplist[j][it])>=0):
												acci +=1
										if(lt == acci):
#											FT = 3#202503292
											SFT +=1
																
#									FT = strlist[i].find(Toplist[j])#202503092
#									print("\t\t纪录正在扫描查询关键字[",Toplist[j],"]",end="")#202406212Toplist1[j]
									if(strlist[i][0]!= '*'):#202503292
										if(SFT > 0):#下增一档
										
#									if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
											print("\t\t\t\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
#									if(FT >= 0 and strlist[i][0]!= '*'):#20240416 strlist[i].find(Toplist1[j]#20240605and strlist[i][0]!= '*'
#										print("\t\t纪录[",strlist[i],"]在(",FT,")位发现关键字[",Toplist[j],"]",end="")#20240609#202406212Toplist1[j]
											FoundP = True
											if BoundP:#20240416
												if(FT<=2):#20240416如果首位发现关键词#20240609(FT==1):
													BoundFP = True#20240416纪录以关键字开头判断
#													print("\t\t\t确定为#绑定，纪录以关键字开头")
										elif(j == Nb):#20250305#202503082 or j== Nb+1
#											print("\t\t等号行扫描查询关键字首词")
											if (VcompareP):
											#20250305如果第三项是'＋'数字或'－'数字时，尝试统计不小于或不大于该数值的单项
												FoundP = True
#												print("\t\t\t等号行扫描发现数值比较关键字值(",TopV1,")设定关键词判断：",FoundP)
												if BoundP:
													BoundV = True#202503083
#													print("\t\t\t\t确定为#绑定，以整条纪录为统计对象")
												break#202503082发现数值比较时中止循环
											
								if FoundP:#对扫描确认，再进行精细统计
									Xji = 0.0#小计
									Sonlist = strlist[i].split()
									ls=len(Sonlist)
									FMItemP=False#20240606
									
									if(BoundV):#202503083对于整条纪录的金额查询
										print("\t\t\t等号行进入综合项，即最后等号右侧数值大小比较分支，不小于判断(",VGEP,")；不大于判断(",VBTP,")，本行词数(",ls,")")
										print("\n\t纪录次行，即‘=’行，整条纪录的金额查询时，检测最后等号行值，",end="")
										if(ls == 2):#如果总共2项，表示实际一项，因为有一项是‘=’
											RcP = False#20250309是否记录判断
											print("\t\t\t\t词数为2项，进入独项纪录查询")
											ft = float(self.GetHindNum(Sonlist[1]))
											if(VBTP):#如果纪录值位于区间查询值#202503082
#												print("\t\t\t\t\t(",TopV1,")<=(2)列数值(",ft,")<=查询数值(",TopV2,")?")
												if(ft >= TopV1 and ft <= TopV2):
													if (not KeypmP):#20250309不是品名查询
														RcP = True#判断为记录
													else:
														FT = -1#202503092
														SFT = 0 #202503292统计发现关键词的次数，如果有力备注项，须>=2
														for j in range (Nb+2,Mitem):#扫描是否有符合关键字项
															if(not isinstance(Toplist[j],list)):#202503092

																if(len(Commentstr)>0):#有备注字串
																	if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																		continue
																	else:
																		FT = strlist[i].find(Toplist[j])

																if(FT >= 0):#202503292
																	SFT +=1
																	if(FT >= 0):#202503292
																		SFT +=1
																		print("\t\t金额区间查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
																	
															else:#202503092
																lt = len(Toplist[j])
																acci = 0
																for it in range(lt):
																	if(strlist[i].find(Toplist[j][it])>=0):
																		acci +=1
																if(lt == acci):
#																	FT = 3#202503292
																	SFT +=1
																		
															if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																
																RcP = True
														
													if(RcP):
														Xji += ft
														Sum += ft
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关‘世家’列表操作即‘列传’#20240114
															if(VcompareP):#20250330金额查询多出前两行
																loclist.append(stritt)#Timenx时间戳行
																loclist.append(strlist[i-1])
																loclist.append(strlist[i])
											elif VGEP:#如果要求不小于查询数的纪录
												print("\t\t\t\t\t纪录数值(",ft,")>=查询数值(",TopV1,")?")
												if(ft >= TopV1):
													if (not KeypmP):#20250309
														RcP = True
													else:
														FT = -1#202503092
														SFT = 0 #202503292统计发现关键词的次数，如果有力备注项，须>=2
														for j in range (Nb+1,Mitem):#扫描是否有符合关键字项
															if(not isinstance(Toplist[j],list)):#202503092
																if(len(Commentstr)>0):#有备注字串
																	if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																		continue
																	else:
																		FT = strlist[i].find(Toplist[j])
																else:
																	FT = strlist[i].find(Toplist[j])
																	if(FT >= 0):#202503292
																		SFT +=1
																		print("\t\t金额‘不小于’查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
															else:#202503092
																lt = len(Toplist[j])
																acci = 0
																for it in range(lt):
																	if(strlist[i].find(Toplist[j][it])>=0):
																		acci +=1
																if(lt == acci):
#																	FT = 3#202503292
																	SFT +=1
																		
															if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																
																RcP = True
														
													if(RcP):
														Xji += ft
														Sum += ft
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
															if(VcompareP):#20250330金额查询多出前两行
																loclist.append(stritt)#Timenx时间戳行
																loclist.append(strlist[i-1])
																loclist.append(strlist[i])
											else:#如果要求不大于查询数的纪录
												print("\t\t\t\t\t纪录数值(",ft,")<=查询数值(",TopV1,")?")
												if(ft <= TopV1):
													if (Mitem <= Nb+1):#20250309
														RcP = True
													else:
														FT = -1#202503092
														SFT = 0 #202503292统计发现关键词的次数，如果有力备注项，须>=2
														for j in range (Nb+1,Mitem):#扫描是否有符合关键字项
															if(not isinstance(Toplist[j],list)):#202503092

																if(len(Commentstr)>0):#有备注字串
																	if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																		continue
																	else:
																		FT = strlist[i].find(Toplist[j])

																if(FT >= 0):#202503292
																	SFT +=1
																	if(FT >= 0):#202503292
																		SFT +=1
																		print("\t\t金额‘不大于’查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
																	

															else:#202503092
																lt = len(Toplist[j])
																acci = 0
																for it in range(lt):
																	if(strlist[i].find(Toplist[j][it])>=0):
																		acci +=1
																if(lt == acci):
#																	FT = 3#202503292
																	SFT +=1
																		
															if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																
																RcP = True
														
														
													if(RcP):
														Xji += ft
														Sum += ft
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
															if(VcompareP):#20250330金额查询多出前两行
																loclist.append(stritt)#Timenx时间戳行
																loclist.append(strlist[i-1])
																loclist.append(strlist[i])
											if(Brch == 1):
												if(Xji>0):#20240605
													loclist.append("\t 笈智小计："+str(round(Xji,2))+"  累计："+str(round(Sum,2)))#20240127退格一档
												
										elif(ls > 2):#如果总共超过2项，表示实际多项取第二个等号，即下一行等号后的数值
											RcP = False#20250309是否记录判断
											print("\t\t\t\t词数>2项，进入多词纪录")
											if(i+1 < nsl):#探测是否最后一行
												if(len(strlist[i+1].split())>1):#20250318
													ft = float(self.GetHindNum(strlist[i+1].split()[1]))
													if(VBTP):#如果纪录值位于区间查询值#202503082
#														print("\t\t\t\t\t(",TopV1,")<=纪录结果(",ft,")<=查询数值(",TopV2,")?")
														if(ft >= TopV1 and ft <= TopV2):
															if (Mitem <= Nb+2):#20250309
																RcP = True
															else:
																FT = -1#202503092
																SFT = 0 #202503292统计发现关键词的次数，有备注项时须>=2
																for j in range (Nb+2,Mitem):#扫描是否有符合关键字项
																	if(not isinstance(Toplist[j],list)):#202503092

																		if(len(Commentstr)>0):#有备注字串
																			if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																				continue
																			else:
																				FT = strlist[i].find(Toplist[j])

																		if(FT >= 0):#202503292
																			SFT +=1
																			if(FT >= 0):#202503292
																				SFT +=1
																				print("\t\t金额区间查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
																	

																	else:#202503092
																		lt = len(Toplist[j])
																		acci = 0
																		for it in range(lt):
																			if(strlist[i].find(Toplist[j][it])>=0):
																				acci +=1
																		if(lt == acci):
#																			FT = 3#202503292
																			SFT +=1
																		
																	if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																		print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																		if(CommentLock):#当不含备注时
																			if(SFT >1):
																				RcP = True
																		else:#下增一档
																
																			RcP = True
														
															if(RcP):
																Xji += ft
																Sum += ft
																if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																	if(VcompareP):#20250330金额查询多出前两行
																		loclist.append(stritt)#Timenx时间戳行
																		loclist.append(strlist[i-1])
																	loclist.append(strlist[i])
																	loclist.append(strlist[i+1])
													elif VGEP:#如果要求不小于查询数的纪录
#														print("\t\t\t\t\t纪录结果(",ft,")>=查询数值(",TopV1,")?")
														if(ft >= TopV1):
															if (Mitem <= Nb+1):#20250309not KeypmP
#																print("\t\t\t\t\t\t整条纪录查询中，关键字项数(",Mitem,")<=(",Nb+1,")项时，返回结果")
																RcP = True
															else:
#																print("\t\t\t\t\t\t整条纪录查询中，关键字项数(",Mitem,")>3项时，表示不仅有金额区间搜索，还需进一步查找文字关键字")
																FT = -1#202503092
																SFT = 0 #202503292统计发现关键词的次数，有备注项时须>=2
																for j in range (Nb+1,Mitem):#扫描是否有符合关键字项
																	if(not isinstance(Toplist[j],list)):#202503092

																		if(len(Commentstr)>0):#有备注字串
																			if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																				continue
																			else:
																				FT = strlist[i].find(Toplist[j])

																		if(FT >= 0):#202503292
																			SFT +=1
																			if(FT >= 0):#202503292
																				SFT +=1
																				print("\t\t‘不小于’查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
																	

																	else:#202503092
																		lt = len(Toplist[j])
																		acci = 0
																		for it in range(lt):
																			if(strlist[i].find(Toplist[j][it])>=0):
																				acci +=1
																		if(lt == acci):
#																			FT = 3#202503292
																			SFT +=1
																		
																	if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																		print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																		if(CommentLock):#当不含备注时
																			if(SFT >1):
																				RcP = True
																		else:#下增一档
																
																			RcP = True
														
															if(RcP):
																Xji += ft
																Sum += ft
																if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																	if(VcompareP):#20250330金额查询多出前两行
																		loclist.append(stritt)#Timenx时间戳行
																		loclist.append(strlist[i-1])
																	loclist.append(strlist[i])
																	loclist.append(strlist[i+1])
													else:#如果要求不大于查询数的纪录
#														print("\t\t\t\t\t纪录结果(",ft,")<=查询数值(",TopV1,")?")
														if(ft <= TopV1):
															if (not KeypmP):#20250309
																RcP = True
															else:
																FT = -1#202503092
																SFT = 0 #202503292统计发现关键词的次数，有备注项时须>=2
																for j in range (Nb+1,Mitem):#扫描是否有符合关键字项
																	if(not isinstance(Toplist[j],list)):#202503092

																		if(len(Commentstr)>0):#有备注字串
																			if(Toplist[j] == Commentstr):#20250305查询关键字恰为备注字串，略过
																				continue
																			else:
																				FT = strlist[i].find(Toplist[j])

																		if(FT >= 0):#202503292
																			SFT +=1
																			if(FT >= 0):#202503292
																				SFT +=1
																				print("\t\t‘不大于’查询中，纪录扫描发现含纪录关键字[",Toplist[j],"]",end="")
																	


																	else:#202503092
																		lt = len(Toplist[j])
																		acci = 0
																		for it in range(lt):
																			if(strlist[i].find(Toplist[j][it])>=0):
																				acci +=1
																		if(lt == acci):
#																			FT = 3#202503292
																			SFT +=1
																		
																	if(SFT > 0 and strlist[i][0]!= '*'):#202503292FT >= 0
																		print("\t\t纪录[",strlist[i],"](",SFT,")次发现符合关键字[",Toplist[j],"]",end="")
																
																		RcP = True
														
															
															if(RcP):
																Xji += ft
																Sum += ft
																if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																	if(VcompareP):#20250330金额查询多出前两行
																		loclist.append(stritt)#Timenx时间戳行
																		loclist.append(strlist[i-1])
																	loclist.append(strlist[i])
																	loclist.append(strlist[i+1])
													if(Brch == 1):
														if(Xji>0):#20240605
															loclist.append("\t 笈智小计："+str(round(Xji,2))+"  累计："+str(round(Sum,2)))#20240127退格一档

										
									else:#202503083对于非整条纪录的金额查询，将逐个查询各列值
										FoundVP = False #金额区间查询判断
										print("\n\t纪录次行，即‘=’行，非整条纪录的金额查询时，遍历各列值，",end="")
										for k in range(1,ls):
											nSf = -1#202503092
											for j in range (Nb,Mitem):
												Found2P = False#20250305
												if(not isinstance(Toplist[j],list)):#202503092如果关键字不是表

													nSf = Sonlist[k].find(Toplist[j])#20240715
												else:#202503092
													lt = len(Toplist[j])
													acci = 0
													for it in range(lt):
														if(Sonlist[k].find(Toplist[j][it])>=0):
															acci +=1
													if(lt == acci):
														nSf = 3

												if(nSf >=0):
													Found2P = True
												elif(VcompareP):#202503274下增一档
													if(VGEP):
														if(float(self.GetHindNum(Sonlist[k]))>= TopV1):
															Found2P = True
													elif(VBTP):#202503082
														if(float(self.GetHindNum(Sonlist[k]))<= TopV2):
															Found2P = True
														
													else:
														if(float(self.GetHindNum(Sonlist[k]))<= TopV1):
															Found2P = True

															
												if(Found2P):#20250305
														
#												if(nSf >=0):#本项扫描各关键字，确认存在时#20250305
													FMItemP=True#确认发现关键词判断
													Bound += 1#20240605发现关键词计次
													print("总共第(",Bound,")次发现关键字为[",Toplist[j],"]")#202406212Toplist1[j]
													if BoundP:
														if(Mitem>3):#20240605对于集合查询
															if(Bound>=Boundmax):#0120如果二个以上含有绑定关键词 >=2#20240606设定数
																BoundM = True#20240416 #小柴胡汤 #小柴胡汤 #比优特
																print("\t\t\t确定为#绑定，纪录含有三项以上查询关键字")
														else:#20240605对于单项查询
															if(Bound>0):#如果含有绑定关键词
																BoundM = True#20240416 #小柴胡汤 #小柴胡汤 #比优特
																print("\t\t\t确定为#绑定，纪录只含一项查询关键字")
														break
													else:#20240606非绑定的集合查询
														if(Mitem>3):#20240606对于集合查询
															if(Bound>=Boundmax):#20240606设定数如果二个以上关键词 >=3
																BoundM = True
																print("\t\t\t非#绑定，纪录含有3项以上查询关键字")
														else:#20240605对于单项查询
															if(Bound>0):#如果含有绑定关键词
																BoundM = True#20240416 #小柴胡汤 #小柴胡汤 #比优特
																print("\t\t\t非#绑定，纪录只含1项查询关键字")
														break
												if(BoundM):
													break#20240605
										print("\n\t纪录次行‘=’行遍历计算，",end="")#20240605
										for k in range(1,ls):
											ExactP = False#20240715精准关键字判断，之后为词尾或实数时为真
											lSk = len(Sonlist[k])
											print("\t第(",k,")词[",Sonlist[k],"]词长(",lSk,")，",end="")
											
											FMItemP=False#20240606
											nSf = -1#202503092
											for j in range (Nb,Mitem):
												Found2P = False#20250305列字串发现符合关键字判断
												if(not isinstance(Toplist[j],list)):#202503092如果关键字不是表
												
													nSf = Sonlist[k].find(Toplist[j])#20240715
													
												else:#202503092
													lt = len(Toplist[j])
													acci = 0
													for it in range(lt):
														if(Sonlist[k].find(Toplist[j][it])>=0):
															acci +=1
													if(lt == acci):
														nSf = 3
														
												if(nSf >=0):
													print("\t\t字符(",nSf,")位发现关键字[",Toplist[j],"]")
													if(VcompareP):
														if(FoundVP):
															Found2P = True
													else:
														Found2P = True
												elif(VcompareP):#202503274
													if(j==Nb and VGEP):
														if(float(self.GetHindNum(Sonlist[k]))>= TopV1):	
															if(Mitem>Nb+1):
																print("\t\t\t关键词扫描未结束，标示符合‘不小于’区间值")
																FoundVP = True
															else:
																Found2P = True
													elif(j==Nb+1 and VBTP):#202503082
														if(float(self.GetHindNum(Sonlist[k]))<= TopV2):
															if(Mitem>Nb+2):
																print("\t\t\t关键词扫描未结束，标示符合区间值")
																FoundVP = True
															else:
																Found2P = True
														
													elif(j==Nb and (not VGEP)):
														if(float(self.GetHindNum(Sonlist[k]))<= TopV1):
															if(Mitem>Nb+1):
																print("\t\t\t关键词扫描未结束，标示符合‘不大于’区间值")
																FoundVP = True
															else:
																Found2P = True

												if(Found2P):#20250305
													print("\t\t关键词扫描结束，符合金额区间及关键字筛选")
														
#											if(nSf >=0):#本项扫描各关键字，确认存在时#20250305
													if(mystr1[-1]==' '):#20240715当查询关键字末尾为空格时
														lTj=len(Toplist[j])
														print("\t\t(",nSf,")位发现关键词[",Toplist[j],"]，词长(",lTj,")",end="")
														if(lSk==nSf+lTj):
															ExactP = True#豌豆
															print("\t\t词长(",lSk,")等于发现位置(",nSf,")+关键词长(",lTj,")精准判断：",ExactP,end="")
														elif (self.IsNumber(Sonlist[k][nSf+lTj])):
															ExactP = True
															print("\t\t发现位置(",nSf,")+关键词长(",lTj,")=(",nSf+lTj,")位，为数字，精准判断：",ExactP,end="")	
															
													if(((mystr1[-1]==' ') and ExactP) or (mystr1[-1]!=' ')):#20240715下整体后退一档 (and (not ExactP))#豌豆	

												#if(Sonlist[k].find(Toplist[j])>=0):#本项扫描各关键字，确认存在时#202406212Toplist1[j]
														FMItemP=True#确认发现精准关键词判断
														break
											if(BoundFP or (BoundP and mystr1[-1]==' ')):#20240610增加空格结尾统计全行#20240609(BoundFP)
												FMItemP=True
											if(((mystr1[-1]==' ') and ExactP) or (mystr1[-1]!=' ')):#20240715下整体后退一档 (and (not ExactP))#豌豆
												#print("末词为空格且符合精准关键词条件，或者末词不为空格")
											
						#						print("含询词判断FMItemP(",FMItemP,")，首行绑定字#判断BoundP(",BoundP,")，询词数匹配判断BoundM(",BoundM,")，首词	绑定判断BoundFP",BoundFP,")")#20240609
												if ((FMItemP and (not BoundP)) or (BoundP and VcompareP) or#202503083
#												if ((FMItemP and (not BoundP)) or 
														((BoundM or BoundFP) and BoundP and FMItemP)):#20240608
													print("\t\t\t开始累加")#20240609
													if(Brch == 1):
														strt += Sonlist[k]+' '
											#		print("\t\tSecP2为",SecP,end="")#20240114OnceP1为",OnceP,"\t
													ft = float(self.GetHindNum(Sonlist[k]))#20250305
													
													if(not self.HvNumber(Toplist[-1])):#1227 20240113not 
#														ft = float(self.GetHindNum(Sonlist[k]))#20250305已前置
														Xji += ft
														Sum += ft
														print("\t\t\t笈智小计2[",Sonlist[k],"]项，次行发现关键字[",Toplist[j],"]，统计小计(",str(round(Xji,2)),")  累计(",str(round(Sum,2)),")")#202406212Toplist1[j]
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
															if(VcompareP):#202503302
																loclist.append(stritt)#20240801Timenx时间戳行
																loclist.append(strlist[i-1].split()[k-1])#20240114strlist[i-1]purestr
													elif((not SecP) and mystr1[-1]==' '):#20240114判断以空格结尾的查询关键词时，纪录首行可能遗漏的统计#SecP 未统计标记	
#														ft = float(self.GetHindNum(Sonlist[k]))#20250305已前置
														Xji += ft
														Sum += ft
														SecP = True
														print("\t\t\t笈智小计3[",Sonlist[k],"]项次行，发现带数的查询关键字[",Toplist[j],"]，统计小计(",str(round(Xji,2)),")  累计(",str(round(Sum,2)),")")#202406212Toplist1[j]
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
															loclist.append(stritt)#20240801Timenx时间戳行
															loclist.append(strlist[i-1].split()[k-1])#20240114strlist[i-1]purestr
															loclist.append(strt)###
													elif(VcompareP):#20250305如果数值判断成立
														if(not BoundP):#202508033
															print("\t\t\t等号行进入单项数值大小比较分支，不小于判断(",VGEP,")；区间值判断(",VBTP,")")
															ft = float(self.GetHindNum(Sonlist[k]))#20250305
															if(VBTP):#如果要求不大于查询数的纪录#202503082
																print("\t\t\t\t(",TopV1,")<=(",k,")列数值(",ft,")<=查询数值(",TopV2,")?")
																if(ft >= TopV1 and ft <= TopV2):
																	Xji += ft
																	Sum += ft
																	if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																		loclist.append(stritt)#20240801Timenx时间戳行
																		loclist.append(strlist[i-1].split()[k-1])#20240114strlist[i-1]purestr
																		loclist.append("= "+Sonlist[k])#202503082strt
															elif VGEP:#如果要求不小于查询数的纪录
																print("\t\t\t\t(",k,")列数值(",ft,")>=查询数值(",TopV1,")?")
																if(ft >= TopV1):
																	Xji += ft
																	Sum += ft
																	if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																		loclist.append(stritt)#20240801Timenx时间戳行
																		loclist.append(strlist[i-1].split()[k-1])#20240114strlist[i-1]purestr
																		loclist.append("= "+Sonlist[k])#202503082strt
															else:#如果要求不大于查询数的纪录
																print("\t\t\t\t(",k,")列数值(",ft,")<=查询数值(",TopV1,")?")
																if(ft <= TopV1):
																	Xji += ft
																	Sum += ft
																	if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
																		loclist.append(stritt)#20240801Timenx时间戳行
																		loclist.append(strlist[i-1].split()[k-1])#20240114strlist[i-1]purestr
																		loclist.append("= "+Sonlist[k])#202503082strt
													
										print("\n")#20240609
										if(Brch == 1):
											if(Xji>0):#20240605
												if(not self.HvNumber(Toplist[-1])):#20240113
													loclist.append(strt)
													loclist.append("\t 笈智小计："+str(round(Xji,2))+"  累计："+str(round(Sum,2)))#20240127退格一档
												elif VcompareP:#202503082
													loclist.append("\t 笈智小计："+str(round(Xji,2))+"  累计："+str(round(Sum,2)))#20240127退格一档
												
												elif(mystr1[-1]==' '):#20240607#20240127(mystr1[0]==' ')
													loclist.append("\t 笈智小计："+str(round(Xji,2))+"  累计："+str(round(Sum,2)))
										if OnlyP:
											if(self.HvNumber(Toplist[-1]) and mystr1[-1]==' '): #20240114,115 #20240608mystr1[0]==' '
#												print("\t\t查询命令末词有数字")
												if(strlist[i].find(Toplist[-1])>=0):#1228
													print("\t\tSecP3为",SecP)#20240114
													if(not SecP):#20240114判断首行未统计
														print("\t\t单项帐目次行，第一个等号式为[",strlist[i],"]")#1226
														sumnum=self.GetHindNum(strlist[i].strip())
														Sum += float(self.GetHindNum(sumnum))#strlist[i][1:])
														print("\t\t笈智小计3： ",str(round(Sum,2)))
														if(Brch == 1):#Brch=0对应于纯统计计算操作，Brch=1对应统计及显示相关世家操作#20240114
															loclist.append(stritt)#20240801Timenx
															loclist.append(strt)###
															loclist.append("\t笈智累计："+str(round(Sum,2)))
											loc = 0
						#20240731else:#对于通行累加，操作第二等号后的数值
#						print("\t\t\t关键字查询判断KeyWdP：(",KeyWdP,")，False即普查模式；备注关键字判断CommentP：(",CommentP,")")#20240731
						if(   ( (not KeyWdP) and (not CommentLock) ) 
							or (CommentLock and CommentP and (not KeypmP) and (not VcompareP)) ):#202503304
#							or (CommentLock and CommentP and KeypmP) ):
							#20240731 对于普查 或 备注关键字查询(not (CommentLock and CommentP and KeyWdP))
							print("\t\t\t判断进入非关键字查询，即普查模式，或备注关键字非数值查询")#20240731顶行单项，非筛选分支
								
							if(mystr1[-1]!=' ' or ((mystr1[-1]==' ' and (not Comment2P)))):#202408023当查询关键字末尾为空格时，精准锁定非备注纪录#20250305增加or 后括号
							
#								if(mystr1[-1]==' '):#202408023
#									print("\t\t\t查询关键字[",mystr1,"]末尾为空格")
#									if(not Comment2P):
#										print("\t\t\t\t且为非备注时间纪录")
#									else:
#										print("\t\t\t\t但为备注时间纪录")
#								else:
#									print("\t\t\t查询关键字[",mystr1,"]末尾非空格")
										
								if OnlyP:
									print("\t\t\t\t判断进入单项分支，等号出现第(",loc,")次")
#									print("(",i,")行整条纪录计算标志(",RCalcuP,")")#202407013
									if(loc == 0) and (RCalcuP):#202406193#202407013增加纪录计算标志判断and (RCalcuP)
										if(not self.TimeP(strlist[i].split()[0])):#20240731如果首词不是时间戳
					#						print("\t\t\t发现等号前单行纪录[",strlist[i],"]")
											hnumstr=self.strcacu(strlist[i],pricefmt).strip()#20250210 
											hnum =self.GetHindNum(hnumstr)
											Sum += float( hnum)
					#						print("\n\t\t\t笈智总计4：(",round(Sum,2),"),单项尾数字串[",hnumstr,"]计算结果(",hnum,")")
									if(Brch == 1):
										print("\t\t\t",strlist[i])#202408023增加一档
										loclist.append(strlist[i])
								
								else:
									if(loc == 2):
					#					print("\t\t发现第二个等号项[",strlist[i],"]，已累计(",Sum,")")
										Sum += float(strlist[i][1:])
					#					print("\t\t笈智总计： ",Sum)
										loc = 0
									if(Brch == 1):
										print("\t\t\t",strlist[i])#202406223	
										loclist.append(strlist[i])
										
#						print("\t\t\t遍历(",i,")行，纪录尾行(",RecordE,")，备注判断CommentP是否取消？",CommentP)#20240804
						if(CommentP):#20240804下减一档
							if(i==RecordE):
								CommentP = False
								print("\t\t\t遍历进入(",i,")行，当为纪录尾行(",RecordE,")时，备注判断CommentP取消：",CommentP)
			if(KeypmP and (not CommentLock)) or (CommentP):#2040623KeypmP如果是品名搜索 #20240731增加
				if(float(Nprice)>0.1):#20240728 0.2
					pricelev=round(pricelev/float(Nprice),3)
				else:
					pricelev=pricemax
					#print("平均价格(",pricelev,")")
				if(math.fabs(Sum)>0.1):#202406302当品名搜索累加结果不为0时
					if(Nrcd>=3):#202407152在品名结果大于等于三项时，显示高中低价格
						timet=time.strptime(Tmax,"%Y年%m月%d日%H时%M分%S秒")#202407152
						Tmax=time.strftime("%Y%m%d",timet)[-6:]
						timet=time.strptime(Tmin,"%Y年%m月%d日%H时%M分%S秒")
						Tmin=time.strftime("%Y%m%d",timet)[-6:]
						Top2 = ""
						if(isinstance(Toplist[2],list)):#202503092
							for it in range(len(Toplist[2])): 
								if(it == 0):
									Top2 += Toplist[2][it]
								else:
									Top2 += '；'+Toplist[2][it]
						else:
							Top2 = Toplist[2]
							if(len(Commentstr)>0):#202503302当带备注查询时防止将备注项放在品名之前
								if(Toplist[2] == Commentstr):
									if(len(Toplist)>3):
										Top2 = Toplist[3]
										
						if(pricemax>0.1):#202503302当品名没有单价时，会显示0，因无必要而过滤
							strtt="笈智总计： "+str(round(Sum,2))+"  "+Top2+"  "+Tmax+"日价格最高( "+str(pricemax)+" )平均( "+str(pricelev)+" )"+Tmin+"日最低( "+str(pricemin)+" )"
						else:
							strtt="笈智总计： "+str(round(Sum,2))
						
					else:
						strtt="笈智总计： "+str(round(Sum,2))
					print("\t\t",strtt)
					loclist.append(strtt )
			else:
				if(math.fabs(Sum)>0.1):#202406302当品名搜索累加结果不为0时
					print("\t\t笈智总计： ",str(round(Sum,2)))#20231230
					loclist.append("笈智总计： "+str(round(Sum,2)) )
		#if(Brch == 1):#202406193
			#print("\t\t显示列表为： ")#,loclist)#1221
			#for strt in loclist:
			#	print(strt)
		if(Brch == 0):
			return round(Sum,2)#202406212Sum
		else:
			return loclist






# 1425 60                      (2774 0 0)

		
	def TimeLag (self,string):#时差计算
		print("\n进入获取时差模块TimeLag，输入字串为[",string,"]")
		daytime = 86400 #s
		newtime=0
		if(self.IsNumber(string)):#天#5
			numdays=self.GetHindNum(string)
			newtime = float(numdays)*daytime#1228
			print("获取时差(",numdays,")天，时长为(",newtime,")")
		else:
			strn=string.find('分')#20240902分
			if(strn>=0):#有分（钟）
				numdays=self.GetHindNum(string[0:strn])
				newtime += float(numdays)*60
				print("获取时差(",numdays,")分，时长为(",newtime,")")
			strn=string.find('时')#20240902时
			if(strn>=0):#有（小）时
				numdays=self.GetHindNum(string[0:strn])
				newtime += float(numdays)*daytime
				print("获取时差(",numdays,")日，时长为(",newtime,")")
			strn=string.find('日')#5日1231
			if(strn>=0):#日
				numdays=self.GetHindNum(string[0:strn])
				newtime += float(numdays)*daytime
				print("获取时差(",numdays,")日，时长为(",newtime,")")
			strn=string.find('天')#1231
			if(strn>=0):#1231
				numdays=self.GetHindNum(string[0:strn])
				newtime += float(numdays)*daytime
				print("获取时差(",numdays,")天，时长为(",newtime,")")
			strn=string.find('周')#周
			if(strn>=0):#1231
				numweek=self.GetHindNum(string[0:strn])
				newtime += float(numweek)*daytime*7.0
				print("获取时差(",numweek,")周，时长为(",newtime,")")
			strn=string.find('月')
			if(strn>=0):#1月
				nummoon=self.GetHindNum(string[0:strn])
				newtime += float(nummoon)*daytime*30
				print("获取时差(",nummoon,")月，时长为(",newtime,")")
			strn=string.find('季')#季
			if(strn>=0):#1231
				numq=self.GetHindNum(string[0:strn])
				newtime += float(numq)*daytime*90
				print("获取时差(",numq,")季，时长为(",newtime,")")
			strn=string.find('年')
			if(strn>=0):#1年
				numyear=self.GetHindNum(string[0:strn])
				newtime += float(numyear)*daytime*364#1222int
				print("获取时差(",numyear,")年，时长为(",newtime,")")
		print("返回时长量为(",newtime,")秒")
		return newtime







# 60 114           (4200 0 0)

	def CatchFTime (self,mystr):#确定统计开始时间
		print("\n进入提取起始时间模块CatchFTime，字串为[",mystr,"]")
		mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
		fh=open(mypath,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			string = fh.read()
			fh.close#1221
		strlist = string.split('\n')#将内容字串转化为表 
		foretime=time.mktime(time.strptime(strlist[0],"%Y年%m月%d日%H时%M分%S秒"))#1227先假设起始时间为首条记录
		uptime = time.time()#1230datetime.date.today()
		print("当前时间为值(",uptime,")")
		newtime= uptime
		newftime= time.localtime(uptime)
		newstime= time.strftime("%Y.%m.%d",newftime)#0123
		newtime = time.mktime(time.strptime(newstime,"%Y.%m.%d"))+86399#20240603x终点时间
		gtime = time.gmtime(uptime)
		daytime = 86400 
		numdays = nummoon = numyear ="0"
		myline1 = mystr.split('\n')[0]#1221编辑框首行
		myline1L = myline1.split()
		mystr1=myline1L[0]#提取编辑框首行首词
		ln=len(myline1L)#1221编辑框首行的词数
		print("首行为[",myline1,"]，共(",ln,")词")
		if(mystr1.isdigit( )):#1220正整数？self.IsNumber(mystr1)):#实数
			numdays=self.GetHindNum(mystr1)#提取尾数
			newtime = newtime-int(numdays)*daytime#20240601uptime
			print("\t前(",numdays,")起点时间值从(",newtime,")到(",uptime,")")
		else:#1231
			strn=mystr1.find('日')#天
			if(strn>=0):#天#5日
				numdays=self.GetHindNum(mystr1[0:strn])
				print("\t发现‘日’前数字(",numdays,") ")
				newtime = newtime-int(numdays)*daytime#20240601uptime
				print("\t前(",numdays,"日)起点时间值从(",newtime,")到(",uptime,")")
			strn=mystr1.find('天')#天
			if(strn>=0):#天#5日
				numdays=self.GetHindNum(mystr1[0:strn])
				print("\t发现‘天’前数字(",numdays,")" )
				newtime = newtime-int(numdays)*daytime#20240601uptime
	#			newtime = newtime-(int(numdays)-1)*daytime#0126
				print("\t前(",numdays,"天)起点时间值从(",newtime,")到(",uptime,")")
			strn=mystr1.find('周')#天
			if(strn>=0):#天#5日
				numdays=self.GetHindNum(mystr1[0:strn])
				print("\t发现‘周’前数字(",numdays,")" )
				newtime = newtime-int(numdays)*daytime*7#20240601uptime
				print("\t前(",numdays,"周)起点时间值从(",newtime,")到(",uptime,")")
			strn=mystr1.find('月')
			if(strn>=0):#1月
				nummoon=self.GetHindNum(mystr1[0:strn])
				print("\t发现‘月’前数字(",nummoon,") ")
				newtime = newtime - int(nummoon)*daytime*28
				newgtime = time.gmtime(newtime)
				print("\t‘月’对应的号数：",newgtime.tm_mday,end="")
				dlta1=newgtime.tm_mday-gtime.tm_mday
				while(newgtime.tm_mday != gtime.tm_mday):#1231 >
					newtime -= daytime
					newgtime = time.gmtime(newtime)
					print("\t匹配‘月’对应的号数：",newgtime.tm_mday,end="")
					dlta2=newgtime.tm_mday-gtime.tm_mday
					if(dlta2-dlta1>0):
						break
				newtime -= daytime#20240601
			strn=mystr1.find('季')
			if(strn>=0):#1月
				numq=self.GetHindNum(mystr1[0:strn])
				print("\t发现‘季’前数字(",numq,") ")
				newtime = newtime - int(numq)*daytime*91#0126
#			print(nummoon," before is from ",uptime," to ",newtime)
			strn=mystr1.find('年')
			if(strn>=0):#发现有关键字‘年’
				numyear=self.GetHindNum(mystr1[0:strn])
	
				newtime = newtime - int(numyear)*daytime*363+1#0123 +1
				newgtime = time.gmtime(newtime)
				print("\t查询‘年’对应的号数为：",newgtime.tm_mday,end="")
				dlta1=newgtime.tm_mday-gtime.tm_mday
				while(newgtime.tm_mday != gtime.tm_mday):#1231 >
					newtime -= daytime
					newgtime = time.gmtime(newtime)
					print("\t匹配‘年’对应的号数：",newgtime.tm_mday,end="")
					dlta2=newgtime.tm_mday-gtime.tm_mday
					if(dlta2-dlta1>0):
						break
				newtime -= daytime#20240601
		print("\t初步设定统计开始时间值(",newtime,")，记录开始时间值(",foretime,")，",end = "")
		if(ln>1):#20240601假设编辑框首行多项
			mystr2=myline1L[1]
			if(mystr2.isdigit()):
				uptime = newtime+(int(mystr2)-1)*daytime
				print("\t记录结束时间值(",uptime,")")
		if((mystr1=='0') or (not  mystr1[0].isdigit())):#202406222只要首字非数字(ln==1 and   ) 
			newtime=foretime
			print("\n\t时间定位模块，依据首项为‘0’或非数字单项时，设定统计开始时间值(",newtime,")")
		if(newtime<foretime):
			newtime=foretime
			print("\n\t时间定位模块，依据输入的统计开始时间早于首条记录时，设定首条记录为统计开始时间值(",newtime,")")
		newftime = time.localtime(newtime)
		upftime = time.localtime(uptime)
		print("\t\t统计起始时间值确定为从(",newtime,")，终点约到(",uptime,")")
		localtime=time.strftime("%Y年%m月%d日",newftime)
		totime = time.strftime("%Y年%m月%d日",upftime)#20240601
		#time1=time.mktime(time.strptime(localtime,"%Y年%m月%d日"))
		print("\t\t\t统计起点时间确定为从(",localtime,")，终点约到(",totime,")")
		return newtime







# 114 67            (4261 0 0)

	def AccountP (self,mystr):#判断统计、计算模式
		accountp = False
		mylist=mystr.split()
		ln=len(mylist)#1221
		print("\n进入 AccountP计算还是统计判断模块,字串为[",mystr,"],首词为mylist[0]=[",mylist[0],"]")
		#1220if(mystr.find('年')>=0 or mystr.find('月')>=0 or mystr.find('日')>=0 or (mylist[0].isdigit( ))): #1220 and mylist[0]!='0')):
		mystr1=mylist[0]
		if(self.OnlyTP(mystr1)):#20240117
			loc=mystr1.find('年')
			if(loc>0 and mystr1[loc-1].isdigit( )):
				accountp = True
				print("发现时间量词'年'，统计判断值AccountP:",accountp)
			loc=mystr1.find('月')#1231
			if(loc>0 and mystr1[loc-1].isdigit( )):
				accountp = True
				print("发现时间量词'月'，统计判断值AccountP:",accountp)
			loc=mystr1.find('日')
			if(loc>0):
				print("日前一位字符为[",mystr1[loc-1],"]")#1230
				if(mystr1[loc-1].isdigit( )):
					accountp = True
					print("发现时间量词'日'，统计判断值AccountP:",accountp)
			loc=mystr1.find('天')#1231
			if(loc>0):
				print("天前一位字符为[",mystr1[loc-1],"]")#1230
				if(mystr1[loc-1].isdigit( )):
					accountp = True
					print("发现时间量词'天'，统计判断值AccountP:",accountp)
			loc=mystr1.find('周')#1231
			if(loc>0):
				print("天前一位字符为[",mystr1[loc-1],"]")#1230
				if(mystr1[loc-1].isdigit( )):
					accountp = True
					print("发现时间量词'周'，统计判断值AccountP:",accountp)
			loc=mystr1.find('季')#1231
			if(loc>0):
				print("天前一位字符为[",mystr1[loc-1],"]")#1230
				if(mystr1[loc-1].isdigit( )):
					accountp = True
					print("发现时间量词'季'，统计判断值AccountP:",accountp)
		if(mystr1.isdigit( )):
			accountp = True
			print("发现单项为0或正整数，统计判断值AccountP:",accountp)
		else:#1227
			print("\t[",mystr[:10],"……]并非0或正整数单项，首字[",mystr[0],"]，统计判断值AccountP:",accountp)
			if (ln==1):
				if((not self.HvNumber(mystr1) ) and (mystr1[0]!='*') ) or (mystr[0]==' ') or self.IsNumber(mylist[0]):#20240121
					accountp = True
					print("编辑框首行，为单项，未含实数且首字非‘*’，或首字为空格，或全为数字，则统计判断值AccountP:",accountp)
			elif(ln>1):#1227
				if(mylist[0].isdigit( )):
					accountp = True
					print("发现首行多项，首词为0或正数，统计判断值AccountP:",accountp)
				else:
					if(((not self.HvNumber(mylist[0]))  and (mystr1[0]!='*') ) or (mystr[0]==' ') or self.IsNumber(mylist[0])):#20240121
						accountp = True
						print("发现首行多项，首字[",mystr1[0],"]未含实数，或首字为空格，统计判断值AccountP:",accountp)
		print("退出AccountP统计判断模块，统计判断值AccountP:",accountp,"\n")
		return accountp







# 67 21           (4376 0 0)

	def OnlyTP (self,mystr):#时间戳行判断
#		print("\n进入只有时间字判断OnlyTP，字串[",mystr,"]")
		Tlist = ['年','季','月','周','日','天','时','分','秒','.']#202406242
		onlyp = True
		n=len(mystr)
		for i in range(n):
			if(not mystr[i].isdigit()):
				if(mystr[i] not in Tlist) :
					onlyp = False
#					print(mystr[i],"不是数字、时间单位及.，因此并非时间字串")
					break
#		print("全部时间字串判断值onlyp:",onlyp,"\n")
		return onlyp







# 21 22           (4444 0 0)

	def HvCacuWord (self,mystr):#包含计算符判断
	#	print("\n进入有无计算符判断模块HvCacuWord，字串为[",mystr,"]")
		caculist=["sin","cos","tg","ctg","arcsin","arccos","arctg","sinh","cosh","tgh","abs","rand","^", "ln", "lg","*","/","+", "-","正弦","余弦","正切","余切","反正弦","反余弦","反正切","反双曲正弦","反双曲余弦","反双曲正切","绝对值","随机数","抓阄","幂","指数","次方","自然对数","对数","十底对数","乘","×","除以","÷","加","＋","减","－"]
		n=len(caculist)
		m=len(mystr)
		CacuP=False
		for i in range(n):
			if(m>=len(caculist[i])):
				if(mystr.find(caculist[i])>=0):
	#				print("\t含(",i,")项计算符[",caculist[i],"]")
					CacuP=True
					break
	#	print("计算式判断值：",CacuP)
		return CacuP







# 22 20            (4466 0 0)

	def HvNumber (self,mystr):#1223包含数字判断
	#	print("\n进入有无数字判断模块HvNumber，字串为[",mystr,"]")
		m=len(mystr)
		NumP=False
		for i in range(m):
			if(mystr[i].isdigit()):
	#			print("\t(",i,")项为数字[",mystr[i],"]")
				NumP=True
				break
	#	print("有无数字判断值：",NumP)
		return NumP








# 20 21           (4489 0 0)

	def TimeP (self,mystr):#包含时间量词判断
		timep = False
		if(mystr.find('年')>=0 and mystr.find('月')>=0 and mystr.find('日')>=0 and mystr.find('时')>=0 and mystr.find('分')>=0  and mystr.find('秒')>=0):
			timep = True
		return timep



	def CTimeP (self,mystr):#品鉴的时间戳判断
		timep = False
		if(mystr.find('年')>=0 and mystr.find('月')>=0 and mystr.find('日')>=0 and mystr.find('时')>=0 and mystr.find('分')>=0  and mystr.find('秒')<0):
			timep = True
		return timep
		
		
		
		
		
		
		
# 21 38            (4510 0 0)

	def ModiAccfile(self):#世家修改
		print("进入ModiAccfile 世家修改模块")
		FileP=False
		mystr=self.menu_screen.ids.Text_Edit.text #__self__ #kv获取编辑框输入
		#20240621if(self.TimeP(mystr)):
		#20240621	FileP = True
		if(len(mystr)>0):#20240621
			if(self.TimeP(mystr.split('\n')[0])):
				FileP = True#确定纪录文件标记
	#		print("编辑框内是文件")
	#	else:
	#		print("编辑框内不是文件")
		mypath=os.path.join(os.getcwd(),"src/JzAccount.txt")
	#	print(mypath)
		if FileP:
			self.Pop2()
		else:
			if(os.path.exists(mypath)):
				ld1=os.path.getsize(mypath)#文件大小
				if(ld1>0):
					fh=open(mypath,mode='r+t',encoding='UTF-8')
					if fh:
						fh.seek(0)
						data=fh.read()
						self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503263	40
						#self.menu_screen.ids.Text_Edit.clear_widgets()#1220
						self.menu_screen.ids.Text_Edit.text = data[:-1]
						self.menu_screen.ids.file.text = '[color=#ffd900]世家修编[/color]'
						#self.menu_screen.ids.file.font_size = 40
						fh.close







# 38 39                    (4532 0 0)

	def ModiClass (self):#归类修改
		print("进入列传查询及归类修改模块ModiClass")#20240715
		mystr=self.menu_screen.ids.Text_Edit.text #__self__ #kv获取编辑框输入
		mylist = mystr.split('\n')#202406182
		mypath=os.path.join(os.getcwd(),"src/OftenWord.txt")
		WriteP=False#文件覆盖判断
		if(len(mylist)>1):# 当多行时，
			print("\t次行为：「",mylist[1],"」有无数字判断：",self.HvNumber(mylist[1]))
			if(not self.HvNumber(mylist[1])):#202406182
				WriteP = True
			else:#非覆盖时放大刷新编辑框字#202406182
#				self.menu_screen.ids.Text_Edit.font_size += 5#0927 #20250318
				self.handle()
	#	print(mypath)
		if WriteP:
			self.Pop1()
		else:
			if(len(mystr)>0 and (mystr != '0')):
				self.AccountStr = mylist[0]#20250318记录已查询字串
				self.NAStr = len(self.AccountStr)#20250318记录已查询字串字长
				self.myAccount(mystr,1)
			if(len(mystr)==0 or mystr=='0'):#202406182编辑框为空或只有'0'时打开显示原有归类设置文件
				if(os.path.exists(mypath)):
					ld1=os.path.getsize(mypath)#文件大小
					if(ld1>0):
						fh=open(mypath,mode='r+t',encoding='UTF-8')
						if fh:
							fh.seek(0)
							data=fh.read()
							self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503263	40
							self.menu_screen.ids.Text_Edit.clear_widgets()
							self.menu_screen.ids.Text_Edit.text = data
							fh.close





#  39 15

	def PinJ (self):#20250407一键‘品鉴全览’
		strt = self.menu_screen.ids.Line_Edit.text	#20250401
		self.menu_screen.ids.Line_Edit.text = "品鉴"
		self.SubApp()
		self.menu_screen.ids.Line_Edit.text = strt	#20250401
		self.menu_screen.ids.Text_Edit.cursor = (0,0)#20250407








# 15  457                    (4681 0 0)

	def SubApp (self):#0123修改子应用
		print("\n进入SubApp 自制「子应用」模块")
		nb=4#202408242恢复前3项保护 0#0123自制应用起始位置#20240806 4
		mystr=self.menu_screen.ids.Text_Edit.text #kv获取编辑框输入
		mystr2=self.menu_screen.ids.Line_Edit.text #0123kv获取编辑行输入

		path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		fh=open(path,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()#20240831#20250325[:-1]
			print("\t\tSubApp读取目录文件模块完成打开文件->",path)
			fh.close()
			mylist = data.split("\n")
#			print("\t\t显示自制「子应用」模块名目列表")#20241006为：",mylist)#0123

		self.selectedItem=SelectableLabel.selectedItem #202408243获取点中行，下格式减一档
		lnum=self.selectedItem

#		lName = (lnum-1)*2#20241229目录名称的列表序号
#		lFile = lName+1#20241229目录文件的列表序号
#		sName = mylist[lName]#目录名
#		sFile = mylist[lFile]#目录文件
#		ln = len(sFile.split('.')[-1])+1#目录文件后缀及点的字符数
#		sFil0 = sFile[:-ln]#目录文件裸文件名
		
		if(isinstance(lnum,int)):
			print("\t\tSubApp选中(",lnum,")行")
			#20240911if(lnum>2):#202408242 0恢复保护#20240806 2
	#		mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".txt")#20241229 lnum-2
			self.Writen = lnum#0125#20240806 -2
			#20240911else:
			#20240911	self.FirstLine("[自制应用]文件及以上不可修改，请点选其下的某行")
			if(lnum>0):
				lName = (lnum-1)*2#20241229目录名称的列表序号
				lFile = lName+1#20241229目录文件的列表序号
				sName = mylist[lName]#目录名
				sFile = mylist[lFile]#目录文件
				ln = len(sFile.split('.')[-1])+1#目录文件后缀及点的字符数
				sFil0 = sFile[:-ln]#目录文件裸文件名
				mypath=os.path.join(os.getcwd(),"src",sFile)#(os.getcwd(),"src",sFile)
				print("\tSubApp选中文件[",mypath,"]，编辑框内容[",mystr[:20],"……]")
				self.Writen = lnum
				#20241229下增一档
			else:
#				print("\t列表无选中，准备打开内部文件。编辑行字串为[",mystr2,"]")#202409072
				if(len(mystr2)>0):#当编辑行有文字时，假定为文件名
					if(len(mystr2.split())==1):#20241229当编辑行单词时
						fWord = mystr2.split()[0]#20240911取首词为文件名
						mypath=os.path.join(os.getcwd(),fWord)#202408243 Test1.txt默认修改第三项
						if(os.path.isfile(mypath)):
							print("\t\t发现文件[",mypath,"]，准备打开内部文件")
							if(len(self.menu_screen.ids.Text_Edit.text)==0):
								with open(mypath,"r+t") as f :#20240831"rb"
									data = f.read()
									self.menu_screen.ids.Text_Edit.text = data
							elif(len(self.menu_screen.ids.Text_Edit.text.split('\n'))>1):#20240911当编辑框多行时准备覆盖该文件	
								data = self.menu_screen.ids.Text_Edit.text
								self.menu_screen.ids.Line_Edit.text += " 该文件已被覆盖"
								with open(mypath,"w") as f:
									f.write(data)				
								return #sys.exit()
						elif(fWord.find(".")>=0):#20240911
							self.menu_screen.ids.Line_Edit.text += " 没有该文件"
						
					else:#20241229当编辑行多词时
#						print("\t编辑行为多词")
						linel = mystr2.split()
						if(linel[0] == "解密"):
							print("\t\t编辑行首词为‘解密’")
							self.decrypt()#20241226linel[1]
								
						elif(linel[0] == "加密"):
							print("\t\t编辑行首词为‘加密’")
							self.encrypt()#20241226linel[1]

					
				else:
					mypath=os.path.join(os.getcwd(),"src/Test3.txt")#202408243 Test1.txt默认修改第三项
					self.Writen = 3#0125#202408243 1
#					print("\tSubApp选中文件[",mypath,"]，编辑框内容[",mystr[:20],"……]")
		else:#202503303没有选中值时，赋值-1
			lnum = -1

		if(len(mystr2.strip())==0):#0123编辑行为空
			print("\t编辑行为空，进入选择项覆盖操作")
			WriteP=False#文件覆盖判断
			mystrl = []#20241123
			if(len(mystr.strip())>0):#20241124.strip()
			
				mystrl = mystr.split('\n')#20241121
			if(len(mystr.split('\n'))>1):#len(mystr)>1):# 当多行时覆盖模式
#				print("编辑框多于一行")
				if(mystrl[0].find('.')<0):#20241121
					WriteP = True
#					print("编辑框首行没有后缀，准备覆盖")
			elif(len(mystrl)==1):#20241123当编辑框为单行时else:
#				print("编辑框只有一行")
#			else:
				if(mystr[:2]=="扫尾"):#目录内没有编辑行内容，而且编辑框有“扫尾”命令，就删除末行
					self.Pop6()

				elif(mystr[:3]=="文件名"):#20241124
#					print("编辑框显示‘文件名’命令")
					if(MenuScreen.fileName_choose.find(self.OftenFiles)>0):#当操作文件库目录时显示文件
						self.FirstLine(sFile)	
				elif(mystr[:2]=="加密"):
					#伪随机数生成器#202408302 https://www.jb51.net/article/203230.htm
					random_generator = Random.new().read
					#rsa算法生成
					rsa = RSA.generate(1024,random_generator)
					prv_key =str(rsa.exportKey(),encoding="utf-8")#生成解密私钥
					save_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".prv")
					with open(save_path,"w") as f:
						f.write(prv_key)				
					pub_key = str(rsa.publickey().exportKey(),encoding="utf-8")#生成加密公钥
					save_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".pub")
					with open(save_path,"w") as f:
						f.write(pub_key)
					file_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".txt")
					save_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".rsa")
					self.rsa_encrypt_binfile(file_path,save_path,pub_key)#202408302
			#		flist[nt]=mystr2+" Test"+str(lnum)+".prv"+" Test"+str(lnum)+".pub"#202408302增加第四词私钥和第五词公钥
					self.menu_screen.ids.Line_Edit.text = "Test"+str(lnum)+"加密成功，密文.rsa，私钥.prv，公钥.pub"
				elif(mystr[:2]=="解密"):#20240831
					prv_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".prv")#私钥文件路径
					if(os.path.isfile(prv_path)):
						P_keyP = False
						with open(prv_path,"r+t") as f :#20240831"rb"
							prv_key = f.read()
							if(prv_key.find("-----BEGIN RSA PRIVATE KEY-----")==0):
								P_keyP = True
								print("\t\t确认定位密钥")
						if(P_keyP):
							with open(prv_path,"rb") as f :
								prv_key = f.read()
								
								file_path = os.path.join(os.getcwd(),"src","Test"+str(lnum)+".rsa")
								save_path = os.path.join(os.getcwd(),"src","Temp.txt")#20240831st"+str(lnum)+".txt")
								if(os.path.isfile(file_path)):
#									print("\t确认已加密文件[","Test"+str(lnum)+".rsa","]存在，准备解密生成Temp.txt，再弹框确认覆盖文件[","Test"+str(lnum)+".txt","]")
									self.rsa_decrypt_binfile(file_path,save_path,prv_key)	
									self.menu_screen.ids.Text_Edit.text = "加密文件[Test"+str(lnum)+".rsa已解密，准备覆盖文件[Test"+str(lnum)+".txt]"
									self.Pop3b()
								else:
									self.menu_screen.ids.Text_Edit.text = "未找到加密原文件Test"+str(lnum)+".rsa"
						else:
							self.menu_screen.ids.Text_Edit.text = "未找到解密密钥文件Test"+str(lnum)+".prv"
					
						
			if WriteP:
				if(lnum<len(mylist)):#202408243*
					if(lnum>0):
						strtl =mylist[(lnum-1)*2].split()#202408243设置密码判断
						if(len(strtl)>1):#当文件行有两词以上时
#							print("\t第(",lnum,")行内容[",mylist[(lnum-1)*2],"]超过一词")
							self.PassWdText = strtl[1]
							self.MenuFile   = mylist[lnum*2-1]
							self.Pop3a()

						else:#202408243下增二档
#							print("\t第(",lnum,")行内容[",mylist[lnum*2-2],"]只有一词")
#							print("\tSubApp模块准备Pop3模块将内容写入到：[",mypath,"]")
							self.MenuFile = mypath#20240911
							self.Pop3()
				
			#20240831elif(mystr[:2]!="扫尾"):
			elif(mystr[:2]!="扫尾" and mystr[:2]!="加密" and mystr[:2]!="解密"):#非覆盖模式
				if(lnum<len(mylist)):#20240825
					if(lnum>0):
						strtl =mylist[(lnum-1)*2].split()#20240825设置密码判断
						if(len(strtl)>1):#当文件行有两词以上时，第二词假定为密码，验证后显示
#							print("\t第(",lnum,")行内容[",mylist[(lnum-1)*2],"]超过一词")
							self.PassWdText = strtl[1]
							self.MenuFile   = mylist[lnum*2-1]
#							print("\t第(",(lnum-1)*2,")行密码[",self.PassWdText,"]第(",lnum*2-1,")行文件名[",self.MenuFile,"]")
							self.Pop9()#20240825

						else:#20240825下增二档#当文件行只有一词时，直接显示文本
							print("\t第(",lnum,")行内容[",mylist[lnum*2-2],"]只有一词")
							
							if(os.path.exists(mypath)):
								ld1=os.path.getsize(mypath)#文件大小
								if(ld1>0):
									with open(mypath,mode='r+t',encoding='UTF-8') as fh:
										data=fh.read()#读入文件
										
										skiP = True#20240927
										dlist = data.split("\n")
										ll = len(dlist)#20240927考虑文本内以密码分级时不予显示
										print("\t\t主页文件共(",ll,")行，末行[",dlist[ll-1],"]")
										for i in range(ll):
											chloc = dlist[i].find('"密码：')
											if(chloc >= 0 and dlist[i].find('.find(')<0 and  dlist[i].find('「')<0):#202503162排除源代码、使用手册
												skiP = False
												for j in range(chloc+3,len(dlist[i])):#查找字符后面的空格或'"'
													if(dlist[i][j] == '"' or  dlist[i][j] == ' '):
														self.PassWdText = dlist[i][chloc+4:j]
														break
												
												break
										if skiP:
											self.MenuName   = mylist[lnum*2-2]#20240930
											print("\t\t选中主页第(",lnum,")行[",self.MenuName,"]，对应文件[",mylist[lnum*2-1],"]未发现有密码")
											if(self.MenuName):
												if(self.MenuName.find(self.NameKey)<0):#20240930如果未发现文件名中有自测题关键字
													print("\t\t\t编辑行为空时，未发现文件名中有自测题关键字")#20241006
													self.menu_screen.ids.Text_Edit.text = data#编辑框显示文件[:-1]
													self.menu_screen.ids.Line_Edit.text = sFile#202503162在编辑行同时显示文件名
												else:
													self.menu_screen.ids.Line_Edit.text = "目录名有‘题’字，不予显示"#202503162在编辑行同时显示文件名
#													print("\t\t\t编辑行为空时，发现目录名中有自测题关键字‘题’字，不予显示")#20241006
												
										else:#20240927
											#self.PassWdText = strtl[1]
											self.MenuName   = mylist[lnum*2-2]
#											print("\t\t选中主页第(",lnum,")行[",self.MenuName,"]，对应文件[",mylist[lnum*2-1],"]中有密码[",self.PassWdText,"]")
											self.Pop9()
											
		else:#0123if(len(mystr2.strip())>0)编辑行不空
			if(len(mystr2.split())==1):#202412172当编辑行单词时下增一档
#				print("\t编辑行不空，进入覆盖、创建、改名、显示操作")
				Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
				fh=open(Oftenpath,mode='r+t',encoding='UTF-8')
				if fh:
					fh.seek(0)
					data=fh.read()#20241006 [:-1]#20101012恢复
					fh.close()
					flist= data.split("\n")#202408242
					#print(flist)#202408242
					if(len(flist[-1])==0):flist.pop()#202408242#20241109
					nf = len(flist)
#					print("\t\t没有同名文件，编辑框开头两字mystr[:2]=[",mystr[:2],"]不为‘改名’或非其它命令如加密、解密、扫尾、品鉴时，创建新目录项,主目录总行数(",nf,")")
					Hvfile = False
					for i in range(nb,nf-1,2):#202408242 nf-1
						#print(flist[i])#202408242
						if(flist[i].split()[0] == mystr2):	
							Hvfile = True
#							print("\t主目录第(",i,")项发现同名「",mystr2,"」")
							break	
					if(mystr2.split()[0]=="品鉴"):#20240911当编辑行首词为“品鉴”
						Hvfile = True
						
					if Hvfile:#当有同名文件时
						ni=int(i/2+1)#20241012i/2-1
						self.Writen=ni
						mypath=os.path.join(os.getcwd(),"src","Test"+str(ni)+".txt")
						if(mystr2.split()[0]=="品鉴"):#20240911
							mypath = os.path.join(os.getcwd(),"src","Comments.txt")
#						print("\t\t同名的指向文件为[",mypath,"]")#内容:\n[",mystr,"]")
						WriteP=False#文件覆盖判断
						if(len(mystr.split('\n'))>1):# 当多行时覆盖原应用文件
							WriteP = True
						if WriteP:
#							print("\t\t\t同名文件覆盖操作")
							#20240825self.Pop3()

							#2024911if(lnum<len(mylist)):#202408243
							if(isinstance(lnum,int)):
								if(lnum>0 and lnum<len(mylist)):#202408243lnum>0
									strtl =mylist[(lnum-1)*2].split()#202408243设置密码判断
									if(len(strtl)>1):#当文件行有两词以上时
#										print("\t第(",lnum,")行内容[",mylist[(lnum-1)*2],"]超过一词")
										self.PassWdText = strtl[1]
										self.MenuFile   = mylist[lnum*2-1]
										self.Pop3a()
	
									else:#202408243下增二档
#										print("\t第(",lnum,")行内容[",mylist[lnum*2-2],"]只有一词")
#										print("\tSubApp模块准备Pop3模块将内容写入到：[",mypath,"]")
										self.MenuName = strtl[0]#20240911os.path.join(os.getcwd(),"src","Test"+strtl[0]+".txt")#mypath #20241012
										self.Pop3()
								elif(lnum==0):#20240911当选中0行时
									self.MenuName   = mypath
									self.MenuFile = os.path.join(os.getcwd(),"src","Comments.txt")#20240911
									self.Pop3()
							else:#20240911当未选中时
									self.MenuName   = mypath
									self.MenuFile = os.path.join(os.getcwd(),"src","Comments.txt")#20240911
									self.Pop3()
				


						else:#编辑框内容为空或单行时，根据编辑行内容读入不同文件,空时加载.txt文件，.rsa时加载加密文件，.prv时加载加密用的私钥,.pub时加载解密用的公允钥#20240831 

							if(len(mystr2)>0):#20240831
								if(mystr2=="已加密文件"):#mystr2.upper()==".RSA"#20240831
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".rsa")#20240831
								elif(mystr2=="私钥"):
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".prv")#20240831
								elif(mystr2=="公钥"):
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".pub")#20240831
								#elif(mystr2=="品鉴"):#20240911
								#	mypath=os.path.join(os.getcwd(),"src","Comments.txt")#20240831
								

							if(os.path.exists(mypath)):
#								print("\t\t编辑框单行文字，且存在同名文件[",mypath,"]，准备调入该文件")#内容:\n[",mystr,"]")
								ld1=os.path.getsize(mypath)#文件大小
								if(ld1>0):
									fh1=open(mypath,mode='r+t',encoding='UTF-8')
									if fh1:
										fh1.seek(0)
										data1=fh1.read()
										self.menu_screen.ids.Text_Edit.text = data1#20240911[:-1]
										fh1.close()
									
					else:#当无同名文件时，可能为特殊文件
#						print("\t\t没有同名文件，编辑框开头两字mystr[:2]=[",mystr[:2],"]是否为‘改名’？非改名且非其它命令如加密、解密、扫尾时，创建新目录项,主目录总行数(",nf,")")
						if(len(mystr)>1):#编辑框文字超过一字
							#20240831掉换条件顺序else:#目录内没有编辑行内容，而且编辑框有“改名”命令，修改原目次
							
							if(mystr[:4]=="结果文件"):#列表没选中，目录内没有编辑行内容，编辑框有“结果文件”命令，由数据文件生成结果文件#20250320

#								print("\n\t\t\t进入生成结果文件模块")
								Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#0501
#								print("准备打开摘引文件：",Indexpath)#20250320WinPath
#								locfile=self.fileName_choose
#								CheckedRowNuber=[]
								f=open(Indexpath,mode='r+t',encoding='UTF-8')#打开摘引文件
								if f:
									f.seek(0)#注意读取文件时候要将文件指针指向第一个
									s=f.read()
									mylist = s.split("\n")#含完整的文件路径
									f.close()#关闭摘引文件
									strt=mylist[1]#提取第二行内容为文件名#20250320手机版为第0项?mylist[1]
#									print("摘引文件指向的母版文件：",strt)#20250320WinPath
##									if(self.fileName_choose.find(strt)<0):#0416
									locfile=os.path.join(os.getcwd(),strt)#041620250320WinPath#20250323"src",
									self.DispIndex(locfile,mylist,3)

							
							
							if(mystr[:2]=="改名"):#目录内没有编辑行内容，编辑框有“改名”命令，修改原目次#20240831
#								print("\t\t\t开头两字为‘改名’时，准备执行改名命令->")
								#self.selectedItem=SelectableLabel.selectedItem 
								#lnum=self.selectedItem
								if(isinstance(lnum,int)):#0720
									if(lnum>2):
									
										if(lnum<len(mylist)):#202408243*
											strtl =mylist[(lnum-1)*2].split()#202408243设置密码判断
											if(len(strtl)>1):#当文件行有两词以上时，密码改名
#												print("\t\t\t\t第(",lnum,")行内容[",mylist[(lnum-1)*2],"]超过一词")
												self.PassWdText = strtl[1]
												self.MenuFile   = mylist[lnum*2-1]
												self.Pop5a()
											else:#202408243当文件行只有一词时，直接改名；如果发现是自测题，须保持带有关键字	下增5档
#												print("\t\t\t\t第(",lnum,")行主页内容[",mylist[lnum*2-2],"]只有一词")
#												print("\t\t\t\tSubApp模块准备Pop3模块将内容写入到：[",mypath,"]")	
												if(mylist[lnum*2-2].find(self.NameKey)<0):	#20240930						
													print("\t\t\t\t\t主页(",lnum,")行内容未发现关键字[",self.NameKey,"]")#20240930
													self.Pop5()
												else:#20240930
#													print("\t\t\t\t\t主页此行含有「题」关键字")
													if(mystr2.split()[0].find(self.NameKey)>=0):
#														print("\t\t\t\t\t\t编辑行含「题」关键字，准备改名")
														self.Pop5()
													else:
#														print("\t\t\t\t\t\t编辑行不含「题」关键字，不允许改名")
														self.menu_screen.ids.Line_Edit.text = mystr2+" 所改名首词须含「题」字"
							#20240831if(mystr[:2]!="改名"):#目录内没有编辑行内容，而且编辑框没有“改名”命令，就创建新条目
							else:#(mystr[:2]!="改名"):#20240831目录内没有编辑行内容，而且编辑框没有“改名”、加密、解密等命令，就在主目录创建新条目
								CreateP = True#20240831创建新条目判断
								if(mystr[:2]=="扫尾" or mystr[:2]=="加密" or mystr[:2]=="解密"):#如果编辑框有命令时，不创建
									CreateP = False
#									print("编辑框有命令[",mystr[:2],"]时，创建新条目判断：",CreateP)
								if(mystr2=="已加密文件" or mystr2=="公钥" or mystr2=="私钥"):#如果编辑行有特殊格式时，不创建
									CreateP = False
#									print("编辑行有特殊格式时，创建新条目判断：",CreateP)
								if CreateP:#创建新条目的情形。下对齐增一档
							
									ni=int(nf/2)+1#202408242 i/2
									self.Writen=ni
									if(len(mystr2)>0):#20240831
										mypath=os.path.join(os.getcwd(),"src","Test"+str(ni)+".txt")
#									print("\t\t\t非改名时，准备创建新文件，链接新文件名[",mypath,"]")
									WriteP=False#文件创建判断
									if(len(mystr.split('\n'))>1):# 当多行时创建新应用文件
										WriteP = True
									if WriteP:
										self.Pop4()
										flist.append(mystr2.split()[0])#20241012
										flist.append(mypath.split('/')[-1])
#										print("\t显示常用文件内容列表成为：",flist)#")#20241006
										nft=len(flist)
										Oftenpath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
										fho=open(Oftenpath,mode='w+t',encoding='UTF-8')
										if fho:
											for l in range(nft-1):#202408242取消 #20241012恢复nft
												fho.write(flist[l]+"\n")
											fho.write(flist[nft-1])#202408242取消#20241012恢复[nft-1]
											fho.close()
									else:
										self.FirstLine("‘改名’请先点选[自制应用]以下的某行")
										
								else:#不创建新条目的情形
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".txt")#默认写入文本文件
									if(len(mystr2)>0):
										if(mystr2=="已加密文件"):#mystr2.upper()==".RSA"#20240831
											mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".rsa")#20240831
										elif(mystr2=="私钥"):
											mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".prv")#20240831
										elif(mystr2=="公钥"):
											mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".pub")#20240831
										with open(mypath,mode='w+t',encoding='UTF-8') as f:
											f.write(mystr)
#											print("\t编辑框内容写入至文件[",mypath,"]成功")
											self.menu_screen.ids.Line_Edit.text = mypath.split()[-1]+"保存成功"
		
						else:#编辑框少于二字情形
							mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".txt")#默认写入文本文件
							if(len(mystr2)>0):
								if(mystr2.find("已加密文件")>=0):#mystr2.upper()==".RSA"#20240831
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".rsa")#20240831
								elif(mystr2.find("私钥")>=0):
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".prv")#20240831
								elif(mystr2.find("公钥")>=0):
									mypath=os.path.join(os.getcwd(),"src","Test"+str(lnum)+".pub")#20240831
							strt = mypath.split()[-1]
#							print("编辑框为空，编辑行内容[",mystr2,"]关联文件：",strt)					
							if(os.path.isfile(mypath)):
								with open(mypath,mode='r+t',encoding='UTF-8') as f:
									data = f.read()
#									self.menu_screen.ids.Text_Edit.text=data
#									print("\t编辑框内容显示文件[",strt,"]成功：",data[:30])
	
									skiP = True#20240927
									dlist = data.split("\n")
									ll = len(dlist)#20240927考虑文本内以密码分级时不予显示
									for i in range(ll):
										chloc = dlist[i].find('"密码：')
										if(chloc >= 0 and dlist[i].find('.find(')<0):#20241018):
											skiP = False
											for j in range(chloc+3,len(dlist[i])):#查找字符后面的空格或'"'
												if(dlist[i][j] == '"' or  dlist[i][j] == ' '):
													self.PassWdText = dlist[i][chloc+4:j]
													break
											
											break
									if skiP:
										self.menu_screen.ids.Text_Edit.text = data#编辑框显示文件[:-1]
									else:#20240927
										#self.PassWdText = strtl[1]
										self.MenuFile   = mylist[lnum*2-1]
#										print("\t选中主页第(",lnum,")行[",self.MenuFile,"]，对应文件[",mylist[lnum*2-2],"]中有密码[",self.PassWdText,"]")
										self.Pop9()
	





	


# 457 32                         (4627 0 0)

	def ZtimeZ (self,n):#中文当地时间扩展
	#电脑中文当地时间，n为整数，0为年月时分秒，1为年月时分，2为月日时分，3为日时分，4为时分
		ct =time.time()
		timet=time.localtime(ct)
		if(n==0):
			localtime=time.strftime("%Y年%m月%d日%H时%M分%S秒",timet)
		elif(n==1):
			localtime=time.strftime("%Y-%m-%d-%H:%M",timet)
		elif(n==2):
			localtime=time.strftime("%m-%d-%H:%M",timet)
		elif(n==3):
			localtime=time.strftime("%d-%H:%M",timet)
		elif(n==4):
			localtime=time.strftime("%H:%M%",timet)
		elif(n==5):
			localtime=time.strftime("%Y年%m月%d日",timet)
		elif(n==6):
			secs= (ct - int(ct))*1000
			localtime=time.strftime("%Y年%m月%d日%H时%M分%S秒",timet)
			localtime += str(int(secs))+'毫秒'
		elif(n==7):
			localtime=time.strftime("%Y年%m月%d日%H时%M分",timet)
#		self.LocalTime=localtime
		print("\t\t当地时间为：",localtime)
		return localtime






# 32 163            (5085 0 0)

	def AltStrm (self,slecstr,digit_num,expbnow):#编辑框分解括号
#digit_num,8模块判断小数位数，>=0表强制输出小数位,-3表示不计算；expbnow表示计算1与否0,也表示当前表首项self.Expbnow位置
		print("\n\n\t＝＝＝进入手机计算字符串分解方法AltStrm：",slecstr)
		mystr=slecstr
#		print("字串为：",mystr)
		strpara=" "
		str1=mystr
#		print("字串为：",str1,"分割符为[",strpara,"]")
		#strlist=[]
		strlist=str1.split()#strpara
		ns = len(strlist)
		#i1 = len(strpara)
		print("一级分解后计算字符串成为表：",strlist,"\t共",ns,"项")
		#if (i1==0):
		#	strpara0=""
		itt=0
		pickp=False
		while(itt<ns):#各表项遍历
			mystr= strlist[itt]
			str1t = strlist[itt]#分解的字串项
			print("\n分解的字串项：",str1t)
			fmt=self.floatfmt(str1t)#v0.60
			print("\t字串小数位数：",fmt)
			bracketn = 0
			slen = len( str1t)
			nct =0 
			while(nct < slen):
				strn = str1t[nct]
				nct+=1
				if(strn == '('):
					bracketn = bracketn+1
	#		print("字符",str1t,"有",bracketn,"个括号")
			nct1=0
			k1=0
			passn=0
			while(k1<=bracketn):#v0.951while(k1<bracketn):#各层括号解析
				if(passn>=slen-1):
	#				print("\n\t循环入口，忽略串长",passn,">=净字符数：",slen)	
					break
	#			else:
	#				print("\n\t循环入口，忽略串长",passn,"<净字符数：",slen)						
				bracketnt = 0
				numn = 0
				bracketb = 0
				brackete = 0
				nct = 0
				sta = 1
				slen = len( str1t)
				while (nct < slen):#找出(需拆解的)最内层括号序号v0.963
					if(nct>nct1+passn):#
						strn = str1t[nct]
						if(strn == '(') :
							bracketnt = nct
						elif(strn==')') :
							bracketb = bracketnt
							brackete = nct
							break
					nct +=1
				sta=brackete-bracketb-1
			#	print("\t第",k1,"层括号开始于：",bracketb,"\t结束于",brackete,"\t净字符数：",sta,"忽略串长",passn)
				if(bracketn==0):#:k1#v0.951没有括号
					prestr =""
					midstr = mystr#strlist[itt]#str1t
					endstr =""
					oristr=""
				elif(k1==bracketn):
					prestr =""
					midstr = str1t
					endstr =""
					oristr=""
				else:
					prestr = str1t[0:bracketb]
					midstr = str1t[(bracketb+1):brackete]
					endstr = str1t[(brackete+1):]
					oristr=midstr
	#			print("\t第(",k1,")层括号分解后，前串[",prestr,"]\t中串[",midstr,"]\t后串[",endstr,"]操作格式行号(",expbnow,"]")
				if(expbnow>=0):#!=0):v0.952由之前的计算标志修改为全显页顶行
			#		print("\t非首页，判断为需变量代换，串长",len(midstr))
					transferp=False
					if (len(midstr) >0):#!= 0):
#						print("\t\talt中间字串：",midstr)
						if(digit_num!=-3):
		#					print("\t\t\tAltstr中间2待计算字串[",midstr,"]")
							if(not self.IsNumber(midstr)):
								midstr=self.strcacu(midstr,digit_num)
						if(midstr==oristr and (not self.IsNumber(midstr))):
							midstr='('+midstr+')'
							passn+=brackete#括号查找点后推到忽略括号后
#							print("\t\t变量代换搜寻摘引文件:",Indexpath,"未找到变量代换,返回原表字串[",midstr,"]")
#						print("\t首字符判断后，midstr＝",midstr)
						mystr=midstr
						str1t=prestr+mystr
						str1t=str1t+endstr
						mystr=str1t
						midstr=str1t#v0.951
		#				print("\t第(",k1,")次括号运算后，成为串[",str1t,"]")
				else:
					print("\t\t判断为不需变量代换")
				if(not transferp):
					k1+=1	
				else:
					ncte =0 #v0.967
					slen=len(str1t)
					bracketn=0
					while(ncte < slen):
						strn = str1t[ncte]
						ncte+=1
						if(strn == '('):
							bracketn = bracketn+1
					if(bracketn>0):
						k1=0
		#			print("循环末重新统计字符串[",str1t,"]内有(",bracketn,")个括号")
					if(bracketn<=0):break #20230331
			print("运算前，字串为：",mystr)#v0.85
			if(digit_num!=-3):#v0.952调整digit_num==-3为不计算
				print("Altstr中间4待计算字串[",mystr,"]")
				if(not self.IsNumber(mystr)):
					mystr=self.strcacu(mystr,digit_num)
			print("运算后，成为串：",mystr)
			if(self.IsNumber(mystr)):#20230218
				value=float(mystr)
	#			print("Alt实数运算结果：",value)
				if(digit_num==8):#<0):v0.97确定8为自动判断，-3不计算
					if((abs(value)<1e5) and (abs(value) >1e-3)):
						mystr=str(round(value,fmt))#self.fmt))
#						print("Alt实数自动判断输出小数位",fmt,"，数字输出为",mystr)
				elif(digit_num>=0):					
					if((abs(value)<1e5) and (abs(value) >1e-3)):
						if(digit_num==0):
							mystr=str(round(value))
						else:
							mystr=str(round(value,digit_num))
	#					print("Altstr强制输出小数位",digit_num,"，数字输出为",mystr)
#				else:
#					print("Altstr第2项参数",digit_num,"无格式变动，输出为",mystr)
			strlist[itt]=mystr
#			print("\n\t第",itt,"表项运算后，成为串：",strlist[itt])
			if(itt==0):
				str1=strlist[itt]
			else:
				str1=str1+" "+strlist[itt]
			itt+=1
			if(pickp):
				str1=str1+' '+pickstr2
	#		print("\n\t＝＝＝Altstr第",k1,"层括号运算后，成为串：\n\t\t[",str1,"]\n")
		strlist=str1.split()#0616
		ns1 = len(strlist)
		if(ns1>1):
			xj=0
			for i in range(ns1):
				xj += float(self.GetHindNum(strlist[i]) )
			xj= str(round(xj,digit_num))#d3.5*0.5 q2*0.6 2
			str1=str1+"\n= "+xj
	#		print("XiaoJi",str1)
		return str1#0607退格一档输出多项







# 163 27           (5118 0 0)

	def GetHindNum (self,string):#提取尾数
	#	print("进入 GetHindNum提取尾数模块，字串为 [",string,"]")
		if(self.IsNumber(string)):
			numstr=string
		else:
			n=len(string)
			n1=0
			for i in range(n-1,-1,-1):
	#			print(" (",i,") ",string[i],end="")
				if(not self.IsNumber(string[i])):
					n1=i+1#202406243+=1
	#				print(" (",i,") is not number ")
					break
			if(n1==n):
				numstr="0"
			else:
				numstr=string[n1:]
	#	print("\n尾数为 [",numstr,"]")
		return numstr







# 27 32           (5282 0 0)

	def GetHindPrice (self,string):#提取尾数价格
		print("进入 GetHindPrice提取尾数价格模块，字串为 [",string,"]")
		numstr=string
		if(not self.IsNumber(string)):
		#20240623	numstr=string
		#20240623else:
			n=len(string)
			n1=0
			for i in range(n-1,-1,-1):
		#		print("\t",n,"(",i,") ",string[i],end="")
				if(string[i]!='*'):#20240623寻找'*'号(not self.IsNumber(string[i])):
					n1+=1#202406243=i+1
		#			print(" (",i,") 不是'*'号，继续前探")
					#20240623break
				else:
		#			print("发现带价格字串[",string[:i],"]")
					numstr = self.GetHindNum(string[:i])
					break
			if(n1==n):
				numstr="0"
			#else:
			#	numstr=string[n1:]
		print("\n尾数价格为 [",numstr,"]")
		return numstr







# 32 71           (5535 0 0)

	def IsNumber (self,localstr):#检测字串是否实数
		lens=len(localstr)
#		print("进入IsNumber模块,检测字串[",localstr,"]共",lens,"个字符，是否实数？")
		if(lens > 0):
			if(localstr[0]=='+'):#20250322
				return False
				
			i1=0
			state=0
			while(i1<lens):
				if(i1==0):
#					print("\t\t",localstr[i1])
					if (localstr[i1].isdigit( ) or (localstr[i1] == '.') or #字串是数字？
						(localstr[i1] == '-') or (localstr[i1]=='+')):
						state+=0
					else:
						state+=1
#					print("\tstate=0表示数字，state=",state)
				else:
#					print("\t\t",localstr[i1])
					if ((localstr[i1] == 'e')or(localstr[i1] == 'E')):#科学计数
#						print("\t\t\t发现可能的科学计数",localstr[i1])
						if(len(localstr)>i1+1):
							if(localstr[i1] == 'e'):
								substre=localstr.split('e')[1]
								if self.IsFloat(substre):
									state += 0
									break
								else:#20250228
									state+=1
#									print("\t\t\t[",localstr[i1],"](",state,")")
									break
							elif(localstr[i1] == 'E'):
								substrE=localstr.split('E')[1]
								if(self.IsFloat(substrE)):
									state += 0
									break
								else:#20250228
									state+=1
#									print("\t\t\t[",localstr[i1],"](",state,")")
									break
#							else:#20250228
#								state+=1
						else:
							state+=1
#							print("\t\t\t[",localstr[i1],"](",state,")")
					elif (not (localstr[i1].isdigit() or (localstr[i1] == '.'))):#20250228 - + or (localstr[i1] == '-' or (localstr[i1] == '+'))
						state+=1
#						print("\t\t\t[",localstr[i1],"](",state,")")
#					print("\t\t0表示数字，state=",state)
				i1+=1

			if state>0:
#				print("\t字串[",localstr,"]不是实数。")
				justnumber=False
			else: 
#				print("\t字串[",localstr,"]是实数。")
				justnumber=True
		else:
			justnumber=False
		return justnumber









# 71 42         (5568 0 0)

	
	def floatfmt (self,lstr):#获取浮点小数位
#		print("\n进入检测字串最大小数位模块floatfmt，字串[",lstr,"]")#2025
		ll=len(lstr)#字串总长
		i0=lstr.find('.')#第一个小数点
		imax =	0
		if(not self.HvNumber(lstr)):#202504223
			imax = -1
			
		if(i0>=0):#如果发现小数点
#			print("第",i0,"位为小数点.")
			i1=i0+1#设定小数点后一位序号
			it=0#小数点后数字开始计数
			i2=i1#从第一位小数点后一位开始循环搜索
			while i2>= i1 and i2<ll :#20240206循环至字总长位退出
			#for i2 in range(i1,ll):
#				print("\t(",i2,")[",lstr[i2],"]",end="")
				if(lstr[i2].isdigit()):#搜索小数点后数字并计数
					it+=1
#					print("计(",it,")")
					if(it>imax):#当计数大于之前最大小数位时，记为新的最大小数位
						imax=it
#						print("\t第(",i2,")位时的最大小数位数为(",imax,")")
				else:#当搜索遇到非数字时，重新计数
					it=0
					i0=lstr.find('.',i2)#重新搜索本位以后的小数点位置
					if(i0>=i2):#如果找到
#						print("\n第(",i0,")位为另一个小数点.")
						i1=i0#设定小数点后一位序号#20250212因后面有循环累加此处不 +1
						i2=i1#从后一位开始新的循环搜索
					else:#如果没找到小数点
						break#退出循环
				i2+=1#循环计数累加
#			print("字串[",lstr,"]的小数位数为(",imax,")\n")
		return imax






# 42 688       (5640 0 0)

	def strcacu (self,mystr,fmt):#算式串计算转化fmt=8时根据算式小数位而定
		caculist1=["sin","cos","tg","ctg","arcsin","arccos","arctg","sinh","cosh","tgh","abs","rand","正弦","余弦","正切","余切","反正弦","反余弦","反正切","反双曲正弦","反双曲余弦","反双曲正切","绝对值","随机数","抓阄"]#20240625
		caculist2=["^", "ln", "lg","幂","指数","次方","自然对数","对数","十底对数"]
		caculist3=["*","/","乘","×","除以","÷"]
		caculist4=["+", "-","加","＋","减","－"]
		listn = len(caculist1)##20240625 12
		passt = 0
#		self.mystr=self.ui.lineEdit_2.text()
		found1 = len(mystr)
		rank =listn
		inow=0
		i1=0
		value=""
		fmtmax = 9#202504233如果精度需要可修改此行
#		if(fmt==8):#20240233 为保证计算精度，又舍弃此修改
#			fmtf=self.floatfmt(mystr)#202504233
#			print("\tstrcacu输入小数位格式(",fmt,")，运行判断为小数位(",fmtf,")")
#			if(fmtf>=0):#202504233
#				fmt= fmtf
#			else:
#				fmt = fmtmax
		ifmt = fmtmax#20250320为保证计算精度，内部小数位取为9位fmt#202504223
		if(ifmt == 2):
			fmt = 2#202503292
		else:
		
			fmt = fmtmax#9#20250320#202504234影响复杂程序精度故重新采用
		numt1id =[0,0,0,0,0]#20250316
		print("\n进入字符串计算strcacu，字符串为[",mystr,"]小数位数(",fmt,")")
		while i1<listn:
			foundt = mystr.find(caculist1[i1],inow)#1014self.
			if(foundt>=0): 
	#			print("计算字符串[ ",mystr," ]中发现一级优先计算符(",caculist1[i1],")位于",foundt)#self.
				if(foundt <= found1):
					rank = i1
					found1 =foundt
				passt = 1
			i1 +=1
		#print("\n位置1发现[",mystr,"]第(",rank,")运算串[",caculist1[rank],"]")#20240625)#self.
		while(passt ==1):
			numbers = 0
			i5=0
	#		print("\t一级前strcacu->ArrangStr中一级运算符:[",caculist1[rank],"],位于found1(",found1,")")
			if(found1>=0):
				loclist=self.ArrangStr(mystr,caculist1[rank])#v0.956
	#			print("\tstrcacu函数中ArrangStr结果返回表：",loclist)#20240625
				numt1id=loclist[0]
				numt1=loclist[1]
			value=""
			if(numt1id[3]==1):#当第四栈数字标记为“有”时20230608
				cacustrt3 = numt1[3]#取第四栈数字
				if(self.IsNumber(cacustrt3)):
					para3= float (cacustrt3)
	#			print("\tstrcacu函数输入值：",cacustrt3)
				if(numt1id[1]==1):#当第二栈数字标记为“有”时20230608
					cacustrt = numt1[1]#取第二栈数字
					para1= float (cacustrt)
	#				print("\tstrcacu函数输入值：",cacustrt)
					if(numt1[2]=="sin" or numt1[2]=="正弦"):
						
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.sin (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
#						print("\tself.IsNumber(cacustrt)值：",self.IsNumber(cacustrt))
#						else:print("\tcacustrt.isalnum()值：",cacustrt.isalnum())
					if(numt1[2]=="cos" or numt1[2]=="余弦" ):
						
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.cos (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="tg" or numt1[2]=="正切"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.tan (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="ctg" or numt1[2]=="余切"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							tv=math.tan (para3)
							if(tv>1e-5):
								value = para1 / tv
								numt1[1]=""
								numt1id[1]=0
								numt1[3]=""
								numt1id[3]=0
								numbers = 1
							else:
								print("\t\t请检查ctg参数")
					if(numt1[2]=="arcsin" or numt1[2]=="反正弦"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.asin (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="arccos" or numt1[2]=="反余弦"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.acos (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="arctan" or numt1[2]=="反正切"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.atan (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="asinh" or numt1[2]=="反双曲正弦"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.asinh (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="acosh" or numt1[2]=="反双曲余弦"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.acosh (para3)
							numbers = 1
					if(numt1[2]=="atanh" or numt1[2]=="反双曲正切"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.atanh (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="abs" or numt1[2]=="绝对值"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							value = para1 * math.fabs (para3)
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					if(numt1[2]=="rand" or numt1[2]=="随机数" or numt1[2]=="抓阄"):
#						print("\tstrcacu函数输入值：",cacustrt3)
						if(self.IsNumber(cacustrt) and self.IsNumber(cacustrt3)):
							para3= math.fabs(float (cacustrt3))
							value = para1 * random.randint(1,int(para3)) #0608 radom.randint()
							numt1[1]=""
							numt1id[1]=0
							numt1[3]=""
							numt1id[3]=0
							numbers = 1
					else:#没有数字时略过
						passt=0
			else:#当第四栈数字标记为“无”时20230608
				if(numt1id[1]==1):#当第二栈数字标记为“有”时20230608
					cacustrt = numt1[1]#取第二栈数字
					if(self.IsNumber(cacustrt)):
						para1= float (cacustrt)
#					print("\tstrcacu函数输入值：",cacustrt)
					if(numt1[2]=="sin" or numt1[2]=="正弦"):
						
						if(self.IsNumber(cacustrt)):
							value = math.sin (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
#						print("\tself.IsNumber(cacustrt)值：",self.IsNumber(cacustrt))
#						else:print("\tcacustrt.isalnum()值：",cacustrt.isalnum())
					if(numt1[2]=="cos" or numt1[2]=="余弦" ):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.cos (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="tg" or numt1[2]=="正切"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.tan (para1)
							numbers = 1
					if(numt1[2]=="ctg" or numt1[2]=="余切"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = 1.0/math.tan (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="arcsin" or numt1[2]=="反正弦"):
		#				print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.asin (para1)
							numbers = 1
					if(numt1[2]=="arccos" or numt1[2]=="反余弦"):
						
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.acos (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="arctan" or numt1[2]=="反正切"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.atan (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="asinh" or numt1[2]=="反双曲正弦"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.asinh (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="acosh" or numt1[2]=="反双曲余弦"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.acosh (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="atanh" or numt1[2]=="反双曲正切"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.atanh (para1)
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					if(numt1[2]=="abs" or numt1[2]=="绝对值"):
#						print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							value = math.fabs (para1)
							print("\t\tabs中strcacu输入值是实数，计算结果(",value,")")
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
						else:
							print("\t\tabs中strcacu输入值不是实数，略过")
					if(numt1[2]=="rand" or numt1[2]=="随机数" or numt1[2]=="抓阄"):
		#				print("\tstrcacu函数输入值：",cacustrt)
						if(self.IsNumber(cacustrt)):
							para1= math.fabs(float (cacustrt))
							value = random.randint(1,int(para1)) #0608 radom.randint()
							numt1[1]=""
							numt1id[1]=0
							numbers = 1
					else:#没有数字时略过
						passt=0
			if(value != ""):#滚动输出
				if(numt1id[0]==1):
					if(not self.Formular(numt1[0])):
						strv=str(round(value,fmt))
					else:
						strv=str(value)
					mystr=numt1[0]+strv#0606 str(value)
					numt1id[0]=0
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				else:
					mystr=str(value)
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				print("一级运算",numt1[2],cacustrt,"\t计算结果值：(",value,")。mystr=",mystr)#20240625self.
				#20240626passt = 0#20240625
			else:#1014
				inow+=found1+1
			passt = 0#20240626
			i1=0#20240625 sin2*cos1.500+5^2lg5.00  正弦2乘余弦1.500加5幂2对数5.00
			while i1<listn:
				foundt = mystr.find(caculist1[i1],inow)#1014self.
				if(foundt>=0): 
	#				print("一级循环后，计算字符串[ ",mystr," ]中仍发现一级优先计算符(",caculist1[i1],")位于(",foundt,")>上次位置(",found1,")?")#self.
					if(foundt > found1):#20240625(foundt <= found1)
						rank = i1
						found1 =foundt
					passt = 1
	#				print("\n循环后一级运算位置1发现[",mystr,"]第(",rank,")运算串[",caculist1[rank],"]")#20240625)#self.
				i1 +=1
#		print("\n位置2",mystr)
		listn = len(caculist2)##20240625 3
		passt = 0
		found1 = len(mystr)
		rank =listn
		inow=0
		i1=0
		while (i1<listn):
			foundt = mystr.find(caculist2[i1],inow)
#			print("\t遍历一级计算串[",i1,"]=",caculist2[i1],"foundt=",foundt)
			if(foundt>=0): 
#				print("计算字符串[ ",mystr," ]中发现二级优先计算符(",caculist2[i1],")")#self.
				if(foundt <= found1):
					rank = i1
					found1 =foundt
				passt = 1
			i1+=1
		while(passt ==1):
			numbers = 0
			i3=rank
#			print("\t二级前strcacu->ArrangStr中运算符:",caculist2[rank])
			loclist=self.ArrangStr(mystr,caculist2[rank])#1014self.
			numt1id=loclist[0]
			numt1=loclist[1]
			value=""
			numbers=0
			if(numt1id[1]==1):
				if( numt1[2]=="^" or numt1[2]=="幂" or numt1[2]=="指数" or numt1[2]=="次方"):
					if(numt1id[1]==1):
						cacustrt1 = numt1[1]
						numt1id[1]=0
						numbers+=1
#						print("\tstrcacu函数输入值一：",cacustrt1)
					if(numt1id[3]==1):					
						cacustrt2 = numt1[3]
						numt1id[3]=0
						numbers+=1
#						print("\tstrcacu函数输入值二：",cacustrt2)
						para2= float (cacustrt2)
						numt1id[3]=0
					if((cacustrt1[0] == 'e') or (cacustrt1[0] == 'E')):
						numt1id[1]=0
						value = math.exp (para2)
					elif (numbers>=2) :
						para1= float (cacustrt1)
						prep = 1.0#20250423
						if(para1<0):
							prep = -1.0
							para1 = prep*para1
							if(para2<0):
								para2 = prep*para2
								prep = 1.0
						elif(para2<0):
							prep = -1.0
							para2 = prep*para2
						
						#numt1id[1]=0
#						print("\t指数计算：",cacustrt1,"^",cacustrt2,"=")#20240120
						value = prep*math.pow (para1,para2)#20250423发现负数指数出错
#						value = math.pow (para1,para2)

#						print(cacustrt1,"^",cacustrt2,"=",value)
				if( numt1[2]=="ln" or numt1[2]=="自然对数"):
					if(numt1id[3]==1):
						cacustrt3 = numt1[3]
						para3= float (cacustrt3)
						if(numt1id[1]==1):
							if(self.IsNumber(numt1[1]) and self.IsNumber(numt1[3])):
								cacustrt = numt1[1]
								numt1id[1]=0
								numt1id[3]=0
#								print("\tstrcacu函数ln输入值：",cacustrt)
								para1= float (cacustrt)
								#numbers =1
								value = para1 * math.log (para3)
								#print("\tln",cacustrt,"=",value)
					else:
						if(numt1id[1]==1):
							if(self.IsNumber(numt1[1])):
								cacustrt = numt1[1]
#								print("\tstrcacu函数ln输入值：",cacustrt)
								para1= float (cacustrt)
								#numbers =1
								value = math.log (para1)
								numt1id[1]=0
				if( numt1[2]=="lg" or numt1[2]=="对数" or numt1[2]=="十底对数"):
					if(numt1id[3]==1):
						cacustrt3 = numt1[3]
						para3= float (cacustrt3)
						if(numt1id[1]==1):
							cacustrt = numt1[1]
#							print("\tstrcacu函数ln输入值：",cacustrt)
							para1= float (cacustrt)
							#numbers =1
							value = para1 * math.log10 (para3)
							numt1id[1]=0
							#print("\tlg",cacustrt,"=",value)
#						print("\n\tmystr值更新为",mystr)
					else:
						if(numt1id[1]==1):
							cacustrt = numt1[1]
#							print("\tstrcacu函数ln输入值：",cacustrt)
							para1= float (cacustrt)
							#numbers =1
							value = math.log10 (para1)
							numt1id[1]=0
							#print("\tlg",cacustrt,"=",value)
		#				mystr=str(value)
#						print("\n\tmystr值更新为",mystr)
			if(value != ""):#滚动输出
				if(numt1id[0]==1):
					if(not self.Formular(numt1[0])):
						strv=str(round(value,fmt))
					else:
						strv=str(value)
					mystr=numt1[0]+strv#0606 str(value)
					numt1id[0]=0
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				else:
					mystr=str(value)
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				print("二级运算计算结果值：",value,"\tmystr=",mystr)#self.
				#self.ui.lineEdit_3.setText(self.mystr)
			else:
				inow+=found1+1
			passt = 0
			found1 = len(mystr)
			rank =listn
			i2=0
			while(i2<listn):
				foundt = mystr.find(caculist2[i2],inow)#1014#self.
				#foundt = found(caculist2[i1],str)
				if(foundt>=0): 
					if(foundt <= found1):
						rank = i2
						found1 =foundt
					passt = 1
				i2+=1
#		print("\n位置3",mystr)#self.
		listn = len(caculist3)##20240625 2
		passt = 0
		found1 = len(mystr)#self.
		rank =listn
		inow=0
		i1=0
		while(i1<listn):
			foundt = mystr.find(caculist3[i1],inow)
			if(foundt>=0): 
#				print("计算字符串[ ",mystr," ]中发现三级优先计算符(",caculist3[i1],")")#self.
				if(foundt <= found1):
					rank = i1
					found1 =foundt
				passt = 1
			i1+=1
		while(passt ==1):
			numbers = 0
			i3=rank
#			i5=0
#			print("\t三级前strcacu->ArrangStr中运算符:",caculist3[rank])
			loclist=self.ArrangStr(mystr,caculist3[rank])
			numt1id=loclist[0]
			numt1=loclist[1]
			value=""
			if(numt1id[3]==1):
				if( numt1[2]=="*" or numt1[2]=="乘" or numt1[2]=="×"):
					if(numt1id[1]==1):
						cacustrt1 = numt1[1]
#						print("\tstrcacu函数输入值*：",cacustrt1)
						if(cacustrt1.isdigit() or (cacustrt1[0]=='-' and cacustrt1[1:].isdigit())):
							para1= int (cacustrt1)
						else:
							para1= float (cacustrt1)
						#para1= float (cacustrt1)
						numbers +=1
						numt1id[1]=0
					if(numt1id[3]==1):
						cacustrt2 = numt1[3]
#						print("\tstrcacu函数输入值：",cacustrt2)
						if(cacustrt2.isdigit() or (cacustrt2[0]=='-' and cacustrt2[1:].isdigit())):
							para2= int (cacustrt2)
						else:
							para2= float (cacustrt2)
						#para2= float (cacustrt2)
						numbers +=1
						numt1id[3]=0
					if(numbers>1):
						value = para1 * para2
				if( numt1[2]=="/" or numt1[2]=="除以" or numt1[2]=="÷"):
					if(numt1id[1]==1):
						cacustrt1 = numt1[1]
#						print("\tstrcacu函数输入值/：%s\n",cacustrt1)
						if(self.floatfmt(cacustrt1)==0):
							para1= int (cacustrt1)
						else:
							para1= float (cacustrt1)
						#para1= float (cacustrt1)
						numbers +=1
						numt1id[1]=0
					if(numt1id[3]==1):
						cacustrt2 = numt1[3]
#						print("\tstrcacu函数/输入值：%s\n",cacustrt2)
						if(self.floatfmt(cacustrt2)==0):
							para2= int (cacustrt2)
						else:
							para2= float (cacustrt2)
						#para2= float (cacustrt2)
						numbers +=1
						numt1id[3]=0
					if(numbers>1):
						if(math.fabs(para2)<1e-10):
							print("除数不能为零！\n")
						else :
							value = para1 / para2
			if(value != ""):#滚动输出
				if(numt1id[0]==1):
					if(not self.Formular(numt1[0])):
						strv=str(round(value,fmt))
					else:
						strv=str(value)
					mystr=numt1[0]+strv#0606 str(value)
					numt1id[0]=0
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				else:
					mystr=str(value)
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
#				print("三级运算结果值：",value,"mystr=",mystr)
			else:
				inow+=found1+1
			passt = 0
			found1 = len(mystr)
			rank =listn
			i1=0
			while(i1<listn):
				foundt = mystr.find(caculist3[i1],inow)
				#foundt = found(caculist3[i1],str)
				if(foundt>=0): 
					if(foundt <= found1):
						rank = i1
						found1 =foundt
					passt = 1
				i1+=1
#		print("\n位置4",mystr)#四级运算开始，＋，－
		listn = len(caculist4)##20240625 2
		passt = 0
		found1 = len(mystr)
		rank =listn
		inow=0
		i1=0
		while(i1<listn):
			foundt = mystr.find(caculist4[i1],inow)
			if(foundt>=0): 
#				print("计算字符串[ ",mystr," ]中发现四级优先计算符(",caculist4[i1],")")#self.
				if(foundt <= found1):
					rank = i1
					found1 =foundt
				passt = 1
			i1+=1
		while(passt ==1):
			numbers = 0
			i3=rank
			i5=0
#			print("\t四级前strcacu->ArrangStr中运算符:",caculist4[rank])
			loclist=self.ArrangStr(mystr,caculist4[rank])
			if(len(loclist)>0):
				numt1id=loclist[0]
				numt1=loclist[1]
			else:
				numt1=[0,0,0,0,0]
			value=""
			if(numt1id[3]==1):
				if( numt1[2]=="+" or numt1[2]=="加" or numt1[2]=="＋"):
					if(numt1id[1]==1):
						cacustrt1 = numt1[1]
						if(cacustrt1.isdigit() or (cacustrt1[0]=='-' and cacustrt1[1:].isdigit())):
							para1= int (cacustrt1)
						#	print("整数",para1)
						else:
							para1= float (cacustrt1)
						#	print("实数",para1)
						numbers +=1
						numt1id[1]=0
						#print("\tstrcacu函数输入值1：",cacustrt1)
					if(numt1id[3]==1):
						cacustrt2 = numt1[3]
						if(cacustrt2.isdigit() or (cacustrt2[0]=='-' and cacustrt2[1:].isdigit())):
							para2= int (cacustrt2)
						#	print("整数",para2)
						else:
							para2= float (cacustrt2)
						#	print("实数",para2)
						numbers +=1
						numt1id[3]=0
						#print("\tstrcacu函数输入值2：",cacustrt2)
					else :
						passt=1
						break
					if(numbers>1):
						value = para1 + para2
						numbers = 2
				if( numt1[2]=="-" or numt1[2]=="减" or numt1[2]=="－"):
					if(numt1id[1]==1):
						cacustrt1 = numt1[1]#v0.73
						if(cacustrt1.isdigit() or (cacustrt1[0]=='-' and cacustrt1[1:].isdigit())):
							para1= int (cacustrt1)
							#print("整数",para1)
						else:
							para1= float (cacustrt1)
						numbers +=1
						numt1id[1]=0
					if(numt1id[3]==1):
						cacustrt2 = numt1[3]
						if(cacustrt2.isdigit() or (cacustrt2[0]=='-' and cacustrt2[1:].isdigit())):
							para2= int (cacustrt2)
							#print("整数",para2)
						else:
							para2= float (cacustrt2)
						numbers +=1
						numt1id[3]=0
					else :
						passt=1
						break
					if(numbers>1):
						value = para1 - para2
						numbers = 2
					passt = 0
					found1 = len(mystr)
					rank =listn
					i1=0
					while(i1<listn):
						foundt = mystr.find(caculist4[i1],inow)
						if(foundt>=0): 
							if(foundt <= found1):
								rank = i1
								found1 =foundt
							passt = 1
						i1+=1
				else:
					passt=0
			if(value != ""):#滚动输出
				if(numt1id[0]==1):
					if(not self.Formular(numt1[0])):
						strv=str(round(value,fmt))
					else:
						strv=str(value)
					mystr=numt1[0]+strv#0606 str(value)
					numt1id[0]=0
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]
						numt1id[4]=0
				else:
					mystr=str(value)
					if(numt1id[4]==1):
						mystr=mystr+numt1[4]#self.#self.
						numt1id[4]=0
	#			print("四级运算计算结果值：",value,"mystr=",mystr)
			else:
				inow+=found1+1
			#print("\n位置5",mystr)
			listn = 2
			passt = 0
			found1 = len(mystr)
			rank =listn
			i1=0
			while(i1<listn):
				foundt = mystr.find(caculist4[i1],inow)
				if(foundt>=0): 
					if(foundt <= found1):
						rank = i1
						found1 =foundt
						passt = 1
#					print("计算字符串[ ",mystr," ]中发现四级优先计算符(",caculist4[i1],")","foundt=",foundt,",found1=",found1,",passt=",passt)
				i1+=1
		print("\t\t\tstrcacu返回值『",mystr,"』")
		return mystr







# 688 26       (5683 0 0)

	def Formular (self,string):#检测计算符
		caculist=["sin","cos","tg","ctg","arcsin","arccos","arctg","sinh","cosh","tgh","abs","rand","^", "ln", "lg","*","/","+", "-","正弦","余弦","正切","余切","反正弦","反余弦","反正切","反双曲正弦","反双曲余弦","反双曲正切","绝对值","随机数","抓阄","幂","指数","次方","自然对数","对数","十底对数","乘","×","除以","÷","加","＋","减","－"]
		ls=len(string)
		lcl=len(caculist)
		Np=False
		Cp=False
		Fp=False
		for i in range(ls):
			if (string[i].isdigit()):
				Np=True
				break
		for i in range(lcl):
			lc=len(caculist[i])
			if(string[-lc:]==caculist[i]):
				Cp=True
		if(Np and Cp):
			Fp=True
			return Fp







# 26 239            (6372 0 0)

	def ArrangStr (self,lstr,symb):#字串数、符分拆至五位列表#20240625
		#lstr为字串，symb为运算符,五位列表：符、数、符、数、符
#		caculist =  ["sin","cos","tg","ctg","arcsin","arccos","arctg","sinh","cosh","tgh", 							"abs","rand", "ln", "lg"]#20030608
		state = 0
		statet = 0
		n5=[]
		i1=0
#		print("\n进入ArrangStr,字符串为：[ ",lstr," ]运算符为：[",symb,"]\n")#(21.6^2+10^2)^0.5
		bracketn = 0
		slen = len (symb)
		xlen = len (lstr)
		ncs = 0
		nct = 0
		nct1 = 0
		pd0 = 0
		pd1 =0 
		founds=0
		pd3 = 0 
		strt = ""#'\0'
		numtt=numt=""
		numt1=["","","","",""]#self.
		numt1id=[0,0,0,0,0]#self.
		if(symb=='-'):
			founds=lstr.find(symb,1)#20250316
		else:
		
			founds=lstr.find(symb)
#		founds=lstr.find(symb)
		NumberP=self.IsNumber(lstr)
#		print("\t字串中发现运行符的位置为 ",founds,"是否数字:",NumberP)#20240625
		loclist=[]
		if(founds>=0 and (not NumberP)):
			while(nct < xlen):
				strnl = lstr[nct]#字串遍历 10+30^2*sinln4
#				print("\n循环中,运算符为：[ ",symb," ]字符串为：[",lstr,"]\n")#30+50+70
#				print("\n总共",xlen,"个字符，操作第",nct,"个字符，同类第",nct1,"个字符，当前字符[",strnl,"]")
#				print("\n五位栈表当前：",numt1,"\n五位栈标记表当前：",numt1id,"中转串numtt[",numtt,"]\n")
				#字串是数字？#正负号#科学计数
				if (strnl.isdigit( ) or (strnl == '.') or (strnl == 'e')  or (strnl == 'E') or 
						(((strnl == '-')or(strnl=='+')) and (nct==0)) or 
						(((strnl == '-')or(strnl=='+'))	and ((lstr[nct-1] == 'e')or(lstr[nct-1] == 'E')))
					):
					state = 1
				else: state=0
#				print("状态参数：statet=",statet,"\tstate=",state)
				if(statet == state):#数与非数状态不变
					#print("\n\t数与非数状态不变")
					#print("\tnumt：",numt,"\tnumtt=",numtt,"\tnct1=",nct1)
					if(nct == (xlen-1)):#末字符时
						numt=numt+strnl#字串追加
						numtt=numt#记录字串
						if(state==1):#是数字
							if(numt1id[1]==0):
								numt1[1]=numtt#写入“数1串”栈[前串，数1串,运算串,数2串，后串]
								numt1id[1]=1#标记有“数1串”
								#print("\n\t分支1-1-1列表numt1：",numt1)
								#print("\n\t分支1-1-1列表numt1id：",numt1id)
							else:
								numt1[3]=numtt#已有“数1串”时写入“数2串”栈
								numt1id[3]=1#标记有“数2串”
								#print("\n\t分支1-1-2列表numt1：",numt1)
								#print("\n\t分支1-1-2列表numt1id：",numt1id)
						else:#不是数字
							if(numt1id[4]==0):
								numt1[4]=numtt#写入“后串”
								numt1id[4]=1#标记有“后串”
								#print("\n\t分支1-1-3列表numt1：",numt1)
								#print("\n\t分支1-1-3列表numt1id：",numt1id)
						break
					elif(nct==founds):#非末字#运算符处10+30^2*sinln4 1+2^3					
						numtt=numt #记录之前串符
						numt=strnl
						if(numt1id[0]==0):#"前串"栈空时，压栈
							numtp=lstr[0:nct]
							numt1[0]=numtp#列表第1格记录"前串"
							numt1id[0]=1#标记有"前串"
							numt1[2]=symb#列表第3格记录"运算串"
							numt1id[2]=1#标记有"运算串"
							nct+=slen-1
							state=0
							nct1=0
							numt=numtt=""
							#print("\n\t分支1-2高级运算符前串:",numtp)
					elif (strnl=="-"):#1014非末字为-号
						if(lstr[nct-1]!='e' and lstr[nct-1]!='E'):#v0.60
							if(nct<xlen-1):
								if(lstr[nct+1].isdigit( )):
									numtt=numt #记录之前串符
									numt=strnl
									#print("\t分支1-3数与非数状态未改变，但为‘-’号")
									#print("\tnumt：",numt,"\tnumtt=",numtt,"\tnct1=",nct1)
									nct1=0
									state=1
						else:#v0.60
							numt=numt+strnl					
					else:#非末字非运算符处
						numt=numt+strnl					
					nct1+=1
				else :#数与非数状态改变	
					numtt=numt #记录之前串符
					numt=strnl
		#			print("\t分支２数与非数状态改变")
		#			print("\tnumt：",numt,"\tnumtt=",numtt,"\tnct1=",nct1)
					nct1=0
					if(state==0):#分割串非数字时+
#						print("\t分支2-1为数字转非数字状态")
						if(nct == 0):#首字时
							numt=strnl
							#print("\n\t分支2-1-1首字串numt：",numt,"\tnct1=",nct1)
							nct1+=1#设置变化位置
						else:
							#numtt=numt #记录之前数符v0.6
							#numt=strnl#v0.6
							if (nct == (xlen-1)):#末字时
								#print("\n\t分支2-1-3末字串numt：",numt,"\t串长nct1=",nct1,"\tnumtt=",numtt)
								if(numt1id[1]==0):#"数1"栈空时，压栈
									numt1[1]=numtt#列表第2格记录运算串
									numt1id[1]=1#标记有"数1"
								elif (numt1id[3]==0):#"数2"栈空时，压栈
									numt1[3]=numtt#列表第4格记录运算串
									numt1id[3]=1#标记有"数2"
								if (numt1id[4]==0):
									numt=numt+strnl
									numt1[4]=numt#字串追加压入[后串栈]
									numt1id[4]=1#标记有后串
							elif(nct==founds) :#中字达到高级运算符时压栈数据
								#print("\n\t分支2-1-2中字串numt：",numt,"\tnumtt=",numtt)
								#print("\n\t\t分支2-1-2-1“数1串”空,压栈",numtt)
								numt1[1]=numtt#压栈列表第2格
								numt1id[1]=1#标记有“数1串”
								numt1[2]=symb#压栈列表第3格
								numt1id[2]=1#标记有“运算串”
								nct1=len(numtt) #临时借用nct1变量							
								if(nct1<nct+1):
									numt1[0]=lstr[0:founds-nct1]#压栈列表第1格
									numt1id[0]=1#标记有“前串”
								nct+=slen-1
								nct1=0
							elif(nct>founds+slen):
								#print("\n\t分支2-1-4中运算串后numtt：",numtt)						
								if(numt1id[1]==0) :#运算符后时，检查“数２串”栈
									#print("\n\t分支2-1-4-1中数2串压栈")	
									#if(IsNumber(numtt)):
										#print("\n\t分支2-1-4-1-1中运算串后有数")						
									numt1[1]=numtt#压栈列表第2格
									numt1[4]=lstr[nct:]#压栈列表第5格
									numt1id[1]=1#标记有“数1串”
									numt1id[4]=1#标记有“后串”
								elif(numt1id[3]==0) :#运算符后时，检查“数２串”栈
									#print("\n\t分支2-1-4-1中数2串压栈")	
									#if(self.IsNumber(numtt)):
										#print("\n\t分支2-1-4-1-1中运算串后有数")						
									numt1[3]=numtt#压栈列表第4格
									numt1[4]=lstr[nct:]#压栈列表第5格
									numt1id[3]=1#标记有“运算串”
									numt1id[4]=1#标记有“后串”
								#print("\n\t分支2-1-4列表numt1：",numt1)
								#print("\n\t分支2-1-4列表numt1id：",numt1id)
								break	
					else:#分割串数字时5
			#			print("\t分支２－２为非数转数字状态")
						if(nct == 0):#首字时
							numt=strnl
#							print("\n\t分支2-2-1首字串numt：",numt,"\tnct1=",nct1)
							nct1+=1#设置变化位置
						else:#非首字时5
	#						numtt=numt
	#						numt=strnl
							if (nct == (xlen-1)):#末字时
			#					print("\n\t分支2-2-2末字串numt：",numt,"\t串长nct1=",nct1,"\tnumtt=",numtt)
								if(numt1id[2]==0):#"运算串"栈空时，压栈实际分割串
									numt1[2]=numtt#列表第3格记录运算串
									numt1id[2]=1#标记"运算串"
								elif(numt1[2]!=symb):#0603numtt):#检查实际分割串与"运算串"不同时清空退出
			#						print("\n\t分支2-2-2-1实际分割运算串[",numtt,"]与运算符[",symb,"]不同，处理清除")
									numt1id=[0,0,0,0,0]
									break	
								if(numt1id[1]==0):
									numt1[1]=numt#列表第2格记录"数1"串
									numt1id[1]=1#标记"数1"
								else:
									numt1[3]=numt#列表第4格记录"数2"串
									numt1id[3]=1#标记"数2"
								nct1+=1#0603
							elif(nct==founds) :#运算符时
#								print("\n\t分支2-2-3中运算串numtt：",numtt)						
								if(numtt==symb):#判断是"运算串"
#									print("\n\t分支2-2-3-1是运算串！")						
									if(numt1id[2]==0):#“运算串”栈空时
#										print("\n\t分支2-2-3-1-1运算串空 ，压栈")						
										numt1[2]=numtt#压栈列表第2格
										numt1id[2]=1#标记有“运算串”
									else:#“运算串”满时,压入后串栈
#										print("\n\t分支2-2-3-1-1运算串满，压入后串退出！")						
										numt1[4]=lstr[nct-1:]#列表第5格记录后串
										numt1id[4]=1#标记有“后串”
										nct=xlen#退出
								else:#判断非"运算串"
#									print("\n\t分支2-2-3-2非运算串！")						
									if(numt1id[0]==0):#“前串”栈空时，压栈
										numt1[0]=numtt#列表第3格记录“前串”
										numt1id[0]=1#标记有“前串”
							elif(nct==founds+slen+1):#v0.969(nct>founds+slen):
				#				print("\n\t分支2-2-４中运算串后numtt：",numtt)						
								if(numt1id[3]==0) :#运算符后时，检查“数２串”栈
									if(self.IsNumber(numtt)):
#										print("\n\t分支2-2-4-1中运算串后有数")						
										numt1[3]=numtt#压栈列表第2格
										numt1[4]=lstr[nct]#压栈列表第5格
										numt1id[3]=1#标记有“数２串”
										numt1id[4]=1#标记有“后串”
									else:	
#										print("\n\t分支2-2-4-2中运算串后无数")						
										numt1[4]=lstr[nct-len(numtt)]#压栈列表第5格
										numt1id[4]=1#标记有“后串”
								break	
							elif(nct>founds+slen+1):
								if(numt1id[2]==1):
									if(numt1[2]!=numtt):
					#					print("\n\t分支2-2-5中实际分割运算串[",numtt,"]不同于运算符[",symb,"]处理清除")
										numt1id=[0,0,0,0,0]
										break	
#				print("\n字串栈：",numt1)
#				print("\n字串栈标记：",numt1id)
				nct+=1
				strt = strnl
				statet =state 
			loclist.append(numt1id)
			loclist.append(numt1)
#		print("\nArrangStr输出五位栈表：",loclist)
		return loclist
	






# 239 10           (6244 0 0)

	def dismiss_popup(self):#取消弹出框
		self._popup.dismiss()







# 10 43           (6701 0 0)

	def QuitRun (self):#日志后退出
		print("\n进入QuitRun")
#		self.Diary()		
		#QCoreApplication.instance().quit
		writep = False#20241106记忆上次的文本大小
		path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		with open(path,mode='r+t',encoding='UTF-8') as f:
			data = f.read()
			dlist = data.split("\n")
			ld = len(dlist)
			dsp = dlist[1].split()#第二行转为表
			fs = self.texthi#202503263self.text_screen.ids.Enlarge_Edit.font_size#保存文本窗口的字高
			print("\t探测当前文本窗口字高(",fs,")")
			if(len(dsp)>1):#探测设置文件的第二行为多词时
				txthi = dsp[1]#读取设置文件的第二行第二词
				print("\t\t准备替换修改设置文件原有第二行第二词的文本窗口字高(",txthi,")")
				if( fs != int(txthi)):#如果上次设置与当前字高不同
					dlist[1] = dsp[0] + " " + str(fs)#修改第二行第二词设置内容
					print("\t\t\t完成修改设置文件原有第二行第二词的文本窗口字高为(",fs,")")
					writep = True#触发覆盖标记
			else:#探测设置文件的第二行只有一词时
				print("\t\t设置文件第二行只有一词，增设字高(",fs,")")
				dlist[1] = dsp[0] + " " + str(fs)
				writep = True
			
		if writep:
			with open(path,mode='w+t',encoding='UTF-8') as f1:#20241106记忆上次的文本大小
				for i in range(ld-1):
					f1.write(dlist[i]+"\n")
				f1.write(dlist[ld-1])
		
		path=os.path.join(os.getcwd(),MenuScreen.IndexFile)	#20241127
#		with open(path,mode='w+t',encoding='UTF-8') as f1:#20241127正常退出时清空索引文件20250317保留方便调试
#			f1.write("")
		sys.exit()







# 43 37           (6650 0 0)

	def IsFloat (self,localstr):#字串是否浮点实数检测
#		print("进入IsFloat",localstr)
		lens=len(localstr)
		i1=0
		state=0
		while(i1<lens):
			if(i1==0):
				if (localstr[i1].isdigit( ) or (localstr[i1] == '.') or #字串是数字？
					(localstr[i1] == '-') or (localstr[i1]=='+')):
					state+=0
#					print("\t\t",localstr[i1])
				else:
					state+=1
#					print("\tstate=",state)
			else:
				if ((localstr[i1] == '.') or localstr[i1].isdigit( )):
					state+=0
#					print("\t\t",localstr[i1])
				else:
					state+=1
#					print("\tstate=",state)
			i1+=1
		if state>0:
#			print("\t字串[",localstr,"]不是纯浮点数。")
			justnumber=False
		else: 
#			print("\t字串[",localstr,"]是纯浮点数。")
			justnumber=True
		return justnumber







# 37 359       (6694 0 0)

	def AltStr (self,slecstr,digit_num,expbnow):#分层拆解括号串
#digit_num,8模块判断小数位数，>=0表强制输出小数位,-3表示不计算；expbnow表示计算1与否0,也表示当前表首项self.Expbnow位置
	#	self.menu_screen.ids.Text_Edit.text += "3"#0913
		print("\n\t＝＝＝进入计算字符串分解方法AltStr[",slecstr,"],digit_num(",digit_num,")")
		mystr=slecstr#测试计算字串 2str3*sin2.000 3str2*cos3.000
#		print("字串为：",mystr)
		strpara=" "
		str1=mystr
#		print("字串为：",str1,"分割符为[",strpara,"]")
		strlist=str1.split()#strpara
		ns = len(strlist)
	#	print("一级分解后计算字符串成为表：",strlist,"\t共",ns,"项")
		itt=0
		pickp=False
		while(itt<ns):#各表项遍历
			mystr= strlist[itt]
			str1t = strlist[itt]#分解的字串项
#			print("\n从0第(",itt,")项分解的字串项：",str1t)
			fmt=self.floatfmt(str1t)#v0.60
			print("\t查表达式，字串小数位数(",fmt,")")
			if(digit_num>=0 and digit_num!=8):#0913
				fmt=digit_num
			print("\t结合输入后，字串小数位数(",fmt,")")
			bracketn = 0
			slen = len( str1t)
			nct =0 
			while(nct < slen):
				strn = str1t[nct]
				nct+=1
				if(strn == '('):
					bracketn = bracketn+1
#			print("字符",str1t,"有(",bracketn,")个括号")
			nct1=0
			k1=0
			passn=0
			while(k1<=bracketn):#v0.951while(k1<bracketn):#各层括号解析
				if(passn>=slen-1):
#					print("\n\t(",k1,")循环入口，忽略串长(",passn,")>=净字符数(",slen,")故归零")	#20240204
					passn = 0
					break
				bracketnt = 0
				numn = 0
				bracketb = 0
				brackete = 0
				nct = 0
				sta = 1
				slen = len( str1t)
#				print("\t扫描小括号已至(",passn,")位[",str1t[:passn+1],"]")	#20240204
				while (nct < slen):#找出(需拆解的)最内层括号序号v0.963
					if(nct>nct1+passn):
						strn = str1t[nct]
#						print("\t",strn,end="")
						if(strn == '(') :
							bracketnt = nct
						if(strn==')') :#20240204
							if(bracketnt>=passn):
								bracketb = bracketnt
								brackete = nct
								break
					nct +=1
				sta=brackete-bracketb-1#最内层括号内字符数
				if(bracketb+1<slen):#20240204#20240616
#					print("\t第",k1,"层括号开始于(",bracketb,")位之[",str1t[bracketb+1],"]前,结束于[",str1t[brackete-1],"]后(",brackete,")位，净字符数(",sta,")忽略串长(",passn,")")#20240616
					if(bracketn==0):#20240415括号数为0，即字串没有括号时#20240616后退一档
						prestr =""
						midstr = mystr#strlist[itt]#str1t
						endstr =""
						oristr=""
					elif(k1==bracketn):#运行到括号数为最多层时，即最外层时
						prestr =""
						midstr = str1t
						endstr =""
						oristr=""
					else:#运行最外层以内的括号时
						prestr = str1t[0:bracketb]
						midstr = str1t[(bracketb+1):brackete]
						endstr = str1t[(brackete+1):]
						oristr=midstr
#				print("\t",str1t,"第(",k1,")层括号分解后，前串[",prestr,"]\t中串[",midstr,"]\t后串[",endstr,"]操作格式行号(",expbnow,")")
				if(expbnow>=0):#!=0):v0.952由之前的计算标志修改为全显页顶行
	#				print("\t非首页，判断为需变量代换，串长",len(midstr))
					transferp=False
					bracketparaP=False#带括号变量判断20240616
					if (len(midstr) >0):#!= 0):
#						print("\t\talt中间字串：",midstr)
#						if(midstr.find('@')>=0):#midstr[0]=='@'):
						if(midstr[0]=='@'):
							#20250317考虑从数据文件读入
							if(self.FDataP):#如果编辑行不空，经判断为数据文件时，不经对话框而直接读入对应序号的字符
								if(self.NFData<len(self.FDataList)):
									midstr = self.FDataList[self.NFData]
#									print("\t\t首字为@，直接从数据文件读入(",self.NFData,")项[",midstr,"]")#如果字串末为#时，表示取为关键词20230224v0.981
									self.NFData += 1#序号递增
							else:
							
								print("\t\t首字为@，AltStr准备弹出框运行")
								#如果字串末为#时，表示取为关键词20230224v0.981	
								midstr = self.PopList(midstr,expbnow)
								#self.PopList(midstr,expbnow)#0724
								#midstr = rslist
								if(midstr!=""):#len(midstr)>0):#20230225
									transferp=True
#									print("\t\t\tAltStr从弹出框获得输入[",midstr,"]字长",len(midstr),"输入有效")
								else:#0805
									MenuScreen.AutoMode=False
#									print("\t\t\tAltStr从弹出框获得输入[",midstr,"]字长(",len(midstr),")为零，故无效，自动摘录模式：",MenuScreen.AutoMode,"取消")
									
						elif(midstr[0]=='?'):#20250317
							print("AltStr中进入三元条件判断模块AltCond，字串[",midstr,"]")
							midstr = self.AltCond(midstr)


									
						elif(midstr[0]=='!' or midstr[0]=='！'):#0327导入内部取值time
							if(midstr[1:]=="时间"):
								midstr=self.menu_screen.Ztime(1)#20240902 self
			#					print("\t\t首字!字符串，返回时间[",midstr,"]")
							elif(midstr[1:]=="与关键词"):
								midstr=self.KVWordStr#0902KeyWordStr
								print("\t\t首字!字符串，返回'与'关键词[",midstr,"]")
							elif(midstr[1:]=="或关键词"):
								midstr=self.KVWordStr2#0902KeyWordStr2
								print("\t\t首字!字符串，返回'或'关键词[",midstr,"]")
							elif(midstr[1:]=="LastKey"):
								midstr=self.LastKey
			#					print("\t\t首字!字符串，返回LastKey[",midstr,"]")


						elif(not self.IsNumber(midstr)):
						#如果有非数字符，进行解析，比如灭火器配置((长)^2+(宽)^2)^0.50
							print("\t\t首字非@，进入非弹出框操作，非?（非三元判断操作），判断是否适用picklist")
							
							nabeP=False
							lmid=len(midstr)
							if(midstr.find(':')>=0):
#								if(midstr.find('~')>=0):#202504213检测灭火器设计时注消此行，下行退一档
									nabeP=True
							if(midstr.find('?')>=0):
								nabeP=True
							if(midstr.find(',')>=0):
								nabeP=True
							if nabeP:
		#						print("\t\t\t",midstr,"首字非@，内含:?,字符串分支2,调用PickList求值,操作格式行号[",expbnow,"]")
								pklist=self.PickList(midstr,expbnow)
#								print("\t\tIn Altstr, Picklist返回表",pklist)
								lp=len(pklist)
								if(lp==1):
									midstr=pklist[0]
								elif(lp>=2):#0912(lp==2):
									midstr=pklist[0]
#									if(len(pklist[1])>0):#20250317准备删
#										pickstr2=pklist[1]
#										pickp=True
									pickstr2 = ""#20250317#202504213因灭火器配置而恢复
									for ipk in range(1,lp):#20250208
										if(len(pklist[ipk])>0):	
											if(ipk==1):
												pickstr2 = pklist[ipk]
											else:
												pickstr2 += ' ' +pklist[ipk]
											pickp=True
											
								print("\t\t\t选取首项返回结果[",midstr,"]，第二项附于总返回值末")
								transferp=True
							elif(midstr.find('#')>=0):#末尾#表示有小数进一取整
								if(self.IsNumber(midstr[:-1])):
									midstr=self.EngInt(midstr[:-1])
#								print("\t\t\t\t无@有#字符串分支4,小数进一取整成",midstr)
							elif(midstr.find('、')>=0 and midstr.find('；')>=0):#当发现关键词或条件分割符'、',与条件'；'时，搜索并弹出框
			#					print("\t\t\t发现特殊符号[、][；]，准备进入弹框搜索->")
								midstr=self.HuntPop(midstr)#20230224v0.981***
								if(midstr!=""):#len(midstr)>0):#20230905
									transferp=True
			#						print("\t\t\tAltStr从弹出框获得输入[",midstr,"]字长",len(midstr),"输入有效")
								else:#0805
									MenuScreen.AutoMode=False
			#						print("\t\t\tAltStr从弹出框获得输入[",midstr,"]字长",len(midstr),"为零，故无效，自动摘录模式：",MenuScreen.AutoMode,"取消")
							elif(midstr[:2]=='[]'):#20250317查到文件表格式时返回相应值
								midstr = self.FData(midstr,"")
								print("\t\t\tAltStr从文件表读入[",midstr,"]")

							else:#就在索引文件中找变量的赋值，如灭火器配置	((长)^2+(宽)^2)^0.50
								print("\t\t\t\t无@无:?;#字符串分支5")
								Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)
			#					print("摘引文件字串为[",Indexpath,"]")
								fh1=open(Indexpath,mode='r+t',encoding='UTF-8')
								if fh1:
									data=fh1.read()
									filelist=data.split("\n")
									fh1.close()
								print("midstr[",midstr,"]准备搜索摘引文件变量")
								if(data.find(midstr)>=0):
									print("\t\tAltStr搜寻索引文件:",Indexpath,"扫描发现待确认赋值变量字串[",midstr,"]digit_num=(",digit_num,")")
									parap=False
									lf=len(filelist)
									for il in range(lf-1,0,-1):#
										linedata=filelist[il]
										lls=len(linedata.split())
										if(lls>3):
									#		print("\t扫描",il,"行[",linedata,"]")
											loclist=self.psplit(linedata,'"','"')
											llsp=len(loclist)
									#		print("\t\t双引号分割成的列表项数:",llsp)
											if(llsp>=3):
												if(loclist[2].find(midstr)>=0):
													if(loclist[1][1:-1].strip()):
														parap=True
														strt=loclist[1][1:-1]#midstr
														if(strt[-1]=='⌇'):
															strt=strt[:-1]
														print("\t\t搜索摘引文件",il,"行",loclist[2],"中发现字串[",midstr,"]->变量值确认为[",strt,"]")
														break
									#		else:
									#			print("\t\t双引号拆分列表项数小于3")
									if parap:#导出变量值进行字串替换
										midstr=strt
									if(digit_num!=-3):#20240415
#										print("\t\t\tAltstr中间1待计算字串[",midstr,"]digit_num=",digit_num)
										if(midstr.find("(")<0):#20240415增加判断，不然计算含括号算式产生错误
											if (not self.IsNumber(midstr)):#20240415
												midstr=self.strcacu(midstr,fmt)
#20250317digit_num	#202504233灭火器配置小数位恢复，但又妨碍了管网平差精度，故又舍弃，下二同
#												midstr=self.strcacu(midstr,digit_num)

												print("\t\t\t检测为算式，计算后成为字串[",midstr,"]")
										else:#20240616
											print("\t\t\t检测到变量为带括号算式字串[",midstr,"]")
											bracketn1 = 0
											slen1 = len( midstr)
											nct2 =0 
											while(nct2 < slen1):
												strn1 = midstr[nct2]
												nct2+=1
												if(strn1 == '('):
													bracketn1 = bracketn1+1
											if(bracketn1>0):
												str1t = midstr
												bracketn=bracketn1
												bracketparaP=True
											print("\t\t\t变量字符串[",midstr,"]有(",bracketn,")个括号")

									if(midstr==oristr and (not self.IsNumber(midstr))):
										midstr='('+midstr+')'
										passn=brackete#20240204sta+2改‘+=’#括号查找点后推到忽略括号后
#										print("\t\t\t变量代换未确认,返回原表字串[",midstr,"]忽略串长(",passn,")")
								else:
									if(digit_num!=-3):
#										print("\t\t\tAltstr中间2待计算字串[",midstr,"],digit_num[",digit_num,"]")
										if(not self.IsNumber(midstr)):#0914
											midstr=self.strcacu(midstr,fmt)
											#20250317digit_num	#202504233灭火器配置小数位恢复
#											midstr=self.strcacu(midstr,digit_num)

										print("\t\t\t计算后字串成为[",midstr,"]")
									if(midstr==oristr):#20240616
#										print("\t\t\tAltstr中间3待计算字串[",midstr,"],digit_num[",digit_num,"]算式判断：",self.IsNumber(midstr))
										if( not self.IsNumber(midstr)):
											midstr='('+midstr+')'
											passn =brackete #20240204改‘+=’ sta+2#括号查找点后推到忽略括号后
#											print("\t\t变量代换搜寻摘引文件:",Indexpath,"未找到变量代换,返回原表字串[",midstr,"]")
										else:#20240616
											midstr=self.strcacu(midstr,fmt)
											#20250317digit_num	#202504233灭火器配置小数位恢复
#											midstr=self.strcacu(midstr,digit_num)

											#passn =brackete #20240204改‘+=’ sta+2#括号查找点后推到忽略括号后
											print("\t\t变量为算式,返回计算结果字串[",midstr,"]")

						print("\t首字符解析后，midstr＝",midstr)#20250321
						mystr=midstr
						str1t=prestr+mystr
						str1t=str1t+endstr
						mystr=str1t
						midstr=str1t#v0.951
						nct1=0#20240204
#						print("\t第(",k1,")次括号运算后，成为串[",str1t,"]")
#				else:
#					print("\t\t判断为不需变量代换")
				if(not transferp):
					k1+=1	
					if(bracketparaP):#带括号变量时#20240616
						k1=0
#					print("\t准备下一次，即(",k1,")次括号运算")
				else:
					ncte =0 #v0.967
					slen=len(str1t)
					bracketn=0
					while(ncte < slen):
						strn = str1t[ncte]
						ncte+=1
						if(strn == '('):
							bracketn = bracketn+1
					if(bracketn>0):
						k1=0
					print("循环末重新统计字符串[",str1t,"]内有(",bracketn,")个括号")
					if(bracketn<=0):break #20230331
#			print("运算前，字串为：",mystr)#v0.85
			if(digit_num!=-3):#v0.952调整digit_num==-3为不计算
#				print("Altstr中间4待计算字串[",mystr,"]")
				if(not self.IsNumber(mystr)):
					mystr=self.strcacu(mystr,fmt)#20250317digit_num
#					mystr=self.strcacu(mystr,digit_num)
#			print("运算后，成为串：[",mystr,"]")
			if(self.IsNumber(mystr)):#20230218
				value=float(mystr)
#				print("Alt转化为实数值运算结果：",value)
				if(digit_num==8 or digit_num == -8):#20250317v0.97确定8或-8为自动判断，-3不计算
#				if(digit_num==8):#<0):v0.97确定8为自动判断，-3不计算

					fmt=self.floatfmt(str1t)#20240206
					if(fmt!=0):#20240206
						if((abs(value)<1e5) and (abs(value) >1e-3)):
							mystr=str(round(float(mystr),fmt))#20240206str(round(value,fmt))
#					print("Alt实数自动判断输出小数位",fmt,"，数字输出为",mystr)
				elif(digit_num>=0):					
					if((abs(value)<1e5) and (abs(value) >1e-6)):
						if(digit_num!=0):#20240206else:
							mystr=str(round(value,digit_num))
						if(digit_num==0):#20250225
							lt = mystr.find('.')
							if(lt>0):
								mystr = mystr[:lt]
								
#						print("Altstr强制输出小数位(",digit_num,")，数字输出为",mystr)
						fmtt = self.floatfmt(mystr)#20250218补偿round输出的缺位
#						print("实际输出小数位为(",fmtt,")")
						if(fmtt<digit_num and mystr.find('e')<0 and  mystr.find('E')<0):#20250228如果round小数位小于设定
							cz = digit_num-fmtt
							for ic in range(cz):
								if(fmtt>0):
									mystr += "0"
								else:
									if(ic==0):
										mystr += ".0"
									else:
										mystr += "0"
#							print("Altstr强制输出小数位(",digit_num,")，补偿数字位后输出为[",mystr,"]")

#				else:
#					print("Altstr第2项参数",digit_num,"无格式变动，输出为",mystr)
			strlist[itt]=mystr
#			print("\n\t共(",ns,")项之第(",itt,")表项运算后，成为串：",strlist[itt])
			if(itt==0):
				str1=strlist[itt]
			else:
				str1=str1+" "+strlist[itt]
			itt+=1
			if(pickp):
				str1=str1+' '+pickstr2
			print("\n\t＝＝＝Altstr第(",k1,")层括号运算后，成为串：\n\t\t[",str1,"]\n")
		return str1#0607退格一档输出多项







# 359 47       (6732 0)
	def EngInt (self,string):#工程取整，有小数则+1
	#	print("\n\t进入EngInt方法")
		if(type(eval(string))== float):
			ls=len(string)
			ep0=string.find('.')
			ep1=string.find('e')
			ep2=string.find('E')
			en=0
			fmt=self.floatfmt(string)
			if(ep1>0):
				strlist=string.split('e')
				en=int(string[ep1+1:])
			elif(ep2>0):
				strlist=string.split('E')
				en=int(string[ep2+1:])
			if(en>0):
				if(ep0>0):
					if(fmt>en):
						fmt1=en+ep0#取到个位数
						strt=strlist[0][:fmt1]+'e'+strlist[1]
						if(int(string[fmt1+1])>0):
							strt=str(int(strt)+1)
					else:
						strt=string
			else:
				if(ep0>0):
					if(ep1>2):
						strt=string[:ep0-1]
					else:
						strt=string[0]
	#				print("实数",string,".前符",strt)
					if(fmt>0):
						if(int(string[ep0+1])>0):
							if(strt=='0'):
								strt='1'
							else:
								strt=str(int(strt)+1)
				elif(ep0==0):
					if (int(string[1])>0):
						strt='1'
			return strt






# 47 21           (6973 0 0)

	
	def build (self):#组建RV类
		#return RV()
		# Create the screen manager
		self.sm = ScreenManager()#20240922sm增加前缀self.
		self.menu_screen = MenuScreen(name='menu')
		self.reading_screen = ReadingScreen(name='reading')
		self.text_screen = TextScreen(name='text')#20240904
		self.sm.add_widget(self.menu_screen)#20240902MenuScreen(name='menu')
		self.sm.add_widget(self.reading_screen)#20240902ReadingScreen(name='reading')
		self.sm.add_widget(self.text_screen)#20240904

		return self.sm







# 21 123       (7176 0 0)

	def RunUp (self):#	slot_btn_openFile (self):#显示目录文件
#		print("\n进入slot_btn_openfile->")
		self.selectedItem=SelectableLabel.selectedItem 
		lnum=self.selectedItem#self.OnOpNumber()
		print("\n\t^RunUp主目录点中(",lnum,")行")
#		self.menu_screen.ids.Text_Edit.text = "RunUp点中("+str(lnum)+")行\n"#20240807
		if(isinstance(lnum,int)):#0720
			if(lnum > 0):#0911((lnum >= 0)20240126) or (lnum == 0 and MenuScreen.OmniState)
				#if(lnum>0):#20240126self.index #20240806
				path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
				nt=lnum*2-1#20240126 self.index
				if(nt<0):
					nt=0
				menulist = MenuScreen.ReadMWLine(self,path,nt)#20241011主页读入模块返回表
				filename = menulist[1]#20240925改为读入列表第二项#20241011
				Nname = menulist[0]#20240925读入列表第一项作为主页选中名#20241011
				print("\t\tRunUp读入主目录文件名为[",filename,"]")
#				self.menu_screen.ids.Text_Edit.text += "RunUp读入主目录文件名["+filename+"]\n"#20240807
				if(filename):#20240823当未通过密码机制时，返回文件名将为空；当为非空时，准备显示
					#20241011self.MenuFile = filename#202410073将文件名赋给全局变量
					#20241011self.MenuName = Nname#202410073将菜单名赋给全局变量
					sonpath=os.path.join(os.getcwd(),"src",filename)#925mypath=
					print("\t\t\tRunUp点中非顶行，准备打开文件")#[",sonpath,"]")
#					self.menu_screen.ids.Text_Edit.text += "RunUp准备打开文件["+sonpath+"]\n"#20240807
					MenuScreen.fileName_choose= sonpath
					if(self.CommentL):#202412312
						self.LoadComment()#20241016加载评论#20241106鉴于加载未明显减慢，未取消通用加载
					y=MenuScreen()#将文件显示到主界面
					#y2 = ReadingScreen()#20240902*
					if(y.col2):
						self.menu_screen.ids.RV_List.data = y.col2 #20240902
					#if(y2.col2):
					#	self.reading_screen.ids.RV_List2.data = y2.col2 #20240902
					if(y.col2):#20240902 or y2.col2
						#20240806
						MenuScreen.Ignore=y.Ignore
						MenuScreen.ExpMode = y.ExpMode
						MenuScreen.lViewList=y.lViewList
						MenuScreen.ViewList=y.ViewList
						MenuScreen.Expbackstep=y.Expbackstep
						MenuScreen.Expforestep=y.Expforestep
						MenuScreen.Expbnow=0#
						MenuScreen.Expfnow=0
						self.FirstLine("点[向前]开始阅读；点[阅读]、[向前]运行")
						print("\t^RunUp文件初打开，回跳行号",MenuScreen.Expbnow,"回跳步长：",MenuScreen.Expbackstep,"前跳行号",MenuScreen.Expfnow,"前跳步长：",MenuScreen.Expforestep)	
						skiP = False
						if(Nname.find(self.NameKey)>=0):#20240925*判断选中列表行的名字中是否含有自测‘题’关键名
							print("\n\t^RunUp判断",MenuScreen.ExpMode,"为专用格式文件！专用格式忽略(",MenuScreen.Ignore,")字，主目录选项名Nname[",Nname,"]，不含跳过全页的关键字NameKey[",self.NameKey,"]")#202504232此打印行从条件判断前移来
							MenuScreen.OmniState = True
							print("阅读/运行 切换状态MenuScreen.OmniState",MenuScreen.OmniState)
							self.menu_screen.ids.Omni_State.text = '[color=#ff0000]自  测[/color]'#'全程模式'字#20240925运行
							skiP = True
							self.PopP = True#202504232如果是自测题状态，判定处于弹出框状态
						
						ll = MenuScreen.lViewList#20240927考虑文本内以密码分级时跳过全页
						lViewList = ll
						P1 = False#20241127
						P2 = False#20241127
						for i in range(ll):
							strt = MenuScreen.ViewList[i]#20241231尝试提速
							if(strt.find(' "密码：')>=0):#20241231增加空格判断以兼容手册为提速减少[:15]
								P1=True
								if(strt.find('.find(')>=0):#20241231增加'.find('判断以兼容源代码
									P2=True
								break
#						for j in range(ll):
#							if(MenuScreen.ViewList[j].find('.f')>=0):#20241106增加空格判断以兼容手册20241127修改测试是否提速'.find('
#								P2=True
#								break
						if (P1 and (not P2)):
							lViewList = i+1#密码设置行后不可见，行数比行号大1
							skiP = True
							print("发现文内密码设置，直接跳至分页(",MenuScreen.Expbnow,")")
							#self.menu_screen.ids.Line_Edit.text = "发现文内密码设置，直接跳至分页"+str(MenuScreen.Expbnow)#20241009

						if skiP:
							self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#刷新屏幕直接进入分页首页#20240925
						else:#202410113不只在主窗口显示，也在阅读窗口全显示
							self.reading_screen.ids.RV_List.data = y.col2 #202410113
							
							print("\t文本窗口准备显示")#20241029
							myText = ""
							if(MenuScreen.lViewList >0):
								for item in MenuScreen.ViewList:
									myText += item+"\n\n"#20241029文本窗口内容
							#20241127文本窗口字高设置内容转移未果#202503263改回前次
							with open(path,mode='r+t',encoding='UTF-8') as f:#202503263读取上次的文本高度设置
								data = f.read()
								dlist = data.split("\n")
								ld = len(dlist)
								dsp = dlist[1].split()
								fs = self.text_screen.ids.Enlarge_Edit.font_size
								print("\tRunup中检测当前文本窗口字高(",fs,")")
								if(len(dsp)>1):#探测设置文件的第二行是否多词
									txthi = dsp[1]#读取设置文件的第二词
									self.texthi = int(txthi)#20250326
									print("\t\t文本窗口字高取为设置文件第二行第二词(",txthi,")")
									self.text_screen.ids.Enlarge_Edit.font_size = int(txthi)
#							self.text_screen.ids.Enlarge_Edit.text= myText#20241029显示文本窗口
#							self.text_screen.ids.Enlarge_Edit.cursor = (0,0)
						
						
						
			elif(lnum == 0):#0911
				if(not MenuScreen.OmniState):#0925
					if(self.MainPage == -1):#0911
						self.MainPage=MenuScreen.Expbnow
						self.MainPrompt ="机动目录页已设置。选顶行，再点[笈智]返回本页；空选，点[向前]，顺接下页；‘＋’号行链接"
						self.FirstLine(self.MainPrompt)
					else:
						topbot=self.ExpView(self.MainPage,0)
						MenuScreen.Expbnow=int(topbot.split()[0])#0911
						MenuScreen.Expfnow=int(topbot.split()[1])#0911
				else:
					self.UpdateMain()#20240126
			






# 123 50       (7176 0 0)

	def  openlabfile(self):#打开库文件
		fh=False
		mypath=os.path.join(os.getcwd(),self.OftenFiles)
		fh1=open(mypath,mode='r',encoding='UTF-8')
		if fh1:
			data=fh1.read()
			filelist=data.split("\n")
			fh1.close() #20230219
		i=0#self.model.item(0).checkState()#检测顶行是否勾选，决定是之后文件格式行显示否
		#print("\n\t检测顶行勾选与否：",i)
		if(i>0):
			self.FormatShow=True#格式行显示
			#print("\n\t格式行显示开关打开",self.FormatShow)
		else:
			self.FormatShow=False#格式行不显示
			#print("\n\t格式行显示开关关闭",self.FormatShow)
		i=self.selectedItem#OnOpNumber()#v0.76
		if (i<=0):
			slecstr=mypath
		else:
			print("\n\ti>0,i=",i)
			if(filelist):
				slecstr=os.path.join(os.getcwd(),"src",filelist[i-1])
		self.fileName_choose=slecstr
		print("\n当前打开文件self.fileName_choose名： ",self.fileName_choose)
		self.prompstr="" #slecstr v0.76
		return self.myfileopen(slecstr,1)







	def PassLine (self):#20250419密码行探测
		print("\n进入密码行号反馈模块PassLine->")
		ll = MenuScreen.lViewList#20240926考虑文本内以密码分级#20250419前移
		lViewList = ll
		for i in range(ll):
			if(MenuScreen.ViewList[i].find(' "密码：')>=0 and  
				MenuScreen.ViewList[i].find('.find(')<0):#20241018
				lViewList = i+1#密码设置行后不可见，行数比行号大1
				break
		return lViewList




		
# 50 110             (7267 0 0)

	def backward (self):#分页回跳  540 6938
		print("\n进入综合回跳模块backward->",self.CheckedRow)
		BackP = True
		if(not MenuScreen.AutoMode):#20250331如果手动执行时，探测编辑行和编辑框
			print("\t\tbackward编辑行手动执行分支")

			ll = MenuScreen.lViewList#20250420考虑文本内以密码分级前移
			lViewList = ll
			nt = 0
			
			strt = self.menu_screen.ids.Line_Edit.text
			if(len(strt)>0):#编辑行不空
				print("\t\t\tbackward编辑行不空分支")
				if(strt.isdigit()):
#					ll = MenuScreen.lViewList#20240926考虑文本内以密码分级
					lViewList = self.PassLine()#20250420增加密码行探测，密码行以后将不显示
					if(int(strt)<lViewList-1):
						BackP = False
						self.PageNow(int(strt))
						self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页
				elif(self.IsNumber(strt)):#202412313如果不是正整数而是实数
					if(strt[0]=='-'):#20250317float(strt)<0.0
						if(len(strt)==1):#20250313
							nt = MenuScreen.Expbnow-1
						elif(len(strt)==2):#20250420增加-0选项，回跳至头部
							if(strt[1]=='0'):
								nt = 0
						else:
							nt = int(MenuScreen.Expbnow+float(strt))
						print("\t综合回跳模块中回跳指令[",strt,"]目标行号(",nt,")")	
						
					lViewList = self.PassLine()#20250420增加密码行探测，密码行以后将不显示
					if(nt<lViewList-1):
						BackP = False
						self.PageNow(nt)
						self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页

				elif(strt[0]=='+'):#20250419增加+0选项，可跳达至尾部。+开头判断为文字，非实数，故减一档
					if(len(strt)==1):#20250313
						nt = MenuScreen.Expbnow+1
					elif(len(strt)==2):#20250419增加-0选项，回跳至头部
						if(strt[1]=='0'):
							nt = ll-2
					else:
						nt = int(MenuScreen.Expbnow+float(strt))
					lViewList = self.PassLine()#20250419增加密码行探测，密码行以后将不显示
					if(nt<lViewList-1):
						BackP = False
						self.PageNow(nt)
						self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页
						
				else:#如果不是正整数、不是实数，而是文字
#					self.ToBack()#20250328
					print("\t\t\t\tbackward不是正整数、不是实数，而是文字分支")
					linestr = strt
					lline = linestr.split()#20250406
					lenll = len(lline)					
					strE = self.menu_screen.ids.Text_Edit.text#20250328探测编辑框有无内容
					if(len(strE)>0):#编辑框不空#考虑‘品鉴全览’书签定位功能
						if(len(linestr)>0):#如果编辑行有内容
							lline = linestr.split()
							lenll = len(lline)
							for ie in range(lenll):
								print("\t\t遍历编辑行(",ie,")词",end="")
								if(lline[ie].isdigit()):#20250418扫描编辑行中的第一数字
									print("\t\t\t\t\t\t\t\t编辑行为[",linestr,"]；第(",ie,")词[",lline[ie],"]是数字")
									BackP = False
									if(ie>1):
									#当数字所在的序号超过第二位（0,1）显示文件所在行
									#第一位是关键字，第二位是文件名，第三位是行号
										filename = lline[ie-1]#数字前一位是文件名
										pline = lline[ie]
										self.ToFileLine(filename,pline)
									else:
										self.PageNow(int(lline[ie]))
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页
									break

			else:#编辑行空
				print("\t\tbackward编辑行空分支")
				strE = self.menu_screen.ids.Text_Edit.text#20250328
				if(len(strE)>0):#编辑框不空#考虑书签定位功能
					linestr = self.GetELine()#20250328
					if(len(linestr)>0):#如果行号返回
						lline = linestr.split()
						lenll = len(lline)
						if(lenll==1):#分割后只有一词时，推测为行号
							if(lline[0].isdigit):
								if(int(lline[0])<MenuScreen.lViewList-1):#行号小于总行号
									self.PageNow(int(lline[0]))
									#找出MenuScreen.Expbnow,MenuScreen.Expfnow
									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页
									self.TextScreenLine(lline[0])#20250407
									
						elif(lenll>1):#分割后不只一词时，Comments返回的文件名、总行号、分行号
							filename = lline[0]
							pline = lline[1]
#							lline = lline[2]
							BackP = False
							self.ToFileLine(filename,pline)#20250420,lline
#							self.TextScreenLine(lline)#20250407
							

		if BackP:#20250406
			self.ToBack()




#  110 33           (7182 0)

	def TextScreenLine (self,string):#20250407字符定位
		print("\n进入大字窗口，内容定位行号模块TextScreenLine，内容[",string[-10:],"]")
		stt = self.text_screen.ids.Enlarge_Edit.text#20250407读取大字窗口字串
		line = 0
		if(len(stt)>0):
			lstt = stt.split('\n')#20250408转为表
			lens = len(lstt)
			for il in range(lens):
				if(lstt[il].find(string)>=0):
					line = il 
					strtt = lstt[il]
					print("\t\t第(",il,")行发现定位字串[",string,"]")
					if(lens>line):
						lent = len(strtt)
						lst = stt.find(strtt)
#						self.menu_screen.ids.Text_Edit.cancel_selection()
#						self.text_screen.ids.Enlarge_Edit.cancel_selection()
						tpt = self.text_screen.ids.Enlarge_Edit.get_cursor_from_index(lst+lent)
						#20250407光标定位编辑框关键语句
						print("\t\tTextScreenLine获取编辑框光标位置",tpt)
						self.text_screen.ids.Enlarge_Edit.cursor = tpt
						print("\t\t大字窗口编辑框定位(",line,")行找到[",strtt,"]符合要求，索引号index为(",lst,")")
						self.text_screen.ids.Enlarge_Edit.select_text(lst,lst+lent)
					break








# 33  36           (7293 0)

	def ToFileLine (self,filename,pline):#20250328定位打开到文件名、总行号、页内分行号,Nname为主目录名，可设为''#20250420舍弃分行号	,lline
		print("\n进入文件行号定位模块ToFileLine，[",filename,"]文件[",pline,"]行")
		sonpath=os.path.join(os.getcwd(),"src",filename)
		print("\t准备打开文件[",sonpath,"]")
		MenuScreen.fileName_choose = sonpath

		fh=open(sonpath,mode='r+t',encoding='UTF-8')
		if fh:
			fh.seek(0)
			data=fh.read()[:-1]#20241006[:-1]
			fh.close()
			MenuScreen.ViewList = data.split("\n")#flist
			MenuScreen.Ignore = MenuScreen.DLFmt(self,MenuScreen.ViewList)
			MenuScreen.ExpMode = True
			MenuScreen.lViewList= len(MenuScreen.ViewList)
#			self.PageNow(int(pline))
#			self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#刷新屏幕直接进入分页相关页

			nt = int(pline)#20250419
			lViewList = self.PassLine()#20250419增加密码行探测，密码行以后将不显示
			if(nt<lViewList-1):
				self.PageNow(nt)
				self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页
#				self.FocusLine(nt-MenuScreen.Expbnow)#20250415#202504183舍弃分行号后推算而得	
			else:#202504192当遇到密码段落时弹出信息
				Mlist = self.PickMName(filename)
				if(len(Mlist)>0):
					MName = Mlist[0]
					MSeN = Mlist[1]






# 36 65           (7327 0)

	def GetELine (self):#20250328#从编辑框内容获取光标所在行号
		print("\n进入从编辑框内容获取光标所在行号模块GetELine")
		strE = self.menu_screen.ids.Text_Edit.text#202503262
		linestr = ""
		if(len(strE)>0):#编辑框不空#考虑书签定位功能
#			print("\t\t编辑框不空")
			lstrE = strE.split('\n')
			lenl = len(lstrE)
			if(len(lstrE[0])>19):#如果首行长度超过19，因为书签首行为时间戳17字加上总行号，分行号
#				print("\t\t\t编辑框首行[",lstrE[0],"]字符数超过19,[17:19]",lstrE[0][17:19])
				if(lstrE[0][17:19]=='品鉴'):#且17、18位是‘品鉴’两字，假定为品鉴(书签)记录
#					print("\t\t\t\t编辑框首行17、18位为字符‘品鉴’")
					csrow = self.menu_screen.ids.Text_Edit.cursor_row
					if(csrow>=0):
#						print("\t\t\t\t\t探测到主界面编辑框的光标位于(",csrow,")行")
						linenow = self.ELineNowM()
						print("\t\t\t\t\t主界面光标位于(",linenow,")行[",lstrE[linenow],"]")
						for ic in range(linenow,-1,-1):#逆向寻找含行号的行
							if(lstrE[ic][17:19]=='品鉴'):
#								print("\t\t\t\t\t\t编辑框(",ic,")行[",lstrE[ic],"]字符数超过19")
								lpstr = self.psplit(lstrE[ic],'(',')')#以小括号进行分割(2／118)
#								print("\t\t\t\t\t\t小括号进行分割为",lpstr)
								if(len(lpstr)>1):
									lp1str = lpstr[1][1:-1]
									chloc = lp1str.find('／')
									linestr = lp1str[chloc+1:]#20250420舍弃分行号+' '+lp1str[:chloc] #20250406
#									print("\t\t\t\t\t\t\t小括号内行号字符为",linestr)
									break
			else:#如果首行长度小于19，可能为Comments.txt，其首行为文件名；或文件搜索文本；或无效文本
			#用是否有后缀.txt，及次行首项为时间戳来判别
				print("\t首行长度小于19，可能为Comments.txt或无效文本[",lstrE[0],"]")
				if(lstrE[0].find('.txt')>0):
					if(lenl>1):#查找次行首词是否为时间戳
						if(self.CTimeP(lstrE[1].split()[0])):
						#确认是Comments.txt，开始逆向遍历寻找文件名及行号
							print("\t查找次行首词是时间戳，确认是Comments.txt，开始逆向遍历寻找文件名及行号")
							csrow = self.menu_screen.ids.Text_Edit.cursor_row
							if(csrow>=0):
								print("\t\t\t\t\t探测到主界面编辑框的光标位于(",csrow,")行")
								linenow = self.ELineNowM()#用光标定位主窗口编辑框内的行号
								print("\t\t\t\t\t主界面光标位于(",linenow,")行[",lstrE[linenow],"]")
								llstr = lstrE[linenow].split()
								linestr = llstr[1]+' '+llstr[2]
								filestr = self.GetEFName(linenow)
								linestr = filestr+' '+linestr
								#品鉴文件共四项，类似于“2004年10月30日06时30分（日期） 52（总行号） 3（分行号） 『人生八苦，生老病』（前几字摘要） （品鉴） ”
				elif(lstrE[0].find('搜索关键字：')>=0):#20250420增加文件间搜索定位
					if(len(lstrE[0].split())>1):#且首行不只一词，搜索定位时第二词为关键字，确定为文件间搜索定位
						csrow = self.menu_screen.ids.Text_Edit.cursor_row
						print("\t\t\t\t\t探测到主界面编辑框的光标位于(",csrow,")行")
						if(csrow>=0):
							linenow = self.ELineNowM()#用光标定位主窗口编辑框内的行号
							print("\t\t\t\t\t主界面光标位于(",linenow,")行，内容[",lstrE[linenow],"]")
							llstr = lstrE[linenow].split()
							linestr = llstr[-1]#20250420末词为行号	llstr[1]+' '+llstr[2]
							filestr = self.GetEFName(linenow)
							linestr = filestr+' '+linestr
						
		print("\t返回光标行内容[",linestr,"]")
		return linestr




#  65 50           (7364 0)

	def GetEFName (self,linenow):#获取已知行号的品鉴文件名
		print("\n进入获取已知行号的品鉴文件名模块GetEFName:(",linenow,")行")
		strE = self.menu_screen.ids.Text_Edit.text#202503262
		if(len(strE)>0):#编辑框不空#考虑书签定位功能
#			print("\t\t编辑框不空")
			filestr = ""
			lstrE = strE.split('\n')
			lenl = len(lstrE)
			if(len(lstrE[0])<19):#如果首行长度小于19，可能为Comments.txt或无效文本
			#用是否有后缀.txt，及次行首项为时间戳来判别
				print("\t首行长度小于19，可能为Comments.txt或无效文本[",lstrE[0],"]")
				if(lstrE[0].find('.txt')>0):
					if(lenl>1):#查找次行首词是否为时间戳
						if(self.CTimeP(lstrE[1].split()[0])):
						#确认是Comments.txt，开始逆向遍历寻找文件名及行号
							print("\t查找次行首词是时间戳，确认是Comments.txt，开始逆向遍历寻找文件名及行号")
#							llstr = lstrE[linenow].split()
#							linestr = llstr[1]+' '+llstr[2]
							#品鉴文件共四项，类似于“2004年10月30日06时30分（日期） 52（总行号） 3（分行号） 『人生八苦，生老病』（前几字摘要） （品鉴） ”
							for ic in range(linenow,-1,-1):#逆向寻找含文件名的行
								if(len(lstrE[ic].split())==1):#当发现该行只有一词时，推测是文件名所在行
									print("\t\t\t\t\t\t发现本行只有一词，推测是文件名所在行")
									if(lstrE[ic].find('.txt')>0):#确定是文件名行
										print("\t\t\t\t\t\t\t\t编辑框(",ic,")行[",lstrE[ic],"]为文件名")
										filestr = lstrE[ic]
#										print("\t\t\t\t\t\t\t\t文件名字串为[",filestr,"]")
										break
										
				elif(lstrE[0].find('搜索关键字：')>=0):#20250420增加文件间搜索定位
					if(len(lstrE[0].split())>1):#且首行不只一词，搜索定位时第二词为关键字，确定为文件间搜索定位
						for ic in range(linenow,-1,-1):#逆向寻找含文件名的行
							if(len(lstrE[ic])>0):#202504183过滤掉空行
								if(len(lstrE[ic].split())==1):#当发现该行只有一词时，推测是文件名所在行
									print("\t\t\t\t\t\t发现(",ic,")行只有一词，推测是文件名所在行")
									locdot = lstrE[ic].find('.')
									if(locdot > 0):#发现后缀点号
										if(len(lstrE[ic])>locdot+1):#后缀不少于一字
											if(not lstrE[ic][locdot+1].isdigit()):#且不为数字，确定是文件名行
												print("\t\t\t\t\t\t\t\t编辑框(",ic,")行[",lstrE[ic],"]为文件名")
												filestr = lstrE[ic]
												print("\t\t\t\t\t\t\t\tGetEFName文件名字串为[",filestr,"]")
												break

		print("\t(",linenow,")行内容所属的文件名[",filestr,"]")
		return filestr




# 50  91 (0 0)

	def ToBack (self):#20240921分开执行代码，方便简化			
		print("\n进入无密回跳操作模块ToBack")
		self.FirstLine(self.MainPrompt)#20240905
		self.CheckedRow=[]#清空多选项表
		self.ok = -1#0903
		if MenuScreen.ExpMode and MenuScreen.Expbnow>0:#在myfileopen兼容模式中已赋值
			bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
			print("\n＝＝＝\n\t＝＝＝由当前(",MenuScreen.Expbnow,")行回跳[",bnowstr,"]")
			lie=bnowstr.split()#转成表
			lcol=len(lie)
			if(lcol>=MenuScreen.Ignore+2):#格式检查#202409232 >
				jumpp=False
				autop=False
				if(self.Listp(bnowstr)):#初检有无阅读跳转链接项
					plist=self.psplit(bnowstr,"(",")")
					liste=plist[-1][1:-1].split()#提取最后一个括号项字符
					if(liste[0].isdigit()):#括号项首项为数字，表示有链接
	#					print("\n\t\t\t阅读链接表为：",liste)
						jumpp=True
					else:
	#					print("\n\t\t\t执行注释命令为：",liste)
						autop=True
				if jumpp:#有阅读跳转链接
					itemn=int(liste[0])#提取回跳链接步长
					print("\t\t\t\t链接表第(",MenuScreen.Expitem,")项所提取链接步长为：\t",itemn)
				else:
					itemn=0
				Expbnow=MenuScreen.Expbnow-int(lie[MenuScreen.Ignore+1])-1-itemn#20250319 self.推算回跳目标行
				loopP = False#20250319
				FixJumP = False#20250322固定回跳判断
#				MenuScreen.Expbnow=MenuScreen.Expbnow-int(lie[MenuScreen.Ignore+1])-1-itemn
				bnowstr2=MenuScreen.ViewList[Expbnow]#获取回跳目标格式行#20250319MenuScreen.Expbnow
				print("\t\t\t由(",MenuScreen.Expbnow,")行推算回跳目标格式(",Expbnow,")行\n『",bnowstr2,"』")#20241225 self.
#				如62 62  (执行 (#循环次数值 (循环次数值)-1) …… (0 1)) (0 0)
				ljump=bnowstr2.split()#获取链接跳转后的格式行表#20240218MenuScreen.ViewList[MenuScreen.Expbnow]
				if(len(ljump)>MenuScreen.Ignore+2):
					if (ljump[MenuScreen.Ignore+2].isdigit()):#检测是否笈语言数字括号格式
#						MenuScreen.Expfnow=MenuScreen.Expbnow+int(ljump[MenuScreen.Ignore+2])+1#20250319
						#print("\n\t＝＝＝回跳目标",MenuScreen.Expbnow,"行：\n",MenuScreen.ViewList[MenuScreen.Expbnow])
#						self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#0329#20250319
#						print("\n\t＝＝＝回跳目标(",MenuScreen.Expbnow,")行 \n[",bnowstr2,"]")#20250319
						if(self.Listp(bnowstr2)):##20240218初检有无阅读跳转链接项
							plist=self.psplit(bnowstr2,"(",")")
							AElist=self.psplit(plist[1][1:-1],"(",")")#20240218提取括号次表，分割为表
							if(len(AElist)>1):#202407184下后退一档.表项超过1时，进一步推测为执行表
								print("\t\t\t\t\t\t外循环检测次项为：",AElist[1])
								if(AElist[1][1]=='#'):
									print("\t\t\t\t\t\t\t外循环检测次项首字为[",AElist[1][1],"]判断是'#'，符合词外循环格式，准备清空运行字典")
									loopP = True#20250319
								else:#20250322固定回跳判断
									FixJumP = True
									
				if loopP:#下减四档
				
					strit=AElist[1][2:-1].split()[1]#取次项值：(循环次数值)-1
					alti=self.AltStr(strit,8,MenuScreen.Expbnow).split()[0]#字符串计算，提取计算结果的首词
					print("\t\tToback双项注释命令字符，经AltStr检索外循环变量后，提取次项为[",alti,"]")
					if(self.IsNumber(alti)):#变量如果是实数
						if(float(alti)>=0.0):
							print("\t\t\t外循环判断变量值(",alti,")>=0，循环继续执行，清空运行字典MenuScreen.Rundic")
							MenuScreen.Rundic.clear()
							print("\t\t\t运行字典为：",MenuScreen.Rundic)#20250319Expdic
							MenuScreen.Expbnow = Expbnow#20241225
							self.forward()
						else:#20250321
							print("\t\t\t外循环判断变量值(",alti,")<0，循环中止执行，运行字典MenuScreen.Rundic不变")
							self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页(1,self.Expbnow)#20241225
							
				else:#20250319无#循环时正常执行
					if (not FixJumP):#20250322非固定回跳判断
						self.PageNow(Expbnow)#20241225#20250319
					else:#202503245
						MenuScreen.Expbnow = Expbnow
						
					self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
#					self.forward()#20250323执行
							
			else:
				print("第(",MenuScreen.Expbnow,")行格式错误")
			MenuScreen.Expitem=-1
	#	else:#20240920*当MenuScreen.Expbnow=0时，如果编辑行有数字，则假定为总行号，进行定位，以利于品鉴定位
	#		strt = self.menu_screen.ids.Line_Edit.text
	#		if(len(strt)>0):
	#			if(strt.isdigit()):
	#				self.PageNow(int(strt))
	#				self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示定位页




# 91 18 (0 0)

	def DisPic (self):#202309232显示图片
		lineslec = self.ELineNow()
		linenow = MenuScreen.Expbnow+lineslec#20240923
		if(linenow<MenuScreen.lViewList-1):
			linetext = MenuScreen.ViewList[linenow]
			if(linetext.find("#")>=0 and linetext.find(".")>=0):#202409062图像格式设置为&开头，后跟空格
				print("\t\tforward模块在编辑框中发现选中行有图像链接符#")
				pict = linetext.split("#")[1].split()[0]
				print("\t\t\t图像文件名为[",pict,"]")#文件名[",popath,"]
				EditStatePopup10.popath = pict#popath#20240907
				MainApp.Pop10(self)
		if(MainApp.CommentL):#202309233显示品鉴
			MainApp.PopComment(self,linenow)#20240923为节省代码尝试将编码模块化
				
				


# 18 22 (0 0)

	def CPass (self,Expbnow):#20240926检测目标行有无密码标志，有就检测密码，通过密码时返回True，否则返回False
		strt = MenuScreen.ViewList[Expbnow]
		if(strt.find('"')>=0):#检测目录格式行有带""的字符串时
			plist = self.psplit(strt,'"','"')#以双引号分离字串
			if(len(plist)>1):#如果分离成功
				if(plist[1].find('"密码：')>=0 and plist[1].find('.find(')<0):#20241018):#探测分离字串中有无“密码：”三个字
					self.PassWdText = plist[1][1:-1].split('：')[1]#进一步分离出：后的密码20240926*
					return True#20241011
					
	#				self.Pop8b()
	#			else:#如果探测分离字串中无“密码：”三个字，说明格式不正确
	#				self.ToForward()
	#		else:#如果分离不成功，说明不是完整的密码格式
	#			self.ToForward()
	#	else:
	#		self.ToForward()
				
		
		


# 22 13            (7728 0)
		
	def forward (self):#202409272由文本内密码设置来分流
		print("\n进入综合前跳模块forward->文本内密码设置判断：",self.CPassP)
	#20241011	self.ToForward()
		if(self.CPassP):#202409272分流有文本内密码
			self.PassForward()
		else:
			self.ToForward()





# 13 221 (0 0 )

	def PassForward (self):#202409272有文本内密码分支
		print("\n进入前跳模块PassForward->","格式是否专用模式文件(",MenuScreen.ExpMode,")，当前回跳行号(",MenuScreen.Expbnow,")，前跳行号(",MenuScreen.Expfnow,")<(",MenuScreen.lViewList-2,")?")#,end=""
		print("\n勾选行表：",self.CheckedRow,"，‘闭环输入’判断self.LoopP=",self.LoopP)#,end=""
		self.CheckedRow=[]#0404	#清空多选项表
		self.ok = 1#0904True#0729
		#MenuScreen.Expitem = -1 #202409232
		if MenuScreen.ExpMode and MenuScreen.Expfnow<= MenuScreen.lViewList-2:#在myfileopen兼容模式中已赋值
			print("当前之‘前跳’行号(",MenuScreen.Expfnow,")")#self.Expfnow,"\n")
			if(MenuScreen.Expfnow==0):#0813
				print("\t检测运行开关：")
				if(MenuScreen.OmniState):
					MenuScreen.AutoMode=True#全程执行模式
					print("\t进入全程运行模式，AutoMode：",MenuScreen.AutoMode)


					self.Line_str = self.menu_screen.ids.Line_Edit.text#20250316
					#20250120准备从文件读入数据的功能self.ui.textEdit_2.toPlainText()
					if(len(self.Line_str)>0 and MenuScreen.Expbnow == 0):
					#如果编辑行不空，假定为数据文件名#20250322	self.NFData == 0
						mypath=os.path.join(os.getcwd(),"src",self.Line_str)#20250315
#						mypath=os.path.join(self.WinPath,"src",self.Line_str)#filelist[i-1])
						print("\t\t发现编辑行不空，假定为数据文件[",mypath,"]")
						if(os.path.exists(mypath)):
							ld1=os.path.getsize(mypath)#文件大小
							if(ld1>0):
								fh=open(mypath,mode='r+t',encoding='UTF-8')
								if fh:
									fh.seek(0)
									data=fh.read()
									fh.close()
									plist = data[:-1].split("\n")
#									print("\t\tForward读入数据文件，转为表：",plist)
									lp = len(plist)
									if(lp>1):#数据文件最小二行，一行可以为#开头的注释
										self.FDataP = True
#										self.FDataList = []#20250211
										for ip in range(lp):
											if(plist[ip][0]!='#'):#数据文件可以用首字#注释
												#self.FDataList.append( plist[i])#20250210
#												print("\t\t\t冠亚字符[",plist[ip][0:2],"]")
												if(plist[ip][0:2]=='[]'):#20250221[]开头将以‘子表’格式读入
													plists = plist[ip][2:].split()#20250224将第二字符后，以空格分割为子表" "
													self.FDataList.append( plists)
#													print("\t\t\t\t读入冠亚字符[]的数据表",plists)
												else:#下增一档
												
													plists = plist[ip].split()#20250224" "
													if(len(plists)==1):#20250210
														self.FDataList.append( plist[ip])
													elif(len(plists)>1):#202502022 当读入行为多词时，以空格分割延展列表方式读入，而非‘子表’
														self.FDataList.extend(plists)
#														print("\t\t\t\t读入冠亚字符非[]的数据表",plists)
										print("\t\t\t从用户路径读入数据文件[",self.Line_str,"]转成数据表self.FDataList：")#20250321	,self.FDataList)
										for idata in range(len(self.FDataList)):
											print(self.FDataList[idata])



				else:
					MenuScreen.AutoMode=False#人工模式
					self.MainPrompt ="选顶行，再点[笈智]，设为机动目录页；‘＋’行为链接；不选，点[向前]顺接下页"#20240905
					self.FirstLine(self.MainPrompt)#0925
					print("\t进入注释命令自动运行模式判断AutoMode：",MenuScreen.AutoMode)
			else:#0813
				bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#0813
				lie=bnowstr.split()#转成表
				if(MenuScreen.Ignore+2 < (len(bnowstr.split())) ):#20240208
					if(int(lie[MenuScreen.Ignore+2]) != 0):#202409232当前行为最后一行时,即格式第二项为0时，不推算调整
						MenuScreen.Expfnow = MenuScreen.Expbnow+int(bnowstr.split()[MenuScreen.Ignore+2])+1
						print("调整计算前跳行号为(",MenuScreen.Expfnow,")")#self.Expfnow,"\n")
			self.EIndex()#0726 显示上页摘录成果
			CheckedRow= self.SelectedList() #0718确定选中行共用，故前移
			#print("\t\tForward模块中，；大字窗口为：",self.text_screen)#202409222
			print("\t\t\t获取窗口管理器当前状态：",app.sm.current)
			if(app.sm.current == 'text'):#202409222尝试从大字编辑框读入光标行作为浏览选中行
				print("\t\t\t\t正在大字界面窗口")
				csrow = self.text_screen.ids.Enlarge_Edit.cursor_row
				if(csrow>=0):
					print("\t\t\t\t\t探测到大字界面的光标位于(",csrow,")行")#，光标索引index=",self.text_screen.ids.Enlarge_Edit.cursor_index
					if(MenuScreen.Expbnow < MenuScreen.lViewList-2):
						MenuScreen.Expitem = self.ELineNow()
						print("\t\t\t\t\t大字界面前跳选中(",MenuScreen.Expitem,")行")#点[向前]弹出图片因可能存在干扰而拟舍弃
						self.DisPic()
					else:
						MenuScreen.Expitem = -1
					
			else:
				if(len(CheckedRow)==0 ):#0813or MenuScreen.AutoMode
					MenuScreen.Expitem=-1#1 #0716
				else:
					MenuScreen.Expitem=CheckedRow[-1]#如果有选择集，取最后一项
				print("\t\t多项选择表为",self.CheckedRow,"，前跳选中(",MenuScreen.Expitem,")行（-1表示未选中，或取最后一项）")
			if not MenuScreen.AutoMode:#非注释命令模式下从屏幕获取，执行模式由AutoE赋值
				self.CheckedRow=[]#清空多选项表#v0.94
				print("检测弹出框状态self.PopP:",self.PopP)#0821
				if(MenuScreen.Expbnow<MenuScreen.lViewList):
					if(not self.PopP):#0821
						bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
						print("\n＝＝＝\n\t＝＝＝前跳模块当前回跳行号(",MenuScreen.Expbnow,")行：[",bnowstr,"]")
						lie=bnowstr.split()#格式行转成表
						lcol=len(lie)
						if(lcol>MenuScreen.Ignore+2):#格式检查
							print("\t当前(",MenuScreen.Expbnow,")行初判为格式行；")
							jumpp=False
							if(MenuScreen.Expitem>0):#阅读链接有选中
								print("\t\t","跳转阅读链接选中第(",MenuScreen.Expitem,")项；")
								if(self.Listp(bnowstr)):#初步检查有无阅读跳转链接项
									plist=self.psplit(bnowstr,"(",")")
									liste=plist[-1][1:-1].split()#提取最后一个括号项字符
									if(liste[0].isdigit()):#括号项首项为数字，表示有链接
										print("\n\t\t\t阅读链接表为：",liste)
										le=len(liste)#获取链接表项数
										jumpp=True
								if jumpp:#有阅读跳转链接
									print("\t\t\t成功获取链接表")
									if(MenuScreen.Expitem<=le-1 ):#v0.76选中行对应链接表项的合规检查,如果行号在链接表项数范围内
										itemn=int(liste[MenuScreen.Expitem])#提取链接步长
										print("\t\t\t\t链接表第",MenuScreen.Expitem,"项所提取链接步长为：",itemn)
										#20240926MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1+itemn#推算下一个回跳行号
										Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1+itemn#20240926推算下一个回跳行号
										#20241011 self.CPass(Expbnow)
										if(self.CPass(Expbnow)):#20241011 
											self.Pop8b()
										else:
											#self.ToForward()
											MenuScreen.Expbnow = Expbnow#20241011 
											ljump=MenuScreen.ViewList[MenuScreen.Expbnow].split()#获取下一个回跳行的格式表
											if(len(ljump)>=MenuScreen.Ignore+2):#20230329初步检测下一个回跳行格式表项数不小于二项
												if(ljump[MenuScreen.Ignore+2].isdigit()):#并且第二项为数字
													MenuScreen.Expfnow=MenuScreen.Expbnow+int(ljump[MenuScreen.Ignore+2])+1#确定其为下一个前跳行号
													print("\t\t前跳forward分显页，确定下一个前跳行号为(",MenuScreen.Expfnow,")行")
													self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
													
									else:#20240805超过链接表项数时，顺页阅读
										print("\t\t\t选中行超过链接表词数")
										#20240926MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#推算前跳行号
										Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#推算前跳行号#20240926
										#20241011 self.CPass(Expbnow)
										if(self.CPass(Expbnow)):#20241011 
											self.Pop8b()
										else:
											#self.ToForward()
											MenuScreen.Expbnow = Expbnow#20241011
											self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
											print("\t\t前跳forward无选中，顺接阅读；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")
								
								else:#20240805
									print("未成功获取链接表")
									if(int(lie[MenuScreen.Ignore+2]) != 0):#202409232当前行为最后一行时,即格式第二项为0时，不推算显示
										#20240926MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#推算前跳行号
										Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#20240926推算前跳行号
										#20241011 self.CPass(Expbnow)
										if(self.CPass(Expbnow)):#20241011 
											self.Pop8b()
										else:
											#self.ToForward()
											MenuScreen.Expbnow = Expbnow#20241011
											self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
											print("\t\t前跳forward无选中，顺接阅读；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")#bnowstrb,
									else:
										print("\t\t前跳forward无选中，且为末格式行；不计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")#bnowstrb,
										
								
							if(not jumpp):#阅读链接没有选中向前项self.Expitem<=0 or 
								if(MenuScreen.Expfnow==0):#MenuScreen.Expitem<0):#0716#202505012	.Expbnow==0
									print("\t\t当前的前跳行号(",MenuScreen.Expfnow,")")#202407172MenuScreen.ViewList:",MenuScreen.ViewList[15:25]
#									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#202505012
						#20241011			MenuScreen.Expbnow=MenuScreen.Expfnow
									Expbnow=MenuScreen.Expfnow#20240926
						#			self.CPass(Expbnow)
									if(self.CPass(Expbnow)):#20241011 
										self.Pop8b()
									else:
										#self.ToForward()
										MenuScreen.Expbnow = Expbnow#20241011
									
										bnowstrb=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
										print(bnowstrb,"\t\t前跳PassForward全显页，且没有选中跳转阅读链接，显示第一页；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")
										MenuScreen.Expfnow=MenuScreen.Expbnow+int(bnowstrb.split()[MenuScreen.Ignore+2])+1
										print("前跳行号为(",MenuScreen.Expfnow,")")
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#20240805
								else:#格式文本的非首页
									print("\t\t非首页格式行")
						#20241011			MenuScreen.Expbnow=MenuScreen.Expfnow#0909
									Expbnow=MenuScreen.Expfnow#20241011
									if(self.CPass(Expbnow)):#20241011 
										self.Pop8b()
									else:
										#self.ToForward()
										MenuScreen.Expbnow = Expbnow#20241011
									
										bnlist=MenuScreen.ViewList[MenuScreen.Expbnow].split()#0909获取当前格式行的表
									#print("MenuScreen.ViewList[",MenuScreen.Expbnow,"]=[",MenuScreen.ViewList[MenuScreen.Expbnow],"],MenuScreen.Expfnow=(",MenuScreen.Expfnow,")")#20240829
										if(MenuScreen.Expbnow<=MenuScreen.lViewList-2):#20240829
											if(MenuScreen.ViewList[MenuScreen.Expbnow][-1]==")"):#说明有可能有链接格式，取首项链接
												plist=self.psplit(MenuScreen.ViewList[MenuScreen.Expbnow],"(",")")#求括号分割最后项
												plastr=plist[-1][1:-1]
												print("\t\t格式行括号分割的末项字串为[",plastr,"]")
												lplastr=plastr.split()
												if(len(lplastr)>1 and lplastr[0].isdigit()):
													nxtlines=lplastr[1]
													print("\t\t\t下跳格式行数字串为[",nxtlines,"]")
													MenuScreen.Expfnow=MenuScreen.Expbnow+int(nxtlines)+1
											else:
												MenuScreen.Expfnow=MenuScreen.Expbnow+int(bnlist[MenuScreen.Ignore+2])+1
											print("\t\t","分显页(",MenuScreen.Expbnow,")行，没有选中跳转阅读链接，步进显示下一页：(",MenuScreen.Expfnow,")行")
											self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
					else:#0821
						print("处于弹出框状态self.PopP=",self.PopP)
						MenuScreen.AutoMode = True
			else:#注释命令模式下由AutoE赋值
				self.ToForward()
		






	
# 221 250    ( 0 0)

	def ToForward (self):#分页前跳 540 7293
		print("\n进入前跳操作模块ToForward->格式是否专用模式文件(",MenuScreen.ExpMode,")，当前回跳行号(",MenuScreen.Expbnow,")，前跳行号(",MenuScreen.Expfnow,")<=(",MenuScreen.lViewList-1,")?")#,end=""
		print("勾选行表：",self.CheckedRow,"‘闭环输入’判断self.LoopP=",self.LoopP)#,end=""
		self.CheckedRow=[]#0404	#清空多选项表
		self.ok = 1#0904True#0729
		#MenuScreen.Expitem = -1 #202409232
		if MenuScreen.ExpMode and MenuScreen.Expfnow<= MenuScreen.lViewList-1:#在myfileopen兼容模式中已赋值#202502224 lViewList-2
			print("当前之‘前跳’行号(",MenuScreen.Expfnow,")，",end="")#self.Expfnow,"\n")
			if(MenuScreen.Expfnow==0):#0813
				print("\t检测运行开关：")
				if(MenuScreen.OmniState):
					MenuScreen.AutoMode=True#全程执行模式
					print("\t进入全程运行模式，AutoMode：",MenuScreen.AutoMode)


					self.Line_str = self.menu_screen.ids.Line_Edit.text#20250317
					#20250120准备从文件读入数据的功能self.ui.textEdit_2.toPlainText()
					if(len(self.Line_str)>0 and MenuScreen.Expbnow == 0):
					#如果编辑行不空，假定为数据文件名#20250322	self.NFData == 0
						mypath=os.path.join(os.getcwd(),"src",self.Line_str)#20250315
#						mypath=os.path.join(self.WinPath,"src",self.Line_str)#filelist[i-1])
						print("\t\t发现编辑行不空，假定为数据文件[",mypath,"]")
						if(os.path.exists(mypath)):
							ld1=os.path.getsize(mypath)#文件大小
							if(ld1>0):
								fh=open(mypath,mode='r+t',encoding='UTF-8')
								if fh:
									fh.seek(0)
									data=fh.read()
									fh.close()
									plist = data[:-1].split("\n")
#									print("\t\tForward读入数据文件，转为表：",plist)
									lp = len(plist)
									if(lp>1):#数据文件最小二行，一行可以为#开头的注释
										self.FDataP = True
#										self.FDataList = []#20250211
										for ip in range(lp):
											if(plist[ip][0]!='#'):#数据文件可以用首字#注释
												#self.FDataList.append( plist[i])#20250210
#												print("\t\t\t冠亚字符[",plist[ip][0:2],"]")
												if(plist[ip][0:2]=='[]'):#20250221[]开头将以‘子表’格式读入
													plists = plist[ip][2:].split()#20250224将第二字符后，以空格分割为子表" "
													self.FDataList.append( plists)
#													print("\t\t\t\t读入冠亚字符[]的数据表",plists)
												else:#下增一档
												
													plists = plist[ip].split()#20250224" "
													if(len(plists)==1):#20250210
														self.FDataList.append( plist[ip])
													elif(len(plists)>1):#202502022 当读入行为多词时，以空格分割延展列表方式读入，而非‘子表’
														self.FDataList.extend(plists)
#														print("\t\t\t\t读入冠亚字符非[]的数据表",plists)
										print("\t\t\t从用户路径读入数据文件[",self.Line_str,"]转化为数据表self.FDataList：")#20250321	,self.FDataList)
										for idata in range(len(self.FDataList)):
											print(self.FDataList[idata])



				else:
					MenuScreen.AutoMode=False#人工模式
					self.MainPrompt ="选顶行，再点[笈智]，设为机动目录页；‘＋’行为链接；不选，点[向前]顺接下页"#20240905
					self.FirstLine(self.MainPrompt)#0925
					print("\t进入注释命令自动运行模式判断AutoMode：",MenuScreen.AutoMode)
			else:#0813
				bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#0813
				lie=bnowstr.split()#转成表
				if(MenuScreen.Ignore+2 < (len(bnowstr.split())) ):#20240208
					if(int(lie[MenuScreen.Ignore+2]) != 0):#202409232当前行为最后一行时,即格式第二项为0时，不推算调整
						MenuScreen.Expfnow = MenuScreen.Expbnow+int(bnowstr.split()[MenuScreen.Ignore+2])+1
						print("调整计算新‘前跳’行号为(",MenuScreen.Expfnow,")")#self.Expfnow,"\n")
			self.EIndex()#0726 显示上页摘录成果
			CheckedRow= self.SelectedList() #0718确定选中行共用，故前移
			#print("\t\tForward模块中，；大字窗口为：",self.text_screen)#202409222
			print("\t\t\t获取窗口管理器当前状态：",app.sm.current)
			if(app.sm.current == 'text'):#202409222尝试从大字编辑框读入光标行作为浏览选中行
				print("\t\t\t\t正在大字界面窗口")
				csrow = self.text_screen.ids.Enlarge_Edit.cursor_row
				if(csrow>=0):
					print("\t\t\t\t\t探测到大字界面的光标位于(",csrow,")行")#，光标索引index=",self.text_screen.ids.Enlarge_Edit.cursor_index
					if(MenuScreen.Expbnow < MenuScreen.lViewList-2):
						MenuScreen.Expitem = self.ELineNow()
						print("\t\t\t\t\t大字界面前跳选中(",MenuScreen.Expitem,")行")#点[向前]弹出图片因可能存在干扰而拟舍弃
						self.DisPic()
					else:
						MenuScreen.Expitem = -1
					
			else:
				if(len(CheckedRow)==0 ):#0813or MenuScreen.AutoMode
					MenuScreen.Expitem=-1#1 #0716
				else:
					MenuScreen.Expitem=CheckedRow[-1]#如果有选择集，取最后一项
				print("\t\t多项选择表为",self.CheckedRow,"，前跳选中(",MenuScreen.Expitem,")行（-1表示未选中，或取最后一项）")
			if not MenuScreen.AutoMode:#非注释命令模式下从屏幕获取，执行模式由AutoE赋值
				self.CheckedRow=[]#清空多选项表#v0.94
				print("检测弹出框状态self.PopP:",self.PopP)#0821
				if(MenuScreen.Expbnow<MenuScreen.lViewList):
					if(not self.PopP):#0821
						bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
						print("\n＝＝＝\n\t＝＝＝前跳模块当前回跳行号(",MenuScreen.Expbnow,")行：[",bnowstr,"]")
						lie=bnowstr.split()#格式行转成表
						lcol=len(lie)
						if(lcol>MenuScreen.Ignore+2):#格式检查
							print("\t当前(",MenuScreen.Expbnow,")行初判为格式行；")
							jumpp=False
							if(MenuScreen.Expitem>0):#阅读链接有选中
								print("\t\t","跳转阅读链接选中第(",MenuScreen.Expitem,")项；")
								if(self.Listp(bnowstr)):#初步检查有无阅读跳转链接项
									plist=self.psplit(bnowstr,"(",")")
									liste=plist[-1][1:-1].split()#提取最后一个括号项字符
									if(liste[0].isdigit()):#括号项首项为数字，表示有链接
										print("\n\t\t\t阅读链接表为：",liste)
										le=len(liste)#获取链接表项数
										jumpp=True
								if jumpp:#有阅读跳转链接
									print("\t\t\t成功获取链接表")
									if(MenuScreen.Expitem<=le-1 ):#v0.76选中行对应链接表项的合规检查,如果行号在链接表项数范围内
										itemn=int(liste[MenuScreen.Expitem])#提取链接步长
										print("\t\t\t\t链接表第",MenuScreen.Expitem,"项所提取链接步长为：",itemn)
										MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1+itemn#推算下一个回跳行号
										ljump=MenuScreen.ViewList[MenuScreen.Expbnow].split()#获取下一个回跳行的格式表
										if(len(ljump)>=MenuScreen.Ignore+2):#20230329初步检测下一个回跳行格式表项数不小于二项
											if(ljump[MenuScreen.Ignore+2].isdigit()):#并且第二项为数字
												MenuScreen.Expfnow=MenuScreen.Expbnow+int(ljump[MenuScreen.Ignore+2])+1#确定其为下一个前跳行号
												print("\t\t前跳forward分显页，确定下一个前跳行号为(",MenuScreen.Expfnow,")行")
												self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
									else:#20240805超过链接表项数时，顺页阅读
										print("\t\t\t选中行超过链接表词数")
										MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#推算前跳行号
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
										print("\t\t前跳forward无选中，顺接阅读；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")
								
								else:#20240805
									print("未成功获取链接表")
									if(int(lie[MenuScreen.Ignore+2]) != 0):#202409232当前行为最后一行时,即格式第二项为0时，不推算显示
										MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1#推算前跳行号
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#显示下一页
										print("\t\t前跳forward无选中，顺接阅读；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")#bnowstrb,
									else:
										print("\t\t前跳forward无选中，且为末格式行；不计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")#bnowstrb,
										
								
							if(not jumpp):#阅读链接没有选中向前项self.Expitem<=0 or 
								if(MenuScreen.Expfnow==0):#MenuScreen.Expitem<0):#0716#202505012	.Expbnow==0
									print("\t\t当前的前跳行号(",MenuScreen.Expfnow,")")#202407172MenuScreen.ViewList:",MenuScreen.ViewList[15:25]
#									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#202505012
									MenuScreen.Expbnow=MenuScreen.Expfnow
									bnowstrb=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
									print(bnowstrb,"\t\t前跳ToForward全显页，且没有选中跳转阅读链接，显示第一页；计算回跳行号(",MenuScreen.Expbnow,")忽略词数为(",MenuScreen.Ignore,")",end="")
									MenuScreen.Expfnow=MenuScreen.Expbnow+int(bnowstrb.split()[MenuScreen.Ignore+2])+1
									print("前跳行号为(",MenuScreen.Expfnow,")")
									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#20240805
								else:#格式文本的非首页
									print("\t\t非首页格式行")
									MenuScreen.Expbnow=MenuScreen.Expfnow#0909
									bnlist=MenuScreen.ViewList[MenuScreen.Expbnow].split()#0909获取当前格式行的表
									#print("MenuScreen.ViewList[",MenuScreen.Expbnow,"]=[",MenuScreen.ViewList[MenuScreen.Expbnow],"],MenuScreen.Expfnow=(",MenuScreen.Expfnow,")")#20240829
									if(MenuScreen.Expbnow<=MenuScreen.lViewList-2):#20240829
										if(MenuScreen.ViewList[MenuScreen.Expbnow][-1]==")"):#说明有可能有链接格式，取首项链接
											plist=self.psplit(MenuScreen.ViewList[MenuScreen.Expbnow],"(",")")#求括号分割最后项
											plastr=plist[-1][1:-1]
											print("\t\t格式行括号分割的末项字串为[",plastr,"]")
											lplastr=plastr.split()
											if(len(lplastr)>1 and lplastr[0].isdigit()):
												nxtlines=lplastr[1]
												print("\t\t\t下跳格式行数字串为[",nxtlines,"]")
												MenuScreen.Expfnow=MenuScreen.Expbnow+int(nxtlines)+1
										else:
											MenuScreen.Expfnow=MenuScreen.Expbnow+int(bnlist[MenuScreen.Ignore+2])+1
										print("\t\t","分显页(",MenuScreen.Expbnow,")行，没有选中跳转阅读链接，步进显示下一页：(",MenuScreen.Expfnow,")行")
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
					else:#0821	#202504252	if self.PopP:
						print("处于弹出框状态self.PopP=",self.PopP)
						MenuScreen.AutoMode = True
			else:#全程注释命令模式
				bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
				lie=bnowstr.split()#转成表
				lcol=len(lie)
				jumpp=False
				autop=False
#				print("\n\t前跳模块自动模式autofore  当前回跳行(",MenuScreen.Expbnow,")，内容[",bnowstr,"]共[",lcol,"]空格项")
				if(lcol>MenuScreen.Ignore+2):#格式检查
#					print("\t(",MenuScreen.Expbnow,")行前跳模块自动模式autofore  初判为格式行；选中项：(",MenuScreen.Expitem,")")
					if(self.Listp(bnowstr)):#初步检查有阅读跳转链接项
#						print("「自动前跳」初步检查有阅读跳转链接项")
						plist=self.psplit(bnowstr,"(",")")
						liste=plist[-1][1:-1].split()#提取括号末项字符
						if(liste[0].isdigit()):#括号项首项为数字，表示有链接
#							print("\n\t\t\t前跳模块自动模式autofore  阅读链接表为：",liste)
							le=len(liste)#获取链接表项数
							jumpp=True#判断为有跳转链接表
							if(len(plist)==3):#包括了阅读链接和执行表
								autop=True
								MenuScreen.Expitem=-1#20230228
								#提取倒数第2个括号项字符为执行表
								stra=plist[-2][1:-1]#self.psplit()[1:]
#								print("\n\t\t\t前跳模块自动模式autofore  共3组表，末组为链接表，末第二组为执行表，执行串为\n[",stra,"]")
						else:#首项非数字时，表明为执行表，提取最后括号项字符为执行表
							autop=True#判断自动执行
							stra=plist[-1][1:-1]#self.psplit()[1:]
#							print("\n\t\t\t前跳模块自动模式autofore  末组为执行表，提取注释命令为：",stra)
					if(MenuScreen.Expitem>=0):#阅读链接[有]选中
#						print("\t\t前跳模块自动模式autofore  跳转阅读链接表选中第(",MenuScreen.Expitem,")项")
						if jumpp:#有阅读跳转链接
							if(MenuScreen.Expitem<=le-1 ):#v0.76选中表项合规检查
								itemn=int(liste[MenuScreen.Expitem])#提取链接步长
#								print("\t\t\t\t前跳模块自动模式autofore  链接表第(",MenuScreen.Expitem,")项，跳转步长为：",itemn)
								MenuScreen.Expbnow=MenuScreen.Expbnow+int(lie[MenuScreen.Ignore+2])+1+itemn
								ljump=MenuScreen.ViewList[MenuScreen.Expbnow].split()#获取链接跳转后的格式行表
								if(len(ljump)>=MenuScreen.Ignore+2 and ljump[MenuScreen.Ignore+2].isdigit()):
									MenuScreen.Expfnow=MenuScreen.Expbnow+int(ljump[MenuScreen.Ignore+2])+1
									#self.Expitem=-1	
									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#0329int(
									bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
									if(self.Listp(bnowstr)):#初步检查有无阅读跳转链接项
										plist=self.psplit(bnowstr,"(",")")
										liste=plist[-1][1:-1].split()#提取最后一个括号项字符
										if(liste[0].isdigit()):#括号项首项为数字，表示有链接
#											print("\n\t\t\t前跳模块自动模式autofore  前跳后阅读链接表为：",liste)
											le=len(liste)#获取链接表项数
											jumpp=True
										else:
											jumpp=False
										if(len(plist)==3):#包括了阅读链接和执行表
											autop=True
											#提取倒数第2个括号项字符为执行表
											stra=plist[-2][1:-1]#self.psplit()[1:]
#											print("\n\t\t\t前跳模块自动模式autofore  前跳后执行表共3项，注释命令为：",stra)
										else:
											autop=False											
									else:
										autop=True
										#提取最后括号项字符为执行表
										stra=plist[-1][1:-1]#self.psplit()[1:]
#										print("\n\t\t\t前跳模块自动模式autofore  前跳后提取末项执行表注释命令为：",stra)
					if autop:
#						print("\n\t2023>>8 前跳模块自动模式autofore  [下翻页模块]准备自动执行注释命令")
						self.AutoE(stra)
#						print("\n\t2023>>9 前跳模块自动模式autofore  [下翻页模块]完成自动执行注释命令！！！\n")
					else:#阅读链接没有选中
#						print("\t\t2023>>10 前跳模块自动模式autofore  [下翻页模块]没有选中跳转阅读链接、接引串，步进显示下一页：")
						MenuScreen.Expbnow=MenuScreen.Expfnow
						bnowstrb=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行
						if(len(bnowstrb.split())>MenuScreen.Ignore+2):#20240204#20240923 >=
							MenuScreen.Expfnow=MenuScreen.Expbnow+int(bnowstrb.split()[MenuScreen.Ignore+2])+1
							self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#3029int(
#							print("\t\t2023>>11 前跳模块forward自动模式autofore  回跳行号(",MenuScreen.Expbnow,")，前跳行号(",MenuScreen.Expfnow,")")
				else:
					print(MenuScreen.Expbnow,"前跳模块自动模式autofore  格式行有误")

# 250 731       (7987 0 0)

	def AutoE (self,string):#自动运行注释命令
#		print("Autoe弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
		print("进入自动摘录模块AutoE,运行(",MenuScreen.Expbnow,")行字串：\n\t{",string,"}")#string为去掉括号的字符串
		Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)
		if(len(string)==1):
			with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
				i1=1
				for i in range(MenuScreen.Expbnow,MenuScreen.Expfnow):
					f.write(str(MenuScreen.Expbnow)+" "+str(i1)+" "+"\n")
					i1+=1
				f.write("\n")#方便undo操作
		else:
			AElist=self.psplit(string,"(",")")
			print("\t自动摘录(",MenuScreen.Expbnow,")行转化操作列表：",AElist)
			la=len(AElist)
#			print("=================格式(",MenuScreen.Expbnow,")行，共(",la,")项=================")
			i=1
			if str(MenuScreen.Expbnow) in MenuScreen.Rundic:#0914
				ir=MenuScreen.Rundic[str(MenuScreen.Expbnow)]#如执行过该行，提取对应的序号
				if(ir>i):
					i=ir
				print("(",MenuScreen.Expbnow,")行曾执行过，从执行字典取出(",MenuScreen.Expbnow,")行运行项序号为(",i,")")
			while (i<la):#0824
				#it=self.model.item(0).checkState()#检测顶行是否勾选，决定是人工逐步模式，还是全程执行模式#2023*0218
#				print("\n\t检测 运行(扫描) 切换状态：[",MenuScreen.OmniState,"]自动模式",MenuScreen.AutoMode)
				if(not MenuScreen.AutoMode):#如果非自动模式，包括局部模式或全局异常退出
					if(MenuScreen.OmniState):#电脑版是顶行勾选，手机版运行标志在打开状态时#0718
						print("\n\t「运行」状态异常，中断退出！")#0821
						break#0821
					else:#电脑版是顶行未勾选，手机版即运行标志未在打开状态时
						if(MenuScreen.Expfnow>0):
							print("\n\t局部页时处于「扫描」状态，说明全局异常，中断退出！")
							break
				stril=AElist[i][1:-1].split()
				lsl=len(stril)
				print("\n\t\t==本页注释格式行号(",MenuScreen.Expbnow,")，总计(",la,")个括号项，执行至第(",i,")项{",AElist[i],"}共(",lsl,")空格分割词")#20250322
#				print("\n\n\t==>注释命令for循环进入第(",i,")项为『",AElist[i],"』共(",lsl,")词")
				if(lsl>1):
					ir=0
					if str(MenuScreen.Expbnow) in MenuScreen.Rundic:
						ir=MenuScreen.Rundic[str(MenuScreen.Expbnow)]#0810 如执行过的提取该行对应的序号
						print("从执行字典取出运行项序号为(",ir,")")#20250322下增一档
						if(i>ir):#(i>=ir)0810 如果提取序号ir<当前的序号，说明没有执行过
							print("\n\t\t\t(",MenuScreen.Expbnow,")行扫描非循环自动执行项，之前执行项序号(",ir,")，当前执行序号(",i,")为大，执行注释命令")
							MenuScreen.Rundic[str(MenuScreen.Expbnow)]=i
						else:
							if(not self.LoopP):#0824
								print("\n\t\t\t(",MenuScreen.Expbnow,")行扫描自动执行项，之前执行项序号为(",ir,")，未小于当前执行序号(",i,")，故略过本项注释命令")
								i+=1#0824
								continue
							else:#0824
								if(self.LoopOn):#0829
									self.nLoop +=1
									print("\n\t\t\t(",MenuScreen.Expbnow,")行扫描自动执行项，之前执行项序号为(",ir,")，未小于当前执行序号(",i,")，self.LoopP=",self.LoopP,",执行本项注释命令,第(",self.nLoop,")次循环录入")
								else:#0829
									self.LoopP =False
									print("\n\t\t\t(",MenuScreen.Expbnow,")行扫描自动执行项，之前执行项序号为(",ir,")，未小于当前执行序号(",i,")，self.LoopP=",self.LoopP,",略过本项注释命令")
									continue
				MenuScreen.Rundic[str(MenuScreen.Expbnow)] = i#202503244执行字典记录执行号


				if((MenuScreen.Expbnow>= MenuScreen.lViewList-1) or (MenuScreen.ViewList[MenuScreen.Expbnow].split()[MenuScreen.Ignore+2]=='0')):break#20250317
				
				Expforestep=int(MenuScreen.ViewList[MenuScreen.Expbnow].split()[MenuScreen.Ignore+2])
				
				
				
				
				
				if(lsl==1):
					print("\n\t*单项注释命令：",AElist[i])
					with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
						stri=AElist[i][1:-1]#去括号
						if(stri.isdigit()):#如果是数字
							if(stri=='0'):
									print("\t\t\t摘引项(0)")
									f.write(str(MenuScreen.Expbnow)+" "+stri+' ""\n')
							else:
								if(int(stri)<Expforestep):#大小在行号之间摘引该行
									strt = str(MenuScreen.Expbnow)+" "+stri
									print("\t\t单项注释摘录字符为数字 ，写入[",strt,"]")
									f.write("\n"+strt)#0911+"\n")
						else:	#非数字的检索若有变量含此字符，提取字符,-3表示算式字串不计算
							if(stri=='全' or stri=='A' or stri=='a' ):#全选本页20230203
								print("\t\t单项注释命令字符为 [",stri,"] 执行过程如下：")
								for i1 in range(1,Expforestep+1):
									strt="\n"+str(MenuScreen.Expbnow)+" "+str(i1)#20230823
									f.write(strt)#str(MenuScreen.Expbnow)+" "+str(i1)+"\n"#20230218
									print("\t",strt,end="")#20230218
									

							elif(stri[0]=='#'):#20250318识别字串是否python注释格式
								print("\t\t单项注释摘录字符非'全'字，且是首字为‘#’的 [",stri,"]，作为注释略过")
							elif(stri[0].isdigit() and stri[-1]==']'):#20250317识别字串是否python取子串格式
#								print("\t\t单项注释摘录字符非'全'字，但首字为数且末字为]的 [",stri,"] 执行过程如下：")
								alti=self.AltStr(stri,8,MenuScreen.Expbnow)#单项首字为数字末字为]时，取计算结果字串
								strl = self.psplit(alti,'[',']')#以[]分割字串
								if(len(strl)>1):#如果项数超过一项，说明较大可能是python子串格式
									if(strl[0].isdigit()):#进一步探测首项是否数字，以指定行号（>0）
										lrow = int(strl[0])
										if(lrow> 0 and lrow<=Expforestep):#数字值>0,且<=于本页行数，准备选中该行对应字符
											formP = True#假定格式正确
											if(strl[1].find(':')>=0):#探测[]内有python字串分割符':'时，假定判断正确
												linestr = MenuScreen.ViewList[MenuScreen.Expbnow+lrow]
												lline = len(linestr)
												strlp = ""
												strlh = ""
												strl2 = strl[1][1:-1].split(':')#以:再分割字串
												lb = 0
												le = lline
												if(len(strl2)>1):
#													print("\t\t\t\t笈命令由:分割为二项",strl2)
													if(len(strl2[0])>0):
														if(strl2[0][0]=='-'):#如果前串首字为‘-’
															strp = strl2[0][1:]
															if(strp.isdigit()):
																if(int(strp)<=lline):
																	lb = lline+int(strl2[0])
														elif(strl2[0].isdigit()):
																if(int(strl2[0])<=lline):
																	lb = int(strl2[0])
														else:
															formP = False
													if(len(strl2[1])>0):
														if(strl2[1][0]=='-'):#如果后串首字为‘-’
															strh = strl2[1][1:]
															if(strh.isdigit()):
																if(int(strh)<=lline):
																	le = lline+int(strl2[1])
														elif(strl2[1].isdigit()):
																if(strl2[1]<=lline):
																	le = int(strl2[1])
														else:
															formP = False
													if(formP):
														alti = linestr[lb:le]
#														print("准备写入(",lrow,")行[",linestr,"](",lb,")~(",le,")位的子串[",alti,"]")
														f.write(str(MenuScreen.Expbnow)+' 0 "'+alti+'"\n')#20250303
										

							else:#不是全字，且首字不为数末字不为]时
								print("\t\t单项注释摘录字符[",stri,"]，非'全'字，且首字不为数末字不为]，首字也不是#的命令注释，  执行过程如下：")
#								if(len(self.AltStr(stri,-3,MenuScreen.Expbnow))>0):#0324加此3句导致莫名其妙循环！！！
#								if(len(stri)>2 and stri.find(" ")>=0):#0331#20250318
#									alti=self.AltStr(stri,-3,MenuScreen.Expbnow).split()[0]
#								else:
								alti=self.AltStr(stri,8,MenuScreen.Expbnow)#弹框搜索#20250321 -3
								print("\t\t单项注释命令字符AltStr检索变量后为[",alti,"]")

								lena = 1#202504213灭火器配置补丁
								if(len(alti)>0):
									lalti = alti.split()
									lena = len(lalti)
								if(lena == 1):#20250417检查检索后的项数，下增一档


									if(alti.isdigit()):#如果是数字
										print("\t\t\t变量替换后是数字[",alti,"]<(",Expforestep,")?")
										if(int(alti)<Expforestep):
											if(alti == '0'):#20250321
												print("\t\t\t摘引数字(",MenuScreen.Expbnow,")行 ",alti)
												f.write("\n"+str(MenuScreen.Expbnow)+' 0 "0"')#0823
											else:#20250321
										
												print("\t\t\t摘引数字(",MenuScreen.Expbnow,")行 ",alti)
												f.write("\n"+str(MenuScreen.Expbnow)+' '+alti)#0823								
									else:#结果非数字，搜索本页，如有含此字串的行，则选中，无此字，则直接输出该字串	#非数字包括本页文字及弹框搜索
										print("\t\t\t变量替换后为字符串[",alti,"]，搜索本页含此字符的行")
										getlinep=False
#										i1=1#20250318i1经检查无用，故相关内容删除
										if(len(alti)>0):#0905
											for i2 in range(1,Expforestep):#0825i#20250318
												if(MenuScreen.ViewList[MenuScreen.Expbnow+i2].find(alti)>=0):
													print("\t\t\tAutoE(",MenuScreen.Expbnow+i2,")行[",MenuScreen.ViewList[MenuScreen.Expbnow+i2],"]发现[",alti,"]记录本行")
													f.write("\n"+str(MenuScreen.Expbnow)+" "+str(i2))#0904+"\n"	
													getlinep=True
													print("(",i2,")行[",MenuScreen.ViewList[MenuScreen.Expbnow+i2],"]含字符[",alti,"]")
													break
#												i1+=1#20250318
										if not getlinep:
											print("\t\t\t没有找到变量替换字符后的行,写入该字符[",alti,"]")
											f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+alti+'"')#20240205
#							f.write("\n")#方便undo操作#20250422
							
							
								else:#202504213检查检索后的项数超过一个时，下增一档
									print("\t\tAutoE单项转化后,成为空格分割超一词的字串[",alti,"]")
									alti = lalti[0]#取转化表的首词
									if(alti.isdigit()):#结果如果是数字
										print("\t\t\t变量替换后是数字(",alti,")vs ",Expforestep)
										if(int(alti)<Expforestep):#数字值小于本页行数，为选中该值对应行
											if(alti == '0'):#2025404
												print("\t\t\t摘引数字(",MenuScreen.Expbnow,")行 ",alti)
												f.write("\n"+str(MenuScreen.Expbnow)+' 0 "0"')#0823
											else:#20250404下增一档
											
												print("\t\t\tAutoe写入摘引数字",MenuScreen.Expbnow," ",alti)
												f.write("\n"+str(MenuScreen.Expbnow)+" "+alti)#20250422换行前置

									else:#结果非数字，搜索本页，如有含此字串的行，则选中，无此字，则直接输出该字串	
										print("\t\t\t变量替换后为字符串[",alti,"]，搜索本页含此字符的行")
										getlinep=False
#										i1=1#20250214 i1经检查无用，故相关内容删除
										if(len(alti)>0):#20250404下增一档
										
											for i2 in range(1,Expforestep):#1014 i#20250214 i2
												if(MenuScreen.ViewList[MenuScreen.Expbnow+i2].find(alti)>=0):#20250214 i1
													print("\t\t\tAutoE(",MenuScreen.Expbnow+i2,")行[",MenuScreen.ViewList[MenuScreen.Expbnow+i2],"]发现[",alti,"]记录本行")
													f.write("\n"+str(MenuScreen.Expbnow)+" "+str(i2))#20250214 i1#20250422换行前置
	
													getlinep=True
													print("(",i2,")行",MenuScreen.ViewList[MenuScreen.Expbnow+i2],"含字符[",alti,"]")#20250214 i1
													break
#												i1+=1#20250214

										if not getlinep:#无此字串的行，则直接输出该字串
											print("没有找到变量替换字符后的行,写入该字符")#20250417检测灭火器应用后区分是不是多项返回值
											f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+alti+'"')#20250214RV \n后置#20250422换行前置
											#f.write(str(MenuScreen.Expbnow)+" 0 "+alti+"\n")

							
							
							
							
				elif(lsl==2):
					print("\n\t**双项注释命令表AElist[",i,"]：",AElist[i])
					if(stril[0]=="0"):#后台执行扫描模式0218
						jumpp=False
						self.LoopOn=True#0831*
						self.nLoop = 0#0831
						print("\t双项式",AElist[i],"注释命令;self.LoopOn->",self.LoopOn)
						if(str(MenuScreen.Expbnow) in MenuScreen.Expdic):#检查本行是否曾扫描过（在字典内）
							i1=MenuScreen.Expdic[str(MenuScreen.Expbnow)]#如扫描过的提取该行对应的序号
							print("\n\t\t\t\t=>自动执行中，扫描(",MenuScreen.Expbnow,")行在执行字典中，之前曾执行到(",i1,")项")
							if(i>=i1):#如果提取序号i1<当前的序号，说明没有扫描过
								print("\n\t\t\t\t当前执行序号(",i,")>=已执行序号，继续执行……")
								MenuScreen.Expdic[str(MenuScreen.Expbnow)]=i
								if(i==la-1):#20250322
									print("\t(",MenuScreen.Expbnow,")行自动摘录表共(",la-1,")项，已执行至(",i,")项，该行将从字典中删除->\n",MenuScreen.Expdic)
									MenuScreen.Expdic.pop(str(MenuScreen.Expbnow))#各项运行后，删除字典该行							
#									print("\t",i,"项删除后的字典表：\n",MenuScreen.Expdic)
								if(stril[1]=="0"):
									self.backward()
								elif(stril[1].isdigit()):
									MenuScreen.Expitem=int(stril[1])
									MenuScreen.Expbnow=self.ForJump(MenuScreen.Expbnow,MenuScreen.Expitem)#链接表第二项为数字时，准备跳转
									print("\t\t\tAutoE模块中，当前格式行为(",MenuScreen.Expbnow,")遍历执行序号(",i,")末项序号为(",la-1,")")
									if(i==la-1):#0827
										self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
										print("\t\t\t\t执行至(",MenuScreen.Expbnow,")行末条注释命令，自动运行模式转化为阅读模式，跳页显示")
									if(MenuScreen.Expfnow < MenuScreen.lViewList-1):#20250314
										self.forward()
									else:break
								else:
									alti=self.AltStr(stril[1],0,MenuScreen.Expbnow).split()[0]
									print("\t\talstr变量替换为字符",alti)
									if(not alti.isdigit()):
										print("\t\t非数字时，Picklist开始查找相关字符行号->")
										alti=self.PickList(alti,MenuScreen.Expbnow)[0]#stril[1]
#										print("\t\tPicklistr返回行号",alti)
									elif(alti.isdigit()):#20250322 if
										if(alti=='0'):#20250322如果计算结果的第二位是0，调用backward
											self.backward()
										else:#20250322下增一档
										
											MenuScreen.Expitem=int(alti)
											MenuScreen.Expbnow=self.ForJump(MenuScreen.Expbnow,MenuScreen.Expitem)
											self.forward()
									else:
										print(string," 中 {",AElist[i],"} 第二项应为数字，请纠正：",stril[1])
							else:#20250322如果提取序号i1>=当前的序号，说明没有扫描过
								print("\n\t\t\t\t当前执行到序号(",i,")，在已执行(",i1,")之列，略过")
								
						else:#检查本列表项，如果没有扫描过。故障摸排测试：错误发生在3932~3952之间
							if(i!=la-1):#如果不是运行到最后一项，在字典中记录行号对应的扫描序号	
								MenuScreen.Expdic[str(MenuScreen.Expbnow)]=i						
								print("\n\t\t\t",MenuScreen.Expbnow,"行->发现自动扫描项，扫描项序号i=",i,"为非末项，记入字典成为",MenuScreen.Expdic)
							print("\t\t当前格式行(",MenuScreen.Expbnow,")表内第二字符为[",stril[1],"]")
							if(stril[1]=="0"):
								self.backward()
							elif(stril[1].isdigit()):#扫描格式第二项为数字时
								MenuScreen.Expitem=int(stril[1])
								MenuScreen.Expbnow=self.ForJump(MenuScreen.Expbnow,MenuScreen.Expitem)
								print("\t\t\t当前格式行为(",MenuScreen.Expbnow,")执行序号(",i,")末项序号为(",la-1,")")
								if(i==la-1):#0827
									self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
									print("执行至末项，注释命令为扫描，跳页显示")
								self.forward()
							else:#扫描格式第二项为文字时
								alti=self.AltStr(stril[1],0,MenuScreen.Expbnow).split()[0]
								print("\t\talstr变量替换为字符[",alti,"]")#故障摸排测试：错误发生在3945~3946之间
								if(not alti.isdigit()):
									alti=self.PickList(alti,MenuScreen.Expbnow)[0]#stril[1]

									print("\t\t\tAutoE中，picklist将变量替换为字符[",alti,"]")#202503244
									if(alti.isdigit()):#202503244
										if(alti=='0'):#202503244如果计算结果的第二位是0，调用backward
											self.backward()
										else:#202503244下增一档
											MenuScreen.Expitem=int(alti)
											MenuScreen.Expbnow=self.ForJump(MenuScreen.Expbnow,MenuScreen.Expitem)
											print("\t\t\t\tAutoE中，当前格式行为(",MenuScreen.Expbnow,")，执行序号(",i,")末项序号为(",la-1,")")
											if(i==la-1):#0827
												self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
												print("\t\t\tAutoE中，执行至末项，注释命令为扫描，跳页显示")
											self.forward()
									


								elif(alti.isdigit()):#20250322 if
									if(alti=='0'):#20250322如果计算结果的第二位是0，调用backward
										self.backward()
									else:#2025032下增一档
										
										MenuScreen.Expitem=int(alti)
										MenuScreen.Expbnow=self.ForJump(MenuScreen.Expbnow,MenuScreen.Expitem)
										print("\t\t\t\t当前格式行为(",MenuScreen.Expbnow,")，执行序号(",i,")末项序号为(",la-1,")")
										if(i==la-1):#0827
											self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
											print("\t\t\t\t\t执行至末项，注释命令为扫描，跳页显示")
										
										self.forward()
								else:
									print(string," 中 {",AElist[i],"} 第二项应为数字，请纠正：",stril[1])
									
					elif(stril[0].isdigit()):
						if(stril[1].isdigit()):
							toi=int(stril[1])
							fri=int(stril[1])-int(stril[0])+1
							print("注释命令为首项非零数字对，记录本页从(",fri,")到(",toi,")行")#0911
							with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
								i1=fri
								for i2 in range(int(stril[0])):#0911
									f.write("\n"+str(MenuScreen.Expbnow)+" "+str(i1))#0912+"\n")
									i1+=1
								f.write("\n")#方便undo操作
							f.close()
						else:
							alti=self.AltStr(stril[1],0,MenuScreen.Expbnow).split()[0]
							print("注释命令首项非零数字，次项尝试转化为数字(",alti,")")#0911
							if(alti.isdigit()):
								toi=int(alti)#0911(stril[1])
								fri=int(alti)-int(stril[0])+1
								print("\t\t双项式",AElist[i],"注释命令，从(",fri,")到(",toi,")")
								with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
									i1=fri
									for i2 in range(int(stril[0])):#0911
										f.write(str(MenuScreen.Expbnow)+" "+str(i1)+"\n")
										i1+=1
									f.write("\n")#方便undo操作
							else:
								print(string," 中 ",AElist[i]," 第二项应为数字，请纠正：",stril[1])
					else:#首字不是数字时，为不显示的两项内部赋值
						if(stril[0][0]=='#'):#20240217当双项命令首字为#时，表示词外循环
							strit=stril[0][1:]
							self.MainPara=strit
							print("\t\t首字为‘#’的双项赋值全局变量名为[",self.MainPara,"]")



#202503177修改始
						else:#20250209 (管号 [](环行号)，(环列号))
							strit=stril[0]
							self.MainPara=stril[0]
							print("\t\t双项赋值全局变量名为[",self.MainPara,"]")
							
						lcom = stril[1].find('，')#20250209变量式字串检测是否存在‘，’，如有而后无数字时表示获取整个字串，否则获取相应词
#						如(试算结果 (-7,(管列号)~:(22)#1)，)
						print("\t发现全角‘，’号位置(",lcom,")")
						strtp = ""
						strth = ""
						alti = ""
						nstrh = 0 #202500306
						wholep = False#返回整个字串判断
						if(lcom<0):#20250209当变量式不存在‘，’时，下行增一档

							alti=self.AltStr(stril[1],8,MenuScreen.Expbnow)#202503244
							if(len(alti)>0):
								alti = alti.split()[0]#将转化后的首词赋给变量名
								print("\t\t\tAutoE返回值#20250306[",alti,"]")
								
#							alti=self.AltStr(stril[1],8,MenuScreen.Expbnow).split()[0]#将转化后的首词赋给变量名
						else:#20250209(lcom>=0):如果发现‘，’符，将之后的数值或变量转化成对应词，赋给变量名
							if(stril[1].find('[]')>=0):#20250224 :1	[](环行号)，(环列号) #20250306stril[1][:2]=='[]'
								#202500306 (环内循环数 (([](运行环行号)，)-1)) 
								#alti = self.FData(stril[1],"")#20250306,strit将文件表数据赋给变量名stril[1]

								alti=self.AltStr(stril[1],8,MenuScreen.Expbnow)#202503244
								if(len(alti)>0):
									alti = alti.split()[0]#将转化后的首词赋给变量名
									print("\t\t\tAutoE返回值#20250306[",alti,"]")
									
#								alti=self.AltStr(stril[1],8,MenuScreen.Expbnow).split()[0]#将转化后的首词赋给变量名

								print("\t\t\tAutoE返回值#20250306[",alti,"]")
							else:#没有[]而有‘，’ #20250306恢复字串中获取表项值
								strtp = stril[1][1:lcom-1]#获取前端变量式
								strth = stril[1][lcom+1:]#获取后端变量式
								print("\t\t\tAutoe二词获取全角逗号前端变量式[",strtp,"]后端变量式[",strth,"]")
								if(self.IsNumber(strth)):#后端变量式如果是实数
									nstrh = int(float(strth))
									print("\t\t\t\tAutoe两项式提取变量对应数字序号字串[",nstrh,"]")
								elif(lcom==len(stril[1])-1):#当‘，’后无内容时，表示返回整个字串
									wholep = True
								elif(strth[0]=='('):#如果为带括号的变量
									lh = strth.find(')')
									if(lh>0):
										strth = strth[1:lh-1]#提取
										print("\t\t\t\tAutoe两项式提取序号变量为[",strth,"]")
										strth = self.AltPara(strth)
										nstrh = int(float(strth))
										print("\t\t\t\tAutoe两项式提取序号变量转化为数字串[",nstrh,"]")
								alti=self.AltStr(strtp,8,MenuScreen.Expbnow)
								if(len(alti)>0):#不空时转为表
									if (not wholep):
										altil = alti.split(' ')
										if(nstrh<len(altil)):#如果序号小于表词数，取相应词，否则返回空字串
											alti = altil[nstrh]
										else:
											alti = ""
											print("\t\t\t\tAutoe两项式提取对应序号变量转化为字串[",alti,"]")
						print("\t\tAutoE双项注释命令字符AltStr检索外循环变量后为[",alti,"]首项[",strit,"]")
						if(len(alti)>0):#20250209当传递空串时略过，下行增一档
							FlistP = False#20250228文件表格式判断
							if(strit[0]=='('):#20250228兼容首字括号
								if(strit[1:3]=='[]'):#20250227如果变量名为数据文件表格式时
									FlistP = True
									strit = strit[1:-1]
							elif(strit[:2]=='[]'):
								FlistP = True
							if FlistP:#20250228

								self.FData(strit,alti)	#20250227								
								print("\t\tautoe双项式[",AElist[i],"]赋值(",alti,")于变量[",strit,"]")
							else:#20250221如果变量名非数据文件表格式时
						
#								if(self.IsNumber(alti)):#变量如果是实数20250209由于可能为表字串，此项判断取消
#								if(float(alti)>=0.0):#20250209由于放宽传递值，不只是列号，有可能为负值放弃此行检测
								print("\t\t双项式[",AElist[i],"]赋值(",alti,")于变量[",strit,"]")
								with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
									if(strit.find('[]')<0):#20250225含[]为直接操作内存，故不记录
										f.write("\n"+str(MenuScreen.Expbnow)+' -8 "'+alti+'" '+strit+"\n")#20250316增加前端“\n”不显示两词赋值，将0改为-8
									
								print("\t\t\tAutoE模块中，当前格式行号(",MenuScreen.Expbnow,")执行序号(",i,")末项序号为(",la-1,")")#20241225
#202503177修改终
									





#							alti=self.AltStr(stril[1],8,MenuScreen.Expbnow).split()[0]
#							print("\t\t双项注释命令字符AltStr检索外循环变量后为[",alti,"]")
#							if(self.IsNumber(alti)):#变量如果是实数
#								if(float(alti)>=0.0):
#									print("\t\t双项式",AElist[i],"赋值[",alti,"]于变量[",strit,"]")
#									with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
#										f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+alti+'" '+strit)#0912+"\n")
#										f.write("\n")#方便undo操作
#							else:
#								print("\t\t双项式[",AElist[i],"]赋值")
#								with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
#									f.write("\n"+str(MenuScreen.Expbnow)+" 0 ")#0912+"\n")
#						else:
#							self.MainPara=stril[0]
#							print("\t\t双项赋值全局变量名为[",self.MainPara,"]")
#							alti=self.AltStr(stril[1],0,MenuScreen.Expbnow)#.split()[0]
#							if(len(alti)>0):
#								alti=alti.split()[0]
#								if(alti.isdigit()):
#									print("\t\t双项式",AElist[i],"赋值[",alti,"]于变量[",stril[0],"]")
#									with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
#										f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+alti+'" '+stril[0])#0912+"\n")
#							else:
#								print("\t\t双项式[",AElist[i],"]赋值")
#								with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
#									f.write("\n"+str(MenuScreen.Expbnow)+" 0 ")#0912+"\n")
						#v0.975引入双变量赋值，第一第二项为字符串时设为变量名
						
						
						
						
						
				elif(lsl==3):
					print("\n\t***参项注释命令：",AElist[i])
					dual1p=False
					dual2p=False
					if (not stril[0].isdigit()):
						dual1p=True
						#print("第1项应为整数或整数变量，请修正")#v0.975

					else:
						print("第一项整数变量")#v0.975 #20240215应为整数或，请修正
						
					if (not stril[1].isdigit()):
						dual2p=True
						#print("第2项应为整数或整数变量，请修正")#第二项为字符串时设为变量名
					else:
						print("第二项整数变量")#第二项为字符串时设为变量名 #20240215应为整数或，请修正
						
					if(stril[2].isdigit()):#第三项为数字时，调出该行字串
						string3=MenuScreen.ViewList[MenuScreen.Expbnow+int(stril[2])]#取整行，若取列用,分割声明
					else:
						string3=stril[2]#第三项非数字时，本身作为字串
						
					if(not dual1p):#首项为数字时
						if(stril[1].isdigit()):#如果次项也为数字时
							toi=int(stril[1])#记录操作末行号
						else:#如果次项非数字时
							alti=self.AltStr(stril[1],0,MenuScreen.Expbnow).split()[0]
							print("\t\tAltstr将字符转换为[",alti,"]")
							if(not alti.isdigit()):#如果转换后依然为字符
								print("\t\t非数字时，Picklist开始查找相关字符行号->")
								alti=self.PickList(alti,MenuScreen.Expbnow)[0]#stril[1]
								print("\t\tPicklistr返回行号",alti)
							if(alti.isdigit()):
								toi=int(alti)
								print("参项摘录第二项转化为整数",toi)
							else:
								print(string," 中 ",AElist[i]," 可能应为数字，请注意检查[",stril[1],"]")
						fri=toi-int(stril[0])+1#计算操作首行号
						print("\t\t三项注释命令，从(",fri,")到(",toi,")")
						Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)
#						if(MenuScreen.Expbnow==0):#v0.74#20250320撤消此判断，下减一档
#							print("\t\t三项注释命令，操作首页")
#							with open(Indexpath,mode='w+t',encoding='UTF-8') as f:
#								f.write(MenuScreen.fileName_choose+"\n")
						#else:#20240418
						#	print("\t\t三项注释命令，操作非首页")
						
						with open(Indexpath,mode='a+t',encoding='UTF-8') as f:#20240418 前置/t
							i1=fri
							irang = int(stril[0])#20250319
							for i2 in range(irang):#0911#20250318int(stril[0])
								strt = str(MenuScreen.Expbnow)+" "+str(i1)#20250214
								if(stril[2]=='0'):
									print("\t(",toi-irang+i2,")行[",strt,"]写入文件")
									f.write("\n"+strt)#20250318str(MenuScreen.Expbnow)+" "+str(i1))#0911+"\n")
#									print("换行")
								else:
									f.write("\n"+strt+' "⌇"')#20250318str(MenuScreen.Expbnow)+" "+str(i1)+' "⌇"')#0911" \"⌇\"\n")
#									print("不换行")
								i1+=1
							f.write("\n")#方便undo操作
					if (dual2p and dual1p):#伯仲项皆非数字时，双赋值操作
						print("伯仲项皆非数字时，双赋值操作")
						with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
							strt=self.AltStr(string3,0,MenuScreen.Expbnow)#第四项字括号或计算式化解
							if(len(strt.split())>1):
								strt1=strt.split()[0]
								strt2=strt.split()[1]#202504224发现此句在油埠消防中出错 [-1]
								print(str(MenuScreen.Expbnow)+' 0 "'+strt1+'" '+stril[1]+"\n"+str(MenuScreen.Expbnow)+' 0 "'+strt2+'" '+stril[0])
								f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+strt1+'" '+stril[1])#0911+"\n")
								f.write("\n"+str(MenuScreen.Expbnow)+' 0 "'+strt2+'" '+stril[0])#0911+"\n")
								f.write("\n")#方便undo操作
								
								
								
								
								
				elif(lsl==4):
					print("\n\t****肆项注释命令：",AElist[i])
					#肆项摘录不计算，在有括号时变量替换；第三项负数时将第四项赋值于第二项，0时换行，非0不换行
					toi=int(stril[1])
					fri=int(stril[1])-int(stril[0])+1					
					if(stril[3].isdigit()):#第四项为数字时，调出该行字串
						string4=MenuScreen.ViewList[MenuScreen.Expbnow+int(stril[3])]
						if(len(string4)>0):#20250322
						
							if(self.Listp(string4)):
								string4=self.AltStr(string4,-3,MenuScreen.Expbnow)#20250322#-3表示不计算
								if(len(string4)>0):
									string4 = string4.split()[0]
#								string4=self.AltStr(string4,-3,MenuScreen.Expbnow).split()[0]

								print("\t\tAElist(",i,")项经Altstr转化，未计算的第四项为串：",string4)
					else:
						print("\t\t本表第四项stril[3]内容为[",stril[3],"]")#20240203
						string4=self.AltStr(stril[3],-3,MenuScreen.Expbnow)#-3表示不计算stril[3]
						print("\n\t\t本表第四项经Altstr转化后内容为[",string4,"]")#20240203
						if(len(string4)>0):
							string4=string4.split()[0]
						print("\t\tAElist(",i,")项第四项经Altstr转化分解后的首项字串为[",string4,"]")
					string2=MenuScreen.ViewList[MenuScreen.Expbnow+toi]#20240203
					if(stril[2][0]=='-'):
						#string2=MenuScreen.ViewList[MenuScreen.Expbnow+toi]#20240203
						lstring2=string2.split()
						if(len(lstring2)>=2):
							if(string2.split()[-1].strip()==":" or string2.split()[-1].strip()=="："):
								laststr2=string2.split()[0]#如最后一项为':'或'：'，取第一项为赋值变量
							else:
								laststr2=string2.split()[-1]#如果目标行为空格多项，取最后一项为赋值变量；
						else:
							laststr2=string2#如果目标行为空格单项，整取赋值
						self.MainPara=laststr2#20240203
						print("四项式传递标的‘变量名’为字串：",laststr2)
					else:#20240203
						laststr2=string2
					print("第二项为串：",laststr2)
					with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
						i1=toi #20240203fri
						self.OnFeed=False
						if(stril[2]=='0'):##2024020520240204
							self.OnFeed=True#赋值全局变量传递给Eindex
						for i2 in range(int(stril[0])):#0914i
							if(stril[2]=='0'):#第三项为‘0’时，写入换行
								wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+string4+'"\n'#20240208 ⌇
								f.write(wstr)#0813
							elif(stril[2][0]!='-'):#第三项不为‘0’时，写入续行；无‘-’号时写入三项
								wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+string4+'⌇"\n'#20240205
								f.write(wstr)
							elif(stril[2][0]=='-'):#第三项不为‘0’时，写入续行；有‘-’号时写入四项：赋值续行
								if(stril[2][1]!='8'):#20250423 =='8' #20240924当第三词为‘-8’时，不予显示
#									wstr = "\n"+str(MenuScreen.Expbnow)+' -8 "'+string4+'⌇" '+laststr2+'"\n'
									#20250319#202504232注销考虑从弹出框接收输入，此句有可能产生冲突，待榷
#									wstr="\n"+str(MenuScreen.Expbnow)+" -8 "#20240205
#									f.write(wstr)#20240203 +' "'+string4+'" '+laststr2+"\n"#202504232注销
#									print("准备写入文件的摘引串为「",wstr,"」")#202504232注销
#								else:#20240924#202504232注销
									wstr = "\n"+str(MenuScreen.Expbnow)+' '+str(i1)+' "'+string4+'⌇" '+laststr2+'\n'#20250319
#									wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+" "#20240205
									f.write(wstr)#20240203 +' "'+string4+'" '+laststr2+"\n"
									print("写入文件的摘引串为「",wstr,"」")
							i1+=1
							


							
							
							
							
				elif(lsl==5):
					print("\n\t*****伍项注释命令：",AElist[i])#五项时计算，小数位按第五项，负值和0进行赋值
					i3=int(stril[2])
					i5=int(stril[4])
					if i5<0:
						i5=-i5
					if(stril[3].isdigit()):##20240203第四项为数字时，调出该行字串
						string4=MenuScreen.ViewList[MenuScreen.Expbnow+int(stril[3])]
#						if(self.Listp(string4)):#20250321
#							string4=self.AltStr(string4,-3,MenuScreen.Expbnow).split()[0]#-3表示不计算
#							print("AElist(",i,")项经Altstr转化，未计算的第四项为串：",string4)
					else:
						print("本表第四项stril[3]内容为[",stril[3],"]")#20240203
						string4=stril[3]#20250321第四项非数字时，本身作为字串
#						string4=self.AltStr(stril[3],i5,MenuScreen.Expbnow)#20240206 -3#20250319 8#20250321
#						print("本表第四项经Altstr转化后内容为[",string4,"]")#20240203
#						if(len(string4)>0):
#							string4=string4.split()[0]#-3表示不计算stril[3]
						print("AElist(",i,")项第四项经Altstr转化分解后的首项字串为[",string4,"]")
						
					fri=int(stril[1])-int(stril[0])+1
					toi=int(stril[1])
					string2=MenuScreen.ViewList[MenuScreen.Expbnow+toi]#-1
					lstring2=string2.split()
					if(len(lstring2)>=2):
			#			if(string2.split()[-1].strip()==":" or string2.split()[-1].strip()=="："):#0928
						if(lstring2[-1].strip()==":" or lstring2[-1].strip()=="："):#0928
							laststr2=lstring2[0]#string2.split()[0]#0328末项为‘：’时，将第一项作为赋值变量
							print("\t空格多项的末项为‘：’时，将第一项[",laststr2,"]作为赋值变量")#0928
						else:
							laststr2=lstring2[-1]#string2.split()[-1]#如果目标行为其它空格多项，取最后一项为赋值变量
							print("\t\t空格多项的末项不为‘：’时，将末项[",laststr2,"]作为赋值变量")#0928
					else:
						laststr2=string2#如果目标行为无空格单项，整取为赋值变量
					print("\t\tAutoE五项注释命令，从",fri,"到",toi,"第2项末串[",laststr2,"]为变量名，其所赋值为第4项字串[",string4,"]")
					with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
						i1=fri
						for i2 in range(int(stril[0])-1):#202503244 i
							f.write(str(MenuScreen.Expbnow)+" "+str(i1)+" "+"\n")
							i1+=1
						strt=self.AltStr(string4,i5,MenuScreen.Expbnow)#0813
						print("\t\t*AutoE五项注释命令进入altstr模块后续，得到中间结果[",strt,"]准备写入.idx文件，变量名为[",laststr2,"]")
						self.MainPara=laststr2#0813
						if(not self.LoopP):#0825
							if(i3==0):#0914季项为0表示换行
								self.OnFeed=True#20240205#赋值全局变量传递给Eindex#20240204
								if(len(strt)>0):#0910
									strt=strt.split()[0]#0912
									if(len(laststr2)>0):#0911
										print("\tAutoE非循环输入,带变量名及字串值，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'" '+laststr2+"]")#0904
										wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'" '+laststr2#20240205
										f.write(wstr)
									else:#0913
										print("\tAutoE非循环输入,仅带字串，无变量名时，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'"]')#0904
										wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'"'#20240205
										f.write(wstr)
								else:#0910
									print("\tAutoE非循环输入,变量值为空时，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1),"]")#0904
									wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+" "#20240205
									f.write(wstr)#0902
							else:#0914季项非0表示不换行
								self.OnFeed=False#20240205
								if(len(strt)>0):#0910
									strt=strt.split()[0]#0912
									if(len(laststr2)>0):#0911
										print("\tAutoE非循环输入,带变量名及字串值，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'⌇" '+laststr2+"]")#0904
										wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'⌇" '+laststr2#20240205
										f.write(wstr)
									else:#0913
										print("\tAutoE非循环输入,仅带字串，无变量名时，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1)+' ⌇"'+strt+'"]')#0904
										wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+' "'+strt+'⌇"'#20240205
										f.write(wstr)
								else:#0910
									print("\tAutoE非循环输入,变量值为空时，换行写入[",str(MenuScreen.Expbnow)+" "+str(i1),"]")#0904
									wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+" "#20240205
									f.write(wstr)#0902
						else:
							print("AutoE循环输入第(",self.nLoop,")轮")#0829
							if(self.nLoop==0):
								wstr="\n"+str(MenuScreen.Expbnow)+" "+str(i1)+" "#20240205
								print("\tAutoE循环输入换行写入[",wstr,"]")#0902
								f.write(wstr)#0902
								print("AutoE五项注释命令下‘闭环输入’判断self.LoopP=",self.LoopP,"，第(",self.nLoop,")次录入")
					if(i==la-1):
						break
				print("\n\t\t\t<==注释命令for循环退出(",MenuScreen.Expbnow,")行第(",i,")括号项之(",lsl,")项式：")
				print("\t\t\t",AElist[i])
				if(not self.LoopP):#0824
					i=i+1
#					print("\t当前状态为非‘闭环输入’，执行序号i递增为(",i,")")
#				else:
#					print("\t‘闭环输入’时，程序循环i不递增")
#			print("\n=================格式(",MenuScreen.Expbnow,")行，共(",la,")项自动摘录结束=================\n",AElist[:5])
		self.EIDisp()
		print("\n=================退出AutoE=================")




# 731 50       (8257 0 0)

	def PickRang (self,n,colstr,row):#202402012分解范围格式***子模块获取~格式参数,row取值：当n=1时，求列值，为某固定行；当n其它值时，求行值，为某固定列
		print("\n进入获取~格式参数模块PickRang，n=1为求列(",n,")字串[",colstr,"]固定行列数(",row,")")
		cb=0
		ce=0
		if(colstr.find(':')>=0):#202402012
			crangstr=colstr.split(':')[0]#列号范围由:分割
		else:
			crangstr=colstr#没有列号，则‘，’后都是列范围字串
		if(crangstr[0]=='~'):#202402012获取始、终列号
			cb=0
		elif(crangstr.split('~')[0].isdigit()):
			cb=int(crangstr.split('~')[0])
		else:
			alti=self.AltStr(crangstr.split('~')[0],-3,MenuScreen.Expbnow).split()[0]
			if (alti.isdigit()):
				cb=int(alti)
			else:
				print("\t\t\t列号范围下界限应为整数，或为整数变量，请修正")
		fto=crangstr.find('~')
	#	print("\t\t比较~位置(",fto,")与字串终位(",len(crangstr)-1,")串长-1，若相等，表示默认终止列号与项数(",ce,")相同")
		if(n==0):
			cols=len(MenuScreen.ViewList[MenuScreen.Expbnow+row].split())
		else:
			cols=int(MenuScreen.ViewList[MenuScreen.Expbnow].split()[MenuScreen.Ignore+2])
			
		if(fto+1 == len(crangstr)):#20240206
			ce=cols
		elif(fto+1 < len(crangstr)):#20240206(水炮行号 (11~16:(ql),2~10@2#1))  (21~22,1~12:(平均概率))  (8~19:(平均概率),0~1)
			print("\t\t标注有终止列号或步长@数，~分割为：",crangstr.split('~'))
			crangstr1 =crangstr.split('~')[1]#20240206
			if(not crangstr1[0].isdigit()):#非数字时也可能是格式(流量列 ((流量压力行),1~@2:(qp)#1))  crangstr[fto+1].isdigit()
				ce=cols
				if(crangstr1.find('@')):#@为同类内容的步长间隔，如“(压力列号 ((射程水炮行),1~19@3:(压力P)#1))”为3
					if(crangstr1.split('@')[0].isdigit()):
						ce=int(crangstr1.split('@')[0])
					else:
						alti=self.AltStr(crangstr1.split('@')[0],-3,MenuScreen.Expbnow).split()[0]
						if(alti.isdigit()):
							ce=int(alti)
						else:
							print("\t\t\t列号范围上界限应为整数，或为整数的变量，请修正")
			else:
				ce = int(self.PickNum(crangstr1))#20240214***
		loclist=[str(cb),str(ce)]
		print("行列号始于[",cb,"]终于[",ce,"]")
		return loclist



# 50 910      (8989 0 0)

	def PickList (self,string,expbnow):#返回行号值，v0.975调整返回列表参数顺序
#确定字符串寻找的行，string不带括号,expbnow本页首行在主列表文件中的位置；
#有问号时，返回归类行号(行末为‘:’的行为归类行)；无问号时返回关键字行号，多结果时弹出框，返回选择行的行号
#例如(11~16:(ql)#-5,7#1)，#正值表示冗余序号，负值表示下浮百分比，默认是行列值≥表达式，行列交错带'-'号表示≤
#数值比较时，默认为寻找行列值>=关键字，如11~16:(ql)#-5,7#1,是寻找第7列中流量>=ql的行号，ql值下浮5％
		#self.PickListP = True #0725
		self.ok  = 0#0904False
		print("\n进入PickList[",string,"],self.PickListP(",self.PickListP,"),操作参照行：",expbnow)
		rslist=['1']#0725
		ie=int(MenuScreen.ViewList[expbnow].split()[MenuScreen.Ignore+2])
		ib=1
		cb=0
		ce=0
		stepl=1
		stepc=1
		row=1#20240214
		prompt="提示"
		keystr=""
		keyattrstr=""
		kAi=0
		GetAttr=False#0724
		GetStr=False
		GetRow=False
		GetCol=False
		Lessp=False
		lrangp=False
		crangp=False
		ChaZhiP = False#202402012
		Redun=1#默认行冗余号，即取符合条件的第1个值
		GetRedun=False
		icol=string.find(',')
		subper='0'
		colnum=0#0911
		formp=False#0913
		ll = len(string)#202504213灭火器配置补丁
		
		if(icol>=0):#涉及列值计算时
			loclist=string.split(',')#将字串拆分为行字串和列字串表
			linstr=loclist[0]
			colstr=loclist[1]
			loclist0=linstr.split(':')#202504213灭火器配置补丁
			ll=len(loclist0)
			
			it=linstr.find('~')
			if(it>=0):
				lrangp=True#判断行有范围，求取符合行的操作结果
			it=colstr.find('~')
			if(it>=0):
				crangp=True#判断列有范围，求取符合列的操作结果
			if(lrangp and crangp and string.find('#') < 0):#202402015  (21~22,1~12:(平均概率))  (8~19:(平均概率),0~1) 非 (水炮行号 (11~16:(ql),2~10@2#1))
				if(linstr.find(':') >= 0):#20240214 (21~22,1~12:(平均概率))
					keystr =linstr
					ChaZhiP = True
					#GetRow = True #20240215
				else:
					keystr =colstr
					#GetCol = True
				if(keystr.find(':') >= 0):#(8~19:(平均概率),0~1)
					linstr1 = keystr.split(':')[1]
					Reached = False
					#colist=MenuScreen.ViewList[expbnow+int(keystr)].split()
					if(keystr[0].isdigit()):
						lin1=self.PickNum(linstr.split('~')[0])
					Rlist= self.PickRang (1,colstr,int(lin1))
					if(len(Rlist[0])>0):
						cb = int(Rlist[0])
					if(len(Rlist[1])>0):
						ce = int(Rlist[1])
					print("\t列号始于(",cb,")终于(",ce,")")
					Rlist= self.PickRang (0,linstr,0)#20240213
					if(len(Rlist[0])>0):
						ib = int(Rlist[0])
					if(len(Rlist[1])>0):
						ie = int(Rlist[1])
					if(ChaZhiP):#求步长
						lrangstr1=linstr.split(':')[0].split('~')[1]#20240206
					else:
						lrangstr1=linstr.split('~')[1]#20240214
					print("\t行号始于(",ib,")终于(",ie,")")
					if(lrangstr1.find('@')>0):#20240213
						stepca=lrangstr1.split('@')[1]
					else:
						stepca="1"
					if(ChaZhiP):#求表的项数,求步长
						lins=int(MenuScreen.ViewList[MenuScreen.Expbnow].split()[MenuScreen.Ignore+2])#20240213
						nb =ib
						ne =ie
						print("\t\t\t解构行的步长字串为「",stepca,"」共(",lins,")行")
					else:
						lins=len(MenuScreen.ViewList[MenuScreen.Expbnow+ib].split())#20240214
						nb =cb
						ne =ce
						print("\t\t\t解构(",ib,")行的步长字串为「",stepca,"」空格分割成(",lins,")列")
					if(stepca.isdigit()):
						stepc=int(stepca)
					form =self.AltStr(linstr1,8,MenuScreen.Expbnow)
					fform = float(form)#行计算式字串的值
					fpstrp = 0.0
					flstrep = 0.0
					for lc in range(nb,ne+1,stepc):
						if(lc < lins):#0912
							if(ChaZhiP):#
								lstr=MenuScreen.ViewList[MenuScreen.Expbnow+lc].split()[cb]
								pstr=self.PickNum(lstr)
								print("\t步长(",stepc,")行间扫描操作(",lc,")行(",cb,")列，字串[",lstr,"]提炼数字后成为[",pstr,"]")
							else:
								lstr=MenuScreen.ViewList[MenuScreen.Expbnow+ib].split()[lc]
								pstr=self.PickNum(lstr)
								print("\t步长(",stepc,")列间扫描操作(",ib,")行(",lc,")列，字串[",lstr,"]提炼数字后成为[",pstr,"]")
							fpstr=float(pstr)#表中的固定列或行的行值
							if(fpstr >= fform):								
								Reached = True
								ratio = (fform - fpstrp)/(fpstr - fpstrp)
								if(ChaZhiP):
									lstre = MenuScreen.ViewList[MenuScreen.Expbnow+lc].split()[ce]
									lstrep = MenuScreen.ViewList[MenuScreen.Expbnow+lc-stepc].split()[ce]
									result = float(lstrep) + (float(lstre) - float(lstrep)) * ratio
									print("(",expbnow+lc,")行发现该页(",lc,")行[",pstr,"]满足条件>=(",form,")前数(",pstrp,")相对比例(",ratio,");(",ce,")列[",lstre,"]，之前行(",MenuScreen.Expbnow+lc-stepc,")行[",lstrep,"]，结果(",result,")")
								else:
									lstre = MenuScreen.ViewList[MenuScreen.Expbnow+ie].split()[lc]
									lstrep = MenuScreen.ViewList[MenuScreen.Expbnow+ie].split()[lc-stepc]
									result = float(lstrep) + (float(lstre) - float(lstrep)) * ratio
									print("(",expbnow+ib,")行发现该页(",ib,")行(",lc,")列字串[",pstr,"]值满足条件>=式(",form,")值，式与前数(",pstrp,")相对比例(",ratio,");(",ie,")行(",lc,")列为：[",lstre,"]，之前列(",lc-stepc,")列串为[",lstrep,"]，结果(",result,")")
								break
							pstrp = pstr
							fpstrp = fpstr
					if Reached:
						rslist=[]
						rslist.append(str(result))
						return rslist
			if(linstr.find('#')>=0):#行有#分离出冗余值，更新行字串
				strfix=linstr.split('#')[1]#分离出行冗余值
				linstr=linstr.split('#')[0]#用剔除冗余的字串，第一次替换原有行字串
				if(strfix[0]=='-'):#当冗余值为负整数时，求取满足行算式字串值小于等于 下浮[",subper,"]%"指定行值
					subper=strfix[1:]#设定下浮值
				if(strfix.isdigit()):
					GetRedun=True#GetRedunL
					Redun=int(strfix)
#冗余值的含义是，取之后数代表序号的结果值，比如#3表示有三个结果时取第3个，少于三结果时取最接近于3的结果
#				print("\t\t行字串中发现#符，分离为行字串[",linstr,"]，冗余值[",Redun,"]关键字值下浮[",subper,"]%")
			if(colstr.find('#')>=0):#列有#分离出冗余值，更新列字串
				strfix=colstr.split('#')[1]
				colstr=colstr.split('#')[0]#用剔除冗余的字串替换原有列字串
				if(strfix[0]=='-'):#冗余的负号，表示求取满足列算式字串值小于等于下浮[",subper,"]%"指定列值
					subper=strfix[1:]
				if(strfix.isdigit()):
					GetRedun=True
					Redun=int(strfix)
				print("\t\t列字串中发现#符，分离为列字串[",colstr,"]，冗余值[",Redun,"]关键字值下浮[",subper,"]%")
			if crangp: #当列号有范围时
				if(colstr.find(':')>=0):
					crangstr=colstr.split(':')[0]#列号范围由:分割
					colstr=colstr.split(':')[1]#用剔除列号的字串，二次替换原列算式字串
				else:
					crangstr=colstr#没有列号，则‘，’后都是列范围字串
			if(linstr[0]=='-'):#由,分割的行值首为-时，判断列算式字串的终值为小于等于某列值
				Lessp=True
				if (linstr[1:].isdigit()):
					#v0.967当行为负整数时，取满足小于等于关键字的列值
					linstr=linstr[1:]#用剔除-号的字串，三次替换原列算式字串
					row=int(linstr)#0913[1:]
					print("行为负数[",linstr,"],取为[",row,"]行，求取列值 < 列字串算式[",loclist[1],"]的列号")#20240212当非整数呢？
			if(linstr.isdigit()):#当行字串是正整数时
				row=int(linstr)
				print("\t\t行为正整数",linstr)
				if (not crangp):#当列为确定值时
					if(colstr.isdigit()):#取出此列值
						colnum=int(colstr)#转化为整数
						lcol=len(MenuScreen.ViewList[expbnow+int(linstr)].split())#调出确定行的列数
						print("\t\t\t列值为正整数[",colnum,"]时，比较是否小于行[",MenuScreen.ViewList[expbnow+int(linstr)],"]项数[",lcol,"]")
						if(not GetRedun):#当没有冗余计算时
							if(colnum<lcol):#当列号小于该行列数时，返回列内容
								print("\t\t\t\t行(",linstr,")，列(",colnum,")均为确定数字，返回内容[",MenuScreen.ViewList[expbnow+int(linstr)].split()[colnum],"]")
								rslist=[]#0912
								rslist.append(MenuScreen.ViewList[expbnow+int(linstr)].split()[colnum])#准备返回列值
								rslist.append(str(colnum))#准备返回列号
								print("\t\t\t行,列都为正整数，搜索返回[列号，内容]表",rslist)
								return rslist
						else:
							print("\t\t\t求取列序号")
							GetCol=True
					elif(colstr[0]=='-'):#由,分割的列值首为-时，判断行算式字串的终值为小于等于某行值
						Lessp=True
						if (colstr[1:].isdigit()):
							#v0.967当列为负整数时，取行算式字串的终值为小于等于某行值
							colnum=int(colstr[1:])
							print("\t\t\t列为负数[",colstr,"],取为[",colnum,"]列，求取行值 < 行算式字串[",loclist[0],"]的行号")
					elif (self.IsNumber(colstr)):#如果列内容是实数
						GetCol=True
					else:#如果列内容是字符
						print("\t\t确定(",linstr,")行含[",colstr,"]字串的列号")
						colist=MenuScreen.ViewList[expbnow+int(linstr)].split()
						#print(colist)
						lc=0
						for cols in colist:
							print("\t\t第(",lc,")列[",cols,"]",end="")#
							if(cols.find(colstr)>=0):
								print("\t\t\t发现[",lc,"]项含字串[",cols,"]")
								break
								#return str(lc)
							lc+=1
						rslist=[]#20240212
						rslist.append(str(lc))#准备返回列号
						rslist.append(cols)#准备返回列字串
						print("\t\t\t行为正整数，列为字符，搜索返回[列号，内容]表",rslist)
						return rslist
				else:
					GetCol=True#求取列号
			elif (self.IsNumber(linstr)):#当行字串是实数时
				print("\t\t行字串为实数[",linstr,"]")
				GetRow=True#求取行号
				if (not crangp):#当列号确定时
					if(colstr.isdigit()):
						colnum=int(colstr)
					elif(colstr[0]=='-'):#列字串首为-时，依次选取本页面中，满足首个（或按冗余）小于等于≤[判断式](即行算式字串值)的行20230224
						Lessp=True
						if (colstr[1:].isdigit()):
							colnum=int(colstr[1:])
							print("\t\t\t列为负数[",colstr,"],取为[",colnum,"]列，求取本页面该列小于行实数[",linstr,"]的行号")
			else:#如果行内容是算式字串
				print("\t\t行关键字为变量运算字符串[",linstr,"]")
				GetRow=True
				if (not crangp):#如果没有列的范围值，即 ~ 
					if(colstr.isdigit()):
						if(int(colstr)>=0):#当列为正数时，取满足大于等于算式字串值的列值
							colnum=int(colstr)
					elif(colstr[0]=='-'):
						Lessp=True
						if (colstr[1:].isdigit()):
							#v0.967当列为负整数时，取满足小于等于关键字的列值
							colnum=int(colstr[1:])
							print("列为负数[",colstr,"],取为[",colnum,"]列，求取本页面该列小于行字串[",loclist[0],"]计算值的行号")
					elif (self.IsNumber(colstr)):#如果列内容是实数
						GetCol=True
					else:#如果列内容是字符
						print("\t\t\t列号应为整数，或为整数的变量，负整数表示≤该列，请修正")
			if GetCol:
				print("\t确定(",linstr,")行,符合列值大于等于行字符数值(",colstr,")的列号")#行为固定正整数时，只返回一个列值
				fcol=float(colstr)
				colist=MenuScreen.ViewList[expbnow+row].split()
#				formp=False#0913
				if(colstr.isdigit()):#当列字串为正整数时，取该数行的算式
					print("\t\t列值关键字",colstr,"为正整数，检测格式行[",MenuScreen.ViewList[expbnow],"]能否调出相应行")
					print("\t\t格式行的向前步长为[",MenuScreen.ViewList[expbnow].split()[MenuScreen.Ignore+2],"]")
					if(GetRedun):#GetRedunC
						print("\t\t\t以冗余判定方式进行列值比较",GetRedun)
						if(int(colstr)<=int(MenuScreen.ViewList[expbnow].split()[MenuScreen.Ignore+2])):
							print("\t\t\t\t\t根据有冗余，及列值小于本页行数判断，该列值为指向(",expbnow+int(colstr),")行内容")#0913
							colstr1=MenuScreen.ViewList[expbnow+int(colstr)]
							if(colstr1.find('$')<0):
								print("\t\t\t\t\t\t内容字串无‘$’符号，进行Altstr字串解析->")#0913
								colstr1=self.AltStr(MenuScreen.ViewList[expbnow+int(colstr)],7,MenuScreen.Expbnow).split()[0]
								if(self.IsNumber(colstr1)):
									colstr=colstr1
									fcol=float(colstr)*(1.0-float(subper)/100.0)
									print("\t\t提取列整数对应行字串,Altstr替换为[",colstr,"]化为实数：",fcol)
								else:
#									colstr1=self.ViewList[expbnow+int(colstr)]#20250205因与前9行重复而注释掉
									print("\t\t提取列整数对应行字串[",colstr1,"]")
							else:
								formp=True#一元变量代换以简化公式转化难度#0913
		#			else:
		#				print("不进行列值比较GetRedun",GetRedun)#GetRedunC
				rc=1#冗余计数
	#			print(colist)
				cols=len(colist)
				if(crangp):#当列号有范围时
	#				print("\t\t列字串有范围")
					Rlist= self.PickRang (1,crangstr,row)#20240213
					if(len(Rlist[0])>0):
						cb = int(Rlist[0])
					if(len(Rlist[1])>0):
						ce = int(Rlist[1])
					crangstr1=crangstr.split('~')[1]#20240206
					if(crangstr1.find('@')>0):#20240213
						stepca=crangstr1.split('@')[1]
					else:#20240213
						stepca="1"
	#					print("\t\t\t解构列的步长字串为「",stepca,"」")
					if(stepca.isdigit()):
						stepc=int(stepca)
					else:
						if(stepca[0]=='-' and stepca[1:].isdigit()):#过滤多余的-号
							stepc=int(stepca[1:])
						else:
							alti=self.AltStr(stepca,-3,MenuScreen.Expbnow).split()[0]
							if(alti.isdigit()):
								stepc=int(alti)
							else:
								print("\t\t\t列号范围步长应为整数，或为整数的变量，请修正")
	#				print("\t\t\t列步长为(",stepc,")")
					if(cb>ce):
						stepc=-stepc
				else:#当列号无范围时
					cb=0
					ce=cols
				print("\t\t列起步(",cb,"),终步(",ce,"),步长(",stepc,"),Lessp(",Lessp,")")#***
				#for cstr in colist:
				Reached = False
				cstr=""
				pstr=""
				for lc in range(cb,ce+1,stepc):
					if(lc<len(colist)):#0912
						cstr=colist[lc]
						pstr=self.PickNum(cstr)
						print("\t固定行操作列",lc,"字串[",cstr,"]提炼数字后成为[",pstr,"]一元变量代换判断(",formp,")")
						if formp:
							if(colstr1.find('$')>=0):#$代表列值变量替换
								nf=colstr1.find('$')
								flist=colstr1.split('$')#准备列值替换表
								if (nf==0):#$+4*(qsum)/(3141.59*$^2)-2.5
									fstring=""
									for i1f in range(len(flist)):
										fstr=flist[i1f]
										fstring+=pstr+fstr
								else:#4*(qsum)/(3141.59*$^2)-2.5+$+5
									fstring=flist[0]
									for i1f in range(1,len(flist)):
										fstr=flist[i1f]
										fstring+=pstr+fstr
								print("变量替换",cstr,"成为",fstring)

								
#								pstr=self.AltStr(fstring,7,MenuScreen.Expbnow).split()[0]#0913
#								if(self.IsNumber(pstr)):
#									print("提取列整数对应行字串,Altstr替换为[",pstr,"]")
#									if Lessp:
#										if(float(pstr)<=0):
#											Reached = True
#									else:
#										if(float(pstr)>=0):
#											Reached = True
								

#20250317替换开始
								strl = []#20250317
								pstrt = pstr
								if(fstring.find('～')>=0):#20250205如果算式中发现‘～’，表示有试算格式
									strl = self.StepCalcu(fstring,Lessp)#进入试算模块
									if(len(strl) <= 1):#20250208无结果判断
										continue #读取下一列数据
									else:
										pstrt += " "+strl[1]#20250317 += " "+strl[1]
										pstr = strl[0]#20250208
								else:	
							
									pstr = self.AltStr(fstring,-1,MenuScreen.Expbnow).split()[0]#20250208pstr计算替换后的算式
								if(self.IsNumber(pstr)):
									print("PickList提取列整数对应行字串,Altstr替换为[",pstr,"]")#20250208pstr
									if Lessp:
										if(float(pstr)<=0):#20250208pstr
											rc+=1
#											Reached = True
											print("\t\t\t(",expbnow+row,")行发现返回第(",lc,")词[",pstr,"]满足小于等于条件")
											if(rc>Redun):
#												rslist.append(str(lc))#20250208
#												rslist.append(cstr)
#												return rslist
												print("\t\t\t运行结果次数rc(",rc,")>冗余值(",Redun,")")
												if(len(pstrt.split(" ")) <= 1):#20250208
													rslist = []
													rslist.append(str(lc))
													rslist.append(cstr)#20250208pstr
													print("\t\t\t\tPickList小于等于条件下单值时返回表：",rslist)
													return rslist
												
												else:#20250208
													rslist = []
													rslist.append(str(lc))
													if(len(strl)>0):
														rslist.extend(pstrt.split(' '))#20250208cstr strl
													else:
														rslist.append(cstr)
													print("\t\t\t\tPickList小于等于条件下多值时返回表：",rslist)
													return rslist
									else:
										if(float(pstr)>=0):
											rc+=1
											print(expbnow+row,"行发现返回[",lc,"]词[",pstrt,"]满足大于等于条件")
											if(rc>Redun):
#												rslist.append(str(lc))#20250208
#												rslist.append(cstr)
#												return rslist
												if(len(pstrt.split(" ")) <= 1):#20250208
													rslist = []
												
													rslist.append(str(lc))
													rslist.append(cstr)#20250208pstr
													print("\t\t\t\tPickList大于等于条件下单值时返回表：",rslist)
													return rslist
												
												else:#20250208
													rslist = []
													rslist.append(str(lc))
													if(len(strl)>0):
														rslist.extend(pstrt.split(' '))#20250208cstr strl
													else:
														rslist.append(cstr)
													print("\t\t\t\tPickList大于等于条件下多值时返回表：",rslist)
													return rslist
#20250317替换结束
													
													
						else:#0913
							fpstr=float(pstr)#表中的列值
							fcstr=float(colstr)#列计算式字串值
							if Lessp:
								if(fpstr<=fcstr):
									Reached = True
							else:
								if(fpstr>=fcstr):								
									Reached = True
						if Reached:#0913
							rc+=1
							print("(",expbnow+row,")行发现返回[",lc,"]项[",pstr,"]满足条件(",Lessp,")>=(",colstr,")")
							if(rc>Redun):
								rslist=[]
								rslist.append(str(lc))
								rslist.append(cstr)
								return rslist
								
					elif(self.IsNumber(colstr)):#当为实数时，比较表中列值与该实数#20240207退格，管道计算出错，故又恢复
						if(lc<len(colist)):#20240214
							cstr=colist[lc]
							pstr=self.PickNum(cstr)
						print("\t\t列字串是实数")
						if Lessp:
							print("\t\t比较(",lc,")列字串[",pstr,"]值是否小于等于算式值")
							if(len(pstr)>0):
								if(self.IsNumber(pstr)):#0912
									if(float(pstr)<=fcol):
										rc+=1
										print("\t\t",expbnow+row,"行发现返回[",lc,"]项:",pstr,"满足小于等于",colstr)
										if(rc>Redun):
											if(rc>Redun):
												rslist=[]#0913
												rslist.append(str(lc))
												rslist.append(cstr)
												return rslist
								else:#0912
									if(float(self.AltStr(pstr,8,MenuScreen.Expbnow))<=fcol):
										rc+=1
										print("\t\t",expbnow+row,"行发现返回[",lc,"]项:",pstr,"满足小于等于",colstr)
										if(rc>Redun):
											if(rc>Redun):
												rslist=[]#0913
												rslist.append(str(lc))
												rslist.append(cstr)
												return rslist
						else:
							print("\t\t比较(",lc,")列字串[",pstr,"]值是否大于等于算式值")
							if(len(pstr)>0):
								if(float(pstr)>=fcol):
									rc+=1
									print("\t\t",expbnow+row,"行发现返回[",lc,"]项:",pstr,"满足大于等于",colstr)
									if(rc>Redun):
										if(rc>Redun):
											rslist=[]#0913
											rslist.append(str(lc))
											rslist.append(cstr)
											return rslist
					else:
						print("\t\t",expbnow+row,"行[",colstr1,"]应为带$符代入列值的方程式，或算式，请检查修正")
		else:#没有列信息
			linstr=string
			it=linstr.find('~')
			if(it>=0):
				lrangp=True
			if(linstr.find('#')>=0):#行有#分离出冗余值，更新行字串
				strfix=linstr.split('#')[1]
				linstr=linstr.split('#')[0]
				if(strfix[0]=='-'):
					subper=strfix[1:]
				if(strfix.isdigit()):
					GetRedun=True#GetRedunL
					Redun=int(strfix)
			#取之后数代表序号的结果值，比如#3表示有三个结果时取第3个，少于三结果时取最接近于3的结果
#行为非固定值的范围时，返回双数列表，顺序：行号在前列号在后；求属性时属性在前，求关键字时关键字在前
		if lrangp:#(it>=0):#linstr[0]!='~'):
			ib=int(linstr.split('~')[0])
			print("发现始行字符,转整数为",ib)
			if(len(linstr)>it+1):
				if(linstr[it+1]!=':'):
					ie=int(self.psplit(linstr,'~',':')[1][1:-1])
					print("发现末行字符,转整数为",ie)
			if(linstr.find("?")>=0):
				GetStr=True
				keystr=self.psplit(linstr,':','?')[1][1:-1]#linstr.split(':')[1].split('?')[0]
#				print("关键字位于:?之间为[",keystr,"]共",len(keystr),"个字")
				if(linstr.strip()[-1]==':'):
					GetAttr=True
					if(linstr.strip()[-2]=='?'):#求归类字符
		#				prompt="请选择归类"
						keyattrstr=":"
#						print("\t\t?后与:之间为归类字,置空意为搜索归类")
					else:#求归类下关键字字符
						prompt=self.psplit(linstr,'?',':')[1][1:-1]#v962linstr.split('?')[1]
						keyattrstr=":"#v970self.psplit(linstr,'?',':')[1]
#						print("\t\t?后与:之间为归类关键字[",keyattrstr,"],搜索该归类下条目")
				else:#求归类下关键字字符
					keyattrstr=linstr.split('?')[1]
					prompt=keyattrstr
				print("\t行格式~:?时关键字[",keystr,"]归类关键字[",keyattrstr,"]")
			else:
				loclist=linstr.split(':')
				ll=len(loclist)
				if(ll==1):
					keystr=loclist[0]#colstr
					keyattrstr=""
				elif(ll==2):
					keystr=loclist[1]#linstr.split(':')[1]
					keyattrstr=""
				elif(ll==3):
					keystr=loclist[1]#linstr.split(':')[1]
					keyattrstr=loclist[2]
				print("\t行格式~:时关键字[",keystr,"]归类关键字[",keyattrstr,"]")
		else:#没有~
			if(linstr.find("?")>=0):#求字符
				GetStr=True
				keystr=linstr.split('?')[0]#v0.970
				keyattrstr=linstr.split('?')[1]
#				print("关键字位于?前为[",keystr,"]共",len(keystr),"个字,归类：",keyattrstr)
				if(linstr.strip()[-1]==':'):#求归类
					GetAttr=True
					if(linstr.strip()[-2]=='?'):#没有具体提示求归类字符
						prompt="请选择带:的归类项"
						keyattrstr=":"
			#			print("\t\t?后与:之间为归类关键字,置空意为搜索归类")
					else:#具体提示求归类字符
						prompt=self.psplit(linstr,'?',':')[1][1:-1]#v962linstr.split('?')[1]
						keyattrstr=":"#v970self.psplit(linstr,'?',':')[1]
#						print("\t\t?后与:之间为归类关键字[",keyattrstr,"],搜索该归类下条目")
				else:#求归类下关键字字符
					keyattrstr=linstr.split('?')[1]
					prompt=keyattrstr
#				print("?:时关键字[",keystr,"]归类关键字[",keyattrstr,"]")
			elif(linstr.find(":")>=0):#求序号,用:分割
				templist=linstr.split(':')
#				print("由:分割的表为",templist)
				keystr=linstr.split(':')[0]
				keyattrstr=linstr.split(':')[1]
#				print("关键字位于:前为[",keystr,"]共",len(keystr),"字,归类于[",keyattrstr,"]")
				if(linstr.strip()[-1]==':'):#求归类
					GetAttr=True
					if(linstr.strip()[-2]==':'):#求归类序号
						prompt="请选择归类项"
						keyattrstr=":"
#						print("\t\t:与:之间为归类关键字,置空意为搜索归类")
					else:#求归类下关键字字符
						prompt=linstr.split(':')[1]
						keyattrstr=prompt
#						print("\t\t:与:之间为归类关键字[",keyattrstr,"],搜索该归类下条目",keystr)
	#			print("::时关键字[",keystr,"]归类关键字[",keyattrstr,"]")
			else:
				keystr=linstr
				keyattrstr=""
	#			print("裸奔时关键字[",keystr,"]归类关键字[",keyattrstr,"]")
		#求行时确认特定归类行范围
		ibt=ib
		iet=ie
		i1=ib
		foundA=False
		if ((not GetAttr) and (len(keyattrstr)>0)):#已知归类找关键字行范围
			for i in range(expbnow+ibt,expbnow+iet+1):
				#print("\t\t",i,"行字符->",MenuScreen.ViewList[i])
				if foundA:
					if MenuScreen.ViewList[i].strip():
						#if((MenuScreen.ViewList[i].find(':')>=0) or (MenuScreen.ViewList[i].find('：')>=0)):
						if((MenuScreen.ViewList[i][-1]==':') or (MenuScreen.ViewList[i][-1]=='：')):
							ie=i1-1
#							print(i1,"行发现末尾为':'的新关键字归类，设上一行为结束行",ie)
							break
				if(MenuScreen.ViewList[i].find(keyattrstr)>=0):#找到归类行
					ib=i1
#					print(i1,"行发现归类关键字",keyattrstr)
					foundA=True
				i1+=1
#		print("\t格式行",expbnow,"所在页获取符合归类[",keyattrstr,"]的行号[",ib,"~",ie,"],关键字[",keystr,"]")
		#查找符合归类及关键字条件的行
		strList=[]#存放发现的归类关键字行字符，归类行末带':',返回值剔除
		numList=[]#存放发现的归类关键字行序号
		i1=ib
		if(crangp):#当列号有范围时
			if(crangstr[0]=='~'):
				cb=0
			elif(crangstr.split('~')[0].isdigit()):
				cb=int(crangstr.split('~')[0])
			else:
				alti=self.AltStr(crangstr.split('~')[0],-1,MenuScreen.Expbnow).split()[0]
				if (alti.isdigit()):
					cb=int(alti)
				else:
					print("列号范围下界限应为整数，或为整数的变量，请修正")
		for i in range(expbnow+ib,expbnow+ie+1):
	#		print("\t\t",i,"行字符->",MenuScreen.ViewList[i])
			if MenuScreen.ViewList[i].strip():
				if((MenuScreen.ViewList[i].strip().split()[-1]==':') or (MenuScreen.ViewList[i].strip().split()[-1]=='：')):#归类:前面需加空格
					if(len(MenuScreen.ViewList[i].strip().split())>1):
						keyattrstr=MenuScreen.ViewList[i].strip().split()[-2]#实际的归类关键字
					else:
						keyattrstr=MenuScreen.ViewList[i].split()#实际的归类关键字
					kAi=i1#实际的归类关键字行号
#					print("\t\t\t本页",kAi,"行为关键字归类->",MenuScreen.ViewList[i])
			if(not self.IsNumber(keystr)):
				if(keystr.find(';')<0):
					if(MenuScreen.ViewList[i].find(keystr)>=0):#记录关键字及归类
#						print("\t\t\t",i,"行[",MenuScreen.ViewList[i],"]找到关键字[",keystr,"]")
						strList.append(MenuScreen.ViewList[i])
						strList.append(keyattrstr)#记录字串，#v970舍弃最后：[:-1]
	
						numList.append(str(i1))
						numList.append(str(kAi))#记录行号
				else:#v0.967
					kslist=keystr.split(';')
					ksandp=True
					for ks in kslist:
						if(MenuScreen.ViewList[i].find(ks)<0):
							ksandp=False#有关键字不符合时，不记录
		#					print("\t\t\t",i,"行[",MenuScreen.ViewList[i],"]未找到关键字[",ks,"]")
		#				else:
		#					print("\t\t\t",i,"行[",MenuScreen.ViewList[i],"]找到关键字[",ks,"]")
					if ksandp:
						strList.append(MenuScreen.ViewList[i])
						strList.append(keyattrstr[:-1])#记录字串，舍弃最后：
	
						numList.append(str(i1))
						numList.append(str(kAi))#记录行号
			elif(GetRow):#关键字是数字，且列为数字时，比较列数值求值
				cols=len(MenuScreen.ViewList[i].split())
				if(crangp):#当列号有范围时
					fto=crangstr.find('~')
					if(fto==len(crangstr)-1):
						ce=cols
					else:
						crangstr1=crangstr.split('~')[1]
						if(crangstr1.isdigit()):
							ce=int(crangstr1)
						elif(crangstr1.find('@')):
							if(crangstr1.split('@')[0].isdigit()):
								ce=int(crangstr1.split('@')[0])
							else:
								alti=self.AltStr(crangstr1.split('@')[0],-3,MenuScreen.Expbnow).split()[0]
								if(alti.isdigit()):
									ce=int(alti)
								else:
									print("列号范围上界限应为整数，或为整数的变量，请修正")
							stepca=crangstr1.split('@')[1]
							if(stepca.isdigit()):
								stepc=int(stepca)
							else:
								if(stepca[0]=='-' and stepca[1:].isdigit()):#过滤多余的-号
									stepc=int(stepca[1:])
								else:
									alti=self.AltStr(stepca,-3,MenuScreen.Expbnow).split()[0]
									if(alti.isdigit()):
										stepc=int(alti)
									else:
										print("列号范围步长应为整数，或为整数的变量，请修正")
					if(cb>ce):
						stepc=-stepc
				else:#当列号无范围时
					cb=colnum
					ce=cb
				if(cols>=ce):#检查列数是否大于所求列号
					for colnum in range(cb,ce+1,stepc):
						runP = False#202504213
						if(len(MenuScreen.ViewList[i])>0):
							if(len(MenuScreen.ViewList[i].split())>colnum):
								runP = True
						if runP:
						
							colcell=self.PickNum(MenuScreen.ViewList[i].split()[colnum])
							print("\t\tPickList模块数文混搭(",colnum,")列[",MenuScreen.ViewList[i].split()[colnum],"]滤出数[",colcell,"]比较关键字值",keystr)
							if(self.IsNumber(colcell)):#0911(float(colcell)):#20230203
								print("\t\t\tPickList模块中检测[",colcell,"]是实数字串")
								subduc=float(keystr)*(1.0-float(subper)/100.0)#百分削减后值
								
								if(Lessp):
									if(float(colcell)<=subduc):
										print("\t\t\t\tPickList模块‘不大于’判断状态，记录(",i1,")行[",MenuScreen.ViewList[i],"]中(",colnum,")列数值[",colcell,"]vs关键字[",keystr,"]下浮",subper,"%值后的结果『",subduc,"』")
										#strList.append(keyattrstr)#记录归类字串：
										strList.append(MenuScreen.ViewList[i])
										strList.append(colcell)#记录列值数据
										numList.append(str(i1))
										numList.append(str(colnum))#colnum)#记录列号
								else:
									if(float(colcell)>=subduc):
										print("\t\t\t\tPickList模块‘不小于’判断状态，记录(",i1,")行[",MenuScreen.ViewList[i],"]中(",colnum,")列数值[",colcell,"]vs关键字[",keystr,"]下浮",subper,"%值后的结果『",subduc,"』")
										#strList.append(keyattrstr)#记录归类字串：
										strList.append(MenuScreen.ViewList[i])
										strList.append(colcell)#记录列值数据
										numList.append(str(i1))#记录列号
										numList.append(str(colnum))#记录行号
			i1+=1
		print("\t归类、关键字之文字表：",strList)
		print("\t归类、关键字之行号表：",numList)
		self.PickListNum=len(strList)#20250422灭火器配置将self.PickListNum替换为ll
		print("\tPickList模块检测：",self.PickListP,"在PickList模块中",self.ZtimeZ(6))
		if(self.PickListNum==2):#结果唯一时
			if(GetStr):
				if(GetAttr):
#					print("返回关键字归类[",strList[1],"]")
					print("\t\tGetAttr下1返回表",strList)
					strList.reverse()
					print("\t\tGetAttr下2返回表",strList)
					return strList
				else:
#					print("返回关键字[",strList[0],"]")
					print("\t\t非GetAttr下1返回表",strList)
					return strList
			else:
				if(GetAttr):
#					print("返回关键字归类序号",str(numList[1]))
					print("\t\tGetAttr下1返回表",numList)
					numList.reverse()
					print("\t\tGetAttr下2返回表",numList)
					return numList
				else:
#					print("返回关键字序号",str(numList[0]))
					print("\t\t非GetAttr下1返回表",numList)
					return numList
				rslist = numList#0724
		elif (self.PickListNum>=4):#多结果时冗余取值，或非冗余取值时弹出框选择
			if GetRedun:#GetRedunL
				if(self.PickListNum>=Redun+Redun):
					if(GetStr):
						rslist.append(strList[Redun-1+Redun])
						rslist.append(strList[Redun-1+Redun-1])
						if(GetAttr):#0724
							print("\t\t冗余",Redun,"返回关键字归类",rslist)#strList[Redun-1+Redun],"]")
							return rslist
							#return strList[Redun-1+Redun]
						if(not GetAttr):#else:
							print("\t\t冗余",Redun,"返回关键字",rslist.reverse())#,strList[Redun-1+Redun-1],"]")
							rslist.reverse()
							return rslist
							#return strList[Redun-1+Redun-1]
					else:
						#print("\t\t冗余",Redun,"返回关键字归类序号",str(numList[Redun-1+Redun]))
						rslist.append(numList[Redun-1+Redun])
						#print("\t\t冗余",Redun,"返回关键字序号",str(numList[Redun-1+Redun-1]))
						rslist.append(numList[Redun-1+Redun-1])
						#print(rslist)
						if(GetAttr):
							print("\t\tGetAttr下返回表",rslist)
							print("\t\t冗余",Redun,"返回关键字归类序号",rslist)#,str(numList[Redun-1+Redun]))
							return rslist
						if(not GetAttr):#0724 else:
							print("\t\t非GetAttr下1返回表",rslist)
							rslist.reverse()
							print("\t\t非GetAttr下2返回表",rslist)
							print("\t\t冗余",Redun,"返回关键字序号",rslist)#,str(numList[Redun-1+Redun-1]))
							return rslist
				else:
					if(GetStr):
						rslist.append(strList[round(self.PickListNum/2)])
						rslist.append(strList[round(self.PickListNum/2)-1])
						if(GetAttr):
							print("不足冗余",Redun,"返回关键字归类[",strList[round(self.PickListNum/2)],"]")
							return rslist
							#return strList[round(self.PickListNum/2)]
						if(not GetAttr):#0724 else:
							print("不足冗余",Redun,"返回关键字[",strList[round(self.PickListNum/2)-1],"]")
							rslist.reverse()
							return rslist
							#return strList[round(self.PickListNum/2)-1]
					else:
						rslist.append(numList[round(self.PickListNum/2)])
						rslist.append(numList[round(self.PickListNum/2)-1])
						if(GetAttr):
							print("不足冗余",Redun,"返回关键字归类序号",str(numList[round(self.PickListNum/2)]))
							return rslist
							#return str(numList[round(self.PickListNum/2)])
						if(not GetAttr):#0724 else:
							print("不足冗余",Redun,"返回关键字序号",str(numList[round(self.PickListNum/2)-1]))
							rslist.reverse()
							return rslist
			else:#当没有冗余选择项时，准备弹出框
				print("PickList没有冗余选择项时，准备弹出框")#20250428
				self.ok=0#self.PickListP =True #202504252弹出框开启#20250428
				if(GetStr):#获取字串
					if(GetAttr):#获取归属类
						title="标题：选择归类行(带':'行)，或输入归类文字"
						self.PopView(strList,0,title)#0822#202504252prompt
						print("PickList弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
						if self.ok==1:#0904==1#0904:
							self.ok=0#0902
							rslist.append(linestr)
							
						title="标题：选择关键字行(无':'行)，或输入关键字"
						self.PopView(strList,0,title)#202504252prompt)#0822
						print("PickList弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
						if self.ok==1:#0904==1#0904:
							self.ok=0#0902
							rslist.append(linestr)
						return rslist#20250320减少一档
						print("PickList弹出框测试获取字串GetStr之GetAttr获取归属类的准备输出表：",rslist)
						
					else:
						title="标题：选择表项或输入关键字"
						self.PopView(strList,0,title)#202504252prompt)#0729
						print("PickList弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
						if self.ok==1:#0904==1#0904:
							self.ok=0#0902
							rslist.append(linestr)
							
						title="标题：选择表项或输入归类"
						self.PopView(strList,0,title)#202504252prompt)#0729
						print("PickList弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
						if self.ok==1:#0904==1#0904:
							self.ok=0#0902
							rslist.append(linestr)
						return rslist#20250320减少一档
						print("PickList弹出框测试获取字串GetStr之GetAttr获取非归属类，即普通值的准备输出表：",rslist)
				else:#获取非字串，即归类项号表
					title="发现有多项归类结果，请选择其一（偶数行，即输入内容的下一行）"
					#202504252"标题：多项归类项号选择"
					self.PopView(strList,0,title)#0729#202504252prompt
					if self.ok==1:#0904==1#0904:###0723
						self.ok=0#0902
						linei=strList.index(linestr)
						if(linei%2==1):
							rslist.append(str(numList[linei]))
							rslist.append(str(numList[linei-1]))
						else:
							rslist.append(str(numList[linei+1]))
							rslist.append(str(numList[linei]))
					if(GetAttr):
						return rslist
					if(not GetAttr):#else:
						rslist.reverse()
						return rslist
		else:#全页选择
			print("\t\t自动搜索未找到符合结果，手动选择，从",ib,"行到",ie,"行")
			print("PickList模块检测：",self.PickListP,"在PickList模块中",self.ZtimeZ(6))
			strList=[]
			numList=[]
			i1=0 #0724 1
			for i in range(expbnow+ib,expbnow+ie+1):
				strList.append(MenuScreen.ViewList[i])
				numList.append(i1)
				i1+=1#0724
			print("弹出框选项表为：",strList,"相应的行号表为：",numList)
			#ok = False#0720
			if(GetStr):
				if(GetAttr):
					titlestr="选择关键字["+keystr+"]的归类"
					print("弹出框标题为[",titlestr,"]提示内容为[",prompt,"]")
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904==1#0904:
						self.ok=0#0902
						rslist.append(linestr)
					titlestr="选择["+keyattrstr+"]归类下关键字["+keystr+"]"
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904==1#0904:
						self.ok=0#0902
						rslist.append(linestr)
					return rslist
				else:
					titlestr="选择["+keyattrstr+"]归类下关键字["+keystr+"]"
					print("弹出框标题为[",titlestr,"]提示内容为[",prompt,"]")
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904==1#0904:
						self.ok=0#0902
						rslist.append(linestr)
					titlestr="选择关键字["+keystr+"]的归类"
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904==1#0904:
						self.ok=0#0902
						rslist.append(linestr)
					return rslist
			else:
				if(GetAttr):
					titlestr="选择关键字["+keystr+"]的归类行（带'：'）"
					print("弹出框标题为[",titlestr,"]提示内容为[",prompt,"]")
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904:
						self.ok=0#0902
						linei=strList.index(linestr)
						rslist.append(str(linei))
					titlestr="选择["+keyattrstr+"]归类下关键字["+keystr+"]行"
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904:
						self.ok=0#0902
						linei=strList.index(linestr)
						rslist.append(str(linei))
					return rslist
				else:
					titlestr="选择关键字["+keystr+"]的归类行（带'：'）"
					print("弹出框标题为[",titlestr,"]提示内容为[",prompt,"]")
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904:
						self.ok=0#0902
						linei=strList.index(linestr)
						rslist.append(str(linei))
					titlestr="选择["+keyattrstr+"]归类下关键字["+keystr+"]行"
					self.PopView(strList,0,prompt)#0729
					if self.ok==1:#0904:
						self.ok=0#0902
						linei=strList.index(linestr)
						rslist.append(str(linei))
					return rslist







# 910 27      (9021 0 0)

	def ForJump (self,Expbnow,Expitem):#当前页首行Expbnow,选择Expitem行前跳的处理
		jump=0
		print("\n进入ForJump模块，准备自动扫描跳进,当前页首行[",Expbnow,"]链接行[",Expitem,"]")
		bnowstr=MenuScreen.ViewList[Expbnow]
		if(len(bnowstr.split())>MenuScreen.Ignore+2):
			jumpp=False
			Expforestep=int(bnowstr.split()[MenuScreen.Ignore+2])
			if(len(self.psplit(bnowstr,'(',')'))>=2):
				linklist=self.psplit(bnowstr,'(',')')[-1][1:-1].split()
				if(linklist[0].isdigit()):
					if(Expitem<len(linklist)):
						jumpp=True
						jump=int(linklist[Expitem])
						if(MenuScreen.Expfnow!=MenuScreen.Expbnow):#0805
							MenuScreen.Expfnow = Expbnow+Expforestep+1+jump-int(linklist[0])#0805
						Expbnow=Expbnow+Expforestep+1+jump
#						print("\t\tForJump模块准备forward模块前跳步长参数(",Expforestep,")，跳行数(",jump,")跳至(",Expbnow,")行")#0813，回跳行(",MenuScreen.Expfnow,")")
			if(not jumpp):
				Expbnow=Expbnow+Expforestep+1
#				print("\t\tForJump模块准备forward模块前进步长参数(",Expforestep,")，跳行数(",jump,")跳至(",Expbnow,")行")
			return Expbnow
		else:
			print("ForJump模块检测第(",Expbnow,")行[",bnowstr,"]格式错误")



# 27 307      (9906 0 0)

	def PopList (self,string,expbnow):#@调出弹出框，字符串,格式中~为必须项，':' '?' ','为可选项，用以分割列 20230223
#string不带括号,expbnow本页首行在主列表文件中的位置。格式符顺序：@3~5:?
#调出弹出框格式，如@9~10,意为本页9~10行组成一个弹出框,如@9~10?姓名,则将?后字符‘姓名’作为提示；
#赋值格式，(1 9 0 (@9~10) 0),意为将弹框选择赋给第9行末项为名的变量
		print("\n进入弹出框模块PopList")
		self.PopP=True#0813
		Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)
		CheckedRow=[]
		ib=1
		ib0=1
		ie=int(MenuScreen.ViewList[expbnow].split()[MenuScreen.Ignore+2])
		GetRow=False#判断获取表中列值<=关键字的行号
		KeyWordp=False
		if(string[-1]=='#'):#末字符是否#判断弹出框选项是否需要加入关键词串20230224
			KeyWordp=True
			print("\tPoplist弹出框，同时获取必选‘与条件’关键字")
			if(string[-2]=='#'):
				self.InduceKP=True#0907
				string=string[:-2]
			else:
				self.LoopP=True#0830
				string=string[:-1]
				print("\tPopList弹出框，同时循环获取必选‘与条件’关键词， self.LoopP=",self.LoopP,",self.LoopOn=",self.LoopOn,",self.nLoop=",self.nLoop)#0830
				if (not self.LoopOn) :#and self.nLoop>1 #str(MenuScreen.Expbnow) not in MenuScreen.Rundic:#0830
					self.LoopP=False#0829
					print("\t\tLoopP have Changed because of self.LoopOn False, self.LoopP=",self.LoopP)#0830
		elif(string[-1]=='￥'):
			self.KeyWord2p=True
			string=string[:-1]
			print("\tPoplist弹出框，同时获取辅助关键字")
		if(string[0]=='@'):#初判格式符合
			if(string.find('~')>0):#再判格式符合
				if(string.find(',')>0):#有'，'表示取列值作为弹出框表
					linstr=string.split(',')[0][1:]
					colstr=string.split(',')[1]
					print("\n\t行字串[",linstr,"]列字串[",colstr,"]")
					#取行的值作弹出框兼容如意(1 9 0 (@9~10:$?姓名,0) 0)
					if(colstr.isdigit()):#列全为数字时，取行值弹出，表示有指定列(1 9 0 (@2~6:$?数值,3) 0)
						GetRow=True#判断求取相关行20230223
						if(string.find('?')>=0):#有？表示有提示文本，是行或列的最后项
							if(string.find(',')>=0):#有指定列
								pstr=string.split(',')[0].split('?')[-1]#提示文本为','前'?'后的内容。如@3~5:?选符合指定列的合适行,4
								if(string.find(':')>0):#有冒号做第一个分割@3~5:?,4
									ie=int(linstr.split(':')[0].split('~')[-1])+expbnow#获取终行号为：前~后的数字，例如11~16:(ql)#-5,7#1
									ib0=int(linstr.split('~')[0])#0731
									ib=ib0+expbnow#获取始行号：前~前的数字20230223
								else:#没有冒号时，问号为第一个分割@3~5?,4
									ie=int(linstr.split('?')[0].split('~')[-1])+expbnow#终行号为？前的末字
									ib=int(linstr.split('~')[0])+expbnow#首行号为～号前的字
							else:
								pstr=string.split('?')[-1]#没有指定列时,提示文本为？后的内容。如@3~5?选合适行
						else:#没有问号时，表示无提示文本
							pstr=""
							if(string.find(':')>0):#有冒号做第一个分割@3~5:
								ie=int(linstr.split(':')[0].split('~')[-1])+expbnow
								ib=int(linstr.split('~')[0])+expbnow#首行号为～号前的数字#20230223
							else:#无冒号时@3~5
								ie=int(linstr.split('~')[-1])+expbnow#起行为0行
								ib=int(linstr.split('~')[0])+expbnow
						print("行数据弹出框提示：[",pstr,"]，起始行：",ib,"，终止行：",ie)
						locList = ListProperty(["?", "?"])#202410073尝试以此增强稳定性
						locList=[]
						for i in range(ib,ie+1):
							locList.append(MenuScreen.ViewList[i])
						print("\t弹出框初始化表[",ib,"~",ie,"]行：\n",locList)
					else:#列值不全为数字时，取列值作弹出框字符兼容如意(1 9 0 (@2,3~6:$?数值) 0)
						if(string.find('?')>=0):
							#GetStr=True
							pstr=colstr.split('?')[-1]
							colstr=colstr.split('?')[0]
						else:
							pstr=""
						if(string.find(':')>0):
							ie=int(colstr.split(':')[0].split('~')[-1])
							ib=int(colstr.split(':')[0].split('~')[0])
						else:
							ie=int(colstr.split('~')[1])
							ib=int(colstr.split('~')[0])
						print("列数据弹出框提示：[",pstr,"]，起始行：",ib,"，终止行：",ie)
						collist=MenuScreen.ViewList[expbnow+int(linstr)].split()

						ie = len(collist)-1#202504213
						locm = string.find(':')#202504152
						loct = string.find('~')
						print("\t\t\t列数据最大列数(",ie,")‘：’在（",locm,"）位，‘～’在(",loct,")位；(",expbnow+int(linstr),")行表",collist)	#202504152					
						if(locm>0):
						
							ib=int(colstr.split(':')[0].split('~')[0])
							if(loct>=0):#202504152
								if(locm>=0):#202504152
									if(locm-loct>1):
								
										ie=int(colstr.split(':')[0].split('~')[-1])
						else:
							ib=int(colstr.split('~')[0])
							if(loct>=0):#202504152
								if(len(colstr)>loct):
									if(colstr[loct+1].isdigit()):
								
										ie=int(colstr.split('~')[1])#202504152
						print("\t\t\t列数据弹出框提示：[",pstr,"]，起始行(",ib,")，终止行(",ie,")，(",expbnow+int(linstr),")行表",collist)#202504152

						locList = ListProperty(["?", "?"])#202410073尝试以此增强稳定性
						locList=[]
						for i in range(ib,ie+1):
							locList.append(collist[i])
						print("\t列弹出框初始化表",expbnow+int(linstr),"行中(",ib,"~",ie,")列：\n",locList)#20230223
				else:#无逗号表示只有取行的值，作为弹出框表的内容#格式(1 9 0 (@9~10?姓名) 0)
					if(string.find('?')>=0):
						pstr=string.split('?')[-1]#取问号分割的末项作为提示文本
						datastr=string.split('?')[0][1:]#取问号分割首项的第二字（首字为@）开始作为输入数据串
					else:
						pstr=""
						datastr=string[1:]
						#取第二字（首字为@）开始作为输入数据串(@7~?建构筑功能（输入非‘：’行关键字如‘普通住宅’）
#					ie=int(datastr.split('~')[-1])+expbnow#2020504213终止行号为~分割的数据串末项
#					ib=int(datastr.split('~')[0])+expbnow#起始行号为~分割的数据串首项

					#20250417增加~省略项ie为总行数(@7~?建构筑功能（输入非‘：’行关键字如‘普通住宅’）
					loct = datastr.find('~')#2020504213
					if(loct>=0):
						if(len(datastr)>loct+1):#20250417当‘~’位于非末位时
						
							ie=int(datastr.split('~')[-1])+expbnow#终止行号为~分隔的数据串末项
						
						else:#20250417当‘~’位于末位时
							ie=ie+expbnow#终止行号为本页末项
						if(loct > 0):#20250417当‘~’位于非首位时
						
							ib=int(datastr.split('~')[0])+expbnow#起始行号为~分隔的数据串首项
						elif(loct == 0):#20250417当‘~’位于非首位时
							ib=ib+expbnow#起始行号为~分隔的数据串首项


					print("\t行弹出框格式无逗号，提示文本：[",pstr,"]，起始行：",ib,"，终止行：",ie)
					locList = ListProperty(["?", "?"])#202410073尝试以此增强稳定性
					locList=[]#开始组织弹出框表字串
					for i in range(ib,ie+1):
						locstr=MenuScreen.ViewList[i]
						locList.append(locstr)
						#20241007下4句涉嫌循环调用，引起程序不稳定，故尝试取消，但可能引发未知bug，未解决故又恢复
						if(self.Listp(locstr) and len(locstr.split())==1):#如果行内有括号，而且是单项
							altstr=self.AltStr(locstr,8,expbnow).split()[0]
							#202504252进行演算，此句如灭火器配置应用中 (@10~13?设计最远距离建议选底行)
							if not (altstr==locstr):
#如果演算结果与原字串不同，大概率是数字，增加作为列表提示选项
								if(self.IsNumber(altstr)):#202504252当是数字时，小数位整理，下增一档
									fmtt = self.floatfmt(locstr)#202504233限制小数位同于输入
									altstr = str(round(float(altstr),fmtt))
									
								locList.append(altstr)
					print("\tPoplist弹出框初始化前表：",locList)
				KeyWordt=""
				if not self.LoopP:#0824
					print("\tPoplist通用弹出框选择，调用popview从(",ib,")表项开始显示")
					self.PopView(locList,ib0+1,pstr)#0822"选择表项或输入")#0731
					print("\n\tPoplist弹出框选择后，从总表(",ib,")行开始显示,输入初始化前，检测self.ok值：",self.ok)
					if self.ok==1:#0904
						if self.InduceKP:#0907
							self.KeyWordStr=self.InduceKeyWord(SRV.Stext)
							print("\tPoplist关键字弹出框获得输入文本：[",SRV.Stext,"]与条件关键词修改为[",self.KeyWordStr,"]")#0404
						elif(self.KeyWord2p):
							if(len(SRV.Stext)>0):
								string= SRV.Stext#0726line
							print("\tPoplist辅助关键字弹出框获得输入文本：[",string,"]")
							if self.KeyWord2p:
								findgp=False#类格式判断
								findkp=False#选项字串判断
								isum=len(locList)
								it=0
								print("\t===发现收集'或条件'辅助关键词标志符‘￥’，拟遍历(",isum,")项弹出框表，操作前关键词为[",self.KVWordStr2,"]")
								for strt in locList:
									print("\t\t(",it,") [",strt,"]",end="")
									if(strt==string):#0331 strt.find(string)>=0精确匹配选定的关键词
										findkp=True
									if(len(strt)>0):
										if(strt[-1]==':'):#到达类行。 放宽中文'：'项的类定义，；因对古文献意义不大 or strt[-1]=='：'
											if findgp:#判断已到过类行时
												if findkp:#已找到选中关键词时，关键词总结退出（1）
													if(len(self.KVWordStr2)==0):
														self.KVWordStr2=KeyWordt+'、'
													else:
														if(KeyWordt!="无"):
															klp=True
															if(self.KVWordStr2.find(KeyWordt)>=0):
																klp=False
															if klp:
																self.KVWordStr2+=KeyWordt+'、'#0331 self.KeyWordStr+'；'
		#											print("\n\t关键字[",self.KVWordStr2,"]加入成功")
													break
											else:#未到过类行时
												findgp=True#标记已到
#												print("\t判断发现成类标记符‘：’[",findgp,"]")
									elif(len(strt)==0):#到达类分割空行（2）（或者第二个以上类行1），关键词总结退出
#										print("\t\t全局'或条件'变量关键词串为[",self.KVWordStr2,"]")
										if findkp:#关键词总结退出
											if(len(self.KVWordStr2)==0):
												self.KVWordStr2=KeyWordt+'、'
											else:
												if(KeyWordt!="无"):
													self.KVWordStr2+=KeyWordt+'、'#0331 self.KeyWordStr+'；'
											print("\n\t关键字[",self.KVWordStr2,"]加入成功")
											break
										else:
											KeyWordt=""#重置关键词中间变量、类标记
											findgp=False
									if findgp:#成类的关键字
										if(len(strt.strip())>0):
				#							print("\t\tstrt=",strt,end="")
											strt1=strt.split()[0]
										else:
											strt1=""
										if(len (KeyWordt)>0):
											if(KeyWordt!="无"):
												KeyWordt=KeyWordt+"、"+strt1#只取空格分割的第一项为关键词
										else:
											KeyWordt=strt1
		#								print("\t预备组装的成类关键字[",KeyWordt,"]")
									else:#单独关键字
										if(strt==string):#0322 strt.find(string)>=0精确匹配
											if(len (KeyWordt)>0 ):
												if(KeyWordt!="无"):
													KeyWordt=KeyWordt+"、"+string.split()[0]#0401
											else:
												KeyWordt=string.split()[0]
		#								print("\t预备组装的单独关键字[",KeyWordt,"]")
									it+=1
		#							if(it==isum):
		#								print("\t循环至总",isum,"项之末第",it,"项，string=",string,",KeyWordt=",KeyWordt)
								if(not findkp):#当发生外部输入时
									KeyWordt=string.split()[0]#取首项为有效关键字
								klp=True
								if(len(self.KVWordStr2)>0):#剔除重复的关键词
									if(self.KVWordStr2.find(KeyWordt)>=0):
											klp=False
								if klp:
									self.KVWordStr2+=KeyWordt+"、"
		#							print("\n\t辅助关键字加入成功，更新为[",self.KVWordStr2,"]")
								self.FirstLine(self.KVWordStr2)#0331下栏0行显示"发现弹出框￥标示辅助关键词，提取更新为["++"]" [:-1]
						string= SRV.Stext#0726line
						print("\tPoplist通用弹出框获得输入文本：[",string,"]")
					else:
						string=""
						GetRow=False#2023*0218
					if GetRow:
						if(len(string.split())>int(colstr)):
							string=string.split()[int(colstr)]
		#					print("\t要求输出列字串，处理为：",string)
				else:	
					n=1
					if self.LoopP:#0824 while LoopP
#					for n in range(3):
						if(len(KeyWordt)>0):
							if(KeyWordt=="无"):
								self.LoopP=False#0824break
								print("self.LoopP=",self.LoopP,",PopLoop exit")
							else:
								KeyWordt=""
						print("\tPoplist循环弹出框选择，调用popview从(",ib,")表项开始显示")
						self.PopView(locList,ib0+1,pstr+"["+str(n)+"]")#0822"选或输入'无'结束循环")#0731
						if self.ok==1:#0904==1#0904:
							self.ok = False#0824
							string= SRV.Stext#0726line
							print("\t循环弹出框获得输入文本：[",string,"]")
							if KeyWordp:
								klp=True
								if(len(self.KeyWordStr)>0):#剔除重复的关键词
									if(self.KeyWordStr.find(string)>=0):
											klp=False
								if klp:
									if(string !="无"):
										if(len(string.strip())>0):
											if(len(self.KeyWordStr)>0):
												self.KeyWordStr+="；"+string.split()[0]
											else:
												self.KeyWordStr=string.split()[0]
		#									print("\n\t'与条件'关键字加入成功，更新为[",self.KeyWordStr,"]")
									else:
										LoopP=False
								if(len(self.KVWordStr2)>0):#0331下栏0行显示“与条件”及“或条件”关键词
									if(len(self.KeyWordStr)>0):
										self.FirstLine(self.KeyWordStr+"；"+self.KVWordStr2)#更新0行数据"主要关键词["++"]辅助关键词["+"]"
									else:
										self.FirstLine(self.KVWordStr2)#更新0行数据辅助关键词
								else:
									if(len(self.KeyWordStr)>0):
										self.FirstLine(self.KeyWordStr)#更新0行数据"主要关键词["++"]"
						else:
							string=""
							GetRow=False
							#0824break
						if GetRow:
							if(len(string.split())>int(colstr)):
								string=string.split()[int(colstr)]
		#						print("\t要求输出列字串，处理为：",string)
					string=self.menu_screen.KeyWordStr#20240902 self
			else:
				print(expbnow,"行字符串[",string,"]弹出框格式错误，应包含~符")
		else:
			print(expbnow,"行字符串[",string,"]弹出框格式错误，首字应为@")
		print("\n\t\t===PopList弹出框操作后主要关键词为[",self.menu_screen.KeyWordStr,"]")#20240902 self.
		print("\t\t\tPopList弹出框处理后字串成为：[",string,"]")
		return string



# 307 333      (9934 0 0)

	def InduceKeyWord (self,ss):#20230321始终行相同表示只归纳该行关键字
#关键词格式：（前缀）＋名词＋（后缀）
#		print("\n***进入行关键词归纳模块-->>[",ss,"]")#202504252
		noun=self.menu_screen.noun#20240902 self
		Adverb=self.menu_screen.Adverb
		Verb=self.menu_screen.Verb
		Verb1=self.menu_screen.Verb1
		KWords=""
		sslistt=[]
		sym=['，','。']
		sslist2=ss.split(sym[0])#由第一分隔符分割后，延展表长	
#			print("\n\t\t+++关键词归纳模块操作行语句为：\n",ss)
		i2=0
		li=len(sslist2)
		for sp in  sym[1:]:#完成所有的分割符拆解
			for i2 in range(li):
				ss1=sslist2[i2]
				if(ss1.find(sp)>=0):
					sslistt.extend(ss1.split(sp))
				else:
					if ss1.strip():
						sslistt.append(ss1)
				if(i2==li-1):
					sslist2=sslistt
					li=len(sslistt)
				#print("i=",i2,"项\t关键词表解构变化：",sslist2)
		sslistt=[]
#		print("\t关键词组按",sym,"无差别展开拆分后结果列表：\n",sslist2)
		cmax=2#关键词最大字数
#		print("\t名词关键词组noun",noun)#202504252
		for i4 in range(cmax):#词构造：前缀1＋名词1或2＋后缀动词1
#			print("\n\t\t\t——————依次按",cmax,"字遍历:",sslist2)
			for st in sslist2:#行内标点分割的各项循环
				Adstrt=""
				Vbstrt=""
				Nounstrt=""
				lst=len(st)
				le=0#提取字末位
				HvN=0#提取字有无名词，决定前缀串联后是否记录
#				print("\n\t\t\t\t",st)
				if(lst>=cmax):#分项字数多于最大关键词字数时，搜索关键词
					i3t=0
					for i3 in range (lst-cmax+1):#遍历分项各字0309
						strt=st[i3:i3+cmax]
#						print("\n(",i3,")位[",strt,"]\t",end="")
						BNounP=False#名词前缀副词True
						NounP=False#名词后接动词
						AVerbP=False#动词
						if((cmax>1) and (i3<=lst-cmax)):#多字名词
#							print("\t\t",cmax,"字，多字名词[",strt,"]比照字典名词")
#							i6=0
							for stt in noun[1]:#遍历双字关键词表
#								print("\t[",strt,"]比照『",stt,"』\t",end="")
#								if(i6%6==5):
#									print("")
#								i6+=1
								if(strt==stt):#0309(strt.find(stt)>=0):
									NounP=True
#									print("\n\t\t\t初发现",cmax,"字多字名词[",strt,"]比照到字典名词『",stt,"』")
#									print("\n\t\t\t---遍历序号(",i3,")位发现",cmax,"字名词前缀，此前，前缀[",Adstrt,"]，名词[",Nounstrt,"]，后缀[",Vbstrt,"]")
									if(Nounstrt==""):#20230307
										Nounstrt=strt
									else:
										if(len(Adstrt)>0):
											if(len(Vbstrt)>0):
												Nounstrt=Adstrt+Nounstrt+Vbstrt+strt[-1]
												#Adstrt=""
												Vbstrt=""
											else:
												Nounstrt=Adstrt+Nounstrt+strt[-1]
												#Adstrt=""
										else:
											if(len(Vbstrt)>0):
												Nounstrt=Nounstrt+Vbstrt+strt[-1]
												Vbstrt=""
											else:
												Nounstrt+=strt[-1]#[i3:i3+cmax]
									i3t=i3t+cmax-1
									if(i3t>le):le=i3t
									HvN+=1
#									print("\t\t多字名词暂存为[",Nounstrt,"]\t,遍历序号第",i3,"位")
									break#continue
#						else:
#							print("\t\t非多字名词\t",end="")
#						print("\n退出多字名词循环i3=",i3,"i3t=",i3t,end="")
						if(not NounP):
							if(i3t<lst):
								sti3t=st[i3t]
							else:
								sti3t=st[i3]#0315
#							print("\n进入前缀判断i3t=",i3t,"，字[",sti3t,"]比照前缀字典",end="")
#							i6=0
							for strA in Adverb:#遍历[名词]前缀的[副词]表，字数为1
#								print("\t\t『",strA,"』\t",end="")
#								if(i6%6==5):
#									print("")
#								i6+=1
								if(sti3t.find(strA)>=0):
#									print("\n\t\t\t遍历至",i3t,"位[",st[i3t],"]，为",cmax,"字单字名词'前缀'，之前前缀[",Adstrt,"]名词[",Nounstrt,"]后缀[",Vbstrt,"]")
									if (len(Adstrt)>0):# (and len(Nounstrt)>0):#如果有前缀
										if(len(Nounstrt)>0):
											if(len(Vbstrt)>0):
												Wordst=Adstrt+Nounstrt+Vbstrt+strA
												Nounstrt=""
												Vbstrt=""
											else:
												Wordst=Adstrt+Nounstrt+strA
												Nounstrt=""
											#Adstrt=""
										else:
											Wordst=Adstrt+strA#+strt
										Adstrt=Wordst
										Nounstrt=""
#										print("\n\t\t\t发现'前缀'[",Adstrt,"]，",cmax,"字名词[",Nounstrt,"]后缀[",Vbstrt,"]，拼接为新前缀[",Adstrt,"]")
									else:
#										print("\n\t\t\t未发现之前'前缀'[",Adstrt,"]")
										if(len(Nounstrt)>0):
											if(len(Vbstrt)>0):
												Wordst=Nounstrt+Vbstrt+strA
												Nounstrt=""
												Vbstrt=""
											else:
												Wordst=Nounstrt+strA
												Nounstrt=""
										else:
											Wordst=strA
										Adstrt=Wordst
#										print("\n\t\t\t",cmax,"字名词[",Nounstrt,"]后接动词[",Vbstrt,"]，新建前缀[",Adstrt,"]")
									if(i3t>le):le=i3t
									BNounP=True#标记已发现名词前缀副词
									break#退出遍历前缀字典
#								else:
#									print("\t\t",st[i3t],"非前缀",end="")
							if (not	BNounP):#不是名词前缀，继续判断是否有后缀动词
								if(i3t<lst):
									sti3t=st[i3t]
								else:
									sti3t=st[i3]
#								print("\n进入后缀判断",i,"行末",lst-1,"位之第(",i3t,")位[",sti3t,"]比照字典\t")
#								i6=0
								for strv in Verb:#遍历后缀关键词表
#									print("\t\t「",strv,"」\t",end="")
#									if(i6%6==5):
#										print("")
#									i6+=1
									if(sti3t.find(strv)>=0):
#										print("\n\t",i,"行第(",i3t,")位，发现单字'后缀'动词表关键词[",strv,"]\t")
										lV=st.find(Vbstrt)
										if(lV>=0):
											if(i3t-lV-len(Vbstrt)<=0):
												Vbstrt+=strv
											else:
												Nounstrt+=Vbstrt
												Vbstrt=strv
										AVerbP=True#名词后接动词
#										print("\t\t\t暂存",cmax,"字后缀成为[",Vbstrt,"]\t")
										#print("\t(",cmax,")字数名词表遍历\t")
										if(i3t>le):le=i3t
										break
#							else:
#								print("\t\t非后缀",end="")
						if((not BNounP) and (not AVerbP) and (i3<=lst-cmax) and (cmax==1)):#不是后缀动词，判断是否名词
		#					print("\n进入单字名词判断i3=",i3,end="")
		#					print("\t\t",cmax,"字，单字名词[",strt,"]比照字典名词")
		#					i6=0
							for stt in noun[0]:#遍历单字关键词表
		#						print("\t[",strt,"]比照『",stt,"』\t",end="")
		#						if(i6%6==5):
		#							print("")
		#						i6+=1
								if(strt.find(stt)>=0):#0309(strt==stt):
									NounP=True
		#							print("\n\t\t\t初发现",cmax,"字，单字名词[",strt,"]比照到字典名词『",stt,"』")
		#							print("\n\t\t\t---遍历序号(",i3,")位发现",cmax,"字单字名词，之前前缀[",Adstrt,"]，名词[",Nounstrt,"]，后缀[",Vbstrt,"]")
									if(len(Nounstrt)>0):
										if(len(Adstrt)>0):
											if(len(Vbstrt)>0):
												Nounstrt=Adstrt+Nounstrt+Vbstrt+strt
												Adstrt=""
												Vbstrt=""
											else:
												Nounstrt=Adstrt+Nounstrt+strt
												Adstrt=""
										else:
											if(len(Vbstrt)>0):
												Nounstrt=Nounstrt+Vbstrt+strt
												Vbstrt=""
											else:
												Nounstrt=Nounstrt+strt
									else:
										if(len(Adstrt)>0):
											if(len(Vbstrt)>0):
												Nounstrt=Adstrt+Vbstrt+strt
												Adstrt=""
												Vbstrt=""
											else:
												Nounstrt=Adstrt+strt
												Adstrt=""
										else:
											if(len(Vbstrt)>0):
												Nounstrt=Vbstrt+strt
												Vbstrt=""
											else:
												Nounstrt=strt
										#Nounstrt+=strt#0401
			#						print("\n\t\t\t---遍历序号(",i3,")位",cmax,"字单字名词后，调整前缀[",Adstrt,"]，名词[",Nounstrt,"]，后缀[",Vbstrt,"]")
									HvN+=1
#									print("\t\t单字名词暂存为[",Nounstrt,"]\t,遍历序号第",i3,"位")#关键词无前缀时
									if(i3t>le):le=i3t
									break#continue
#								else:
#									print("\t\t",st[i3],"非单名词",end="")
#						print("\n\t\t退出单字名词循环i3=",i3,"i3t=",i3t,end="")
								#print("跟踪名词循环(",i3,")[",Nounstrt,"] ",end="")
	#						if(i3t==lst-1):
	#							print("\n\t\t<<<字串[",st,"]遍历到串末(",i3t,")位'",st[i3t],"'\t\t此时前缀[",Adstrt,"]+名词[",Nounstrt,"]+后缀[",Vbstrt,"]")
#						else:
#							print("\n\t\t……字串[",st,"]遍历到(",i3t,")位'","'\t\t此时前缀[",Adstrt,"]+名词[",Nounstrt,"]+后缀[",Vbstrt,"]")#,st[i3t]
						if((not BNounP) and (not NounP) and (not AVerbP) and (i3<lst-cmax+1)
								or (i3t==lst-1)):#else:#非前缀、名词、后缀
							Wordstt=""
							lA=len(Adstrt)
							lN=len(Nounstrt)
							lV=len(Vbstrt)	
							lW=lA+lN+lV
							if(i3t==lst-1 and i3t==le):#0311 and cmax==1cmax=1cmax>1
#								print("\t末位",lst-1,"，词尾遍历到第(",i3t,")位,i3t=i3关键字排序始于(",i3t-lW+1,")")
								Aloc=st.find(Adstrt,i3t-lW+1)
								Nloc=st.find(Nounstrt,i3t-lW+1)
								Vloc=st.find(Vbstrt,i3t-lW+1)
							else:
								Aloc=st.find(Adstrt,i3t-lW)
								Nloc=st.find(Nounstrt,i3t-lW)
								Vloc=st.find(Vbstrt,i3t-lW)
#								print("\t末位",lst-1,"，词尾遍历到第(",i3t,")位,关键字排序始于(",i3t-lW,")")
			#				print("执行到(",i3t,")位字段[",st,"]总长",lst,"，前缀[",Adstrt,"]位置(",Aloc,")，名词[",Nounstrt,"]位置(",Nloc,")，后缀[",Vbstrt,"]位置(",Vloc,")")
							for i7 in range(lst):
								if(i7==Aloc):
									Wordstt+=Adstrt
								if(i7==Nloc):
									Wordstt+=Nounstrt
								if(i7==Vloc):
									Wordstt+=Vbstrt
			#				print("\t\t***循环法***将关键词拼接为[",Wordstt,"]")									
							Wordst=""
							if(lN>0):
								if (lA>0 ):#如果有前缀
									if(lV>0):#还有后缀
										Wordst=Wordstt
									else:#没有后缀动词
										if(Aloc<Nloc):
											Wordst=Wordstt#Adstrt+Nounstrt
#											print("前缀＋名词＝",Wordst)
										else:
											Wordst=Wordstt#Nounstrt+Adstrt
#											print("名词＋前缀＝",Wordst)
								else:#如果无前缀
									if(lV>0):#还有后缀动词
										if(Nloc<Vloc):
											Wordst=Wordstt#Nounstrt+Vbstrt
				#							print("名词＋后缀＝",Wordst)
										else:
											Wordst=Wordstt#Vbstrt+Nounstrt
#											print("后缀＋名词＝",Wordst)
									#else:#没有后缀动词
									#	Wordst=Nounstrt
							else:
								if (lA<=0 ):#如果无前缀
									if(lV==1):
										for sttt in Verb1:
											if (Wordstt==sttt):#0326sttt.find(Vbstrt)>=0):
												Wordst=Wordstt
#												print("\n\t\t\t\t\t保留",cmax,"字名词循环，单独后缀[",Vbstrt,"]审查后，待榷关键词成为[",Wordst,"]")
												break
									elif(lV>1):
										if(cmax==1): 
											Wordst=Wordstt
#											print("\n\t\t\t\t\t",cmax,"字名词循环，后缀为",lV,"字数[",Vbstrt,"]，待榷关键词成为[",Wordst,"]")
								else:
									if(lV>0):
										if(Aloc<Vloc):#如果顺位20230323
											if(HvN>0):#前缀如含有名词，记录20230314
												Wordst=Wordstt#Adstrt+Vbstrt
#												print("前缀＋后缀＝",Wordst)
#												print("\n\t\t\t\t\t保留",cmax,"字后缀[",Vbstrt,"]，关键词成为[",KWords,"]")
											else:
												resvP=False
												for ch in Verb1:
													if(Wordstt.find(ch)):
														resvP=True
														break
												if resvP:Wordst=Wordstt
											if(HvN>0):#前缀如含有名词，记录20230314
												if(Aloc<Vloc):#如果顺位20230313
													Wordst=Wordstt#Adstrt+Vbstrt
#													print("前缀＋后缀＝",Wordst)
#												print("\n\t\t\t\t\t保留",cmax,"字后缀[",Vbstrt,"]，关键词成为[",KWords,"]")
									else:
										if(HvN>0):#前缀如含有名词，记录20230314
											Wordst=Adstrt
#											print("前缀＝",Wordst)
							lw=len(Wordst)
							SVbP=False
							if(lw==1):
								for sttt in Verb1:
									if (sttt.find(Wordst)>=0):
										SVbP=True
#										print("\n\t\t\t\t\t",cmax,"字单字[",Wordst,"]发现在白名单，审查通过")
										break
								if not SVbP:
									Wordst=""
							if(len(Wordst)>0):
								if(len(KWords)>0):
#									print("已存关键词字符数[",len(KWords),"]")
									if(KWords.find(Wordst)<0):
										KWords=KWords+Wordst+'；'
								else:
									KWords=Wordst+'；'
#								print("\n\t\t\t>>>",cmax,"字遍历至非关键字符或项末[",st[i3t],"]前缀[",Adstrt,"]+名词[",Nounstrt,"]+后缀[",Vbstrt,"]，关键词转化为[",KWords,"]")
							Adstrt=""
							Nounstrt=""
							Vbstrt=""
						i3t+=1
#			print("\n第[",i4,"]次执行名词关键字归纳，字数为[",cmax,"]字的关键词后，成为\n[",KWords,"]")		
			cmax-=1	
		lk=len(KWords.split('；'))
	#	print("\n[",ss,"]种子法提取关键字共",lk-1,"项，为\n[",KWords,"]")		
	#	self.FirstLine("种子法提取"+str(lk-1)+"项关键词「"+KWords+"」")
		return KWords



# 333 9            (10323 0 0)

	def FirstLine (self,myStr):#上栏顶行更新
		mystrt = "操作提示："+myStr#20240120 +"；再点[向前]一二次"
		myStr=self.LineFeed(mystrt,self.LineChars)#20240829 RV
		print("标题行显示模块FirstLine手机分行整理后成为『",myStr,"』")
		self.menu_screen.ids.RV_Title.text='[color=#ffd900]'+myStr+'[/color]'



# 9 12            (10657 0 0)

	def RowCount (self,mydic):#选中项统计
		print("进入数据的选中项统计模块：")
		n=0
		for item in mydic:
			if(item['selected']):
				n+=1
		print("共计(",n,")项表被选中")
		return n



# 12 52         (10667 0 0)

	def SelectedList (self):#选中行汇总
		print("\n进入选中行汇总模块SelectedList  ‘闭环输入’判断self.LoopP=",MainApp.LoopP)#20240908self
		CheckedRow=[]
		n= MenuScreen.lViewList#0805
		mylist=[]
		if(MenuScreen.Expbnow == 0):
			#n= MenuScreen.lViewList#0805
			print("\t本页为全文件页，共计(",n,")项")
		else:
			if(MenuScreen.Expbnow<= n):#0811
				bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#Expfnow]0717#获取当前格式行
#				print("\t格式(",MenuScreen.Expbnow,")行字符串[",bnowstr,"]")
				lie=bnowstr.split()#转成表
		#		print("转成表",lie)
				if(MenuScreen.Ignore+2<len(lie)):#20240206
					n=int(lie[MenuScreen.Ignore+2])+1#20230715
#					print("\t\t检测弹出框状态self.PopP:",MainApp.PopP)#20240207self
		#			if(MainApp.PopP):#20240207self#20241026考虑gpu状况，注销此行，下减一档
					plist1=self.psplit(bnowstr,'(',')')
					if(len(plist1)>1):
						plist=self.psplit(plist1[1][1:-1],'(',')')
						lp = len(plist)
						for j in range(lp):
							c1=plist[j].find('@')
							c2=plist[j].find(',')
							c3=plist[j].find('~')
							c4=plist[j].find('?')
							if(c1>=0 and c2>=0 and c3>=0 and c4>=0):
								if(c1>=0 and c2>c1):#有列弹框
									if(self.IsNumber(plist[j][c1+1:c2])):#2025004222下增一档
										nc=int(plist[j][c1+1:c2])
										n=len(MenuScreen.ViewList[MenuScreen.Expbnow+nc].split())
										if(c3>c2): 
											nc1=int(plist[j][c2+1:c3])
											if(c4>c3):
												nc2=int(plist[j][c3+1:c4])
												n=nc2-nc1+1
#					print("\t本页为分页，共计(",n,")行,忽略跳格数MenuScreen.Ignore+2(",MenuScreen.Ignore+2,")<当前格式项数(",len(lie),")")
		for i in range(0,n):#(1,n):#v0.86
			#print("\t\t",i,end="")#20240926
			if(len(self.menu_screen.ids.RV_List.data)>i):#0715
				sitem=self.menu_screen.ids.RV_List.data[i]#MenuScreen.data[i]
				if sitem['selected']:
#					print("\t\t本页共(",n,")行，检索弹出列表第",i,"行已勾选")
					if(i not in CheckedRow):#0.33
						CheckedRow.append(i)
		print("\t汇选返回表：",CheckedRow)
		return CheckedRow



# 52 348   (10625 0 0)

	def EIndex (self):#索引模式摘录
		print("\n进入索引摘录模块　EIndex")
		CheckedRow= self.SelectedList() #0909
		print("\n\tEIndex当前操作文件路径为[",MenuScreen.fileName_choose,"]，勾选行数量(",len(CheckedRow),")")
		Indexpath=os.path.join(os.getcwd(),self.menu_screen.IndexFile)
		IndexLogFile=os.path.join(os.getcwd(),self.IndexLogFile)
		print("\tEIndex中回跳行号MenuScreen.Expbnow=",MenuScreen.Expbnow,"行，勾选行数量(",len(CheckedRow),")")
		AppendP=True #0715 False
		Item4P = True#四维码判断（四项笈格式）
		if(MenuScreen.Expbnow==0):#v0.74
			f=open(Indexpath,mode='w+t',encoding='UTF-8')
			lcwd=len(os.getcwd())#0404
			ztime=self.reading_screen.Ztime(0)
			if(MenuScreen.fileName_choose.find(os.getcwd())>=0):
				filenamet=MenuScreen.fileName_choose[lcwd+1:]
				print("\t\t当前文件去除环境变量后成为[",filenamet,"]")
			else:
				filenamet=self.fileName_choose
			if f:
				f.write(ztime+"\n")#操作时间
				f.write(filenamet+"\n") #0726
				f.close()
		else:#0726
			if(len(CheckedRow)==0):#0920无选中的行
				linestr=self.menu_screen.ids.Line_Edit.text#查询编辑行有无输入

				blankP = True#20250325考虑文件名不清空
				strt = linestr#202504232避免重复读入 self.menu_screen.ids.Line_Edit.text
				lens = len(strt)
				if(lens>0 and lens<12):#12字符以内
					ls = strt.find('.')#查询有无文件后缀
					if(ls>0):#含‘.’
						if(ls<lens-1):#‘.’后有字符
							if(not  strt[ls+1].isdigit()):#‘.’后字符不是数字
								if(os.path.isfile(os.path.join(os.getcwd(),"src",strt))):
								#查询是否文件存在
									blankP = False#判定是文件名，不清空编辑行
				if (blankP and lens>0 ):#不是文件名时就清空，下增一档

					self.menu_screen.ids.Line_Edit.text = ""#20240205获取编辑行内容后，马上清空
				if(len(linestr)>0 and self.PopP):#0925编辑行有内容，且在弹出框状态时，就 记录
					f=open(Indexpath,mode='a+t',encoding='UTF-8')
					if f:
						if(MenuScreen.Expbnow<MenuScreen.lViewList):#0811
							if(len(self.MainPara)<=0):#.strip()):#0813 20240418
								print('\t\t\t无变量名传递，且无勾选行，准备写入[ "',linestr,'"]')#20240205
								f.write(' "'+linestr+'"')#0925"\n"+str(MenuScreen.Expbnow)+' 0 
							else:								
								strtt = str(MenuScreen.Expbnow)+' -8 "'+linestr+'" '+self.MainPara#202504232重修自测题
#								strtt = str(MenuScreen.Expbnow)+' 0 "'+linestr+'" '+self.MainPara#20250409修正自测题
								print('\t\t\t有变量名传递，但无勾选行时准备写入[',strtt,' ]')#20240205#20250409"',linestr,'" ',self.MainPara,'
								f.write('\n'+strtt)#0925"\n"+str(MenuScreen.Expbnow)+' 0#20250409' "'+linestr+'" '+self.MainPara#202504252灭火器配置自动搜索变量出错，修改增加换行
						f.close()#20240204#20241007退一档
						if(MenuScreen.AutoMode):#0925#20241007
							self.menu_screen.ids.Line_Edit.text=""#20241007
			elif(len(CheckedRow)>0):# or len(self.menu_screen.ids.Line_Edit.text)>0):#0823	有选中的行							
				f=open(Indexpath,mode='a+t',encoding='UTF-8')
				if f:
					f.seek(0)
					data=f.read()
					print("\t\t\tEIndex摘引模块，完成打开文件->",Indexpath)#,end=""
					f.close()
					mylist = data.split("\n")
				print("\t\tEIndex操作前表最末项：",mylist[-1])
				bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#0813

				lbnow = bnowstr.split()#20250502
				
				if(len(lbnow) > MenuScreen.Ignore+2):#下增一档
					MenuScreen.Expfnow = MenuScreen.Expbnow+int(bnowstr.split()[MenuScreen.Ignore+2])+1#20250502
#					MenuScreen.Expfnow = MenuScreen.Expbnow+int(lbnow[MenuScreen.Ignore+2])+1#0813int(linklist[0])#0805#20250502
				
					print("\t\t此时回跳行号(",MenuScreen.Expbnow,"),前跳行号(",MenuScreen.Expfnow,")，本页选中的行号为",CheckedRow)
					print("\t\t在Eindex 模块,继续循环判断LoopOn(",self.LoopOn,"),‘闭环输入’弹框判断LoopP(",self.LoopP,"),弹框选择Stext[",SRV.Stext[:20],"……]行号(",SRV.Sline,")")#0918
					if(self.LoopOn):#20240905下增1tab
						print("\t\t\t进入自动摘录分支")
						for i in CheckedRow:
							print("\t\t\t\t遍历选择集CheckedRow中的(",i,")项")#0918
							linet=SRV.Preline+i
							if(linet!=SRV.Sline):
								print("\t\t\t\t\t检测『最后操作』(",SRV.Sline,")项异于『最后选中』(",linet,")项，进行过滤修正")	
								#y=RV()#0708
								for item in self.menu_screen.ids.RV_List.data:#0919y
									#print(item)
									if(item["text"]==str(linet)):#i
										SRV.Stext=item["Name"]
										SRV.Sline=linet
										print("\t\t\t\t\t\tEIndex弹出列表中[",item,"]项为『最后选中』项，字串修正为[",SRV.Stext,"]后退出比选")#0919
										break
							print("\t\t\t\tEindex当前格式(",MenuScreen.Expbnow,")行，弹出框从Preline(",SRV.Preline,")行显示，选中(",i,")行,为本页第(",linet,")行")#0918
							if SRV.Stext == "无" or SRV.Stext == "":#0831 i< MenuScreen.lViewList and i!=0:#V0.94 将i限制在本页；0行为顶行，作为操作行，予以排除
								self.FirstLine("已选中『 无 』，再点一次[>]结束输入")#20240616
								self.LoopOn=False
								print("\t\t\t\t\t在Eindex 模块,选中『 无 』，结束循环输入，变量self.LoopOn：",self.LoopOn,"变量self.LoopP=",self.LoopP,"变量self.PopP=",self.PopP)
								ThirdText1=""#0831
								LastL1=mylist[-1].split()
								if(len(LastL1)>2):
									ThirdText1=LastL1[2][1:-1]
									print("\t\t\t\t\t\tEindex结束循环输入状态时，取索引文件末行第三项字串[",ThirdText1,"]")
									KeyWordStr = self.KVWordStr
									print("\t\t\t\t\t\t 之前与条件关键字为[",KeyWordStr,"]")
									if(len(KeyWordStr)>0 ):
										if(KeyWordStr.find(ThirdText1)<0):#0911
											KeyWordStr += "；"+ThirdText1
									else:
										KeyWordStr = ThirdText1
									print("\t\t\t\t\t\t循环输入后与条件关键字转化为[",KeyWordStr,"]")
									self.KVWordStr=KeyWordStr
									print("\t\t\t\t\t\t调整全局与条件关键为[",self.KVWordStr,"]")
							else:
								self.LoopOn=True#0831
								if(MenuScreen.Expbnow == 0):# #0731MenuScreen.Expfnow
									f=open(Indexpath,mode='w+t',encoding='UTF-8')
								else:
									f=open(Indexpath,mode='a+t',encoding='UTF-8')
								if f:
									if(MenuScreen.Expbnow+i<MenuScreen.lViewList):#0811
										if(MenuScreen.Expbnow==0):#0731MenuScreen.Expfnow
											Is1=str(i-1)
										else:
											DeStext=self.DeLineFeed(SRV.Stext,self.LineChars)#0822
											print("\t\t\t\t\t\t\tEIndex引用弹出框选中行号1SRV.Sline=(",SRV.Sline,"),字串[",SRV.Stext,"],去换行符后成为[",DeStext,"]")
											strt = self.menu_screen.ids.Line_Edit.text#0920发热,烦躁
											if(len(strt)>0):
												print("\t\t\t\t\t\t\t\t列表框选择内容『",DeStext,"』，编辑框输入内容[",strt,"]，弹出框时首选采用，主框时忽略")
												if(self.PopP):
													DeStext=strt

													blankP = True#20250325考虑文件名不清空
													strt = self.menu_screen.ids.Line_Edit.text
													lens = len(strt)
													if(lens>0 and lens<12):#12字符以内
														ls = strt.find('.')#含‘.’
														if(ls>0):
															if(ls<lens-1):#‘.’后有字符
																if(not  strt[ls+1].isdigit()):#字符不是数字
																	if(os.path.isfile(os.path.join(os.getcwd(),"src",strt))):#查询是否文件
																		blankP = False#是文件就保留
													if (blankP and lens>0 ):#下增一档

														self.menu_screen.ids.Line_Edit.text = ""#20240205获取编辑行内容后，马上清空
											if(len(DeStext)>1):#0829
												if self.InduceKP:#0907
													self.InduceKP=False
													self.KVWordStr=self.InduceKeyWord(DeStext)#0907SRV.Stext)
													print("\t\t\t\t\t\t\t\t\t关键字弹出框获得输入文本：[",DeStext,"]与条件关键词修改为[",self.KVWordStr,"]")#0404
												else:
													if(DeStext[-1]==':' or DeStext[-1]=='：'):#0823
														DeStext=DeStext[:-2]
													elif(DeStext[-1]==')'):#0907
														plist=self.psplit(DeStext,'(',')')
														if(len(plist)>2):
															lps=len(DeStext)
															lpf=len(plist[0])
															lpe=len(plist[-1])
															DeStext=DeStext[lpf:lps-lpe]
															print("\t\t\t\t\t\t\t\t\t\t字串总长(",lps,")首括号长(",lpf,")尾括号长(",lpe,")字串去除首尾格式后成为：\n[",DeStext,"]")
															lineloc=self.LineNow(DeStext,0)
															print("\t\t\t\t\t\t\t\t\t\t选中字串的行号为(",lineloc,")")
															self.PageNow(lineloc)
															print("\t\t\t\t\t\t\t\t\t\t当前页格式行号为(",MenuScreen.Expbnow,")下页行号(",MenuScreen.Expfnow,")")
															self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)
													strnow=MenuScreen.ViewList[MenuScreen.Expbnow]#20240204获取原文件中i行字符0821	
													AElist=self.psplit(strnow,"(",")")
													print("\t\t\t\t\t\t\t\t\t(",MenuScreen.Expbnow,")行分割为表的末项：",AElist[-1])
													stril=self.psplit(AElist[1][1:-1],"(",")")
													print("\t\t\t\t\t\t\t\t\t第二分割表(",MenuScreen.Expbnow,")行提取命令表后三项：",stril[-3:])
													if(len(stril)>1):#20240208命令表内为多表，表示有命令
														lenir = 0
														nn = 0#202504213因灭火器配置而补丁
														print("\t\t\t\t\t\t\t\t\t\t检查(",MenuScreen.Expbnow,")行是否在执行字典",MenuScreen.Rundic)
														if str(MenuScreen.Expbnow) in MenuScreen.Rundic:
															ir=MenuScreen.Rundic[str(MenuScreen.Expbnow)]#如执行过该行，提取对应的序号
															lenir = len(stril[ir][1:-1].split())#20240205
															print("\t\t\t\t\t\t\t\t\t\t\t(",MenuScreen.Expbnow,")行曾执行过，从执行字典取出(",MenuScreen.Expbnow,")行运行项序号为(",ir,")对应项[",stril[ir],"]共(",lenir,")词")
															locoma = stril[ir].find(',')
															if(locoma >=0):#20240204#202504213因灭火器配置而补丁
																nastr = stril[ir][locoma+1:]
																na = ""
																for ni in range(len(nastr)):
																	if(nastr[ni].isdigit()):
																		na +=nastr[ni]
																	else:
																		break
																print("\t\t\t\t\t\t\t\t\t\t\t\t弹框序号[na]")
																if(len(na)>0):
																	nn = int(na)
																
														else:#202503244#当本命令首次执行时
															ir = 1
															lenir = len(stril[ir][1:-1].split())#20240205
															print("\t\t\t\t\t\t\t\t\t\t\t(",MenuScreen.Expbnow,")行执行首个命令，运行项序号为(",ir,")对应项[",stril[ir],"]共(",lenir,")词")
															
														if (lenir == 4):
															DeStext=self.AltStr(DeStext,-3,MenuScreen.Expbnow)
														elif (lenir == 5):#20240208
															DeStext=self.AltStr(DeStext,8,MenuScreen.Expbnow).split()[nn]#20240204#202504213因灭火器配置，取为.split()[-1]
														elif (lenir == 2):#20240208
															DeStext=self.AltStr(DeStext,8,MenuScreen.Expbnow)#20240218
														else:#20240208
															Item4P = False
											print("\t\t\t\t\t\t\tEIndex引用弹出框选中行号2SRV.Sline=(",SRV.Sline,"),字串[",SRV.Stext,"],去换行符后成为[",DeStext,"]")
											if(self.PopP):#0909(SRV.Sline):
												Is1=SRV.Sline
											else:
												Is1=str(i)
											linenow=MenuScreen.Expbnow+int(Is1)-1
										print("\t\t\t\t\t\t正在操作文件第(",linenow,")行")
										print("EIndex传递摘引变量self.MainPara=[",self.MainPara,"],内容[",DeStext,"]‘闭环输入’判断(",self.LoopP,"),继续循环(",self.LoopOn,"),换行判断(",self.OnFeed,"),自动运行判断(",MenuScreen.AutoMode,")续行开关判断(",MenuScreen.UnLineFeed,")肆伍判断(",Item4P,")")#0914
										ThirdText=""#0827
										if(self.LoopP):#0827
											LastL=mylist[-1].split()
											if(len(LastL)>2):
												if(LastL[0]==str(MenuScreen.Expbnow)):#0828
													ThirdText=mylist[-1].split()[2]
													print("\t\t\t\t\t\t\tEindex在循环输入状态时，取索引文件末行第三项字串[",ThirdText,"]")
										if(Item4P or (not MenuScreen.AutoMode)):#20240208 0220
											if( ((not MenuScreen.AutoMode) and MenuScreen.UnLineFeed) or (not self.OnFeed)):#如果人工态、续行开关打开，或自动态注释命令传递换行
												print("人工态、续行开关打开，或自动态注释命令传递换行")#20240205
												if(len(self.MainPara)<=0):#.strip()):#0813
													strt=str(MenuScreen.Expbnow)+" "+Is1+' "⌇"'
													print("\t\t\t\t\t\t\t选中(",i,")行并续行的摘引格式[",strt,"]准备写入")
													mylist.append(strt)
													f.write("\n"+strt)#0813str(MenuScreen.Expbnow)+" "+Is1+" \"⌇\"")
												else:#0813
													if(not self.LoopP):#0827
														strt='"'+DeStext+'⌇" '+self.MainPara #0822#0914
														print("\t\t\t\t\t\t\t\t有摘引变量传递，续行的摘引格式[",strt,"]")
														if(self.KeyWord2p):#*0924
															kvword2=DeStext
															if(len(kvword2.split())>1):
																kvword2=kvword2.split()[0]
															if(kvword2[-1]==':' or kvword2[-1]=='：'):
																kvword2=kvword2[:-2]
															self.KVWordStr2 +=kvword2+"、"
															self.KeyWord2p = False
															print("\t\t\t\t\t\t\t\t\t可选‘或条件’关键词成为[",self.KVWordStr2,"]")
													else:
														if(len(ThirdText)>0):
															kstrt=ThirdText[:-1]+'；'+DeStext#0831
															#strt=' "'+kstrt+'" '+self.MainPara+' "⌇"'  #0831#0914
															strt=' "'+kstrt+'⌇" '+self.MainPara  #0831#0914
															print("\t\t\t\t\t\t\t\t\t循环输入时，组合索引文件末行第三项及选项的首项字串成为[",strt,"]与条件关键字中间转化为[",kstrt,"]")										
														else:
															kstrt=DeStext#0831
															#strt=' "'+DeStext+'" '+self.MainPara+' "⌇"' #0822#0914
															strt=' "'+DeStext+'⌇" '+self.MainPara #0822#0914
															print("\t\t\t\t\t\t\t\t\t循环输入的首项字串[",strt,"]与条件关键字中间转化为[",kstrt,"]")		
													while (len(mylist[-1])==0 or (not mylist[-1].split()[0].isdigit())):#20240203
														print("\t\t\t\t\t\t\t\t索引表扫尾\t")
														mylist.pop()
													strtl=mylist[-1].split()#0828strt1=mylist[-1]
													if(len(strtl)>1):
														strt = strtl[0]+' '+strtl[1]+' '+strt
													mylist.pop()
													mylist.append(strt)
													print("\t\t\t\t\t\t\t准备写入[",strt,"]")#20240205
													f.write(strt)
													self.MainPara=""
													if not self.OnFeed:#0914
														self.OnFeed=True
											else:#0914如果续行的开关按钮 关闭
												print("\t\t\t\t\t\t人工态、续行开关关闭")#20240205
												if(len(self.MainPara)<=0):#.strip()):#0813
													if(not self.PopP):#0821
														strt=str(MenuScreen.Expbnow)+" "+Is1
														print("\t\t\t\t\t\t\t\t选中(",i,")行并换行的摘引格式[",strt,"]准备写入")#2024020	5
														#if(MenuScreen.AutoMode):#202409032去除阅读模式下自动摘录链接行的问题
														mylist.append(strt)
														f.write("\n"+strt)#0813str(MenuScreen.Expbnow)+" "+Is1)
												else:#202410062
													if(not self.LoopP):#0827
														strt=' "'+DeStext+'" '+self.MainPara #0822
														lm=len(mylist)#0905
														i2=0
														strt1=""#20240905
														for i1 in range(lm-1,0,-1):
															i2+=1
															strt1=mylist[i1]#0905
															print("\t\t\t\t\t\t\t\t\t扫描非空末(",i1,")行[",strt1,"]",end="")
															if(len(strt1)>0):
																strt1L=strt1.split()
																if(len(strt1L)>1):#2240207
																	strt1=strt1L[0]+" "+strt1L[1]+" "#2240207取前两项mylist[i1][:-1]#0905
																break
														print("\t\t\t\t\t\t\t\t有摘引变量名传递，换行的末行摘引格式[",strt1,"]")
														if(self.KeyWord2p):#*0924
															kvword2=DeStext
															if(len(kvword2.split())>1):
																kvword2=kvword2.split()[0]
															if(kvword2[-1]==':' or kvword2[-1]=='：'):
																kvword2=kvword2[:-2]
															self.KVWordStr2 +=kvword2+"、"
															self.KeyWord2p = False
															print("\t\t\t\t\t\t\t\t\t可选‘或条件’关键词成为[",self.KVWordStr2,"]")
														strt = strt1+strt
														for i in range(i2):#0905
															mylist.pop()
														mylist.append(strt)
														print("\t\t\t\t\t\t\t\t\t\t准备写入[",strt,"]")#20240205
														f.write(strt)
														self.MainPara=""
														print("\t\t\t\t\t\t\t\t\t\t有摘引变量名传递，换行的摘引格式[",strt,"]")
													else:#部位与症状连续循环输入
														if(len(DeStext.split())>1):#0829
															DeStext = DeStext.split()[0]
														if(len(ThirdText)>0):
															kstrt=ThirdText[:-1]+'；'+DeStext#0831
															strt=' '+kstrt+'" '+self.MainPara #0831
															print("\t\t\t\t\t\t\t\t\t\t\t循环输入的后项字串[",strt,"]")										
														else:
															kstrt=DeStext#0831
															strt=' "'+DeStext+'" '+self.MainPara #0822
															print("\t\t\t\t\t\t\t\t\t\t\t循环输入的首项字串[",strt,"]")										
														strtl=mylist[-1].split()#0828strt1=mylist[-1]
														if(len(strtl)>1):
															strt = strtl[0]+' '+strtl[1]+' '+strt
														mylist.pop()
														mylist.append(strt)
														print("\t\t\t\t\t\t\t\t\t\t准备写入[",strt,"]")#20240205
														f.write(strt)
														if(not self.LoopOn):#0910
															self.MainPara=""
														print("\t\tt\t\t\t\t\t\t\t有摘引变量名传递，循环输入的换行摘引格式[",strt,"]")
									f.close()#20241007
#						if f:
#							f.close()
						if(Item4P or (not MenuScreen.AutoMode)):#20240208
							print("\t\t\t\tEIndex摘引模块准备退出,操作后表",mylist)
							f=open(Indexpath,mode='w+t',encoding='UTF-8')
							lm1=len(mylist)
							if f:
								f.seek(0)
								for i in range(lm1-1):	#0414 lm1
									f.write(mylist[i]+"\n")
								f.write(mylist[lm1-1])#0414 
								f.close()
							self.EIDisp()

		print("\t退出EIndex摘引模块\n")







# 348 15   (10733 0 0)

	def SetMode (self):#阅读执行模式切换
		MenuScreen.OmniState = not MenuScreen.OmniState
		if(MenuScreen.OmniState):
			print("阅读/运行 切换状态MenuScreen.OmniState",MenuScreen.OmniState)
			self.menu_screen.ids.Omni_State.text = '[color=#ff0000]运  行[/color]'#'全程模式'字#20240925运行20241005从「自测」恢复
			LoopOn = True #20240905
		#	print("\t进入全程运行模式，AutoMode：",MenuScreen.AutoMode)
		else:
			print("阅读/运行 切换状态MenuScreen.OmniState",MenuScreen.OmniState)
			self.menu_screen.ids.Omni_State.text = '阅  读'#'阅读模式'
			LoopOn = False #20240905



# 15 21               (9934 0 0)

	def UnFeed (self):#消除换行
		MenuScreen.UnLineFeed = not MenuScreen.UnLineFeed
		if(MenuScreen.UnLineFeed):#locrv.UnLineFeed):
			self.menu_screen.ids.Un_Feed.text = '[color=#ff0000]续行[/color]'
			print("换行/续行 切换到‘续行’状态，同时将列表框选中内容传送给编辑行",MenuScreen.UnLineFeed)#0129
			self.selectedItem=SelectableLabel.selectedItem 
			lnum=self.selectedItem
			if(isinstance(lnum,int)):
				#strt = self.menu_screen.ids.Line_Edit.text #获取编辑行输入#20240626
				DeStext=self.DeLineFeed(SRV.Stext,self.LineChars)#20240203
				strt = DeStext#20240626两次点中[换行]，编辑行复制选中行内容 += DeStext
				self.menu_screen.ids.Line_Edit.text = strt
				if(lnum==0):#20240626两次点中[换行]，无选中行时，编辑行清空
					self.menu_screen.ids.Line_Edit.text = ""
		else:
			print("换行/续行 切换状态MenuScreen.UnLineFeed",MenuScreen.UnLineFeed)
			self.menu_screen.ids.Un_Feed.text = '换行'



# 21 16           (11043 0 0)

	def Listp (self,localstr):#判断括号成对
		i2=i3=0
		n1=len(localstr)
		for i1 in range(n1):
			if(localstr[i1]=='('):
				i2+=1
			elif(localstr[i1]==')'):
				i3+=1
		if((i2 == i3) and (i2>0)):
			return True
		else:
			return False



# 16 43             (11065 0 0)

	def psplit (self,string,p1,p2):#配对分割字串
	#配对p1,p2字符分割字串string
		i=ib=0
		ls=len(string)
		#print("进入psplit,字串",string,",串长",ls)
		res=[]
		s=""
		unlock=True
		for i in range(ls):
			#print("i=",i,"unlock=",unlock,"ib=",ib)
			if(unlock):
				if(string[i]==p1):#"("
					#print("发现左边界 ",p1,end="")#括号
					if(s.strip()):
						res.append(s)
					#print(" ,左边界前字串：",s)#括号
					unlock=False
					s=p1 #"("
					ib=1
				else:
					s=s+string[i]
					if(i==ls-1):
						if(s.strip()):
							res.append(s)
			else:
				s=s+string[i]
				if(string[i]==p2):#")"
					ib-=1
				if(p1 != p2):
					if(string[i]==p1):#"("
						ib+=1
				if(ib==0 or i==ls-1):
					res.append(s)
					#print("双界内字串：",s)#括号
					unlock=True
					s=""
				#print(s)
		#print(res)
		return res



# 43 13            (11137 0 0)

	def Extract (self):#顶行勾选时运行本页；否则摘录本页20230218
		print("\n\t进入Extract模块，检测[运行/阅读]切换开关状态：",MenuScreen.OmniState)#0717
		if(MenuScreen.OmniState):#运行状态时
			self.AutoMode=False#202300413结束自动运行状态
			print("\n\t运行状态时，进入执行本页模式：")#,i)
			self.PageRun()#按格式行运行本页
		else:
			print("\n\t阅读状态时，进入注释命令模式：")#,i)
			self.ExtractNow()#摘录本页



# 13 20            (11126 0 0)

	def PageRun (self):
		print("进入PageRun模块")
		bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#获取当前格式行20230218
		if(self.Listp(bnowstr)):#初步检查有无阅读跳转链接项
			plist=self.psplit(bnowstr,"(",")")
			liste=plist[-1][1:-1].split()#提取最后一个括号项字符
			if(not liste[0].isdigit()):#括号项首项为数字，表示有链接
				stra=plist[-1][1:-1]
			if(len(plist)==3):#包括了阅读链接和执行表
				#提取倒数第2个括号项字符为执行表
				stra=plist[-2][1:-1]#self.psplit()[1:]
				print("\n\t\t\t执行表共3项，注释命令为：",stra) 
			if(len(stra)>0):
				self.AutoE(stra)
		else:
			print("请检查",MenuScreen.Expbnow,"行格式，可能无括号项，或括号不配对错误")



# 20 23             (11140 0 0)

	def ExtractNow (self):#手动摘录
		print("\n进入手动摘录总模块　ExtractNow")
		Fruitpath=os.path.join(os.getcwd(),MenuScreen.FruitFile)#结果文本路径
		CheckedRow=self.SelectedList()#读取选中行列表
		if(MenuScreen.Expfnow==0):
			print("手动摘录模块中，如果在全文件显示状态，MenuScreen.Expfnow=",MenuScreen.Expfnow)
			with open(Fruitpath,mode='w+t',encoding='UTF-8') as f:
				for i in CheckedRow:
					print("\n梳理选中的第",i-1,"项，写入文件[",Fruitpath,"]")
					#s=self.menu_screen.ids.RV_List.data[i]['Name']#self.model.item(i).index().data()
					s=MenuScreen.ViewList[MenuScreen.Expbnow+i-1]
					print("\t\t选中项字符：\n",s)          
					if(MenuScreen.UnLineFeed):#(i in self.CheckedRow):
						print("选中",i-1,"行需续行")
						f.write(s+"⌇\n")
					else:
						f.write(s+"\n")
			self.displayextract()
		else:
			print("手动摘录模块中，专用格式状态，MenuScreen.Expfnow=",MenuScreen.Expfnow)
			self.ManualEx ()

#  23 59           (11025 0)

	def ManualEx (self):
		print("\n进入手动摘录模块　ManualSlec")
		CheckedRow= self.SelectedList() #0909
		print("\tManualSlec当前操作文件路径为[",MenuScreen.fileName_choose,"]，勾选行数量(",len(CheckedRow),")")
		Indexpath=os.path.join(os.getcwd(),self.menu_screen.IndexFile)
		IndexLogFile=os.path.join(os.getcwd(),self.IndexLogFile)
		print("\tManualSlec中回跳行号MenuScreen.Expbnow(",MenuScreen.Expbnow,"),前跳行号(",MenuScreen.Expfnow,")为0时清空索引文件Fruit.idx，勾选行数量(",len(CheckedRow),")")
		AppendP=True #0715 False
		Item4P = True
		ld1=os.path.getsize(Indexpath)#20241127文件大小
		print("\t当前摘引文件大小(",ld1,")")
		if(MenuScreen.Expfnow==0 or ld1==0):#20241003修正以方便首页选中，这样只有在刚开始选中时才会清空摘引文件#20241127  or ld1==0
			f=open(Indexpath,mode='w+t',encoding='UTF-8')
			lcwd=len(os.getcwd())#0404
			ztime=self.reading_screen.Ztime(0)
			if(MenuScreen.fileName_choose.find(os.getcwd())>=0):
				filenamet=MenuScreen.fileName_choose[lcwd+1:]
				print("\t\t当前文件去除环境变量后成为[",filenamet,"]")
			else:
				filenamet=self.fileName_choose
			if f:
				f.write(ztime+"\n")#操作时间
				f.write(filenamet+"\n") #0726
				f.close()
		#20241003修正首页不能选中，不退一档else:#0726
		lrow = len(CheckedRow)#20240905
		
		if(lrow>0):# or len(self.menu_screen.ids.Line_Edit.text)>0):#0823	有选中的行							
			f=open(Indexpath,mode='r+t',encoding='UTF-8')#20241003 'a+t'
			if f:
				f.seek(0)
				data=f.read()[:-1]#20241127:
				print("\tManualSlec摘引模块，完成打开文件->",Indexpath)#,end=""
				f.close()
				mylist = data.split("\n")
			print("\t\tManualSlec操作前的表：",mylist)
			bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#0813
			MenuScreen.Expfnow = MenuScreen.Expbnow+int(bnowstr.split()[MenuScreen.Ignore+2])+1#0813int(linklist[0])#0805
			print("\t\t此时回跳行号(",MenuScreen.Expbnow,"),前跳行号(",MenuScreen.Expfnow,")，本页选中的行号为",CheckedRow)
			print("\t\t在ManualSlec 模块,继续循环判断LoopOn(",self.LoopOn,"),循环弹框判断LoopP(",self.LoopP,"),弹框选择Stext[",SRV.Stext[:20],"……]行号(",SRV.Sline,")")#0918
			#20240905手动摘录else:
			print("手动摘录写入索引文件")
			#202401003下退一档if(lrow>0):
			with open(Indexpath,mode='a+t',encoding='UTF-8') as f:
				if(lrow == 1):
					strt=str(MenuScreen.Expbnow)+" "+str(CheckedRow[-1])+" "+self.menu_screen.ids.Line_Edit.text#202409233
					print("\t手动选中(",CheckedRow[-1],")行并换行的摘引格式[",strt,"]准备写入")#20240205
					f.write("\n"+strt)#0813str(MenuScreen.Expbnow)+" "+Is1)
				else:
					for char in CheckedRow:
						strt=str(MenuScreen.Expbnow)+" "+str(char)
						print("\t手动选中(",char,")行并换行的摘引格式[",strt,"]准备写入")#20240205
#						mylist.append(strt)
						f.write("\n"+strt)#0813str(MenuScreen.Expbnow)+" "+Is1)
			self.EIDisp()
					
					

# 59  27             (11240 0 0)

	def displayextract (self):#编辑框显示摘录
		Fruitpath=os.path.join(os.getcwd(),'src',MenuScreen.FruitFile)
		f=open(Fruitpath,mode='r+t',encoding='UTF-8')
		if f:
			f.seek(0)#注意读取文件时候要将文件指针指向第一个
			s=f.read()
			mylist = s.split("\n")#含完整的文件路径
			f.close()
			self.menu_screen.ids.Text_Edit.text=""#clear_widgets()
			linefeed= not MenuScreen.UnLineFeed#True
			for s in mylist:
				if(s.strip()):
					if linefeed:
						if(s[-1]=='⌇'):
							#self.ui.textEdit.append(s[:-1])#v0.76
							self.menu_screen.ids.Text_Edit.text += s[:-1]
						else:
							#self.ui.textEdit.append(s)#v0.76
							self.menu_screen.ids.Text_Edit.text += s+'\n'
					if(s[-1]=='⌇'):
						linefeed=False
				else:
					self.menu_screen.ids.Text_Edit.text += s+'\n'



# 27 26           (11300)

	def OutPut (self):#0925回看功能 *输出之前摘录
		print("进入异常中断回看模块OutPut，显示摘录文本")#20240924
		if(len(MenuScreen.fileName_choose)<1):
			self.menu_screen.ids.Line_Edit.text = "请先选中上次的相关功能，点[笈智]打开"#20240807
		else:
			#self.EIDisp()#输出到编辑框#20240924
			Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#
			print("准备打开摘引文件：",Indexpath)
			locfile=MenuScreen.fileName_choose
			print("当前母版文件：",locfile)
			
			f=open(Indexpath,mode='r+t',encoding='UTF-8')#打开摘引文件
			if f:
				f.seek(0)#注意读取文件时候要将文件指针指向第一个
				s=f.read()
				mylist = s.split("\n")#含完整的文件路径
				#print("\t摘引显示EIDisp转化摘引表为：",mylist)#")#20240924
				f.close()#关闭摘引文件
				strt=mylist[1]#20240204[0]#提取第二行内容为文件名#0416
				print("\t摘引文件的母版文件为：",strt)
				if(MenuScreen.fileName_choose.find(strt)<0):#如果当前母版文件名中包含摘引母版文件#20240924<#202410072恢复 >=
					locfile=os.path.join(os.getcwd(),strt)#0416
					print("\t当前母版文件名中包含摘引母版文件，确定母版文件的全路径为：",locfile)
				self.DispIndex(locfile,mylist,0)#通过母版文件及索引文件表显示文本

#  26 42           (11137 0)

	def GetScore (self):
		print("进入评分子模块GetScore")#20240924
		Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#
		print("准备打开摘引文件：",Indexpath)
		f=open(Indexpath,mode='r+t',encoding='UTF-8')#打开摘引文件
		if f:
			f.seek(0)#注意读取文件时候要将文件指针指向第一个
			s=f.read()
			mylist = s.split("\n")#含完整的文件路径
			#print("\t摘引显示EIDisp转化摘引表为：",mylist)#")#20240924
			f.close()#关闭摘引文件
			strt=mylist[1]#20240204[0]#提取第二行内容为文件名#0416
			print("\t摘引文件的母版文件为：",strt)
			if(MenuScreen.fileName_choose.find(strt)>=0):#如果当前母版文件名中包含摘引母版文件#20240924<
				locfile=os.path.join(os.getcwd(),strt)#0416
				print("\t当前母版文件名中包含摘引母版文件，确定母版文件的全路径为：",locfile)
			
#				GradeP = False#20240924假设评分判断条件不符合
			mylist1=[]#20240924评分功能
			with open(locfile,mode='r+t',encoding='UTF-8') as f:
				data = f.read()
				print("\t\t已打开母版文件：",locfile)
				mylist1 = data.split("\n")	#母文件转为表	
				print("\t\t母版文件转为表")	#20240924	,mylist1	
				
				strt2 = mylist1[0]#获取母版文件中0行的格式行文本
				Ignore=self.menu_screen.DLFmt(mylist1)#20240924求取忽略格式
				if(len(strt2.split()) > Ignore+2):#判断当首行词数大于格式需要的词数时，表明是笈格式文本
					loclist=self.psplit(strt2,"(",")")#探测是否存在表
					if(len(loclist)>1):#发现有表时
						llistre=loclist[-1][1:-1]#获取最后一个表的字串
						el = llistre.split()#再转为表
						print("\t\t\t括号分割不少于2项，略项数Ignore为{",Ignore,"}，括号内为(",llistre,")，拆为后表：",loclist)
						nitem = 0
						if(len(el)>0):
							for i in range(len(el)):
								if(int(el[i])>0):
									nitem +=1
							print("检测到共有自评题目(",nitem,")道")
			self.GradeScore(locfile,mylist,nitem)#20240924通过索引文件表得出评分结果
			
#  42 9

	def ImageOut (self):#20240907
		print("进入图像显示模块")
		img = Test_Image(self)
		img.open()
		#Clock.schedule_once(lambda dt: img.RefreshImage())
		
		
		
# 9   26            (11343 0 0)

	def EIDisp (self):#索引摘录显示		global DlgStr
		print("\n进入当前摘引显示EIDisp")
		Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#
		print("准备打开摘引文件：",Indexpath)
		locfile=MenuScreen.fileName_choose
		print("当前母版文件：",locfile)
		CheckedRow=[]
		f=open(Indexpath,mode='r+t',encoding='UTF-8')#打开摘引文件
		if f:
			f.seek(0)#注意读取文件时候要将文件指针指向第一个
			s=f.read()
			mylist = s.split("\n")#含完整的文件路径
#			print("\t摘引显示EIDisp转化摘引表为：",mylist)#")#20250317
			f.close()#关闭摘引文件
			strt=mylist[1]#20240204[0]#提取第二行内容为文件名#0416
			print("\t摘引文件的母版文件为：",strt)
			if(MenuScreen.fileName_choose.find(strt)<0):#如果当前母版文件名中包含摘引母版文件#20240924 >=#20241002恢复#20240924之前
				locfile=os.path.join(os.getcwd(),strt)#0416
				print("\t当前母版文件名中包含摘引母版文件，确定母版文件的全路径为：",locfile)
				
			self.DispIndex(locfile,mylist,0)#20241002通过母版文件及索引文件表显示文本




#  26 91           (11217 0)

	def GradeScore (self,FilePath,mylist,nitem):
		print("\n进入评分模块GradeScore，输入表为",mylist)
		ucore = 2
		lm = len(mylist)
		strt = mylist[1]#20240928从主页取单题分值
		mypath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		with open(mypath,mode='r+t',encoding='UTF-8') as f:
			data = f.read()
			dlist = data.split('\n')
			for i in range(len(dlist)):
				if(dlist[i]==strt):
					if(len(dlist[i].split())>2):
						ucore = round(float(dlist[i].split()[2]),1)
					elif(len(dlist[i].split())>1):
						ucore = round(float(dlist[i].split()[1])/nitem,1)
					elif(len(dlist[i].split())>0):
						ucore = round(100/nitem,1)
		fname = mylist[1].split("/")[1]
		core = 0.0
		print("\t单道自评题百分制分数为(",ucore,")")
		tcore = 0.0
		for i in range(3,lm):
			fn = 0
			if(len(mylist[i].split())==4):#当摘录索引为四词格式时，表示是计分项
				plist = self.psplit(mylist[i],'"','"')#以""分拆评分记录
				if(len(plist)>2):
					p1 = plist[1][1:-1]
					p2 = plist[2].split()[0]
					l1 =len(p1)#自评答题字数
					l2 =len(p2)#参考答案字数
					print("自评答题[",p1,"]，字数(",l1,")；参考答案[",p2,"]，字数(",l2,")")
					if(ord(p2[0])<= 75):#202401003'A'的asII值为65，表明是选择题，取参考答案字数作为自测答题的字数
						l1 = l2
						print("本题判断为选择题，答题字数取答案字数前几位，以防止多选")
					fullP = False
					if(l2>0):
						for j in range(l2):
							if(l1>0):
								for k in range(l1):
									if(p2[j] == p1[k]):
										fn +=1
								#		print("\t\t自评答题p1(",k,")位匹配参考答案p2(",j,")位的字「",p1[k],"」；累计匹配字数(",fn,")")
										if(fn>=l2):#当自评答题发现答案的字数已经达到参考答案的字数时，中断比较
											fn =l2#20241002
											fullP = True#20241002
											break
							if fullP:#20241002
								break#20241002
						core = round(fn/l2*ucore,1)
						tcore += core
						print("\t\t第(",i,")题匹配(",fn,")字，评分为(",core,")；累计评分得到(",tcore,")")
							
		print("\t评分得到总分为(",round(tcore),")")
		spath=os.path.join(os.getcwd(),"src","Scores.txt")#评分文本路径
		if(os.path.isfile(spath)):#如果评分文件已经存在，就读入
			with open(spath,mode='r+t',encoding='UTF-8') as f:
				data = f.read()
				dlist = data.split("\n")
				ld = len(dlist)
			print("\t\t评分文件已经存在，读入相关内容，共(",ld,")行[",data[:10],"……]")
			if(ld>0):
				if(data.find(fname)>=0):#评分格式每行为文件名、分数，如果评分文件中以前对自评评过分
					for i in range(ld):
						llist = dlist[i].split()
						if(len(llist)>1):
							if(llist[0] == fname):
								if(float(llist[1])< tcore):#此次自评分数高于历史，更改记录
									dlist[i] = fname +" "+ str(round(tcore))
				else:
					dlist.append(fname +" "+ str(round(tcore)))
			with open(spath,mode='w+t',encoding='UTF-8') as f:
				ld =len(dlist)
				for i in range(ld-1):
					f.write(dlist[i]+'\n')
				f.write(dlist[ld-1])
		else:#如果评分文件不存在，就创建
			strt = fname +" "+ str(round(tcore))
			with open(spath,mode='w+t',encoding='UTF-8') as f:
				f.write(strt)
			dlist=[]
			dlist.append(strt)
			
		Hscore = self.Tscore()	#20240927	
		if(tcore>80.0):
			self.menu_screen.ids.Line_Edit.text = "恭喜！获得学分"+str(round(tcore))+"，累计"+str(round(Hscore))+"分"
		else:
			self.menu_screen.ids.Line_Edit.text = "加油！获得学分"+str(round(tcore))+"，累计"+str(round(Hscore))+"分"
		self.DispIndex(FilePath,mylist,1)
#		return tcore
										
#  91 20

	def Tscore (self):#20240927统计总学分
		Hscore = 0.0
		spath=os.path.join(os.getcwd(),"src","Scores.txt")#评分文本路径
		if(os.path.isfile(spath)):#如果评分文件已经存在，就读入
			with open(spath,mode='r+t',encoding='UTF-8') as f:
				data = f.read()
				dlist = data.split("\n")
				ld = len(dlist)
			print("\t\t评分文件已经存在，读入相关内容，共(",ld,")行[",data[:10],"……]")
			if(ld>0):
				for i in range(ld):#20240925计算总分
					llist = dlist[i].split()
					if(len(llist)>1):
						Hscore += round(float(llist[1]),1)
					
		return Hscore
		
		
	
# 20   228           (11472 0 0)

	def DispIndex (self,FilePath,IndexList,n):#FilePath母版文件，IndexList显示列表;当n=1时附加变量显示于行尾评分模式,n=3时提取[]数据生成结果文件;
#v0.993 0417分拆显示模块，方便日志及本次摘录共用
		print("\n进入摘引内容显示模块 DispIndex")
		endpath = ""#20250324
		locfile=FilePath
		mylist=IndexList
		lm=len(mylist)
#		print("\n\t母版文件[",locfile,"]包含列表(",lm,")项，前10为",mylist[:10])
		f1=open(locfile,mode='r+t',encoding='UTF-8')#self.fileName_choose
		if f1:
			s=f1.read()
			f1.close()
#			print("\t\t母版文件已打开")#20250324,locfile)
		mylist1 = s.split("\n")#含完整的文件路径
		lm1=len(mylist1)#20250319母板表项数

#		self.ui.textEdit.clear()
		Dstr=""#0909clear_widgets()#20250323用Dstr代替self.menu_screen.ids.Text_Edit.text
		linefeed= not MenuScreen.UnLineFeed#True#0718
#		print("\t检测有无换行:",linefeed)
		ss=""
		state=True
		endfileP = False#20250318判断是否要提取输出结果文件
		firstP = True #20250318
		for i in range(2,lm):#0404 1->2遍历摘引表各行
			s=mylist[i]#从摘引文件成表中读项，如雨水管线计算268 5
#			if(i<8):
#				print("\t\t摘引文件第(",i,")行[",s,"]",end="")
			if(s.strip()):#202407183未if(len(s)>=0):
				list2=s.split()#摘引表的行转化为行表
				l2=len(list2)#获取行表词数
#				print("\t\t共(",l2,")词")
				if(l2==1):#单词为撤消与恢复操作
					if(s[0]=="-"):#－号表示已撤消，将进入不予显示状态
						state=False
				if (not state):#遍历致到不需要显示的行时
					if(s.strip()):#如果遇到非空行
						if(len(s.split())==1):#且是单词
							if(s.isdigit()):#且是数字
								state=True#就恢复显示状态
				if(l2>1 and state):#只有显示状态，且多词行，才进一步解析268 5
					if(i<=lm-1):#20241221冬至，遍历至最后行号
						i1=int(list2[0])+int(list2[1])#0518行表的前两词之和为母版文件行号273
#						print("\t\t摘引文件第",i,"行「",s,"」指向实际母版文件[",i1,"]行")
#						if(lm-4>1):#20240918
#							if(i>lm-4):
#								print("\t\t\t\t\t\t摘引文件条目第(",i-2,")行:[",s,"]")
#						if(list2[1]!='0' and list2[1]!='-8'):#20240924用第二词为-8来阻止显示#20250319
#							i1=int(list2[0])+int(list2[1])
#						else:#20240924*此行可能出错
#							i1 = int(list2[0])+1

						if(l2>=3):#索引文件三词及以上，表示有附加字串
							plist2=self.psplit(s,'"','"')#用一对双引号分割为字串表，20250214将双引号改为单引号
#							print("\t\t\t三以上项字串[",s,"]配对分割表：",plist2)
							if(len(plist2)>=2):#仅有字串时项数为2；同时有字串及变量时项数为3
								sse=plist2[1][1:-1]#将字串剔除引号引号作为附加字串
#								print("\t\t第(",i,")行摘引[",s,"]拆为词：[",list2[0],"]、[",list2[1],"]及附加输入[",sse,"]")
								if(n==3):#20250318
#									print("\t\t\tn==3")
									if(sse == '['):#20250214准备判断，是否提取输出格式结果文件，依赖于编辑行文件名
										if(firstP):#首次打开文件采用覆盖模式
											firstP = False
											mystr2 = self.menu_screen.ids.Line_Edit.text
											#20250319self.ui.textEdit_2.toPlainText()#读入编辑行内容
											strfil = "output.end"
											if(len(mystr2)>0):#如果编辑行不空
												lpoint = mystr2.find(".")
												if(lpoint>0):#如果有后缀点号
													strfil = mystr2[:lpoint+1]+"end"
												elif(lpoint<0):#如果无后缀点号
													strfil = mystr2+".end"
												print("\t\t\t\t\t格式结果文件名为[",strfil,"]")
												endpath = os.path.join(os.getcwd(),"src",strfil)#20250319self.WinPath
													
#												if(os.path.isfile(endpath)):#20250318舍弃对话框确认
#													reply = QMessageBox.information(self,"覆盖结果文件提示", "src目录下文件["+strfil+"]将被覆盖更新，你确定吗？",QMessageBox.Yes | QMessageBox.No)#使用infomation信息框v0.62
#													if(reply==QMessageBox.Yes):
#													fh=open(endpath,mode='w+t',encoding='UTF-8')#打开结果文件
#													endfileP = True
#												else:
#													reply = QMessageBox.information(self,"创建结果文件提示", "对应于数据文件名的结果文件["+strfil+"]将创新在src目录，你需要吗？",QMessageBox.Yes | QMessageBox.No)#使用infomation信息框v0.62
#													if(reply==QMessageBox.Yes):
												fh=open(endpath,mode='w+t',encoding='UTF-8')#打开结果文件
												endfileP = True
										else:#非首次打开文件采用追加模式
											fh=open(endpath,mode='a+t',encoding='UTF-8')#打开结果文件
											endfileP = True
									elif(sse == ']'):#20250214判断提取输出结果文件结束
										if endfileP:#如果文件打开时
											endfileP = False
											fh.close()
									


							else:
								sse=""
								
						if(l2>=3):#括号分割超过两项时，提取原文件该行字符，以及变量名
							if(list2[1]!='-8'):#20240924用第二词为-8来阻止显示
								if(i1<lm1):#20250319当行号小于总行号时，即未到末行时
									ss = ss+mylist1[i1]+sse#20240924 i1为行总序号，取出该序号表值
							else:
								if(i1<lm1):#20250319当行号小于总行号时，即未到末行时
									ss = ss+sse#20240924 第二词为-8时，忽略
							if(list2[1]=='0' or list2[1]=='-8' ):#第二数为0或-8时，特别处理
#								print("\t\t空格次项为0，格式分割成(",len(list2),")个括号分割项")#0906引号
								if(len(plist2)==2):#只有字串时0914(len(list2)==3):#0906
									ss = sse	
								elif(len(plist2)==3):#包含字串与变量两项0914(len(list2)==4):#0906)
									if(sse.isdigit()):#0917						
										ss="⌇"							
									else:
										ss = sse							
								if (n==1):#20240924当n==1时是评分模式，现时显示变量，即答案
									if(len(plist2)==3):
										ss += "／"+plist2[2]+"(参考答案)"
#								print("\t\t\t引号分割三项以上，次串为0时，提取",list2[0],"+",list2[1],"=(",i1,")行及附加字串[",sse,"]后成为：\n\t[",ss,"]")
							else:#第二数非0或-8时时，提取原文件该行字符，附加字串#20240924
								if(self.tiP):#20250318自测题判断变量
									if(i1<lm1):#20250115
										ss = mylist1[i1]+"／"+sse
								else:
									if(i1<lm1):#20250115

										ss = mylist1[i1]+sse
#								print("\t\t\t三项以上，次串非0时，提取",list2[0],"+",list2[1],"=(",i1,")行及附加字串[",sse,"]后成为：\n\t\t\t[",ss,"]")
						else:#括号分割为两项时只提取原文件该行字符268 5
							#ss = ss+mylist1[i1]
							if(list2[1]=='0' or list2[1]=='-8'):#第二数为0时，特别处理#20240924或-8时
								ss = ""				
							else:#第二数非0或-8时，提取原文件该行字符，附加字串
								if(i1<lm1):#20250115
									ss = mylist1[i1]
#								print("\t两项时提取母版文件(",i1,")行字串\n[",ss,"]")#[",locfile,"]
						if(i==2):
#							print("\t摘引文件第(",i,")行，准备清空编辑框")
							Dstr = ""#.clear_widgets()
						if(len(ss)>0):#20240202(ss.strip()):#202504234雨水管线计算结果未换行
						
						
							if linefeed:#20250318有回车符时
								if(len(ss)>0):#20240203(ss.strip()):
									if(ss[-1]=='⌇'):
#										print("\n\t\t\t\t有回车符(",i1,")行末有⌇[",ss,"]去除成为[",ss[:-1],"]")
										strt = ss[:-1]
										Dstr += strt
										#20250318self.ui.textEdit.append(strt)#v0.76
										if(n==3):#20250214
											if(endfileP):
	#											print("\t\t\t\t\t回车、续行时结果文件写入开关endfileP打开",endfileP)
												if(strt!="[" and strt!="]"):
													if fh:
	#													print("\t\t\t\t\t\t显示模块DispIndex，写入结果文件[",strt,"]")
														fh.write(ss[:-1])#20250214
									else:
	#									print("\n\t\t\t\t\t有回车符(",i1,")行末无⌇，显示[",ss,"]")
										Dstr += ss+'\n'
										#20250318self.ui.textEdit.append(ss)#v0.76
										if(n==3):#20250214
											if(endfileP):
	#											print("\t\t\t\t\t回车、换行时检测结果文件写入开关endfileP状态为打开",endfileP)
												if(ss!="[" and ss!="]"):
#													if(ss.strip()):#202504234雨水管线计算结果未换行，下减一档
													if fh:
	#													print("\t\t\t\t\t\t显示模块DispIndex，写入结果文件[",ss,"]")
														fh.write(ss+"\n")#20250214
								elif(l2>=2):#20230414v0.992保留空行，前(l2>=3)为去除空行
									Dstr += ss+'\n'
									#20250318self.ui.textEdit.append(ss)#v0.76
							else:#无回车符时
								if(len(ss)>0):#20240203(ss.strip()):
									if(ss[-1]=='⌇'):
#										print("\n\t\t\t\t无回车符(",i1,")行末有⌇",ss,"去除成为：",ss[:-1])
										strt = ss[:-1]
										Dstr += strt#20250318
#										self.ui.textEdit.moveCursor(QTextCursor.End)
#										self.ui.textEdit.insertPlainText(strt)
										if(n==3):#20250214
											if(endfileP):
	#											print("无回车、续行时结果文件写入开关endfileP打开",endfileP)
												if(strt!="[" and strt!="]"):
													if fh:
	#													print("\t\t\t\t\t显示模块DispIndex，写入结果文件[",ss[:-1],"]")
														fh.write(strt)#20250214
									else:
	#									print("\n\t\t\t\t无回车符(",i1,")行末无⌇，显示[",ss,"]")
										Dstr += ss+'\n'#20250318
#										self.ui.textEdit.moveCursor(QTextCursor.End)
#										self.ui.textEdit.insertPlainText(ss)#[:-1])
										if(n==3):#20250214
											if(endfileP):
	#											print("\t\t\t\t\t无回车、换行时结果文件写入开关endfileP打开",endfileP)
												if(ss!="[" and ss!="]"):
													if(ss.strip()):
														if fh:
	#														print("\t\t\t\t\t\t显示模块DispIndex，写入结果文件[",ss,"]")
															fh.write(ss+"\n")#20250214

						
#							if(ss[-1]=='⌇'):
#								print("\n\t(",i1,")行末有⌇\n[",ss,"]去除成为\n[",ss[:-1],"]")
#								Dstr += ss[:-1]
#							else:
#								Dstr += ss+'\n'

						elif(l2>=2):#20230414v0.992保留空行，前(l2>=3)为去除空行
							Dstr += ss+'\n'
		self.menu_screen.ids.Text_Edit.text = Dstr#20250323
		if(n==3):
			if(os.path.isfile(endpath)):#20250324
				self.menu_screen.ids.Line_Edit.text = os.path.basename(endpath)+"结果文件已生成"
				f2=open(endpath,mode='r+t',encoding='UTF-8')#self.fileName_choose
				if f2:
					strend = f2.read()
					f2.close()
					self.text_screen.ids.Enlarge_Edit.text = strend#在文本窗口显示

		print("退出摘引内容显示模块 DispIndex\n")








# 228 108   (11493 0 0)

	def ExpView (self,top,bot):#分页显示#显示self.ViewList第top行到第bot行
		print("\n进入专用格式显示模块ExpView->顶(",top,")行，文件名[",MenuScreen.fileName_choose,"]")
		mymodel = ListProperty(["?", "?"])#202409233尝试以此增强稳定性
		modelt1 = ListProperty(["?", "?"])#202409233尝试以此增强稳定性
		modelt = ListProperty(["?", "?"])#202409233尝试以此增强稳定性
		mymodel =[]
		MenuScreen.CheckedRow=[]#0404	
		bnowstr=MenuScreen.ViewList[top]#获取当前格式行
		print("字符：[",bnowstr,"]")
		lie=bnowstr.split()#转成表
	#	print("转成表",lie)
		if(MenuScreen.Ignore+2<len(lie)):#020240206
			step=int(lie[MenuScreen.Ignore+2])#20230329
			bot=top+step+1#20230225
			print("\t本页底行为第(",bot,")行,忽略跳格数MenuScreen.Ignore+2(",MenuScreen.Ignore+2,")，当前格式项数<(",len(lie),")")
		lcol=len(lie)
		lp0=0
		le=0
		jumpp=False
		autop=False
		le=0
		if(self.Listp(bnowstr)):#检查有无阅读链接项
#			print("\t检查有无阅读链接项")
			plist=self.psplit(bnowstr,"(",")")
			lp0=len(plist[0].split())#去除括号项后的列表项数
			liste=plist[-1][1:-1].split()#提取最后一个括号项字符
			if(liste[0].isdigit()):#确定为跳转链接表
				le=len(liste)#获取链接表项数
#		print("\t准备显示")
		myText = ""
		i1=0
		for i in range(top,bot):
	#		print("\t\t\t显示(",i,")行[",MenuScreen.ViewList[i],"]")
			if(i==top):#格式行
				if self.reading_screen.FormatShow:
					item = MenuScreen.ViewList[i]#QStandardItem(self.ViewList[i])
				else:
					item = ""#QStandardItem("")
				
				mymodel.append(item)#self.model.appendRow(item)
			else:#非格式行
				item = MenuScreen.ViewList[i]#QStandardItem(self.ViewList[i])
				if(self.CommentL):#20240916当已经加载品鉴时，行前标记*
					for j in range(len(self.CommentL)):
						if(self.CommentL[j].find(str(i))>=0):#初步搜索有无总行号字符
							CL=self.CommentL[j].split()
							Cn=len(CL)
							if(Cn>=2):
								if(CL[1]==str(i)):#品鉴总行号与显示行号相同
									if(item[0]!="*"):
#										print("\t\t总第(",i,")行因为有品鉴，在行[",item[:10],"]前增加*")
										item = '*' + item
									
				if(le>0):#有链接表时，显示[+]图标
					if((i1<=le-1) and liste[i1]!='0'):
						item = '+' + item
				mymodel.append(item)#self.model.appendRow(item)
				myText += item+"\n\n"#20240904文本窗口内容
				
			i1+=1
			
	#	print("\n\tExpView模块准备显示文本窗口文字[",myText,"]")#20240904
#		strt=self.text_screen.ids.Enlarge_Edit.text#20240904#20240917此行用于调试故舍弃
	#	print("\n\tExpView模块调用文本窗口文字[",strt,"]")#20240904
	#202410073	self.text_screen.ids.Enlarge_Edit.text= myText#20240904显示文本窗口
	#202410073	self.text_screen.ids.Enlarge_Edit.cursor = (0,0)#202409043
		modelt1 = []#0717
		for item in mymodel:
			item1=self.LineFeed(item,self.LineChars)
			if(len(item)>0):#202505042
				if(item[0]!='／'):#202505034
	#				print("\t(",i2,")",item1)
					modelt1.append(item1)
	#	print("\n\tExpView模块执行调整每行字数，调用self.LineChars得(",self.LineChars,")")
#		i2=0#20240917此行用于调试故舍弃
			
		if(len(self.MenuName)>0):#202410073
#			print("\t\t发现主页菜单名「",self.MenuName,"」")
			if(self.MenuName.split()[0].find(self.NameKey)<0):
#				print("\t\t\t未发现主页菜单名中含有自测题关键字「",self.NameKey,"」")
				if(not MenuScreen.AutoMode):#202503252非运行时显示，下增一档
				
					self.text_screen.ids.Enlarge_Edit.text= myText#202410073显示文本窗口
					self.text_screen.ids.Enlarge_Edit.cursor = (0,0)#202410073
					modelt = self.reading_screen.QtSetmodel(modelt1,0)#20240902显示阅读窗口
					self.menu_screen.ids.RV_List.data = modelt
			else:#202410073判断选中列表行的名字含有自测‘题’关键字名时不显示
				modelt = self.menu_screen.QtSetmodel(modelt1,0)#20240902显示主页窗口
#				print("\t\t\t发现主页菜单名中含有自测题关键字，故阅读窗口不显示")
		else:#下增加一档
#			print("\t\t未发现主页菜单名")
#			if(not MenuScreen.AutoMode):#202503252非运行时显示，下增一档#202503253因妨碍中医功能而撤消
				
			self.text_screen.ids.Enlarge_Edit.text= myText#202410073显示文本窗口
			self.text_screen.ids.Enlarge_Edit.cursor = (0,0)#202410073
			modelt = self.reading_screen.QtSetmodel(modelt1,0)#20240902显示阅读窗口
			self.menu_screen.ids.RV_List.data = modelt
		
		print("\t专业格式显示模块Expview完成，当前回跳行号(",MenuScreen.Expbnow,")页底行号(",bot,")")
		topbot=str(top)+" "+str(bot)
		return topbot
		





# 108 21   (11696 0 0)

	def LineFeed (self,string,n):#主程序换行
		#print("\n进入列表行内换行模块Linefeed->[",string,"](",n,")")#20240829
		ls=len(string)
		ln = n
		if(ls<n):
			strt = string
		else:
			strt = ""
			for i in range(0,ls,n):
				if(ls-i > n):
					strt += string[i:ln]+'\n'
					ln += n
				else:
					strt += string[i:]
#				print("Linefeed string[",strt,"]")	
#		print("Linefeed string is [",strt,"]")
		return strt		



# 21 22            (11805 0 0)

	def DeLineFeed (self,string,n):#主程序去换行
		#print("\n进入去换行模块DeLinefeed->[",string,"](",n,")self.LoopP=",self.LoopP)
		ls=len(string)
		n1=n+1#0905
		ln = n1#0905
		if(ls<n1):
			strt = string
		else:
			strt = ""
			for i in range(0,ls,n1):
				if(ls-i > n1):
					strt += string[i:ln-1]
					ln += n1
				else:
					strt += string[i:]#0906[i+1:]
	#0905			print("去换行模块DeLinefeed得到运行字串[",strt,"]")	
		#print("去换行模块DeLinefeed得到结果字串[",strt,"]")
		return strt		



# 22 392            (11827 0 0)

	def HuntPop (self,keystr):#弹框搜索当前行到指定行[始行、保留关键字；终行]，默认始于本页格式行，终文件末行
		fl=MenuScreen.Expbnow
		tl=MenuScreen.lViewList
		ss=self.KVWordStr#0903KeyWordStr	
		ss2=self.KVWordStr2#0903KeyWordStr2	
		LastKey=""#0903
		self.ok = 0#0904
		if(len(ss.strip())>0):
			if(ss[-1]=="；"):
				ss=ss[:-1]
		if(len(ss2.strip())>0):
			if(ss2[-1]=="、"):
				ss2=ss2[:-1]
		print("\n进入HuntPop弹框搜索->主要关键词组[",ss,"]辅助关键词[",ss2,"]")
		KeyR=""
		if(len(keystr)>2):
			strtL=keystr.split("；")	
			if(len(strtL)>0):#判断提取终止行
				if(strtL[-1].isdigit() and len(strtL[-1])>0):		
					if(fl+int(strtL[-1])<=tl):#相对定位方便笈文本修改
						tl=fl+int(keystr.split("；")[-1])
			strtL=keystr.split("；")[0].split("、")
			if(len(strtL)>0):
				if(strtL[0].isdigit() and len(strtL[0])>0):	#判断提取起始行	
					if(fl+int(strtL[0])<=tl):#相对定位方便笈文本修改
						fl=fl+int(strtL[0])
				if((not strtL[-1].isdigit()) and len(strtL[-1])>0):#判断提取保留关键字
					KeyR=strtL[-1]
		print("\t解析输入后关键词组[",ss,"]搜索[",fl,"]行到[",tl,"]行，保留关键字[",KeyR,"]")
		ssk=""
		sst=""
		if(len(ss)>0):
			if(len(ss2)>0):
				sst=ss+"；"+ss2
				if(len(KeyR)>0):
					ssk=ss+"；"+KeyR+"；"+ss2
				else:
					ssk=ss+"；"+ss2
			else:
				sst=ss
				if(len(KeyR)>0):
					ssk=ss+"；"+KeyR
				else:
					ssk=ss
		else:
			if(len(ss2)>0):
				sst=ssk=ss2
		print("\t关键词组合后，'与条件'为[",ssk,"]；'或条件'（不包括保留关键词[",KeyR,"]），因此为\n\t\t[",sst,"]"	)
		ls=len(sst)
		sslist2=[]#由'；'解构'与条件'项
		sslist2t=[]#由'；','、'解构'与条件'及'或条件'项
		sslistt=[]#中间表
		sslist1=[]#不区分‘或’‘与’条件的关键词表
		sym=['；','、']
		sslist2=sst.split(sym[0])#由第一分隔符分割后，延展表长#中文"；"解构'与条件'关键词	
		lk=len(sslist2)#用于后面关键字匹配
		print("\n'与条件'关键词表sslist2：",sslist2)
		for st in sslist2:
			if(st.find("、")>=0):
				sslist2t.append(st.split("、"))
			else:
				sslist2t.append(st)
		print("\nsslist2'与条件'关键词表，进一步展开'、'号后，成为表、字混合的关键词表sslist2t：\n\t\t",sslist2t)
		lenl2=len(sslist2)
		i=0
		for sp in  sym[1:]:#所有分割符都拆解为'或条件'
			for i in range(lenl2):
				ss1=sslist2[i]
				if(ss1.find(sp)>=0):
					sslist1.extend(ss1.split(sp))
				else:
					if ss1.strip():
						sslist1.append(ss1)
				if(i==lenl2-1):#li-1):
					sslistt=sslist1
					li=len(sslistt)
#				print("i=",i,"\t关键词表解构变化：",sslist1)
		sslist1=sslistt
		print("\t关键词无差别展开'、''；'后表sslist1：\n\t\t",sslist1)
		ssh=""
		for st in sslist1:
			ssh+=st+"、"
		ssh=ssh[:-1]
		sshr=ssh+"；"+KeyR
		print("\tssh=",ssh,"sshr=",sshr)#0903
		lenl1=len(sslist1)
		bn=fl
		runP=True
		while runP:
			bnowstr=MenuScreen.ViewList[bn]#获取当前格式行
#			print("\t弹框搜索HuntPop当前[",bn,"]行：\n",bnowstr)
			lie=bnowstr.split()#转成表
			lcol=len(lie)
			if(lcol>MenuScreen.Ignore+2 and len(lie[MenuScreen.Ignore+2])>0):#格式行检查通过
				runP=False
			elif(bn>MenuScreen.lViewList):
				break
			else:
				bn+=1
		if(not runP):#格式检查
			stepbstr=bnowstr.split()[MenuScreen.Ignore+2]
			if(stepbstr.isdigit() and len(stepbstr)>0):
				Expforestep=int(stepbstr)
				bf=bn+Expforestep+1
#				print("\t[",bn,"]行判断为格式行,下个格式行为[",bf,"]行")
			else:
				print("\t第(",bn,")行判断为格式行错误，HuntPop模块退出")
		poplist=[]
		rankmax=0
		for i in range(bn+1,tl+1):
			if(i==bf):#回避格式行
				bn=bf
				bnowstr=MenuScreen.ViewList[bn]
#				print("\t弹框搜索循环HuntPop当前[",bn,"]行：\n",bnowstr)
				lie=bnowstr.split()#转成表
				lcol=len(lie)
				if(lcol>MenuScreen.Ignore+2):#格式检查
					stepbstr=bnowstr.split()[MenuScreen.Ignore+2]
#					print("\t\t行格式第二字符串为[",stepbstr,"]")
					if(stepbstr.isdigit() and len(stepbstr)>0):
						Expforestep=int(stepbstr)
						if(Expforestep==0):
	#						print("\t已至搜索终点，退出循环")
							break
						else:
							bf=bn+Expforestep+1
#							print("\t当前(",bn,")行判断为格式行,下个格式行为(",bf,")")
					else:
	#					print("\t(",bn,")行判断为非格式行，HuntPop模块因‘格式行错误’退出")
						break
			else:
				s=MenuScreen.ViewList[i]#获取当前行字符
	#			print("\t弹框搜索循环HuntPop当前[",i,"]行：\n",s)
				rank0=0
				for i1 in range(lenl1):#所有关键词混合搜索
					if(s.find(sslist1[i1])>=0):
						rank0+=1
	#					print("\t\t\t\t",rank0,"项'或条件'初筛发现关键字[",sslist1[i1],"]于",i,"行")
				if(rank0>0):#加入预选表
					listt=str(bn)+" "+str(i-bn)+" "+str(rank0)#记录格式行号，本页内容行号，频次
					if(rank0>rankmax):
						if(rankmax==0):
							poplist.append(listt)
						else:
							poplist.reverse()
							poplist.append(listt)
							poplist.reverse()
						rankmax=rank0
	#					print("\t关键字有",rank0,"项符合'或条件'初筛弹出表,前置更新为",poplist,end="")	
					else:
						lt=len(poplist)
						#print("\t目前弹出表共计",lt,"项，为",poplist)	
						if(lt>0):
							for i4 in range(lt): 
								#print("\t\t调序循环在第",i4,"次进行，或条件初筛弹出表目前为",poplist)	
								rankt=int(poplist[i4].split()[2])
								if(rank0>rankt):
									poplist.insert(i4,listt)
	#								print("\t\t\t更新循环序号(",i4,")发现次数为",rank0,"比较已有次数",rankt)
									break
								elif(i4==lt-1):
									poplist.append(listt)
	#								print("\t\t\t更新循环序号(",i4,")发现次数为",rank0,"比较已有次数",rankt)
									break
	#				print("\t\t当前页行号(",bn,")，页内(",i-bn,")行，'或条件'初筛弹出表目前为",poplist)	
		it=len(poplist)#完成'或条件'的搜索摘录表poplist，下为'与条件'精筛为poplist1
	#	print("\t\t'或条件'关键字过滤后弹出表为",poplist)	
		poplist2=[]#通用关键字过滤，如伤寒论处方关键字'主之'
		if(len(KeyR)>0):
			for n2 in range(it):
				strt=poplist[n2]
				bn=int(strt.split()[0])
				bh=int(strt.split()[1])
				num=bn+bh
				s=MenuScreen.ViewList[num]#获取替换为该行字串
				if(s.find(KeyR)>=0):
					poplist2.append(strt)
		it2=len(poplist2)#通用关键字KeyR过滤'或条件'的搜索摘录表poplist，成为poplist2，下'与条件'精筛为poplist1
	#	print("\t\t'或条件'弹出表经通用关键字过滤后成为",poplist2)	
		poplist1=[]
		rankmax=0
		if(len(ss2)>0):
			ls=len(ssk)
			print("精筛准备：组合原关键词[",ss,"]与辅助关键词[",ss2,"]消除尾符后成为(",ls,")字的\n\t\t[",ssk,"]")
			sslist2=[]#由'；'解构'与条件'项
			sslist2t=[]#由'；','、'解构'与条件'及'或条件'项
			sslist2=ss.split(sym[0])#由第一分隔符分割后，延展表长#中文"；"解构与条件搜索	
			lk=len(sslist2)#用于后面关键字匹配
			print("\n精筛'与条件'关键词组sslist2=",sslist2)
			sslistt=[]#中间表
			for st in sslist2:
				if(st.find("、")>=0):
					sslist2t.append(st.split("、"))
				else:
					sslist2t.append(st)
			print("\n精筛'与条件'关键词组sslist2展开'、'号后为 ",sslist2t)
		lenl2=len(sslist2t)#'与条件'符号表
	#	print("'或条件'搜索总共(",it2,")项记录，由'与条件'表精筛：",sslist2t)
		if(it2>1):#选项多于一项，精细筛选‘与条件’
			for i2 in range(it2):
				strt=poplist2[i2]
				bn=int(strt.split()[0])
				bh=int(strt.split()[1])
				num=bn+bh
				s=MenuScreen.ViewList[num]#0321将字串替换为该行的关键字
				sk=self.InduceKeyWord(s)
				rank2=True
				rank0=0
	#			print("\t\t'与条件'精筛第[",i2,"]项，位于第",num,"行-->>\n\t\t\t其内容：",s)#的提取关键词为[",sk,"]
				ls=len(sk)
				if(ls>2):
					lists=sk.split("、")#将文本关键词解析为表
					listk=[]
					for i1 in range(lenl2-1):#0329
						st=sslist2t[i1]#取弹框关键词
						if isinstance(st,list):#判断弹框关键词变量st的数据类型为表时
							for strt in st:#弹框关键词遍历
								for s1 in lists:#0321文本关键词s1
									if(s1.find(strt)>=0):#如文本关键词包含弹框关键词0322降低精准度 (strt==s1):
										print("\t\t\t子表文本关键词[",s1,"]中发现弹框关键字[",strt,"]")
										rankP=True
										for kt in listk:
											if(kt.find(strt)>=0):
												rankP=False
										if rankP:
											rank0+=1
											listk.append(strt)#记录已遍历的弹框关键字，以免重复统计
	#										print("\t\t\t\t其中项[",s1,"]在第(",rank0,")次发现弹框关键词[",strt,"]弹框排除表",listk)
						else:#判断弹框关键词变量st的数据类型为'非表'时
							for s1 in lists:#0321文件串s1
#								print("\t\ts1[",s1,"]",end="")
								if(s1.find(st)>=0):#文本关键词中发现弹框关键字
		#							print("\t\t\t文本关键词[",s1,"]中发现弹框关键字[",st,"]")
									rankP=True
									for kt in listk:#排除已计
										if(kt.find(st)>=0):
											rankP=False
									if rankP:
										rank0+=1
										listk.append(st)#记录已遍历的弹框关键字，以免重复统计
		#								print("\t\t\t\t中关键词 [",s1,"]在第(",rank0,")次发现弹框关键词[",st,"]弹框排除表",listk)
					if(rank0<lk-1):#lk定义见模块首部，放宽匹配标准
						rank2=False
				if(rank2):#符合全部与条件，加入预选表
					lsk=len(lists)
					if(lsk>1):
						ratio=round(int(rank0)*100/(int(lsk)-1),0)
					else:
						ratio=round(int(rank0)*100,0)
		#			print("\t\t\t计算弹框'与条件'表",sslist2t,"对[",strt,"]文本位置表提取关键词命中量为(",rank0,")相比总项数(",lsk-1,")的命中率为(",ratio,"％)，")
					listt=str(bn)+" "+str(bh)+" "+strt.split()[2]+" "+str(rank0)+" "+str(ratio)#记录格式行号，本页内容行号，频次，占比
					if(rank0>rankmax):
						poplist1.insert(0,listt)
		#				print("\t关键字符合精筛'与条件'计(",rank0,")项>之前最大项数rankmax(",rankmax,")，符合'与条件'精筛表,前置更新为",poplist1)	
						rankmax=rank0
						rank0=0
					else:
						lt=len(poplist1)
		#				print("\t目前弹出表共计",lt,"项，内容为",poplist1)	
						if(lt>0):
							for i4 in range(lt): 
								rankt=int(poplist1[i4].split()[3])
								ratiot=float(poplist1[i4].split()[4])
		#						print("\t\t\t'与条件'调序循环在第",i4,"次进行，rank0(",rank0,")，vs rankt(",rankt,")")#，弹出表目前为",poplist1)	
								if(rank0>rankt):
									poplist1.insert(i4,listt)
		#							print("\t\t\t调序循环在第",i4,"次进行，符合精筛'与条件'(",rank0,")项>(",rankt,")已有项[",poplist1[i4],"]")	
									rank0=0
									break
								elif(rank0==rankt):
									if(ratio>ratiot):
										poplist1.insert(i4,listt)
		#								print("\t\t\t调序循环在第",i4,"次进行，符合精筛'与条件'数(",rank0,")项=(",rankt,")，命中率",ratio,">前",ratiot,"表调整为",poplist1[i4])	
										rank0=0
										break
									elif(i4==lt-1):
										poplist1.append(listt)
		#								print("\t\t\t调序循环末项第",i4,"次进行，符合精筛'与条件'数(",rank0,")项=(",rankt,")，命中率",ratio,"<=前",ratiot,"表项",listt,"后置")
								elif(i4==lt-1):
									poplist1.append(listt)
		#							print("\t\t\t调序循环末项第",i4,"次进行，符合精筛'与条件'数(",rank0,")项<前(",rankt,")，表项",listt,"后置调整")
		#					print("\t\t当前页行号(",bn,")，页内(",bh,")行，'与条件'精筛弹出框表目前为",poplist1)	#")
		lp1=len(poplist1)		
		string=""
		pstr = ""#20240902
		if(lp1<=0):
			poplistr=[]
			if(it2>0):
				print("\t无符合'与条件'的项，列出通用'或条件'项，共(",it2,")项")
				pstr="相关条件无必选结果，["+sshr+"]可选初筛结果(共"+str(it2)+"项)，"#0903[<]至0925
				for i6 in range(it2):#lt8):
					strt=poplist2[i6]
					num=int(strt.split()[0])+int(strt.split()[1])
					poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
		#			print("\t\t("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
				print("\t'与条件'关键字行弹出表为")#0904,poplistr)	
				title="[取消]扩选至全部'或条件'结果，选择行，或输入"
				self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
				print("Huntpop弹出框测试选中(",SRV.Sline,")行，内容[",SRV.Stext,"]")
				if self.ok==1:#0904==1#0904:
					string= SRV.Stext#0903line
					LastKey=sshr#0903
					sslistt=poplist2
				elif self.ok==-1:#0904se:
					poplistr=[]
					for i6 in range(it):#lt8):
						strt=poplist[i6]
						num=int(strt.split()[0])+int(strt.split()[1])
						poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
			#			print("\t\t("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
					pstr="可选结果["+ssh+"](共"+str(it)+"项)，[<]退出"#0903
					title="[取消]退出，选择，或输入"
					self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
					if self.ok==1:#0904==1#0904:
						string= SRV.Stext#0903line
						LastKey=ssh
						sslistt=poplist
					else:
						string=""
				print("\t\t\t弹框搜索HuntPop处理后字串成为：[",string,"]")
			elif(it>0):
				print("\t无符合'与条件'及通用'或条件'项，列出'或条件'项，共(",it,")")
				pstr="没有符合初筛的结果，请在符合'或条件'["+ssh+"]的全部结果中选择(共"+str(it)+"项)"
				for i6 in range(it):#lt8):
					strt=poplist[i6]
					num=int(strt.split()[0])+int(strt.split()[1])
					poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
				print("\t关键字行弹出表为",poplistr)	
				title="[取消]退出，选择，或输入"
				self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
				if self.ok==1:#0904==1#0904:
					string= SRV.Stext#0903line
					LastKey=ssh
					sslistt=poplist
				else:
					string=""
				print("\t\t\t弹框搜索HuntPop处理后字串成为：[",string,"]")
			else:
				print("\t无符合'与条件'及'或条件'项，建议调整关键字或规则文件krule.txt的内容重新搜索……")
		if(lp1>0):
			poplistr=[]
			print("\t符合'与条件'的数量为(",lp1,")列出(不多于前16项)self.ok=",self.ok)
			for i6 in range(lp1):#lt8):
				strt=poplist1[i6]
				num=int(strt.split()[0])+int(strt.split()[1])
				poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+"与"+strt.split()[3]+"命中率"+strt.split()[4]+"％)")
			title="[取消]扩选至初筛'或条件'结果，选择，或输入"
			self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
			if self.ok==1:#0904==1#0904:
				string= SRV.Stext#0903line
				LastKey=ssk
				sslistt=poplist1
			elif self.ok==-1:#0904se:
				poplistr=[]
				for i6 in range(it2):
					strt=poplist2[i6]
					num=int(strt.split()[0])+int(strt.split()[1])
					poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
	#				print("\t\t("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
				pstr="可选条件["+sshr+"]结果(共"+str(it2)+"项)，[<]至全可选"#0903
				title="[取消]扩选至全部'或条件'结果，选择或双击输入"
				self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
				if self.ok==1:#0904==1#0904:
					string= SRV.Stext#0903line
					LastKey=sshr
					sslistt=poplist2
				elif self.ok==-1:#0904se:
					poplistr=[]
					for i6 in range(it):#lt8):
						strt=poplist[i6]
						num=int(strt.split()[0])+int(strt.split()[1])
						poplistr.append("("+str(i6+1)+")"+MenuScreen.ViewList[num]+"(或"+strt.split()[2]+")")
					pstr="全可选["+ssh+"]结果(共"+str(it)+"项)，[<]退出"#0903
					title="[取消]退出，选择，或输入"
					self.PopView(poplistr,0,pstr)#0903locList,ib0+1,pstr+"["+str(n)+"]")
					if self.ok==1:#0904==1#0904:
						string= SRV.Stext#0903line
						LastKey=ssh
						sslistt=poplist
					else:
						string=""
			else:#0904
				#self.LoopP = True
				print("self.ok=0")
		print("LastKey为[",LastKey,"]sslistt=",sslistt)#0903
		self.LastKey=LastKey
		print("self.LastKey为[",self.LastKey,"]string=[",string,"]")
		return string



# 392 10 (0 0 )

	def PopGetItem (self,poplist,title,pstr):#未使用弹出框
		SRV.Model= poplist
		SRV.Title = title
		SRV.Prompt = pstr
		y = SRV(self)
		y.open()
		print("弹出框已打开")


# 10 39      (12269 0 0)

	def PopView (self,mymodel,n,string):#推送框显示
#		modelt1 = ListProperty(["?", "?"])
		#20241026尝试以此增强稳定性#202504252因不弹出尝试撤消此行
		print("\n进入弹出框显示模块PopView->从第(",n,")行开始显示")#0903,mymodel)
		self.ok = 0#20241026 False
		SRV.Sline=-1#0813
		SRV.Stext=""
		modelt1 = []#0717
		print("\tPopView模块执行调整每行字数，调用self.LineChars(",self.LineChars,")")
		i2=0
		for item in mymodel:
			item1=self.LineFeed(item,self.LineChars)
			if(i2<5):
				print("\t(",i2,")",item1)
				i2+=1
			modelt1.append(item1)
		modelt =  self.menu_screen.QtSetmodel(modelt1,n)
		#20240902#202504252分成二行尝试修正不显示
		self.menu_screen.ids.RV_List.data =  modelt
#		print("['RV_List'].data->",self.menu_screen.ids.RV_List.data)
		self.FirstLine(string)#20240220*
		blankP = True#20250325考虑文件名不清空
		strt = self.menu_screen.ids.Line_Edit.text
		lens = len(strt)
		if(lens>0 and lens<12):#12字符以内
			ls = strt.find('.')#含‘.’
			if(ls>0):
				if(ls<lens-1):#‘.’后有字符
					if(not  strt[ls+1].isdigit()):#字符不是数字
						if(os.path.isfile(os.path.join(os.getcwd(),"src",strt))):#查询是否文件
							blankP = False#是文件就保留
		if (blankP and lens>0 ):#下增一档
		
			self.menu_screen.ids.Line_Edit.text = ""#0823
		print("清空编辑框")#0823
		print("退出Popview模块")


# 39 43      (12280 0 0)

	def PageNow (self,MaxLine):#0907本页格式行号定位，改变全局变量MenuScreen.Expbnow
		print("\n进入所在页格式行定位模块PageNow,检查(",MaxLine,")行")
		print("\t文件表首项",MenuScreen.ViewList[0])
		MenuScreen.Ignore=self.menu_screen.DLFmt(MenuScreen.ViewList)#20240902 self
		ExpMode = False#20250420整合文件间搜索定位
		MenuScreen.lViewList=len(MenuScreen.ViewList)
		if(len(MenuScreen.ViewList[0])>0):
			lie = MenuScreen.ViewList[0].split(' ')
			if(len(lie)>MenuScreen.Ignore+2):#202504272
				if(lie[MenuScreen.Ignore+1][-1]=='0' and lie[MenuScreen.Ignore+2].isdigit()):
				#首行格式位的词末为0，且次字为数，判定为笈格式文本
					ExpMode=True
		if(not ExpMode):
			MenuScreen.Expbnow = 0
			MenuScreen.Expfnow = MenuScreen.lViewList-1
		else:#下增一档
			for i in range(MaxLine,-1,-1):#定位格式行
			#	print("\t(",i,")行[",MenuScreen.ViewList[i],"]")
				if(len(MenuScreen.ViewList[i].split())>MenuScreen.Ignore+2):
					loclist=MenuScreen.ViewList[i].split()
#					print("\t\t空格分割不少于2项，略项数Ignore为(",MenuScreen.Ignore,")，下跳值为(",loclist[MenuScreen.Ignore+2],")，拆为后表：",loclist)
					ign2=loclist[MenuScreen.Ignore+2]
					if(ign2.isdigit()):
						lt=MenuScreen.ViewList[i+int(ign2)+1].split()
						if(len(lt)>MenuScreen.Ignore+2):
#							print("\t\t\t[",MenuScreen.ViewList[i+int(ign2)+1],"]为(",i,")行之后(",int(ign2)+1,")行"	)
							strt=lt[MenuScreen.Ignore+1]
							if(loclist[MenuScreen.Ignore+2]==strt):
#								print("\t\t(",i,")行下跳项值(",loclist[MenuScreen.Ignore+2],")匹配(",strt,")，判定为格式行")
								MenuScreen.Expbnow=i
								MenuScreen.Expfnow=MenuScreen.Expbnow+int(loclist[MenuScreen.Ignore+2])+1
								print("\t\t搜索结果:格式行位置",MenuScreen.Expbnow,"行，本页至"	,MenuScreen.Expfnow,"行")
								if(MenuScreen.OmniState):#20240918
									self.MainPrompt ="选择本页首字为+的行，点[向前]完成。"#20240918#20250404
									self.FirstLine(self.MainPrompt)#20240918
								else:#20240920用于定位总行数
									self.MainPrompt ="以编辑行数字"+str(MaxLine)+"为行号，定位页面成功"#20250404
									self.FirstLine(self.MainPrompt)
								break



# 43 16             (12375 0 0)

	def LineNow (self,string,i0):#0907字串行号定位
		print("\n进入定位字串行号模块LineNow，字串为[",string,"]")
		ls=len(string)
		n=MenuScreen.lViewList
		for i in range(i0,n):
			s=MenuScreen.ViewList[i]
			if(len(s)>=ls):
				if(string.find(s)>=0):
					print("发现字串包含(",i,")行内容[",s,"]")
					break
		return i




#  16 20           (12228 0)

	def ELineNow (self):#202409222*定位文本窗口编辑框内的行号
		print("\n进入光标定位行模块ELineNow")
		strt0 = self.text_screen.ids.Enlarge_Edit.text
		sf=self.text_screen.ids.Enlarge_Edit.selection_from
		print("\t光标位置第(",sf,")")
		strt=strt0[:sf]
		linet = 0
		print("\t\t选中文字以开始到光标处计，为[",strt[:10],"……]")
		if(len(strt)>=0):
			for i in range(len(strt)):
				if(strt[i]=='\n'):
					linet +=1
			line = (linet+1)//2+1
		print("\t\t字符串中发现(",linet,")个换行符，推算出光标位于第(",line,")行")
		return line
		
		


#  20 22           (12245 0)
		
	def ELineNowM (self):#202503262用光标定位主窗口编辑框内的行号
		print("\n进入主窗口光标定位行模块ELineNowM")
		strt0 = self.menu_screen.ids.Text_Edit.text
		sf=self.menu_screen.ids.Text_Edit.selection_from
#		print("\t光标位置第(",sf,")")
		strt=strt0[:sf]
		linet = 0
#		print("\t\t选中文字以开始到光标处计，为[",strt[:10],"……]")
		if(len(strt)>=0):
			for i in range(len(strt)):
				if(strt[i]=='\n'):
					linet +=1
			line = linet#(linet+1)//2+1	#+1
		print("\t\t字符串中发现(",linet,")个换行符，推算出光标位于第(",line,")行")
		return line
		
		



		
# 22   71             (12457 0 0)

	def To_Search (self):#文件及列表搜索响应
		print("进入To_Search搜索->")
		FullStep=True#0908False
		#0908self.model.item(0).index().data()#获取listView的0行字符
		ss=self.menu_screen.ids.Line_Edit.text#0908
		print("\t获取搜索关键词：[",ss,"]")
		if(len(ss)>0):#202409073当编辑行有字符时进行搜索
			st = self.menu_screen.ids.Text_Edit.text#202504013
			if(len(st)>=len(ss)):#2025040113当编辑框有内容时行搜索编辑框
				self.menu_screen.Comments = False#20250408
				self.menu_screen.ids.run_sch.text = '搜索/品鉴'#20250408
				s = st[:-1].split('\n')
				ss = ss.split()[0]
				self.SearchExp(s,ss)
				linenow = self.PosFound
				print("\t\tSearchUp搜索选中(",linenow ,")行")
				if(linenow > 0):
				#20250406 >=0删除=，意味着首行不会被搜索到，对于品鉴没问题，但其它可能会出现bug，下增一档
					strt = s[linenow]
					lens = len(strt)#202504023
					print("\t\tTo_Search搜索中(",linenow ,")行(",lens,")字[",strt,"']")
					#此处内容后移

					ls = st.find(strt)#20250402
					tp = self.menu_screen.ids.Text_Edit.get_cursor_from_index(ls+lens)
					#202504023‘品鉴全览’光标定位编辑框关键语句至行末
					print("\t\tTo_Search搜索获取编辑框光标位置",tp)
					self.menu_screen.ids.Text_Edit.cursor = tp
					print("\t\t编辑框定位(",linenow,")行找到[",strt,"]符合要求，索引号index为(",ls,")")
					self.menu_screen.ids.Text_Edit.select_text(ls,ls+lens)

					linestr = ss+' '+self.GetELine()#20250406
#					llstr = strt.split()
#					linestr = llstr[1]+' '+llstr[2]
#					filestr = self.GetEFName(linenow)
#					linestr = ss+' '+filestr+' '+linestr

					self.menu_screen.ids.Line_Edit.text = linestr
					print("\t\t搜索后编辑行成为[",linestr,"]")



			else:#当编辑框无内容，或字数未超过编辑行时，搜索列表框,下增一档
				#当顶选中时
				CheckedRow= SelectableLabel.SelectedLines#20250420self.SelectedList() #0909
				print("\tTo_Search当前操作文件路径为[",MenuScreen.fileName_choose,"]，勾选行数量(",len(CheckedRow),")勾选行:",CheckedRow)
				localpath = os.path.join(os.getcwd(),MenuScreen.OftenFiles)#self.WinPath,
				if(MenuScreen.fileName_choose == "" or MenuScreen.fileName_choose == localpath):#当前文件是主目录时					
					if('0' in CheckedRow):#选中顶行时跨文件搜索
						print("\t\tTo_Search中顶行被选中，准备跨文件搜索")
						self.SearchFile(localpath,ss)


		else:#202409073当编辑行无字符时，开启品鉴
			if(not self.menu_screen.Comments):#品鉴开关未打开时
	
				self.menu_screen.Comments = not self.menu_screen.Comments#20240917赋值品鉴判断的变量	
				if(self.menu_screen.Comments):#品鉴开关打开时，修改界面按钮文字
					self.menu_screen.ids.run_sch.text = '[color=#ff0000]品  鉴[/color]'#20250327
				MainApp.Pop11 (self)
			else:
				if(len(self.menu_screen.ids.Text_Edit.text)==0):#当编辑框为空时才切换[品鉴]状态为[搜索/品鉴]
					self.menu_screen.Comments = not self.menu_screen.Comments#赋值品鉴判断的变量
					print("搜索/品鉴 切换状态self.menu_screen.Comments",self.menu_screen.Comments)
					self.menu_screen.ids.run_sch.text = '搜索/品鉴'#20250327
				if(len(self.menu_screen.ids.Text_Edit.text)>0):#当编辑框不空时品鉴
				#2024090916			self.CommentL	= []#202409093*
					MainApp.Pop11b (self)
			print("To_Search模块之后，品鉴模式：",self.menu_screen.Comments)

#  71 49            (12289)

	def LoadComment(self):#20241016加载评论
		print("\n进入加载评论模块LoadComment")
		cmtpath=os.path.join(os.getcwd(),"src","Comments.txt")#品鉴文本路径
		fname = MenuScreen.fileName_choose.split('/')[-1]
		print("\t当前文件[",fname,"]，当前格式行号(",MenuScreen.Expbnow,")，下个格式行号(",MenuScreen.Expfnow,")")
		if(os.path.isfile(cmtpath)):#如果品鉴文件已经存在，就读入
			with open(cmtpath,mode='r+t',encoding='UTF-8') as f:
				data = f.read()
				dlist = data.split("\n")
				ld = len(dlist)
				f.close()#20240912
			print("\t\t品鉴文件已有内容，共(",ld,")行，文首摘要[",data[:30],"……]")
			if(ld>0):
				if(data.find(fname)>=0):#品鉴格式第一行为相对路径文件名，之后行为时间戳 、总行号、标的首字、品鉴文本
					print("\t\t\t品鉴文件Comments.txt中发现[",fname,"]文件，寻找品鉴内容行，转化为全局表self.CommentL")
					FoundP = False
					linend = 0
					for j in range(ld):
#						print("\t\t\t循环",j,end="")
						if FoundP:
							if(dlist[j].find(".txt")>=0 and j>0):
								linend = j-1
								print("\t\t\t\t找到文件[",fname,"]的内容尾行号(",linend,")")
								break
						if(dlist[j].find(fname)>=0):
							FoundP = True
							lineb = j+1
							print("\t\t\t\t找到文件[",fname,"]的内容首行号(",lineb,")")
					if(j== ld-1):#如果已至文末，取末行号为品鉴末行号
						linend = j
					print("\n\t\t\t扫描循环结束于行号j=(",j,")；文末行号ld-1=(",ld-1,")该文件内容从(",lineb,")行到(",linend,")行")#,dlist)
					k=0	#将本文件品鉴内容转存到全局表self.CommentL
					strt = ""
					CdisP = False
					for j in range(lineb,linend+1):#20240909
						print("\t\t\t循环",j,end="")

						InsertP = True#202409122排除重复
						if(self.CommentL):#之前有过全局表
							for k in range(len(self.CommentL)):
								print("\t\tCommentL(",k,")[",self.CommentL[k],"]",end="")
								if(self.CommentL[k] == dlist[j]):
									InsertP = False#20240917
									print("全局表内容(",len(self.CommentL),")项包含了品鉴文件的内容，故不加入全局表，其判断InsertP(",InsertP,")")#20240917 (",ln,")行
							
						if InsertP:
							self.CommentL.append(dlist[j])

#   49 147            (12361 0)

	def ShowComment (self):#显示品鉴#20240908
		chs = 8
		print("\n进入显示品鉴模块")
			
		cmtpath=os.path.join(os.getcwd(),"src","Comments.txt")#品鉴文本路径
		#mypath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		CheckedRow= MainApp.SelectedList(self)#读取选中行列表self
#		print("\n品鉴模块读取选中行列表",CheckedRow)
			#localtime=MainApp.ZtimeZ(self,7)#品鉴时间精确到分钟，以区分于记帐时间戳
			#strt = self.menu_screen.ids.Text_Edit.text#读入编辑框文字
		self.menu_screen.ids.Text_Edit.text = ""#20240909清空编辑框文字
			
		fname = os.path.basename(MenuScreen.fileName_choose)#20250327采用系统模块.split('/')[-1]
#		print("\t当前文件[",fname,"]，当前格式行号(",MenuScreen.Expbnow,")，下个格式行号(",MenuScreen.Expfnow,")")
		if(os.path.isfile(cmtpath)):#如果品鉴文件已经存在，就读入
			with open(cmtpath,mode='r+t',encoding='UTF-8') as f:
				data = f.read()
				dlist = data.split("\n")
				ld = len(dlist)
				f.close()#20240912
#			print("\t\t品鉴文件已有内容，共(",ld,")行，文首摘要[",data[:30],"……]")
			if(ld>0):
				if(data.find(fname)>=0):#品鉴格式第一行为相对路径文件名，之后行为时间戳 、总行号、标的首字、品鉴文本
#					print("\t\t\t品鉴文件Comments.txt中发现[",fname,"]文件，寻找品鉴内容行，转化为全局表self.CommentL")
					FoundP = False
					linend = 0
					for j in range(ld):
#						print("\t\t\t循环",j,end="")
						if FoundP:
							if(dlist[j].find(".txt")>=0 and j>0):
								linend = j-1
#								print("\t\t\t\t找到文件[",fname,"]的内容尾行号(",linend,")")
								break
						if(dlist[j].find(fname)>=0):
							FoundP = True
							lineb = j+1
#							print("\t\t\t\t找到文件[",fname,"]的内容首行号(",lineb,")")
					if(j== ld-1):#如果已至文末，取末行号为品鉴末行号
						linend = j
#					print("\n\t\t\t扫描循环结束于行号j=(",j,")；文末行号ld-1=(",ld-1,")该文件内容从(",lineb,")行到(",linend,")行")#,dlist)
					k=0	#将本文件品鉴内容转存到全局表self.CommentL
					strt = ""
					CdisP = False
					for j in range(lineb,linend+1):#20240909
#						print("\t\t\t循环",j,end="")

						InsertP = True#202409122排除重复
						if(self.CommentL):#之前有过全局表
							for k in range(len(self.CommentL)):
#								print("\t\tCommentL(",k,")[",self.CommentL[k],"]",end="")
								if(self.CommentL[k] == dlist[j]):
									InsertP = False#20240917
#									print("全局表内容(",len(self.CommentL),")项包含了品鉴文件的内容，故不加入全局表，其判断InsertP(",InsertP,")")#20240917 (",ln,")行
							
						if InsertP:
							self.CommentL.append(dlist[j])
						strtl = dlist[j].split()
						if(len(strtl)>4):#20240909 3):#当一行五词及以上，表示是格式行
							dplist = self.psplit(dlist[j],'『','』')#202409092
							strtl3 = dplist[1][1:-1]
							strtl4 = dplist[2][1:]
#							print("\t品鉴标的[",strtl3,"]，品鉴[",strtl4,"]")

							s=MenuScreen.ViewList[int(strtl[1])][:chs]#MenuScreen.Expbnow+i
#							print("\t\t\t\t\t比较品鉴行第三词首(",chs,")字[",strtl3[:chs],"]，与当前行内容[",s,"]是否相同，以确认文件内容未变更")
							if(strtl3[:chs] == s):#.find(s)==0):#20240909判断品鉴的摘要首字 与 该行首字 匹配，再进行品鉴显示
#								print("\t\t\t\t\t品鉴标的相同！当前选中行数为(",len(CheckedRow),")品鉴行第二项总行号为[",strtl[1],"]")#20240916
								if(MenuScreen.Expfnow==0):#20250327当处于全页状态时，显示全文件品鉴项
#									print("\t\t\t\t\t全文件页无选中！")
#									print("\t\t\t\t\t当前格式行(",MenuScreen.Expbnow,")下页格式行(",MenuScreen.Expfnow,")")
									CdisP = True
									if(len(strt)==0):
										strt += strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
										#20240909 strt += strtl[0]+"品鉴：\n"+strtl3
									else:
										strt += "\n"+strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
										#20240909strt += "\n"+strtl[0]+"品鉴：\n"+strtl3
#									print("\t\t\t\t\t\t全文件提取已有品鉴内容为「",strt,"」")
								else:	#202503272当处于分页状态时，显示分页品鉴项
									lenc = len(CheckedRow)#20250327
									if(lenc==1):#针对只选中一行的情况
#										print("\t\t\t\t\t\t当只选中一行时：")
										i = CheckedRow[-1]#获取选中行号
										linenow = MenuScreen.Expbnow+i#-1
#										print("\t\t\t\t\t\t选中行列表只有一项，选中的行号为本页第(",i,")行(始行编号为0)，本页格式总第(",MenuScreen.Expbnow,")行，选中行总第(",linenow,")")
#										print("\t\t\t\t(",j,")行不少于五词，比较当前第二词[",strtl[1],"]与总行号(",linenow,")是否相同")
										if(strtl[1] == str(linenow)):#品鉴格式行包括时间戳 、总行号、标的首字、品鉴文本。如果行号相等时，显示品鉴内容
											CdisP = True
											if(len(strt)==0):
												strt += strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
												#20240909* strt += strtl[0]+"品鉴：\n"+strtl3
											else:
												strt += "\n"+strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
												#20240909strt += "\n"+strtl[0]+"品鉴：\n"+strtl3
									
#											print("\t\t\t\t\t\t提取已有品鉴内容为「",strt,"」")
										else:
											CdisP = False
									elif(lenc == 0):#20250327下增一档
#									else:#202503272当处于分页状态时，显示分页品鉴项
#										print("\t\t\t\t\t(",MenuScreen.Expbnow,")行到(",MenuScreen.Expfnow-1,")行的分页面无选中！")
										if(int(strtl[1])>MenuScreen.Expbnow):
											bnowstr=MenuScreen.ViewList[MenuScreen.Expbnow]#20240916获取当前格式行
#											print("\t\t\t\t\t\tShowComment模块中顶(",MenuScreen.Expbnow,")行字符：[",bnowstr,"]")
											lie=bnowstr.split()#转成表
	#										print("\t\t\t\t\t\t转成表",lie)
											if(len(lie) > MenuScreen.Ignore+2):#020240327当项数大于格式位时
												step=int(lie[MenuScreen.Ignore+2])#20230329
												bot=MenuScreen.Expbnow+step+1#
#												print("\t\t\t\t\t\t\t本页底行为第(",bot,")行,忽略跳格数MenuScreen.Ignore+2(",MenuScreen.Ignore+2,")，当前格式项数<(",len(lie),")")
										
											if(int(strtl[1]) < bot):
												CdisP = True
												if(j<linend-1):
	#												print("\t\t\t\t\t品鉴文件Comments.txt第(",j+1,")行内容",dlist[j+1])
													if(self.CTimeP(dlist[j+1].split()[0])):
														CdisP = False
#												print("接续状态判断CdisP",CdisP)
												if(len(strt)==0):
													strt += strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4		
													#20240909 strt += strtl[0]+"品鉴：\n"+strtl3
												else:
													strt += "\n"+strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
													#20240909strt += "\n"+strtl[0]+"品鉴：\n"+strtl3
									
#												print("\t\t\t\t\t\t范围提取已有品鉴内容为「",strt,"」")
							
							
						elif(len(strt)>0 and CdisP):
							strt += "\n"+dlist[j]
#							print("\t\t\t\t提取已有品鉴内容换行接续为「",strt,"」")
					self.menu_screen.ids.Text_Edit.text = strt#20240909+= "\n"+strt#编辑框显示品鉴
					EditStatePopup11.poptext =strt#202409093*
		self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#20240916即时更新品鉴行前标记*号，需下一次浏览时生效#202504032#20240917因手机运行稳定性而舍弃
		
#20241016		self.popup11.dismiss()
		
		try:#20250327恢复取消功能
			self.popup11.dismiss()
		except :#Nopop7 as alias
			print("\t不在弹出框状态!")




					
#  147  80            (12411 0)
	
	def ToComment (self):#进行品鉴#202409073
		chs = 8
		print("\n进入保存品鉴模块ToComment")
		#self.menu_screen.Comments = not self.menu_screen.Comments
		#print("ToComment模块中，品鉴模式：",self.menu_screen.Comments)
		#if(not self.menu_screen.Comments):#locrv.UnLineFeed):
		#	self.menu_screen.ids.run_sch.text = '[color=#ff0000]评  注[/color]'
		cmtpath=os.path.join(os.getcwd(),"src","Comments.txt")#品鉴文本路径
		#mypath=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		CheckedRow=self.SelectedList()#读取选中行列表
		print("\n品鉴保存模块读取选中行列表",CheckedRow)
		if(len(CheckedRow)==1):
			i = CheckedRow[-1]
			print("\t选中行列表只有一项，为本页第(",i,")行")
			linenow = MenuScreen.Expbnow+i#20240908 -1
			localtime = MainApp.ZtimeZ(self,7)
			strt = self.menu_screen.ids.Text_Edit.text#读入主编辑框文字
			s=MenuScreen.ViewList[MenuScreen.Expbnow+i][:chs]#读入总行的文本前若干字
			print("选中本页(",i,")行，为总第(",linenow,")行，当地时间[",localtime,"]，品鉴[",strt,"]品鉴标的[",s,"……]")
			fname = MenuScreen.fileName_choose.split('/')[-1]
			istrt = localtime+" "+str(linenow)+" "+str(i)+" 『"+s+"』 "+strt#202409092
			istrtl =  istrt.split("\n")#202409122即时显示品鉴
			
			print("\t当前打开的文件名为[",fname,"]品鉴内容[",istrt,"]")
			if(os.path.isfile(cmtpath)):#如果品鉴文件已经存在，就读入
				with open(cmtpath,mode='r+t',encoding='UTF-8') as f:
					data = f.read()
					dlist = data.split("\n")
					ld = len(dlist)
				print("\t\t品鉴文件已经存在，读入相关内容，共(",ld,")行[",data[:30],"……]")
				if(ld>0):
					if(data.find(fname)>=0):#品鉴格式第一行为相对路径文件名，之后行为时间戳 、总行号、品鉴标的若干字摘要、可多行品鉴文本
						print("\t\t\t品鉴文件Comments.txt中发现相关文件名，找到该行")
						#k = 0
						FoundP = False
						lineb = 0
						for j in range(ld):
							print("\t\t\t",j,end="")
							if(dlist[j].find(fname)>=0):
								FoundP = True
								lineb = j+1
								break
								
						dlist.insert(lineb,istrt)
			#20240916if self.CommentL:#202409122即时显示品鉴
			#				for k in range(len(istrtl)):
			#					self.CommentL.insert(0,istrtl[k])
						
					else:
						print("品鉴文件Comments.txt中未发现相关文件名")
						dlist.insert(0,fname)
						dlist.insert(1,istrt)
					with open(cmtpath,mode='w+t',encoding='UTF-8') as f:
						for l in range(len(dlist)-1):
							f.write(dlist[l]+"\n")
						f.write(dlist[-1])
					
			else:#202409082如果品鉴文件不存在 同页测试 笈智中医 难得暇满  珍贵稀有 换行测试 异页测试 202409092*异文件测试手册修订
				print("品鉴文件Comments.txt不存在，创建并记录品鉴[",istrt,"]")
				with open(cmtpath,mode='w+t',encoding='UTF-8') as f:
					f.write(fname+"\n")
					f.write(istrt)
			if self.CommentL:#20240916加入全局品鉴表，以便即时显示品鉴
				for k in range(len(istrtl)):
					self.CommentL.insert(k,istrtl[k])#20240916 0 当本文件非首次品鉴时，插入首项模式
			else:#20240916
				for k in range(len(istrtl)):
					self.CommentL.append(istrtl[k])#20240916 当本文件首次品鉴时，追加模式
			print("\t\t\t\t品鉴模块ToComment中全局品鉴表self.CommentL:",self.CommentL)						

			istrt = localtime+"品鉴("+str(i)+"／"+str(linenow)+")行「"+s+"……」：\n"+strt#20240909
			self.menu_screen.ids.Text_Edit.text = istrt
		else:
			self.menu_screen.ids.Text_Edit.text = "品鉴时需要只点中一行"
#20240917因照顾手机运行稳定性而舍弃		self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#20240916即时更新品鉴行前标记*号
		self.popup11b.dismiss()


	
# 80   117             (12750 0 0)

	def SearchExp (self,st,ss):
	#在字符串列表s中搜索ss定位其所在行号。专业搜索，区分‘、’分割的‘或条件’，及‘；’分割的‘与条件’
		print("\n进入专业搜索模块SearchEXP，从字符列表中搜索可选、必选关键词混合条件的[",ss,"]列表末3项")
		print("\t",st[-3:])
		foundp = self.PosFound#20250406记录超步位置

		step = 1#202504012
		end = len(st)#202504013MenuScreen.lViewList
		if(len(ss)>0):#202504012
			if(ss[0]=='-' or ss[0]=='－'):#如果字串首字为减号
				print("\t\t发现逆向搜索关键字[",ss[0],"]")
				if(not self.IsNumber(ss[1:])):#排除负数搜索
					step = -1
					end = -1
					ss = ss[1:]#202504012取第1位以后为搜索字段
		print("\t搜索起始点行(",self.PosFound+step,")步长(",step,")终行(",end,")搜索关键词[",ss,"]")
			
		sslist2=[]
		sslistt=[]
		sslist1=[]
		sym=[' ','、']
		sslistt.extend(ss.split(sym[0]))
		i=0
		li=len(sslistt)
		for sp in  sym[1:]:
			for i in range(len(sslistt)):
				ss1=sslistt[i]
				if(ss1.find(sp)>=0):
					sslist1.extend(ss1.split(sp))
				else:
					if ss1.strip():
						sslist1.append(ss1)
				if(i==li-1):
					sslistt=sslist1
					li=len(sslistt)
					sslist1=[]
				if(len(sslist1)>0):#202504013
					print("i=",i,"\t列表变化：",sslist1[-1])
		sslist1=sslistt
#		print("\t关键字'、'拆分后列表结果：",sslist1)#202504013
		lenl1=len(sslist1)
		for i1 in range(lenl1):
			if(sslist1[i1].find(";")>=0):
	#			print("搜索关键字中含';'")
				sslist2=sslist1[i1].split(";")#";"解构多条件搜索	
	#			print("\n多条件关键字集sslist2=",sslist2)
			elif(sslist1[i1].find("；")>=0):
	#			print("搜索关键字中含中文'；'")
				sslist2=sslist1[i1].split("；")#中文"；"解构多条件搜索	
	#			print("\n多条件关键字集sslist2=",sslist2)

		lenl2=len(sslist2)
#		step = 1#20250113
#		end = MenuScreen.lViewList
		
		if(self.PosFound<0):
			print("\t\t当前运行文件[",MenuScreen.fileName_choose,"]")
			if(MenuScreen.fileName_choose):#202504013
				if(MenuScreen.fileName_choose.find(MenuScreen.OftenFiles)<0):
					self.PosFound= MenuScreen.Expbnow
				else:
					self.PosFound= 0
			else:
				self.PosFound= 0
		elif(self.PosFound == end -1):
			self.PosFound= 0
			
#			self.PosFound= MenuScreen.Expbnow#20250113 -1

	#	searchP = True
#		str2 = self.menu_screen.ids.Text_Edit.text#self.model.item(i).index().data()#20250113获取顶行字串#202504012
#		if(len(str2)>0):#202504012
#			if(str2[0]=='-' or str2[0]=='－'):#如果字串首字为减号
#				step = -1
#				end = -1
#		print("搜索起始点行(",self.PosFound,")步长(",step,")终行(",end,")")

		exitp=False
		for i in range(self.PosFound+step,end,step):#20250113
			s = st[i]#202504013	MenuScreen.ViewList[i]
#			print("\t\t(",i,")",s,end="")
			for i1 in range(lenl1):#并集搜索
				if(sslist2):
					i2p=0
					for i2 in range(lenl2):#交集搜索
						newpos2=s.find(sslist2[i2])
						#print("\t\t\t位置",i,"行，交集搜索第[",i2,"]项条件[",sslist2[i2],"]")
						if (newpos2>=0):
							print("\t\t\t\t交集搜索发现关键字",sslist2[i2])
							i2p+=1
					if(i2p>=len(sslist2)):
						print("\n\t\t\t",i,"行[",s,"]匹配交集搜索所有条件")
						self.PosFound=i
						exitp=True
						break
				if(exitp):
					break
				if(s.find(sslist1[i1])>=0):
					self.PosFound=i
					print("\n\t\t",i,"行[",s,"]发现并集搜索条件")
					exitp=True
					break
			if(exitp):
				break
		print("\n\t搜索锁定",self.PosFound)
		if(foundp == self.PosFound):#20250406
			self.PosFound = 0
		else:
			print("\n\t搜索锁定",self.PosFound)
#		print("退出SearchEXP搜索->")






# 117 45                    (12795 0)

	def PickNum (self,string):#从数文混杂表项中提取数字
	#	print("\n进入提取数字模块PickNum，操作字串为[",string,"]")
		nlist=[]
		ln=len(string)
		nstr=""
		State=False#数字状态为非
		Change=False
		for i in range(ln):
			#print("i=",i," ? ",ln)
			if(string[i].isdigit() or string[i]=='.' or (string[i]=='-' and i==0)):
				if not State:
					Change=True
				else:
					Change=False
				State=True
			else:
				if State:
					Change=True
				else:
					Change=False
				State=False
			if Change:
				if(i==0):
					nstr+=string[i]
					if(i==ln-1):
						nlist.append(nstr)
				else:
					nlist.append(nstr)
					nstr=string[i]
			elif(i==ln-1):
					nstr+=string[i]
					nlist.append(nstr)
			else:
				nstr+=string[i]
		rnstr=""
		for nstr1 in nlist:
			if(self.IsNumber(nstr1)):
				rnstr=nstr1
				break#20240215
	#	print("退出提取数字模块PickNum，返回数字为[",rnstr,"]\n")
		return rnstr#20240214nstr1



# 45 9            (11777 0 0)

	def CopyIn (self):#全复制
		if(len(self.menu_screen.ids.Line_Edit.text)==0): #20241229获取编辑行输入字符数，空时为全复制
			strt=self.menu_screen.ids.Text_Edit.text
			Clipboard.copy(strt)
			print("复制到剪贴板的内容：[",strt[:10],"……",strt[-10:],"]")
		else:#20241229不空时为加密功能
			self.encrypt()
		
#  9 10            (12804 0)

	def CopyIn2 (self):#文本窗口全复制
		strt=self.text_screen.ids.Enlarge_Edit.text
		Clipboard.copy(strt)
		print("复制到剪贴板的内容：[",strt[:10],"……",strt[-10:],"]")
		
		



# 10  15            (11833 0 0)

	def BCopyIn (self):#20240604内复制
		strt=self.menu_screen.ids.Text_Edit.text
		strt1="\n"
		slist = strt.split("\n")
		sn = len(slist)
		for i in range(1,sn-2):
			strt1 += slist[i]+"\n"
		if(len(slist[sn-2])>0):
			strt1 += slist[sn-2]
		Clipboard.copy(strt1)
		print("备份复制到剪贴板的内容：[",strt[:10],"……",strt[-10:],"]")



# 15 26              (11844 0 0)

	def CopyStr (self):#202406122复制
		strt=self.menu_screen.ids.Text_Edit.text
		sf=self.menu_screen.ids.Text_Edit.selection_from
		#print("编辑框内容：[",strt,"……]选择开始于(",sf,")")#202406122.split('\n')[0]
		if(self.CopyFrom==None):#202409042
			self.CopyFrom = -1
			
		cpstr = ""
		if(self.CopyFrom>=0):
			if(self.CopyFrom<sf):
				cpstr = strt[self.CopyFrom:sf]
				self.menu_screen.ids.Text_Edit.select_text(self.CopyFrom,sf)
				#self.menu_screen.ids.Line_Edit.text= cpstr
				print("复制开始于(",self.CopyFrom,")to(",sf,"):[",cpstr[0:10],"……]")
				self.CopyFrom = -1
			elif(self.CopyFrom>sf):
				cpstr = strt[sf:self.CopyFrom]
				self.menu_screen.ids.Text_Edit.select_text(sf,self.CopyFrom)
				#self.menu_screen.ids.Line_Edit.text= cpstr
				print("复制开始于(",sf,")to(",self.CopyFrom,"):[",cpstr[0:10],"……]")
				self.CopyFrom = -1
			Clipboard.copy(cpstr)
		else:
			self.CopyFrom = sf

#  26 28            (12841 0)

	def CopyStr2 (self):#202406122复制
		strt=self.text_screen.ids.Enlarge_Edit.text
		sf=self.text_screen.ids.Enlarge_Edit.selection_from
		print("放大编辑框内容：[",strt,"……]选择开始于(",sf,")")#202406122.split('\n')[0]
		if(self.CopyFrom==None):#202409042
			self.CopyFrom = -1
			
		cpstr = ""
		if(self.CopyFrom>=0):
			if(self.CopyFrom<sf):
				cpstr = strt[self.CopyFrom:sf]
				self.text_screen.ids.Enlarge_Edit.select_text(self.CopyFrom,sf)
				#self.menu_screen.ids.Line_Edit.text= cpstr
				print("复制开始于(",self.CopyFrom,")to(",sf,"):[",cpstr[0:10],"……]")
				self.CopyFrom = -1
			elif(self.CopyFrom>sf):
				cpstr = strt[sf:self.CopyFrom]
				self.text_screen.ids.Enlarge_Edit.select_text(sf,self.CopyFrom)
				#self.menu_screen.ids.Line_Edit.text= cpstr
				print("复制开始于(",sf,")to(",self.CopyFrom,"):[",cpstr[0:10],"……]")
				self.CopyFrom = -1
			Clipboard.copy(cpstr)
		else:
			self.CopyFrom = sf



# 28  33            (11887 0 0)

	def CutStr (self):#20240615删选
		print("\n进入主窗口删选模块CutStr")
		if(len(self.menu_screen.ids.Text_Edit.selection_text)>0):#202410112
			self.menu_screen.ids.Text_Edit.delete_selection()#Clipboard.cut()
			
		else:#202503242
			if(len(self.menu_screen.ids.Text_Edit.text)>0):#如果主窗口编辑框有内容
				ltexts = len(self.text_screen.ids.Enlarge_Edit.text)
				print("\t文本窗口页的字数为(",ltexts,")")
				if(ltexts<5):#如果文本窗口编辑框无内容
					strm = self.menu_screen.ids.Text_Edit.text
					print("\t头尾各20字为[",strm[:20],"]……[",strm[-20:],"]")
					self.text_screen.ids.Enlarge_Edit.text = strm
					tp = self.text_screen.ids.Enlarge_Edit.get_cursor_from_index(0)#202504224
					self.text_screen.ids.Enlarge_Edit.cursor = tp#202504224将主窗口内容传至文本窗口
				else:#202410112选择集为空时如果文本窗口编辑框有内容
					print("选择集为空，且文本窗口不空，准备切换编辑框字体")
					self.FontBold = not self.FontBold
					if(self.FontBold):
						self.menu_screen.ids.Text_Edit.font_name = "jzh"#bold = True#202503272	"jzz"发行简化
						CheckedRow= self.SelectedList() 
						lrow = len(CheckedRow)
						if(lrow>0):# or len(self.menu_screen.ids.Line_Edit.text)>0):#0823	有选中的行							
							line = MenuScreen.Expbnow+CheckedRow[-1]
							strt =MenuScreen.ViewList[line]
							#myStr=self.LineFeed(strt,self.LineChars)
							print("标题行显示藏文[",strt,"]")
							self.menu_screen.ids.RV_Title.text='[color=#ffd900]'+strt+'[/color]'##202410112myStr
					else:
						self.menu_screen.ids.Text_Edit.font_name = "jzh" #bold = False#202503272"jzx"发行简化


#  33 23            (12897 0)

	def CutStr1 (self):#20250323文本窗口删选按钮
		print("\n进入文本窗口删选模块CutStr1")
		if(len(self.text_screen.ids.Enlarge_Edit.selection_text)>0):
			self.text_screen.ids.Enlarge_Edit.delete_selection()#Clipboard.cut()
		
		else:#202503242没有选中内容时
			if(len(self.text_screen.ids.Enlarge_Edit.text)>0):#如果文本窗口编辑框有内容
				ltexts = len(self.menu_screen.ids.Text_Edit.text)
				print("\t主窗口页的字数为(",ltexts,")")
				if(ltexts==0):#如果主窗口编辑框无内容<5
					strm = self.text_screen.ids.Enlarge_Edit.text
					print("\t头尾各50字为[",strm[:50],"]……[",strm[-50:],"]")
#					self.menu_screen.ids.Text_Edit.foreground_color = [0,0,0,1]#前景颜色
#					self.menu_screen.ids.Text_Edit.background_color = [0,1,1,1]#背景颜色
					self.menu_screen.ids.Text_Edit.text = strm
#					print(self.menu_screen.ids.Text_Edit.text)
					#将文本窗口内容传至主窗口，但没有显示？





#  23 10

	def CursorFore (self):#202503232光标后
		if(len(self.text_screen.ids.Enlarge_Edit.text)>0):
			self.text_screen.ids.Enlarge_Edit.do_cursor_movement(cursor_pgdown,control=False,alt=False)#Clipboard.cut()






# 10   10            (11974 0 0)

	def PasteStr (self):#202406122光标处通用[粘贴]功能
		strt=Clipboard.paste()
		print("粘贴出剪贴板的内容：[",strt.split('\n')[0],"……]")
		self.menu_screen.ids.Text_Edit.insert_text(strt)#20240612 text
		#self.menu_screen.ids.Text_Edit.text =''
		#self.menu_screen.ids.Text_Edit.text =strt



# 10 20            (11985 0 0)

	def PasteOut (self):#[全粘贴]功能，去除中间的空行，以兼容导入windows格式的应用文本
		if(len(self.menu_screen.ids.Line_Edit.text)==0): #20241229获取编辑行输入字符数，空时为全粘贴
			strt=Clipboard.paste()
			print("粘贴出剪贴板的原有内容：[",strt[:10],"……",strt[-10:],"]，附加去空行操作")
			ldt=len(strt)#202406242
			data1=''
			for i in range(0,ldt-1):
				if(not (strt[i]=='\n' and strt[i+1]=='\n')):
					data1 +=strt[i]
			data1 +=strt[ldt-1]
			strt = data1
			print("去空行后的剪贴板内容为:[",strt[:10],"……",strt[-10:],"]")
			self.menu_screen.ids.Text_Edit.text =''
			self.menu_screen.ids.Text_Edit.text =strt
		else:#20241229不空时为解密功能
			self.decrypt()



# 20 35            (11996 0 0)

	def BPasteOut (self):#20240719[合账贴]区分同时值时覆盖或忽略
		print("进入[合账贴]总模块")
		strt=Clipboard.paste()#获取粘贴板内容
		strtl = strt.split('\n')#202406242
		ns=len(strtl)#粘贴板行数
		print("\t按时序粘贴到位的剪贴板内容(",ns,")行包括：",strt[:20],"……")
		data=self.menu_screen.ids.Text_Edit.text#获取编辑框内容
		OverWriteP = False#20240727
		self.Line_str = self.menu_screen.ids.Line_Edit.text#20240729获取编辑行内容
		self.PInsertP = False
		if(len(self.Line_str)>0):#20240729如果编辑行有字符包括空格.strip()
			self.PInsertP = True
		print("编辑行字串为[",self.Line_str,"]串长(",len(self.Line_str),")粘贴备注判断：",self.PInsertP)
						
		
		for i in range (ns):
			li = len(strtl[i])
#			print("\t\t粘贴板第(",i,")行",end="")
			if(li>0):#排除空行
				strtl0 = strtl[i].split()[0]
				if(len(strtl0)==20):#20240720只操作首词可能为时间戳字数20的行(li==20):#
					if(self.OnlyTP(strtl0)):#20240720strtl[i]) ):#判断是否为时间戳
#				if(li==20):#只操作可能为时间戳字数20的行
#					if(self.OnlyTP(strtl[i]) ):#判断是否为时间戳
						if(data.find(strtl[i])>=0):#20240727
							OverWriteP = True
							break
		if(OverWriteP):#20240727
			self.Pop7()
		else:
			self.BPasteOutA()
						

					
# 35 256              (12017)
	def BPasteOutA (self):#20240604[合账贴]不覆盖模块，即[时序贴]功能，将外部世家导入到适当位置
		print("\n进入[合账贴]不覆盖模块")
		strt=Clipboard.paste()#获取粘贴板内容
		strtl = strt.split('\n')#202406242
		ns=len(strtl)#粘贴板行数
		print("\t按时序粘贴到位的剪贴板内容(",ns,")行包括：",strt[:20],"……")
		nR = 0# 统计记录条数，即时间戳数量
		data=self.menu_screen.ids.Text_Edit.text#获取编辑框内容
		datal = []#20240727
		nd = 0
		if(len(data)>0):
		
			datal = data.split('\n')
			nd=len(datal)#编辑框行数
			print("\t编辑框内容(",nd,")行包括：",data[:20],"……")#20240727
		
		ibegin = -1
		iend = ns-1
		insertP=False#202406252考虑有可能重复，重复时不粘贴判断
		insertBP=False#20240729当库纪录为空时的插入判断
		
		print("\t\t遍历粘贴板内容进行合账，")
			
		for i in range(ns):#遍历粘贴板行
			li = len(strtl[i])
#			print("\t\t粘贴板第(",i,")行(",li,")字",end="")
			if(li>=20):#20240802排除非时间戳行
				strtl0 = strtl[i].split()[0]
				if(len(strtl0)==20):#20240719只操作首词可能为时间戳字数20的行(li==20):#
					if(self.OnlyTP(strtl0)):#20240719strtl[i]) ):#判断是否为时间戳
						if(ibegin<0):#第一次遇到时间戳时
							ibegin = i#记录为起始行号
							pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#记录粘贴板时间值20240729strtl[i]
							print("\t\t合账贴的时间点为[",strtl0,"]时间值为(",pastotime,")发现本粘贴板内容始行号(",ibegin,")")#20240729strtl[i]
						else:#第二次及以后的时间戳，
							iend = i-1#记录前溯一行为终止行号
							print("\t\t\t粘贴板第(",nR,")条世家纪录内容终行号(",iend,")")
							jend = nd-1#世家终行序号，为总行数-1
							jbegin = 0
							for j in range(nd-1,-1,-1):#世家纪录文件倒数遍历到'-1'之前，即0
								lj=len(datal[j])#世家行的词数
								if(lj>=20):#20240802排除非时间戳行
									print("\t\t\t世家书(",j,")行[",datal[j],"]")
									strdl0 = datal[j].split()[0]#20240730
									if(len(strdl0)==20):#只操作首词字数为20的行，可能为时间戳20240730(lj==20)
										if(self.OnlyTP(strdl0) ):#判断世家行首词，是否为时间戳20240730datal[j]
											datatime =time.mktime(time.strptime(strdl0,"%Y年%m月%d日%H时%M分%S秒"))#记录世家行时间值20240730datal[j]
#											print("\t\t\t\t遍历世家的时间点为[",strdl0,"]时间值为(",datatime,")")#20240730datal[j]
											if(pastotime>datatime):#202406252修改>=为>，==表示重复，须跳过	当粘贴纪录位于世家纪录之后
												insertP=True#202406252判断准备粘贴
												print("\t\t\t\t合账时间点[",strtl0,"]值(",pastotime,")在库世家时间点值(",datatime,")后，准备插入[",datal[jend][:15],"……]之后")
												#20240729for k in range(ibegin,iend+1):#粘贴整条纪录

												if(self.PInsertP):#20240729
													print("插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]甲粘贴备注判断：",self.PInsertP)
													datal.insert(jend+1,strtl[ibegin]+' '+self.Line_str)
												else:
													print("插入(",jend+1,")行[",strtl[ibegin].split()[0],"]甲粘贴备注判断：",self.PInsertP)
													datal.insert(jend+1,strtl[ibegin].split()[0])													
												jend +=1		

												for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240729 ibegin
												
													datal.insert(jend+1,strtl[k])
													print("\t\t",strtl[k])
													jend +=1
#												print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
												nd += iend+1-ibegin
												jend = nd-1
												jbegin = 0
#												print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
												break
											elif(pastotime==datatime):#202406252==表示重复，须中断粘贴此项纪录
												#20240802insertP=False#20240630
												#20240802break#本条纪录中断寻找合适的时间点
												if(strtl[i]==datal[j]):#20240802确认时间行完全相同，则跳过，下文进格一档
													insertP=False#20240630
													break#本条纪录中断寻找合适的时间点
												else:
													insertP=True#判断准备覆盖粘贴，标记修改
													print("\t\t\t\t\t合账时间点值(",pastotime,")与世家时间点值(",datatime,")相同，准备覆盖[",datal[jend][:15],"……]之后")
													for k in range(jend,j-1,-1):
														print("\t\t删除(",k,")行[",datal[k],"]")
														datal.pop(k)
													nd -= jend+1-j
													jend = j-1
								
													if(self.PInsertP):#20240730
														print("插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]甲粘贴备注判断：",self.PInsertP)#20240801.split()[0]
														datal.insert(jend+1,strtl[ibegin].split()[0].split()[0]+' '+self.Line_str)#20240801.split()[0]
													else:
														print("插入(",jend+1,")行[",strtl[ibegin].split()[0],"]甲粘贴备注判断：",self.PInsertP)#20240801.split()[0]
														datal.insert(jend+1,strtl[ibegin].split()[0].strip())													
													jend +=1		
																						
													for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240730 ibegin
														datal.insert(jend+1,strtl[k])
														print("插入(",jend+1,")行[",strtl[k],"]")#20240801
														jend +=1
													print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
													nd += iend+1-ibegin
													jend = nd-1
													jbegin = 0
													print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
													break

											else:#当粘贴纪录位于世家纪录之前
												jend = j-1#记录世家的终行为本行之前一行
							
							if(jend<0):#20240727退格三档如果世家的终行位于所有纪录之前时
								insertP=True#202406252准备插入世家首行之前
								insertBP = True#20240729
								jend=0
								#print("\t\t\t合账时间已遍历世家，皆早于世家，准备插入首项[",datal[jend],"]之前")
								#20240729for k in range(ibegin,iend+1):#粘贴整条纪录
							if(insertBP):#20240729
								if(self.PInsertP):#20240729
									datal.insert(jend,strtl[ibegin].split()[0]+' '+self.Line_str)
								else:
									datal.insert(jend,strtl[ibegin].split()[0])													
								jend +=1												
								for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240729 ibegin

									datal.insert(jend,strtl[k])
#									print("\t\t",strtl[k])
									jend += 1
								print("\n\t\t\t(",nR,")条纪录合账前，世家行数为(",nd,")")#粘贴完成时输出换行
								nd += iend+1-ibegin
								jend = nd-1
								jbegin = 0
								print("\t\t\t(",nR,")条纪录合账后，世家行数为(",nd,")")
								#break#20240727

							ibegin = i
							nR += 1# 计入统计纪录组数
							strtl0 = strtl[i].split()[0]
							pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#20240729strtl[i]
							print("\t下一条合账贴的时间点为[",strtl0,"]时间值为(",pastotime,")")#20240729strtl[i]
		#strtl0 = strtl[i].split()[0]#20240804
		#pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#20240804
		print("粘贴板行数遍历循环结束后，序号i=(",i,"),粘贴板最大行号ns-1=(",ns-1,")，两者如相等，表示操作至粘贴板最后，即第(",nR,")纪录")
		print("\t\t合账贴的时间点为[",strtl0,"]时间值为(",pastotime,")发现本粘贴板内容始行号(",ibegin,")")#20240729strtl[i]
		if(i==ns-1):
			insertP=False#20240630True#202406252
			iend = ns-1
			jend = nd-1
			jbegin = 0
#			print("\t\t世家扫描")
			for j in range(nd-1,-1,-1):
				lj=len(datal[j])
#				print("\t\t第(",j,")行",end="")
				if(lj>0):
					sdatal0 = datal[j].split()[0]
					if(len(sdatal0)==20):#20240719只操作首词可能为时间戳字数20的行(li==20):#
						if(self.OnlyTP(sdatal0)):#20240719strtl[i]) ):#判断是否为时间戳

	#				if(lj==20):#20240719
	#					if(self.OnlyTP(datal[j]) ):#20240719
#							strtl0 = strtl[i].split()[0]#20240804
#							pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#20240804恢复
							datatime =time.mktime(time.strptime(sdatal0,"%Y年%m月%d日%H时%M分%S秒"))#20240719datal[j]
#							print("遍历世家的时间点为[",sdatal0,"]时间值为(",datatime,")")#20240719datal[j]
							if(pastotime>datatime):
								insertP=True#202406252
								print("\t\t\t\t合账时间点值(",pastotime,")在库世家时间点值(",datatime,")后，准备插入[",datal[jend][:15],"……]之后")
								#20240729for k in range(ibegin,iend+1):#粘贴整条纪录
								if(self.PInsertP):#20240729
									datal.insert(jend+1,strtl[ibegin].split()[0]+' '+self.Line_str)
								else:
									datal.insert(jend+1,strtl[ibegin].split()[0])													
								jend +=1												
								for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240729 ibegin
										
									datal.insert(jend+1,strtl[k])
#									print("\t\t",strtl[k])
									jend +=1
								
								print("\n\t\t\t(",nR,")条纪录合账前，世家行数为(",nd,")")#粘贴完成时输出换行
								nd += iend+1-ibegin
								jend = nd-1
								jbegin = 0
								print("\t\t\t(",nR,")条纪录合账后，世家行数为(",nd,")")
								break
							elif(pastotime==datatime):#202406252==表示重复，须中断粘贴此项纪录
								if(strtl[i]==datal[j]):#20240802确认时间行完全相同，则跳过，下文进格一档
									insertP=False#20240630
									break
								else:
									insertP=True#判断准备覆盖粘贴，标记修改
									print("\t\t\t\t\t合账时间点值(",pastotime,")与世家时间点值(",datatime,")相同，准备覆盖[",datal[jend][:15],"……]之后")
									for k in range(jend,j-1,-1):
										print("\t\t删除(",k,")行[",datal[k],"]")
										datal.pop(k)
									nd -= jend+1-j
									jend = j-1
								
									if(self.PInsertP):#20240730
										print("插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]甲粘贴备注判断：",self.PInsertP)#20240801.split()[0]
										datal.insert(jend+1,strtl[ibegin].split()[0].split()[0]+' '+self.Line_str)#20240801.split()[0]
									else:
										print("插入(",jend+1,")行[",strtl[ibegin].split()[0],"]甲粘贴备注判断：",self.PInsertP)#20240801.split()[0]
										datal.insert(jend+1,strtl[ibegin].split()[0].strip())													
									jend +=1		
																						
									for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240730 ibegin
										datal.insert(jend+1,strtl[k])
										print("插入(",jend+1,")行[",strtl[k],"]")#20240801
										jend +=1
									print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
									nd += iend+1-ibegin
									jend = nd-1
									jbegin = 0
									print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
									break

							else:
								jend = j-1
						if(jend<0):#20240727
							break
			
			if(jend<0):#20240727退格三档
				insertP=True#202406252
				jend=0
				#print("合账时间在遍历世家，准备插入[",datal[jend],"]之前")
				#20240729for k in range(ibegin,iend+1):#粘贴整条纪录
				if(self.PInsertP):#20240729
					datal.insert(jend,strtl[ibegin].split()[0]+' '+self.Line_str)
				else:
					datal.insert(jend,strtl[ibegin].split()[0])													
				jend +=1												
				for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240729 ibegin
												
					datal.insert(jend,strtl[k])
					print("\t\t",strtl[k],end="")
					jend +=1
				
				print("\n\t\t\t(",nR,")条纪录合账前，世家行数(",nd,")")#粘贴完成时输出换行
				nd += iend+1-ibegin
				jend = nd-1
				jbegin = 0
				print("\t\t\t(",nR,")条纪录合账后，世家行数为(",nd,")")
				
		if(insertP):#202406252
			datastr=""
			for datastrt in datal:
				datastr += 	datastrt+'\n'
			data = datastr[:-1]
			print("粘贴后字串：",data[:10],"……",data[-10:])
		self.menu_screen.ids.Text_Edit.text = data#20240719str[:-1]
		try:
			self.popup7.dismiss()#20240720
		except :#Nopop7 as alias
			print("There is no Popup7!")



# 256 246              (12053)
	def BPasteOutO (self):#20240719[合账贴]覆盖模块，覆盖相同时间行世家
		print("\n进入[合账贴]覆盖模块")
		strt=Clipboard.paste()#获取粘贴板内容
		strtl = strt.split('\n')#202406242
		ns=len(strtl)#粘贴板行数
		print("\t按时序粘贴到位的剪贴板内容(",ns,")行包括：",strt[:20],"……")
		nR = 0# 统计记录条数，即时间戳数量
		data=self.menu_screen.ids.Text_Edit.text#获取编辑框内容
		datal = data.split('\n')
		nd=len(datal)#编辑框行数
		ibegin = -1
		iend = ns-1
		insertP=False#202406252考虑有可能重复，重复时不粘贴判断
		insertBP=False#20240801当库纪录为空时的插入判断

		print("\t\t从粘贴板内容进行合账，")
		for i in range(ns):#遍历粘贴板行
			li = len(strtl[i])
#			print("\t\t粘贴板第(",i,")行",end="")
			if(li>=20):#20240802排除非时间戳行
				strtl0 = strtl[i].split()[0]
				if(len(strtl0)==20):#20240719只操作首词可能为时间戳字数20的行(li==20):#
					if(self.OnlyTP(strtl0)):#20240719strtl[i]) ):#判断是否为时间戳
						if(ibegin<0):#第一次遇到时间戳时
							ibegin = i#记录为起始行号
							pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#记录粘贴板时间值20240730 strtl[i]
							print("\t\t合账贴的时间戳行为[",strtl[i],"]时间值为(",pastotime,")发现本纪录始行号(",ibegin,")")
						else:#第二次及以后的时间戳，
							iend = i-1#记录前溯一行为终止行号
							print("\t\t\t粘贴板第(",nR,")条世家纪录终行号(",iend,")")
							jend = nd-1#世家终行序号，为总行数-1
							jbegin = 0
							for j in range(nd-1,-1,-1):#编辑框库世家纪录倒数遍历到'-1'之前，即0
								#jend=j#202408022标记库纪录末行
								lj=len(datal[j])#世家行的字数
								if(lj>=20):#20240802排除非时间戳行
									print("\t\t\t库世家(",j,")行[",datal[j],"]")
									strdl0 = datal[j].split()[0]#20240730
									if(len(strdl0)==20):#只操作首词字数为20的行，可能为时间戳20240730(lj==20)
										if(self.OnlyTP(strdl0) ):#判断世家行首词，是否为时间戳20240730datal[j]
											jbegin = j#202408022标记库纪录首行
											print("\t\t\t\t库纪录首行号(",jbegin,")尾行号(",jend,")")
											datatime =time.mktime(time.strptime(strdl0,"%Y年%m月%d日%H时%M分%S秒"))#记录世家行时间值20240730datal[j]
											print("\t\t\t\t遍历库世家的时间点为[",strdl0,"]时间值为(",datatime,")")#20240730datal[j]
											if(pastotime>datatime):#202406252修改>=为>，==表示重复，须跳过	当粘贴纪录位于世家纪录之后
												if(self.Line_str!="笈智删除"):#202408022编辑行不为删除命令时再插入，下文进一档
													insertP=True#202406252判断准备粘贴
													print("\t\t\t\t合账时间点[",strtl[ibegin].split()[0],"]，值(",pastotime,")，在库世家时间点值(",datatime,")后，准备插入[",datal[jend][:15],"……]之后")
													if(self.PInsertP):#20240729
														print("插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]乙粘贴备注判断：",self.PInsertP)
														datal.insert(jend+1,strtl[ibegin].split()[0]+' '+self.Line_str)
													else:
														print("插入(",jend+1,")行[",strtl[ibegin].split()[0],"]乙粘贴备注判断：",self.PInsertP)
														datal.insert(jend+1,strtl[ibegin].split()[0].strip())													
												
													jend +=1		
																						
													for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240730 ibegin
														datal.insert(jend+1,strtl[k])
														print("\t\t",strtl[k])
														jend +=1
													print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
													nd += iend+1-ibegin
													jend = nd-1
													jbegin = 0
													print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
												break
											elif(pastotime==datatime):#20240719==表示重复，须粘贴此项纪录且覆盖之前纪录
												print("\t\t\t\t合账时间点[",strtl0,"]值(",pastotime,")与库世家时间点值(",datatime,")相同，如备注相同则覆盖，如备注不同则插入其后")
												if(strtl[ibegin]==datal[j]):#20240802确认时间行完全相同再覆盖，下进格一档
													print("\t\t\t\t时间戳行完全相同，先倒序删除旧行(",jend,")到(",jbegin,")，再插入新行，实现覆盖")
													insertP=True#202406252判断准备粘贴，修改标记
													print("\t\t\t\t\t合账时间点值(",pastotime,")与世家时间点值(",datatime,")相同，准备倒序删除覆盖[",datal[jend][:15],"……]之前")
													for k in range(jend,jbegin-1,-1):#20240730*202408022j-1
														print("\t\t删除(",k,")行[",datal[k],"]")
														datal.pop(k)
													nd -= jend+1-jbegin
													jend = jbegin-1#202408022 j
													
													if(self.Line_str!="笈智删除"):#202408022编辑行不为删除命令时再插入，下文进一档
														if(self.PInsertP):#20240729
															print("\t\t未删插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]乙粘贴备注判断：",self.PInsertP)
															datal.insert(jend+1,strtl[ibegin].split()[0]+' '+self.Line_str)
														else:
															print("\t\t未删插入(",jend+1,")行[",strtl[ibegin].split()[0],"]乙粘贴备注判断：",self.PInsertP)
															datal.insert(jend+1,strtl[ibegin].split()[0].strip())													
												
														jend +=1		
																						
														for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240730 ibegin
															datal.insert(jend+1,strtl[k])
															print("\t\t插入(",jend+1,")行[",strtl[k],"\n\t\t\tdatal(",jend+1,")[",datal[jend+1],"]")#2040801
															jend +=1
															
														print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
														nd += iend+1-ibegin
														jend = nd-1
														jbegin = 0
														print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
														break
													#	insertP=False#20240719
													#	break#本条纪录中断寻找合适的时间点
													else:
														print("\t\t\t编辑行字串为[",self.Line_str,"]，当为‘笈智删除’命令时，不插入库世家(",ibegin,")到(",iend,")行")
												else:#20240802确认时间行不完全相同，略过
													print("\t\t\t\t时间戳行不完全相同，略过")
											
											else:#当粘贴纪录位于世家纪录之前20240801
												jend = j-1#记录世家的终行为本行之前一行
											jend=j-1#202408022标记库纪录末行

							if(jend<0):#20240727退格三档如果世家的终行位于所有纪录之前时
								insertP=True#202406252准备插入世家首行之前
								insertBP = True#20240729
								jend=0
								#print("\t\t\t合账时间已遍历世家，皆早于世家，准备插入首项[",datal[jend],"]之前")
								#20240729for k in range(ibegin,iend+1):#粘贴整条纪录
							if(insertBP):#20240729当库世家为空时
								if(self.PInsertP):#20240729
									datal.insert(jend,strtl[ibegin].split()[0]+' '+self.Line_str)
								else:
									datal.insert(jend,strtl[ibegin].split()[0])													
								jend +=1												
								for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240729 ibegin

									datal.insert(jend,strtl[k])
#									print("\t\t",strtl[k])
									jend += 1
								print("\n\t\t\t(",nR,")条纪录合账前，世家行数为(",nd,")")#粘贴完成时输出换行
								nd += iend+1-ibegin
								jend = nd-1
								jbegin = 0
								print("\t\t\t(",nR,")条纪录合账后，世家行数为(",nd,")")
								#break#20240727
								
							ibegin = i
							nR += 1# 计入统计记录条数
							strtl0 = strtl[i].split()[0]#20240801
							#strdl0 = datal[j].split()[0]#20240801
							pastotime=time.mktime(time.strptime(strtl0,"%Y年%m月%d日%H时%M分%S秒"))#20240801strtl[i]
							print("\t下一条合账贴的时间点为[",strtl0,"]时间值为(",pastotime,")")#20240801strtl[i]
		print("粘贴板行数遍历循环结束后，序号i=(",i,"),粘贴板最大行号ns-1=(",ns-1,")，两者如相等，表示操作至粘贴板最后，即第(",nR,")纪录")
		if(i==ns-1):
			insertP=False#20240630True#202406252
			iend = ns-1
			jend = nd-1
			jbegin = 0
#			print("\t\t世家扫描")
			for j in range(nd-1,-1,-1):
				lj=len(datal[j])
#				print("\t\t第(",j,")行",end="")
				if(lj>0):
					sdatal0 = datal[j].split()[0]
					if(len(sdatal0)==20):#20240719只操作首词可能为时间戳字数20的行(li==20):#
						if(self.OnlyTP(sdatal0)):#20240719strtl[i]) ):#判断是否为时间戳
							jbegin = j+1#202408022标记库纪录首行

	#				if(lj==20):
	#					if(self.OnlyTP(datal[j]) ):
							datatime =time.mktime(time.strptime(sdatal0,"%Y年%m月%d日%H时%M分%S秒"))#20240719datal[j]
#							print("遍历世家的时间点为[",sdatal0,"]时间值为(",datatime,")")#20240719datal[j]
							if(pastotime>datatime):
								if(self.Line_str!="笈智删除"):#202408022编辑行不为删除命令时再插入，下文进一档
									insertP=True#202406252
									print("\t\t\t\t合账时间点值(",pastotime,")在库世家时间点值(",datatime,")后，准备插入[",datal[jend][:15],"……]之后")
									for k in range(ibegin,iend+1):
										datal.insert(jend+1,strtl[k])
										print("\t\t",strtl[k])
										jend +=1
									print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
									nd += iend+1-ibegin
									jend = nd-1
									jbegin = 0
									print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
								break
							elif(pastotime==datatime):#20240719==表示重复，，须粘贴此项纪录且覆盖之前纪录
								if(strtl[ibegin]==datal[j]):#20240802确认时间行完全相同再覆盖，下进格一档
									insertP=True#202406252判断准备粘贴
									print("\t\t\t\t\t合账时间点值(",pastotime,")与世家时间点值(",datatime,")相同，准备覆盖[",datal[jend][:15],"……]之后")
									for k in range(jend,j-1,-1):
										print("\t\t删除(",k,")行[",datal[k],"]")
										datal.pop(k)
									nd -= jend+1-j
									jend = j-1
								
									if(self.Line_str!="笈智删除"):#202408022编辑行不为删除命令时再插入，下文进一档
										if(self.PInsertP):#20240730
											print("插入(",jend+1,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]粘贴备注判断：",self.PInsertP)#20240801.split()[0]
											datal.insert(jend+1,strtl[ibegin].split()[0].split()[0]+' '+self.Line_str)#20240801.split()[0]
										else:
											print("插入(",jend+1,")行[",strtl[ibegin].split()[0],"]粘贴备注判断：",self.PInsertP)#20240801.split()[0]
											datal.insert(jend+1,strtl[ibegin].split()[0].strip())													
										jend +=1		
																						
										for k in range(ibegin+1,iend+1):#粘贴整条纪录#20240730 ibegin
											datal.insert(jend+1,strtl[k])
											print("插入(",jend+1,")行[",strtl[k],"]")#20240801
											jend +=1
										print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
										nd += iend+1-ibegin
										jend = nd-1
										jbegin = 0
										print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
									else:
										print("\t\t\t编辑行字串为[",self.Line_str,"]，当为‘笈智删除’命令时，不插入库世家(",ibegin,")到(",iend,")行")
									
									break
							#		insertP=False#20240630
							#		break
							else:
								jend = j-1
							jend= j-1#202408022
						if(jend<0):
							insertP=True#202406252
							jend=0
							print("合账时间在遍历世家，准备插入[",datal[jend],"]之前")
								
							if(self.PInsertP):#20240730
								print("插入(",jend,")行[",strtl[ibegin].split()[0]+' '+self.Line_str,"]粘贴备注判断：",self.PInsertP)#20240801.split()[0]
								datal.insert(jend,strtl[ibegin].split()[0]+' '+self.Line_str)#20240801.split()[0]
							else:
								print("插入(",jend,")行[",strtl[ibegin].split()[0],"]粘贴备注判断：",self.PInsertP)#20240801.split()[0]
								datal.insert(jend,strtl[ibegin].split()[0].strip())	#20240801.split()[0]	20240804.strip() 										
							jend +=1		
																						
							for k in range(ibegin+1,iend+1):#20240717 iend#20240730 ibegin
								datal.insert(jend,strtl[k])
								print("插入(",jend+1,")行[",strtl[k],"]")#20240801
								jend +=1
							print("\n\t\t\t(",nR,")条纪录合账前，世家数量为(",nd,")")#粘贴完成时输出换行
							nd += iend+1-ibegin
							jend = nd-1
							jbegin = 0
							print("\t\t\t(",nR,")条纪录合账后，世家数量为(",nd,")")
							break
		if(insertP):#202406252
			datastr=""
			for datastrt in datal:
				datastr += 	datastrt+'\n'
			data = datastr[:-1]
			print("粘贴后字串：",data[:10],"……",data[-10:])
		self.menu_screen.ids.Text_Edit.text = data#20240719str[:-1]
		self.popup7.dismiss()



# 246 55             (12299)
	def passok (self):#20240823密码运行确认
		print("\n进入弹出框密码输入确认模块passok")
		ptext = self.popup8.ids['Pass_Edit'].text
		print("弹出框输入密码为：[",ptext,"]，笈文本密码[",self.PassWdText,"]菜单文件名[",self.PassFile,"]")#self.
		
		if(self.PassWdText==ptext):
			print("\t\t\t\t弹出框输入密码与笈文本密码相同")
			self.MenuFile = self.PassFile#20241013
			filename = self.MenuFile
			if(filename):#20240823如果文件名非空，下格式增一档
				sonpath=os.path.join(os.getcwd(),"src",filename)#925mypath=
				print("\t\tSelectableLabel点中非顶行时，准备打开文件[",sonpath,"]")
#				self.menu_screen.ids.Text_Edit.text += "RunUp准备打开文件["+sonpath+"]\n"#20240807
				MenuScreen.fileName_choose= sonpath

				y=MenuScreen()
				if(y.col2):
					self.menu_screen.ids.RV_List.data = y.col2 #
					#20240806
					MenuScreen.Ignore=y.Ignore
					MenuScreen.ExpMode = y.ExpMode
					MenuScreen.lViewList=y.lViewList
					MenuScreen.ViewList=y.ViewList
					MenuScreen.Expbackstep=y.Expbackstep
					MenuScreen.Expforestep=y.Expforestep
					MenuScreen.Expbnow=0#
					MenuScreen.Expfnow=0
	
					self.FirstLine("点[向前]开始阅读；点[阅读]、[向前]开始运行")
					print("\n\tpassok判断",MenuScreen.ExpMode,"为专用格式文件！专用格式忽略(",MenuScreen.Ignore,")字")	
					print("\tpassok文件初打开，回跳行号",MenuScreen.Expbnow,"回跳步长：",MenuScreen.Expbackstep,"前跳行号",MenuScreen.Expfnow,"前跳步长：",MenuScreen.Expforestep)	

					skiP = False#20241009
					ll = MenuScreen.lViewList#20240927考虑文本内以密码分级时跳过全页
					lViewList = ll
					for i in range(ll):
						if(MenuScreen.ViewList[i].find('"密码：')>=0 and MenuScreen.ViewList[i].find('.find(')<0):#20241018):
							#MenuScreen.lViewList = i+1#密码设置行后不可见，行数比行号大1#20241013因手机运行不稳而取消
							skiP = True
							print("\t\t发现文内密码设置，直接跳至分页(",MenuScreen.Expbnow,")")
							#self.menu_screen.ids.Line_Edit.text = "发现文内密码设置，直接跳至分页"+str(MenuScreen.Expbnow)#20241009
							break
					if skiP:
						self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#刷新屏幕直接进入分页首页
						
		self.popup8.dismiss()
#		else:
#			self.MenuFile = ""
#			print("\t\t\t\t弹出框输入密码与笈文本密码不同，返回菜单文件名[",self.MenuFile,"]")
#		self.popup8.dismiss()
#		try:
#			self.popup8.dismiss()
#		except :#Nopop8 as alias
#			print("\t不在弹出框popup8状态!")
	
#  55 14

	def Bpassok (self):#20240926文本内容密码运行确认
		print("进入文本内容阅读弹出框密码输入确认模块")
		ptext = self.popup8b.ids['Pass8b_Edit'].text
		print("\t弹出框输入密码为：[",ptext,"]，笈文本内容密码[",self.PassWdText,"]")
		
		if(self.PassWdText==ptext):
			print("\t\t\t\t弹出框输入密码与笈文本内容密码相同")
			MainApp.CPassP = False#20241011self
			MainApp.ToForward(self)#20241011
		self.popup8b.dismiss()
		


# 14  11             (12602)

	def pass3aok (self):#202408243
		print("进入弹出框确认密码输入模块")
		ptext = self.popup3a.ids['Pass3a_Edit'].text
		print("弹出框输入密码为：[",ptext,"]，笈文本密码[",self.PassWdText,"]菜单文件名[",self.MenuFile,"]")
		if(self.PassWdText==ptext):
			print("\t\t\t\t弹出框输入密码与笈文本密码相同，故覆盖原文件")
			self.WriteTesta()
		self.popup3a.dismiss()
		

# 11 10               (12617 0)
	def pass5aok (self):#202408243
		print("进入弹出框确认密码改名模块")
		ptext = self.popup5a.ids['Pass5a_Edit'].text
		print("弹出框输入密码为：[",ptext,"]，笈文本密码[",self.PassWdText,"]菜单文件名[",self.MenuFile,"]")
		if(self.PassWdText==ptext):
			print("\t\t\t\t弹出框输入密码与笈文本密码相同，故原文件改名")
			self.RenameTesta()
		self.popup5a.dismiss()
		

# 10 21               (12629)
	def pass9ok (self):#20240825*
		print("进入弹出框确认密码显示模块")
		ptext = self.popup9.ids['Pass9_Edit'].text
		print("弹出框输入密码为：[",ptext,"]，笈文本密码[",self.PassWdText,"]菜单文件名[",self.MenuFile,"]")
		if(self.PassWdText==ptext):
			print("\t\t\t\t弹出框输入密码与笈文本密码相同，故显示原文件")
			mypath=os.path.join(os.getcwd(),"src",self.MenuFile)#20240825

			if(os.path.exists(mypath)):
				ld1=os.path.getsize(mypath)#文件大小
				if(ld1>0):
					fh=open(mypath,mode='r+t',encoding='UTF-8')
					if fh:
						fh.seek(0)
						data=fh.read()#读入文件
						self.menu_screen.ids.Text_Edit.text = data[:-1]#编辑框显示文件
						fh.close()
		self.popup9.dismiss()

		

# 21 9               (12640)
	def passno (self):#20240823
		print("进入弹出框取消密码输入模块")
		self.MenuFile = ""
		ptext = self.popup8.ids['Pass_Edit'].text
		print("弹出框输入密码为：[",ptext,"]，笈文本密码[",self.PassWdText,"]菜单文件名[",self.MenuFile,"]")
		self.popup8.dismiss()


		
# 9 21             (12662)
	def rsa_decrypt_binfile (self,file_path,save_path,priv_key):#202408302
		'''
		rsa 解密二进制文件
		:param file_path:需要解密的文件路径
		:param save_path:解密之后存放的文件路径
		:param priv_key: 私钥
		'''
		random_generator = Random.new().read#此句杂加，存疑
		print("伪随机数：",random_generator)
		with open(file_path,"rb") as f :
			line = f.readline()
			while line:
				message = base64.b64decode(line.strip(b"\n"))
				rsakey = RSA.importKey(priv_key)
				cipher = Cipher_pkcs1_v1_5.new(rsakey)
				plaintext = cipher.decrypt(message,random_generator)
				with open(save_path,"ab+") as w :
					w.write(plaintext)
				line = f.readline()		
				
	
#   21 43           (12672)

	def rsa_decrypt_textedit (self,priv_key):#rsa编辑框解密
		'''
		rsa 解密二进制文本
		:param file_path:需要解密的文件路径
		:param save_path:解密之后存放的文件路径
		:param priv_key: 私钥存放的文件路径
		'''
		print("\n进入解密模块rsa_decrypt_binfile")
		random_generator = Random.new().read#此句杂加，存疑
		print("伪随机数：",random_generator)
		file_path=os.path.join(os.getcwd(),"src/Temp0.txt")#os.path.expanduser('~'),self.LocalPath
		save_path=os.path.join(os.getcwd(),"src/Temp.txt")#os.path.expanduser('~'),self.LocalPath
		with open(save_path,"wt") as w :#20241208若文件存在
			w.write("")#20241208清空原文件
			
		data = self.menu_screen.ids.Text_Edit.text#self.ui.textEdit.toPlainText()#读取编辑框中字符
		with open(file_path,"wt") as w :#20241208若文件存在
			w.write(data)#20241208清空原文件

		with open(file_path,"rb") as f :
			line = f.readline()
			while line:
				message = base64.b64decode(line.strip(b"\n"))
				rsakey = RSA.importKey(priv_key)
				cipher = Cipher_pkcs1_v1_5.new(rsakey)
				plaintext = cipher.decrypt(message,random_generator)
				with open(save_path,"ab+") as w :#20241208
					w.write(plaintext)
				line = f.readline()		
			print("\n解密文件[",save_path,"]完成")
		with open(save_path,mode='r+t',encoding='UTF-8') as r :#202412172
			data =r.read()
		with open(save_path,"wt") as w :
			w.write("")#清空临时文件
		with open(file_path,"wt") as w :
			w.write("")#清空原文件
		self.menu_screen.ids.Text_Edit.text = data#20241229
#		self.ui.textEdit.clear()#显示#20241229
#		self.ui.textEdit.append(data)#20241229
#		self.show()#20241229
	

# 43 35           (12694)

	def decrypt (self):#20241229编辑框解密操作
		print("\n进入编辑框解密操作模块decrypt")#，字串[",string,"]
		mystr2= self.menu_screen.ids.Line_Edit.text#20241229self.ui.textEdit_2.toPlainText()
		linel = mystr2.split()
		if(len(mystr2)>0):#20241227(len(linel)>1):
			string = linel[-1]#20241227linel[1]
			if(string.find('Test')>=0):#202503272限制手机私钥文件名
				if(string.find('.prv')>=0):
					prv_path = os.path.join(os.getcwd(),"src",string)#私钥文件路径20241229os.path.expanduser('~'),self.LocalPath
				else:
					prv_path = os.path.join(os.getcwd(),"src",string+".prv")#私钥文件路径20241229os.path.expanduser('~'),self.LocalPath	
			else:
				prv_path = os.path.join(os.getcwd(),"src","Test0.prv")#默认私钥文件路径
			print("\t\t\t编辑行私钥文件为[",prv_path,"]")
			if(os.path.isfile(prv_path)):#如果私钥文件存在
				print("\t\t\t\t发现私钥文件[",prv_path,"]")
				P_keyP = False
				with open(prv_path,"r+t") as f :#20240831"rb"
					prv_key = f.read()
					if(prv_key.find("-----BEGIN RSA PRIVATE KEY-----")==0):
						P_keyP = True
						print("\t\t\t\t\t确认找到私钥文件")
				if(P_keyP):
					with open(prv_path,"rb") as f :
						prv_key = f.read()
					self.rsa_decrypt_textedit(prv_key)	








# 35 38             (12738)

	def rsa_encrypt_binfile (self,file_path,save_path,pub_key):#202408302
		'''
		#202408302 https://www.jb51.net/article/203230.htm
		rsa 加密二进制文件
		:param file_path:需要加密的文件路径
		:param save_path:加密之后存放的文件路径
		:param pub_key: 公钥
		'''
		with open(file_path,'rb') as f:
			message = f.read()
		length = len(message)
		default_length = 117 #1024/8-11 1024为密钥长度
		rsakey = RSA.importKey(pub_key)
		cipher = Cipher_pkcs1_v1_5.new(rsakey)
		result = []
		if(length <= default_length):#不需要切分
			result.append(base64.b64encode(cipher.encrypt(message)))
		else:#需要切分
			offset = 0
			while length - offset >0:
				if length - offset > default_length:
					result.append(base64.b64encode(cipher.encrypt(message[offset:offset+default_length])))
				else:
					result.append(base64.b64encode(cipher.encrypt(message[offset:])))
				offset += default_length
				
		with open(save_path,"ab+") as w :
			for ciphertext in result:
				ciphertext += b"\n"
				w.write(ciphertext)







# 38 60             (12774)

	def rsa_encrypt_textedit (self,pub_key):#编辑框加密
		'''
		#202408302 https://www.jb51.net/article/203230.htm
		rsa 加密二进制文件
		:param file_path:需要加密的文件路径
		:param save_path:加密之后存放的文件路径
		:param pub_key: 公钥
		'''
		print("\n进入加密模块rsa_encrypt_binfile")
		file_path=os.path.join(os.getcwd(),"src/Temp0.txt")
		save_path=os.path.join(os.getcwd(),"src/Temp.txt")
		with open(save_path,"wt") as w :#20241208若文件存在
			w.write("")#20241208清空加密后文件

		data=self.menu_screen.ids.Text_Edit.text#20241229self.ui.textEdit.toPlainText()#读取编辑框中字符
		with open(file_path,"wt") as w :#20241208若文件存在
			w.write(data)#20241208清空加密前文件

		with open(file_path,'rb') as f:
			message = f.read()
		length = len(message)
		default_length = 117 #1024/8-11 1024为密钥长度
		rsakey = RSA.importKey(pub_key)
		cipher = Cipher_pkcs1_v1_5.new(rsakey)
		result = []
		if(length <= default_length):#不需要切分
			result.append(base64.b64encode(cipher.encrypt(message)))
		else:#需要切分
			offset = 0
			while length - offset >0:
				if length - offset > default_length:
					result.append(base64.b64encode(cipher.encrypt(message[offset:offset+default_length])))
				else:
					result.append(base64.b64encode(cipher.encrypt(message[offset:])))
				offset += default_length
				
		with open(save_path,"ab+") as w :
			for ciphertext in result:
				ciphertext += b"\n"
				w.write(ciphertext)
			print("\n加密文件[",save_path,"]完成")

		with open(save_path,mode='r+t',encoding='UTF-8') as r :#202412172
			data =r.read()
		with open(save_path,"wt") as w :
			w.write("")#清空临时文件
		with open(file_path,"wt") as w :
			w.write("")#清空原文件
		self.menu_screen.ids.Text_Edit.text = data#20241229
#		self.ui.textEdit.clear()#显示#20241229
#		self.ui.textEdit.append(data)#20241229
#		self.show()#20241229







# 60 35            (12813)

	def encrypt (self):#20241229编辑框加密操作
		print("\n进入编辑框加密操作模块encrypt")#，字串[",string,"]
		mystr2= self.menu_screen.ids.Line_Edit.text#20241229self.ui.textEdit_2.toPlainText()
		linel = mystr2.split()
		if(len(mystr2)>0):#20241227(len(linel)>1):
			string = linel[-1]#20241227linel[1]
			if(string.find('Test')>=0):#202503272限制手机公钥文件名
				if(string.find('.pub')>=0):
					pub_path = os.path.join(os.getcwd(),"src",string)#公钥文件路径os.path.expanduser('~'),self.LocalPath,
				else:
					pub_path = os.path.join(os.getcwd(),"src",string+".pub")#公钥文件路径os.path.expanduser('~'),self.LocalPath,	
			else:
				pub_path = os.path.join(os.getcwd(),"src","Test0.pub")#公钥文件路径
			print("\t\t\t编辑行公钥文件路径为[",pub_path,"]")
			if(os.path.isfile(pub_path)):#如果公钥文件存在
				print("\t\t\t\t找到公钥文件[",pub_path,"]")
				P_keyP = False
				with open(pub_path,"r+t") as f :#20240831"rb"
					pub_key = f.read()
					if(pub_key.find("-----BEGIN PUBLIC KEY-----")==0):
						P_keyP = True
						print("\t\t\t\t\t确认找到公钥文件")
				if(P_keyP):
					with open(pub_path,"rb") as f :
						pub_key = f.read()
					self.rsa_encrypt_textedit(pub_key)








# 35 16           (12874 0)

	def ReadingSet (self):#阅读屏幕设置
		print("进入阅读屏幕设置模块")
		MainApp.LineChars = int((Window.width-360)/540)+19#20200910适配华为mate10改为19#20240902适配青春版720-16dp6.09吋20 self.LineChars 1080-18dp6.67吋23
		Hfont = self.menu_screen.ids.RV_List.font_size
		#MainApp.LineChars = int(Window.width/float(Hfont)/1.15-6)#20240903适配青春版720-16dp6.09吋 满27 表20 self.LineChars 1080-18dp6.67吋 满27 表21
		print("进入主程序窗口设置，宽度为(",Window.width,")字高(",Hfont,")，行字数(",MainApp.LineChars,")")#20240829s
		#self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#刷新屏幕
		self.reading_screen.ids.RV_Title.text = self.menu_screen.ids.RV_Title.text#20240905







# 16 15            (12910 0)
		
	def MenuSet (self):#主屏幕设置
		print("进入主屏幕设置模块")
		MainApp.LineChars = int((Window.width-360)/540)+15#20240902适配青春版720-16dp6.09吋20 self.LineChars 1080-18dp6.67吋23
		Hfont = self.menu_screen.ids.RV_List.font_size
		#MainApp.LineChars = int(Window.width/float(Hfont)/1.15-11)#20240903适配青春版720-16dp6.09吋 满27 表20 self.LineChars 1080-18dp6.67吋 满27 表21
		print("进入主程序窗口设置，宽度为(",Window.width,")字高(",Hfont,")，行字数(",MainApp.LineChars,")")#20240829s
		#self.ExpView(MenuScreen.Expbnow,MenuScreen.Expfnow)#刷新屏幕






		
# 15 9              (12927 0)

	def Enlarge (self):#20240904文本窗口放大字体
		print("进入放大字体模块")
		self.texthi += 5
		self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503282
		self.menu_screen.ids.Line_Edit.font_size = self.texthi
		self.text_screen.ids.Enlarge_Edit.font_size = self.texthi

		
#  9 79            (13935 0)

	def TopCursor (self):#20241030文本窗口光标翻页
		print("\n进入光标定位模块TopCursor")
		step = 10
#		stepmax = 30
		strt = self.text_screen.ids.Enlarge_Edit.text#202504022
		ls = len(strt)
		
		if(ls>0):#202503242
			stepmax = len(strt.split('\n'))#20250415 50
		
			tpmax = self.text_screen.ids.Enlarge_Edit.get_cursor_from_index(ls)
			#202504022从字符索引，获取光标最大值
			ymax = int(tpmax[1])
			tpnow = self.text_screen.ids.Enlarge_Edit.cursor#_pos#光标当前位置
			print("\t\ttpmax",tpmax,",tpnow",tpnow)
			xnow = int(tpnow[0])
			ynow = int(tpnow[1])
			strm = self.menu_screen.ids.Line_Edit.text#202504022
			AddP = True
			if(len(strm)>0):
				strm = strm.split()[0]
				if(strm[0] == '-' or strm[0] == '－'):
#					if(ynow>10):
					AddP = False
					if(strm[1:].isdigit()):
						step = int(strm[1:])#20250415	si
						si = int(strm[1:])
#						if(si<stepmax):
#							step = si
				elif(strm[0] == '+' or strm[0] == '＋'):#20250412
					AddP = True
					if(strm[1:].isdigit()):
						step = int(strm[1:])#20250415	si
						
				else:
					if(strm.isdigit()):
						step = int(strm)#20250415	si
#						si = int(strm)
#						if(si<stepmax):
#							step = si
			if AddP:
				ynow += step#光标一次上移10行
				if(ynow>ymax):
					if(ynow<ymax+step):
						ynow = ymax
					elif(ynow == ymax+step):
						ynow = 0
			else:
				ynow -= step#光标一次上移10行
				if(ynow<0):
					if(ynow>-step):
						ynow = 0
					elif(ynow == -step):
						ynow = ymax
			tpnxt = (xnow,ynow)
			print("\t\t\ttpnxt",tpnxt)
			self.text_screen.ids.Enlarge_Edit.cursor = tpnxt#一页29～38行
			
		else:#202503242如果文本窗口编辑框没有内容时，配合主窗口编辑行，生成结果文件
			Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#0501
#			print("准备打开摘引文件：",Indexpath)#20250320WinPath
			f=open(Indexpath,mode='r+t',encoding='UTF-8')#打开摘引文件
			if f:
				f.seek(0)#注意读取文件时候要将文件指针指向第一个
				s=f.read()
				mylist = s.split("\n")#含完整的文件路径
				f.close()#关闭摘引文件
				strt=mylist[1]#提取第二行内容为文件名
#				print("摘引文件指向的母版文件：",strt)
				locfile=os.path.join(os.getcwd(),strt)
				self.DispIndex(locfile,mylist,3)
	






#  79 64            (13945 0)

	def NxtCursor (self):#202504024主窗口光标翻页
		print("\n进入光标定位模块TopCursor")
		step = 4
		strt = self.menu_screen.ids.Text_Edit.text#202504024
		ls = len(strt)
		
		if(ls>0):
			stepmax = len(strt.split('\n'))#20250415 50
			tpmax = self.menu_screen.ids.Text_Edit.get_cursor_from_index(ls)
			#202504024从字符索引，获取光标最大值
			ymax = int(tpmax[1])
			tpnow = self.menu_screen.ids.Text_Edit.cursor#_pos#光标当前位置
			print("\t\ttpmax",tpmax,",tpnow",tpnow)
			xnow = int(tpnow[0])
			ynow = int(tpnow[1])
			strm = self.menu_screen.ids.Line_Edit.text
			AddP = False#20250412改为上翻页	True
			if(len(strm)>0):
				strm = strm.split()[0]#取编辑行首词
				if(strm[0] == '-' or strm[0] == '－'):
					AddP = False
					if(strm[1:].isdigit()):
						step = int(strm[1:])#20250415	si
#						if(si<stepmax):
#							step = si

				elif(strm[0] == '+' or strm[0] == '＋'):#20250412
					AddP = True
					if(strm[1:].isdigit()):
						step = int(strm[1:])#20250415	si
#						si = int(strm[1:])
#						if(si<stepmax):
#							step = si
				else:
					if(strm.isdigit()):
						step = int(strm)#20250415	si
#						si = int(strm)
#						if(si<stepmax):
#							step = si
			if AddP:
				ynow += step#光标一次上移5行
				if(ynow>ymax):
					if(ynow<ymax+step):
						ynow = ymax
					elif(ynow == ymax+step):
						ynow = 0
			else:
				ynow -= step#光标一次上移10行
				if(ynow<0):
					if(ynow>-step):
						ynow = 0
					elif(ynow == -step):
						ynow = ymax
			tpnxt = (xnow,ynow)
			print("\t\t\ttpnxt",tpnxt)
			self.menu_screen.ids.Text_Edit.cursor = tpnxt#一页9～8行
			






#  64 11            (14025 0)

	def ClearT (self):#202503305文本窗口清空
		self.text_screen.ids.Enlarge_Edit.text = ""







		
# 11    11              (13098 0)
		
	def Minish (self):#20240904文本窗口缩小字体
		print("进入缩小字体模块")
		self.texthi -= 5
		self.menu_screen.ids.Text_Edit.font_size = self.texthi#202503282
		self.menu_screen.ids.Line_Edit.font_size = self.texthi
		self.text_screen.ids.Enlarge_Edit.font_size = self.texthi




# 11 50             (13110 0)

	def PopComment (self,linenow):#202409233弹出品鉴
		print("\t\t\t进入弹出品鉴模块，品鉴模式已开启，模块SelectableLabel正在扫描行号(",SRV.Sline,")")
		chs = 3
		#linenow = MenuScreen.Expbnow+int(SRV.Sline)
		s=MenuScreen.ViewList[linenow][:chs]
		dlist = MainApp.CommentL
		lc = len(dlist)
		CdisP = False
		strt = ""
		for j in range(lc):			
			strtl = dlist[j].split()
			if(len(strtl)>4):#202409093):#当一行五词及以上，表示是格式行
				dplist = MainApp.psplit(self,dlist[j],'『','』')#202409092
				strtl3 = dplist[1][1:-1]
				strtl4 = dplist[2][1:]
#				print("\t\t\t\t(",j,")行[",dlist[j],"]不少于五词，比较当前第二词[",strtl[1],"]与总行号(",linenow,")是否相同")
				if(strtl[1] == str(linenow)):#品鉴格式行包括时间戳 、总行号、标的首字、品鉴文本。如果行号相等时，显示品鉴内容
#					print("\t\t\t\t\t模块SelectableLabel初检备注文件中发现相同行号，可能有品鉴")
					#MainApp.ShowComment (self)
#					print("\t\t\t\t\t比较品鉴行第三词前(",chs,")字[",strtl3[:chs],"]，与当前行内容[",s,"]是否相同，以确认文件内容未变更后，显示品鉴")#20240909 [2]
					if(strtl3[:chs] == s):#20240909 [2]判断品鉴的摘要首字 与 该行首字 匹配，再进行品鉴显示
						CdisP = True
						#nchar = dlist[j].find(s)
						#hindstr = dlist[j][nchar+chs:]
						if(len(strt)==0):
							strt += strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
							#20240909* strt += strtl[0]+"品鉴：\n"+strtl3
						else:
							strt += "\n"+strtl[0]+"品鉴("+strtl[2]+"／"+strtl[1]+")行「"+strtl3+"……」：\n"+strtl4
							#20240909strt += "\n"+strtl[0]+"品鉴：\n"+strtl3
						
#						print("\t\t\t\t\t\t提取已有品鉴内容为「",strt,"」")
				else:
					CdisP = False
				
			elif(len(strt)>0 and CdisP):
				strt += "\n"+dlist[j]
#				print("\t\t\t\t提取已有品鉴内容换行接续为「",strt,"」")
		#self.menu_screen.ids.Text_Edit.text = strt#编辑框显示品鉴，此句不知如何调整？
		if(len(strt)>0):
			EditStatePopup11.poptext =strt
			MainApp.Pop11(self)







# 50 329            (13122 0)
		
	def PFormat (self):#段落格式编辑
		print("\n进入首次分页模块PFormat")
		#self.PMark='♢' 
		data=self.text_screen.ids.Enlarge_Edit.text
		#data=self.ui.textEdit.toPlainText()#读取编辑框中字符
		print("data末字：",data[-1])#20240929
		MarkP=False
		if(data.find('♢')>=0):
			MarkP=True
		stre="(执行 (全) (0 1)) (♡"#20240929"(执行 (全) (0 1)) (0 0 ♡"
		strh = "♡"#20240929
		Ascii_0=97
		Ascii_1=65
		AscLoop=26
		na=0
		i2=-1
		i3 = 0
		Pass=False
		ss=""
		lsum=0#行数
		addline = 0#20241001操作的附加行数
		gradPre = False#True#20241001上一次为二级目录的双行分段格式判断
		linep = 0 #20241001测算二级目录时上页的格式行
		if(len(data)>0):
			#ss=self.model.item(0).index().data()#获取listView的0行字符作为格式前缀
			ss = self.menu_screen.ids.Line_Edit.text#20241005取主页编辑行的字符作为格式前缀
			i1=len(data)
		#	if(self.IFid=="1" or self.IFid=="2"):
		#		QMessageBox.setStyleSheet(self,"border-image:url(/usr/share/jz/sty/cloud.png)")###0423 information.
			if(i1>3):
				if(len(ss)>5):#20241005
					Pass=False
				else:
					Pass=True
					print("将获取列表框顶行字符作为格式前缀「",ss,"」字长异常，请核对")
		#		reply = QMessageBox.information(self,"首次分页操作","将获取列表框顶行字符作为格式前缀「"+ss+"」字长异常，如无分页标记'♢'，将按一行及以上空行作为依据，你确定吗？",
		#			QMessageBox.Yes | QMessageBox.No)  
		#		if(reply==QMessageBox.No):
		#			Pass=False
		#		else:
		#			Pass=True
		#	else:
		#		print("将获取列表框顶行字符作为格式前缀「",ss,"」，请核对")
		#		reply = QMessageBox.information(self,"首次分页操作","将获取列表框顶行字符作为格式前缀「"+ss+"」，如无分页标记'♢'，将按一行以上空行作为依据，你确定吗？",
		#			QMessageBox.Yes | QMessageBox.No)  
		#		if(reply==QMessageBox.No):
		#			Pass=False
		#		else:
		#			Pass=True
		if Pass:
			fh2=TemporaryFile('w+t',encoding='utf-8' )
			chstr =" "#20240929
			ih=0	#光标在每行的位置
			in1 =0#起点行
			in2=0#终点行
			PageP=False
			nblanks=1#0423作为分页标记的最少空行数
			nblank=0
			paralist = []#20241001
			gradP = False#20241001二级目录判断
	#		self.ui.textEdit.setStyleSheet("border-image:url(src/cloud.png)")
			i=0
			for i in range(i1):
				#print(data[i],end="")
				if(i%70==69):print("")
				if(data[i]!=self.PMark):#检查非标记字符时
					if (data[i]=='\n'):#统计行数
						in2+=1#以每行终点的字符来计算行数
						lsum+=1#累计行数
						if(ih==0):###0423(strn.strip()):
							nblank+=1
							if(nblank >= 2):#20241001多行空格时判断为二级目录，清空前字串重新累加
								if not gradP:
									chstr = " "
									gradP =True
								print("\t\t当前(",lsum,")行之前空(",nblank,")行，判断为二级目录gradP：",gradP)
						else:
							nblank=0
						ih=0#对本行字符开始计数供判断是否行首
						#print("in2=",in2)
					
					else:
						if(ih==0):###0423(strn.strip()):
							if(nblank>=nblanks):
								#print("\t\t\tnblank>=nblanks->(",nblank,")>=(",nblanks,")准备分页")
								PageP=True
							
						ih+=1
					
				#else:#检查是标记字符时0423
				if(MarkP and data[i]==self.PMark):
					print("in2=",in2)
					ch_1=chr(Ascii_0 + int(na / AscLoop))
					ch_2=chr(Ascii_0 + na % AscLoop)
					nowmark = strh+ch_1+ch_2#20241001
					if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
						chstr += " "
					else:
						chstr += nowmark+" "#20240929
#					print("\t\t格式行标记编号数为(",Ascii_0 + int(na / AscLoop),",",Ascii_0 + na % AscLoop,")字母为[",ch_1,ch_2,"]")
					if(ih == 0):#标记为行首时
						in2+=1
						if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
							fh2.write(ss+str(in1)+" "+str(in2)+" "+stre[:-1]+"0\n")#0411 stre="(执行 (全) (0 1)) (♡"
						elif(nblank>=2):#20241001考虑二级目录
							fh2.write(ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+"\n")#0411 stre="(执行 (全) (0 1)) (♡"
						else:
						
							fh2.write(ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+")\n")#0411
						fh2.write(data[i2+1:i]+"\n")
						in1=in2
						in2=0
						i2 = i
					else :#标记非行首时
						in2+=1
						if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
							fh2.write(ss+str(in1)+" "+str(in2+1)+" "+stre[:-1]+"0\n")#0411
						elif(nblank>=2):#20241001考虑二级目录
							fh2.write(ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+"\n")#0411 stre="(执行 (全) (0 1)) (♡"
						else:
						
							fh2.write(ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+")\n")
						fh2.write(data[i2+1:i]+"\n\n")
						in1=in2+1
						in2=0
						i2 = i
						ih+=1
					na+=1
					if(na>=676):
						Ascii_0-=32
						na-=676
				#***************
				if((not MarkP) and PageP):#0423#检查非标记字符时
					print("\t\t执行至总(",lsum,")行，之前空行数(",nblank,")",end="")
					#if(nblank>1):
					print("\t当前标记字串[",chstr,"]")
					ch_1=chr(Ascii_0 + int(na / AscLoop))
					ch_2=chr(Ascii_0 + na % AscLoop)
					if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
						chstr += " "
					else:
						if(not gradP):#20241002适应一级目录
							chstr += " "+strh+ch_1+ch_2#20240929
					print("\t\t格式行标记编号数为(",Ascii_0 + int(na / AscLoop),",",Ascii_0 + na % AscLoop,")字母为[",ch_1,ch_2,"]上次是否二级目录格式：",gradPre)#
					if(gradPre):#20241001#当遇到上次二空行以上时nblank >= 2
						paralist.append(linep)
						paralist.append(na+1)
						chstr += " "+strh+ch_1+ch_2#20240929
						print("\t当前测算转换格式(",linep,")行，空行数(",nblank,")，准备(",na+1,")次标记，列表转化为",paralist,"；中转字串「",chstr,"」")
					if(ih == 0):#标记为行首时
						in2+=1
						if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
							strt = ss+str(in1)+" "+str(in2)+" "+stre[:-1]+"0 0\n"
							fh2.write(strt)#0411
							print("\t\t\t首行格式：",strt)
							#fh2.write(ss+str(in1)+" "+str(in2)+" "+stre[:-1]+"0\n")#0411 stre="(执行 (全) (0 1)) (♡"
						else:
							if(gradPre):
								strt = ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+" 0 0\n"
								fh2.write(strt)#0411
								print("\t\t\t上次二级目录行格式：",strt)
								#fh2.write(ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+" \n")#0411
								gradPre = False
							else:
								strt = ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+" 0)\n"
								fh2.write(strt)#0411
								print("\t\t\t上次非首行非二级目录行格式：",strt)
								#fh2.write(ss+str(in1)+" "+str(in2)+" "+stre+ch_1+ch_2+" 0)\n")#0411
						fh2.write(data[i2+1:i]+"\n")#[i2+1:i]
						in1=in2
						linep += in1+1#20241001
						in2=0
						i2 = i-1#0423 i
					else :#标记非行首时
						in2+=1
						if(ch_1 == 'a' and ch_2 == 'a'):#20240929文件开始时特殊标记
							strt = ss+str(in1)+" "+str(in2+1)+" "+stre[:-1]+"0 0\n"
							fh2.write(strt)#0411
							print("\t\t\t首行格式：",strt)
						else:
							if(gradPre):
								strt = ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+" 0 \n"
								fh2.write(strt)#0411
								print("\t\t\t上次二级目录行格式：",strt)
								#fh2.write(ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+" \n")#0411
								gradPre = False
							else:
								strt = ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+" 0)\n"
								fh2.write(strt)#0411
								print("\t\t\t上次非首行非二级目录行格式：",strt)
								#fh2.write(ss+str(in1)+" "+str(in2+1)+" "+stre+ch_1+ch_2+" 0)\n")#0411
						fh2.write("\n"+data[i2+1:i]+"\n")#0424
						in1=in2+1
						linep += in1+1#20241001
						in2=0
						i2 = i-1#0423 i
						ih+=1
						
					if(nblank>1):
						gradPre = True
					na+=1
					print("\t\t追踪字符标记序号**na(",na,")")
					PageP=False
					if(na>=676):
						Ascii_0-=32
						na-=676

			print("\t\t执行至文末总(",lsum,")行，之前空行数(",nblank,")",end="")
			if(nblank>1):
				print("\t当前标记字串[",chstr,"]")
			ch_1=chr(Ascii_0 + int(na / AscLoop))
			ch_2=chr(Ascii_0 + na % AscLoop)
			print("\t\t格式行标记编号数为(",Ascii_0 + int(na / AscLoop),",",Ascii_0 + na % AscLoop,")字母为[",ch_1,ch_2,"]上次是否二级目录格式：",gradPre)#

			if(gradPre):#20241001#当遇到上次二空行以上时nblank >= 2
				paralist.append(linep)
				paralist.append(na+1)
#20241002				chstr += " "+strh+ch_1+ch_2+")"#20240929
				if(gradP):#202401001#20241002not 
					chstr += " "+strh+ch_1+ch_2+")"#20240929
				else:
					chstr += ")"#20241001
				print("\t文末测算转换格式(",linep,")行，空行数(",nblank,")，准备(",na+1,")次标记，列表转化为",paralist,"；中转字串「",chstr,"」")
			
			else:#20241002适应一级目录
				if(not gradP):
					chstr += " "+strh+ch_1+ch_2+")"
			if(ih == 0):#标记为行首时
				in2+=1
				if(gradPre):
					strt = ss+str(in1)+" "+str(in2+2)+" "+stre+ch_1+ch_2+"\n"
					fh2.write(strt)#0411
					print("\t\t\t上次二级目录行格式：",strt)
					gradPre = False
				else:
					strt = ss+str(in1)+" "+str(in2+2)+" "+stre+ch_1+ch_2+")\n"
					fh2.write(strt)#0411
					print("\t\t\t上次非首行非二级目录行格式：",strt)
#20241002				fh2.write(data[i2+1:i]+"\n")#[i2+1:i]
				fh2.write("\n"+data[i2+1:]+"\n\n")#20240929 增前"\n"+,删:后i，修复前少一行，后少一字bug(data[i2+1:i]+"\n\n")
				in1=in2
				linep += in1+1#20241001
				i2 = i-1#0423 i
			else :#标记非行首时
				in2+=1
				if(gradPre):
	#		fh2.write(ss+str(in1)+" "+str(in2+3)+" "+stre+ch_1+ch_2+")\n")#20240929修复初次分段末行号少1问题 in2+1
					strt = ss+str(in1)+" "+str(in2+3)+" "+stre+ch_1+ch_2+"\n"
					fh2.write(strt)#0411
					print("\t\t\t上次二级目录行格式：",strt)
					gradPre = False
				else:
					strt = ss+str(in1)+" "+str(in2+3)+" "+stre+ch_1+ch_2+")\n"
					fh2.write(strt)#0411
					print("\t\t\t上次非首行非二级目录行格式：",strt)
	#		fh2.write("\n"+data[i2+1:]+"\n\n")#20240929 增前"\n"+,删:后i，修复前少一行，后少一字bug(data[i2+1:i]+"\n\n")
				fh2.write("\n"+data[i2+1:]+"\n\n\n")#0424后面需要增加2行\n\n

	#		fh2.write(ss+str(in2+3)+" "+"0\n")#20240929修复初次分段末行号少1问题 in2+1
			if(ih == 0):#标记为行首时
				fh2.write(ss+str(in2+2)+" "+"0\n")#20241002修复初次分段末行号少1问题 in2+1
			else:
				fh2.write(ss+str(in2+3)+" "+"0\n")#20241002修复初次分段末行号少1问题 in2+1

			fh2.write(chstr)#20240929附加链接标记
			fh2.seek(0)
			data=fh2.read()
			dlist = data.split("\n")#20240929准备替换首行及二级目录项内容
			data =""
			if(gradP):
				lpara = len(paralist)#202401001二级目录项数量8
				print(paralist)
				dlist[0] += chstr#20241020#20241013区分最后段前面不空两行时，不增加右括号")+")"
				if(dlist[0][-1]!=")"):#20241020if(gradPre):#20241013区分最后段前面空两行时，增加右括号")
					dlist[0] += ")"#20241020dlist[0] += chstr+")"#20241010 #20241012撤消
				#20241020else:
				for i in range(len(dlist)-2):
				#	print("\t\ti=",i,end="")
					if(lpara>0):
						FparaP=False
						for j in range(0,lpara,2):
					#		print("\t\tj=",j,end="")
							if(i == paralist[j]):#发现二级目录行，开始推算该行增加的标记
								FparaP=True
								nb = paralist[j+1]
								if(lpara>j+2):
									endna = paralist[j+3]
								else:
									endna = na+2
								print("\t\t(",i,")行组装标记，发现在标记列表内(",paralist[j],")词，最终字符标记序号na为(",na,")")
								chstr = ""
								for k in range(nb,endna-1):
								#	print("\tk=",k,end="")
									nat = k
									ch_1=chr(Ascii_0 +int( nat / AscLoop))
									ch_2=chr(Ascii_0 + nat % AscLoop)
									chstr += " "+strh+ch_1+ch_2#20240929###138
									if(nat>=676):
										Ascii_0-=32
										nat-=676
								print("\t\t第(",i,")行的跳行格式字串推算为[",chstr,"]\n该行格式成为")
								#print("\n")	
								#break
								
						if(FparaP):	
							data += dlist[i]+chstr+")\n"
							print(data)
						else:
							data += dlist[i]+"\n"
							
					else:
						
						data += dlist[i]+"\n"
				data += dlist[len(dlist)-2]
			else:
				dlist[0] += chstr 
				for i in range(len(dlist)-2):
					data += dlist[i]+"\n"
				data += dlist[len(dlist)-2]
			
			fh2.close()
			self.text_screen.ids.Enlarge_Edit.text=data#20241005
			#self.ui.textEdit.setPlainText(data)
			#if(self.IFid=="1" or self.IFid=="2"):
			#	self.setStyleSheet(self.BackGround)#;border:Opx;###0423


				
# 329 116          (13173 0)
				
	def JFormat (self):#链接格式编辑#20241005
		#self.JMark='♡'
		data=self.text_screen.ids.Enlarge_Edit.text#20241005self.ui.textEdit.toPlainText()#读取编辑框中字符
		mylist=data.split('\n')
		i1=len(data)
		stepf=0
		stepb=0
		ifmt=0
		i3 = 0
		in1 =0#起点行
		in2=0#终点行
		ih=0	
		if(i1>0):
			self.Ignore=self.menu_screen.DLFmt(mylist)#20241005self.DLFmt(mylist)
			lm=len(mylist)

	#		print("运行行")
			for i in range(lm):
	#			print("\t\t",i,end="")
				if(i==ifmt):#只对格式行检索
	#				print("\n检索",i,"格式行：",mylist[i])
		#			self.ui.textEdit.append("链接格式模块正在检索第("+str(i)+")格式行["+mylist[i]+"]")#v0.994 0419
					linelist=mylist[i].split()
					if(len(linelist)>=self.Ignore+3):#初步判断格式行
						if(linelist[self.Ignore+2]!='0'):
							ifmt+=1+int(linelist[self.Ignore+2])#准备下一步要检索的行距
	#						print("\t计算下一个格式行为:",ifmt)
						else:
	#						print("\t前跳值为0")
							break
						if(self.Listp(mylist[i])):#有无括号格式
							jumpstr=self.psplit(mylist[i],'(',')')[-1]
	#						print("\t\t发现括号字串",jumpstr)#最后一个括号项为跳跃格式
							if(jumpstr.find(self.JMark)>=0):#整体浏览有链接标记
								jumplist=jumpstr[1:-1].split()
								i2=0
								for jumpit in jumplist:#搜索标记符，确定前半标记
									if(jumpit.find(self.JMark)<0):#子项没有发现链接标记
										if(i2==0):
											strt=jumpit
										else:
											strt=strt+" "+jumpit
									else:	#子项有发现链接标记
										markstr=jumpit
										stepf=int(linelist[self.Ignore+2])
										ifmt1=i+stepf+1
										for i3 in range(i+stepf+1,lm):#搜索配对标记，直到发现替换
											if(i3==ifmt1):#只对格式行检索
	#											print("\t\t\t配对标记检索",i3,"格式行：",mylist[i3])
												linelist1=mylist[i3].split()
												if(len(linelist1)>=self.Ignore+3):#初步判断格式行
													if(linelist1[self.Ignore+2]!='0'):
														ifmt1+=1+int(linelist1[self.Ignore+2])
	#													print("\t\t寻找配对链接计算下一个格式行为:",ifmt1)
													f3=mylist[i3].find(markstr)
													if(f3>=0):
														stepb=int(linelist1[self.Ignore+1])
														ifstr=str(i3-(i+stepf+1))
														ibstr=str(i3-(stepb+1)-i)
														strt=strt+" "+ifstr
	#													print(i3,"行配对链接标记：",markstr,"前跳",ifstr,"回跳",ibstr,"跳跃格式",strt)
														if(self.Listp(mylist[i3])):
	#														print(i3,"行有括号，准备替换")
															jumpstr1=self.psplit(mylist[i3],'(',')')[-1][1:-1]
															jumplist1=jumpstr1.split()
															i4=0
															for jumpit1 in jumplist1:
																if(jumpit1!=markstr):
																	if(i4==0):
																		strt1=jumpit1
																	else:
																		strt1=strt1+" "+jumpit1
																else:
																	if(i4==0):
																		strt1=ibstr
																	else:
																		strt1=strt1+" "+ibstr
																i4+=1
															if(len(self.psplit(mylist[i3],'(',')'))==2):
																mylist[i3]=self.psplit(mylist[i3],'(',')')[0]+' ('+strt1+')'#更新后半表项0328'('
	#															print(i3,"行跳跃格式替换更新为：",mylist[i3])
															else:
																mylist[i3]=self.psplit(mylist[i3],'(',')')[0]+' '+self.psplit(mylist[i3],'(',')')[1]+' ('+strt1+')'#0328'('
	#															print(i3,"行跳跃格式替换更新为：",mylist[i3])

														else:#无括号格式时丢弃
															if(f3+1+len(markstr)==len(mylist[i3])):#串末
																strt1=mylist[i3][:f3-1]
															else:#非串末
																strt1=mylist[i3][:f3-1]+mylist[i3][f3+len(markstr):]
															mylist[i3]=strt1#更新表项
	#														print(i3,"行丢弃跳跃标记更新为：",mylist[i3])
														break
											i3+=1
									i2+=1
								if(len(self.psplit(mylist[i],'(',')'))==2):
									mylist[i]=self.psplit(mylist[i],'(',')')[0]+' ('+strt+')'#更新前半表项0328'('
	#								print(i,"行跳跃格式替换更新为：",mylist[i])
								else:
									mylist[i]=self.psplit(mylist[i],'(',')')[0]+' '+self.psplit(mylist[i],'(',')')[1]+' ('+strt+')'#更新前半表项0328'('
	#								print(i,"行跳跃格式替换更新为：",mylist[i])
					else:
						print("\t\t第(",i,")行格式错误")
						#QMessageBox.information(self,"Information","第("+str(i)+")行格式错误，请予以修正",
						#								QMessageBox.Ok,QMessageBox.Ok)# | QMessageBox.Cancel

		#	self.ui.textEdit.clear()
			strt =""
			for data in mylist:
				#self.ui.textEdit.append(data)
				strt += data+"\n"
			self.text_screen.ids.Enlarge_Edit.text = strt



# 116 14           (13503 0)

	def PJAdjust (self):#增删行格式调整#20241005
		#data=self.ui.textEdit.toPlainText()#读取编辑框中字符
		data=self.text_screen.ids.Enlarge_Edit.text#20241005读取编辑框中字符
		mylist=data.split('\n')
		mylist=self.PJList(mylist)
#		self.ui.textEdit.clear()
		#for data in mylist:
		#	self.ui.textEdit.append(data)
		strt =""
		for data in mylist:
			strt += data+"\n"
		self.text_screen.ids.Enlarge_Edit.text = strt
		
# 14 184             (13620 0)

	def PJList (self,mylist):#执行增删行格式调整20241005
		#self.JMark='♡'
		i1=len(mylist)#data
		stepf=stepb=0
		ifmt=oldfmt=0
		i3 = 0
		in1 =0#起点行
		in2=0#终点行
		ih=0	
		Peditp=False#调整段格式
		Elist=Elinl=[]
		if(i1>0):
			self.Ignore=self.menu_screen.DLFmt(mylist)#20241005self.DLFmt(mylist)
#			mylist=data.split('\n')
			lm=len(mylist)
			for i in range(lm):
				#print("浏览至行",i)
				if(i==ifmt):#只对格式行检索
	#				print("遍历",i,"格式行：",mylist[i])
					linelist=mylist[i].split()
					ll=len(linelist)
					if(ll>=self.Ignore+3):#初步判断格式行
						if(linelist[self.Ignore+2]!='0'):#前跳格式不为0
							if(ifmt+1+int(linelist[self.Ignore+2])<=lm):
								ifmt=ifmt+1+int(linelist[self.Ignore+2])#准备下一步要检索的行距
								oldfmt+=1+int(linelist[self.Ignore+2])
								#print("原行号：",oldfmt,"预计下一个格式行为:",ifmt)
								linelist1=mylist[ifmt].split()
							if(len(linelist1)>=self.Ignore+2):#预读行为格式行
								if(linelist1[self.Ignore+1]!=linelist[self.Ignore+2]) or (not linelist1[self.Ignore+2].isdigit()):
									Peditp=True
							else:
								Peditp=True
							if Peditp:
				#				print(ifmt,"行检测不符合数字括号格式，开始逐行扫描定位格式行")
								for ir in range(i+2,lm):#从下面第2行开始逐行检验
				#					print("\t",ir,"行：",mylist[ir])
									if(len(mylist[ir].split())>=self.Ignore+2):
										if(mylist[ir].split()[self.Ignore+1]==linelist[self.Ignore+2]) and (mylist[ir].split()[self.Ignore+2].isdigit()):
											ifmt=ir
											stepf=ir-i-1#计算步长
											dlta=stepf-int(linelist[self.Ignore+2])#计算行增删偏差
											ito=i+int(linelist[self.Ignore+2])+1
											Elinl=[i,ifmt,oldfmt-int(linelist[self.Ignore+2])-1,oldfmt,int(linelist[self.Ignore+1]),int(linelist[self.Ignore+2]),dlta]
											Elist.append(Elinl)#将误差存入编辑列表
											ss=""
											for i4 in range(self.Ignore+2):
												ss+=linelist[i4]+" "
				#							print(i,"上格式行前缀字串",ss)
											ss=ss+str(stepf)#ss=linelist[0]+" "
											if(ll>=self.Ignore+3):
												for i4 in range(self.Ignore+3,ll):
													ss+=" "+linelist[i4]
											#print(i,"格式行调整后",ss)
											#if(ll>2):
											#	for ir1 in range(2,ll):
											#		ss=ss+" "+linelist[ir1]
											mylist[i]=ss
				#							print("\t上格式",i,"行更新为：",mylist[i])
										
											linelist=mylist[ifmt].split()
											ll=len(linelist)
											ss=""
											for i4 in range(self.Ignore+1):
												ss+=linelist[i4]+" "
											#print(ifmt,"下格式行前缀字串",ss)
											ss=ss+str(stepf)#ss=linelist[0]+" "
											if(ll>=self.Ignore+2):
												for i4 in range(self.Ignore+2,ll):
													ss+=" "+linelist[i4]
											#print("\t下格式",ifmt,"行调整为",ss)
											#ss=str(stepf)+" "+linelist[self.Ignore+2]
											#if(ll>2):
											#	for ir1 in range(2,ll):
											#		ss=ss+" "+linelist[ir1]

											mylist[ifmt]=ss
				#							print("\t下格式行",ifmt,"更新为：",mylist[ifmt],"\n\n")
											Peditp=False
											break
						else:#前跳格式不为0，文件已至尾部
				#			print("\t前跳值为0，文件已至尾部")
							break
			#调整链接格式
			print("\n===调整链接格式===\n")
			print("分页偏差表：",Elist)
			ifmt=oldfmt=0
			le1=len(Elist)
			for i in range(lm):
				#print("\t\t调整至行",i,)
				if(i==ifmt):#只对格式行检索
#					print("\n检索",i,"格式行：",mylist[i])
					linelist=mylist[i].split()
					ll=len(linelist)
					if(ll>=self.Ignore+3):#初步判断格式行
						if(i==0):#0行特殊判断
							stepb=int(linelist[self.Ignore+1][-1])
						else:
							stepb=int(linelist[self.Ignore+1])
						stepf=int(linelist[self.Ignore+2])
						if(linelist[self.Ignore+2]!='0'):#前跳格式不为0
							if(ifmt+1+int(linelist[self.Ignore+2])<=lm):
								ifmt=ifmt+1+int(linelist[self.Ignore+2])#准备下一步要检索的行距
								#print("\t\t\t预计下一个格式行为:",ifmt)
						if(self.Listp(mylist[i])):#检查有无表（链接）
							jlstr=self.psplit(mylist[i],'(',')')[-1]
							lenstr=len(jlstr)
							jlist=jlstr[1:-1].split()#获取最末列表
							lj=len(jlist)
							editp=False
							if(jlist[0].isdigit()):#当表首项为数字时，判断为数字括号链接格式
								for i1 in range(lj):#检查各链接值是否有非0
									if(int(jlist[i1])>0):editp=True
								if editp:
									dltab=0
									dltaf=0
									for i3 in range(le1):
										if(i<=Elist[i3][1]):
											dltab=Elist[i3][2]-Elist[i3][0]#v0.966+=
							#				print("\t\t遍历各调整段确定回跳名义偏差dltab",dltab)
											break#v0.966
	
										elif(i3==le1-1):
											if(i>Elist[i3][1]):
												dltab=Elist[i3][3]-Elist[i3][1]#v0.966
	
									for i3 in range(le1):
										if(i>=Elist[i3][0]):
											dltaf=Elist[i3][3]-Elist[i3][1]
							#				print("\t\t遍历各调整段确定前跳名义偏差dltaf",dltaf)
							#		print("\t",i,"行名义格式增补： 回跳dltab",dltab,"行,前跳dltaf",dltaf,"行")
									for i1 in range(lj):#检查各链接值是否与调整段交叉
										if(i1==0):
											i4=int(jlist[i1])
											i3=i4
							#				print("\t\t回跳行数[",i3,"]")
											if(i3>0):
												for i2 in range(le1):#遍历各调整段
													#检查回跳行是否至本行名义格式(未调整前格式)前=
													stepb1=stepb+1
													if(stepb==0):stepb1=0
													njumpb=i+dltab-stepb1
							#						print("\t回跳点计算：当前行",i,"+名义格式增补回值",dltab,"-回步长",stepb1,"-回跳步长",i3)
							#						print("\t\t结果=",njumpb-i3,"<=调整前原回步点",Elist[i2][2],"?(关键因素1)")
							#						print("\t回跳点计算：当前行",i,"+名义格式增补回值",dltab,"-回步长",stepb1)
							#						print("\t\t结果=",njumpb,">=调整前原回步点",Elist[i2][3],"?(关键因素2)")
													if ((njumpb-i3) <= Elist[i2][2]) and (njumpb >= Elist[i2][3]):
													#if (njumpb-i3 <= Elist[i2][2]) and (njumpb >= Elist[i2][3]):#v0.966
							#							print(Elist)
							#							print(i,"行[",mylist[i],"]行回跳跃链接跨越",Elist[i2][0],"至",Elist[i2][1],"行","调整",Elist[i2][6])
														i4=i4+Elist[i2][6]
							#							print("\t\t\t回跳格式调整值",i4)
												ss=str(i4)
							#					print("\t\t\t0项",ss,"\n")
											else:
												ss="0"
										else:
											i4=int(jlist[i1])
											i3=i4
							#				print("\t\t前跳",i3,"行")
											if(i3>0):
												for i2 in range(le1):#遍历各调整段
													#检查前跳行是否至本行名义格式(未调整前格式)后
													njumpf=i+dltaf+stepf+1
#													print("\t前跳点计算：当前行",i,"+名义格式增补前值",dltaf,"+前步长",stepf+1)#v0.966,"+前跳步长",i3
#													print("\t\t结果=",njumpf,">调整前原前步",Elist[i2][3],"?(关键因素)")
#													print("\t前跳点计算：当前行",i,"+名义格式增补前值",dltaf,"+前步长",stepf+1,"+前跳步长",i3)
#													print("\t\t结果=",njumpf+i3,">=调整前原前步",Elist[i2][3],"?(关键因素)")
													if (njumpf < Elist[i2][3]) and ((njumpf+i3) >= Elist[i2][3]):
										#				print(Elist)
#														print(i,"行[",mylist[i],"]前跳跃链接跨越原",Elist[i2][2],"至",Elist[i2][3],"行","调整",Elist[i2][6])
														i4=i4+Elist[i2][6]
#														print("\t\t\t后跳格式调整值",i4)
												ss+=" "+str(i4)
										#		print("\t\t调整后",ss)
											else:
												ss+=" 0"
									mylist[i]=mylist[i][:-lenstr]+' ('+ss+')'#20230219
									#print("\t",i,"行调整后:[",mylist[i],"]\n")
			return  mylist



# 184 9             (13635 0)
	
	def PasteStrT (self):#202410052文本窗口[粘贴]功能
		strt=Clipboard.paste()
		print("粘贴出剪贴板的内容：[",strt.split('\n')[0],"……]")
		self.text_screen.ids.Enlarge_Edit.insert_text(strt)#20240612 text




#  9 162             (14812 0)

	def FData (self,strit,alti):#文件件操作
	#根据字串strit操作数据文件表self.FDataList,alti空串时读入；如‘[]’打印整个表；如‘[]，’返回子表的项数；非空字串时将此赋给文件表；如alti不空，且末字为空格，则视之为表，比如单独一个空格，也会将此行内容设为空表，末字不是空格，则视为字串（包括中间有空格的字串）；目前仅支持+行表，有现实需要时可修改此模块。
	#(管号 [](环行号)，(环列号)) 		 (环内循环数 [](环行号))
	#(([](运行环行号)，)-1)
		print("\n进入操作数据文件表模块FData，变量名字串为[",strit,"]变量字串[",alti,"]")
		
		fmin = 1e-5#定义‘实数相等’的最小精度
		n=0
		if(len(alti)>0):
			n=1#,n=0时将读取，n=1时alti赋值给strit
		
		stritt = ""
		if(strit[:2]=='[]'):#20250221如果变量名为数据文件表格式时 :1
			print("\t发现[]")
			Dlta = 10#设置最大超过已有列数值
			strtp = ""
			strth = ""
			stritt = strit[2:]
			litt = stritt.find('，')
			comaP = False#有没有逗号判断
			if(litt>0):
				comaP = True
				strtp = stritt[:litt]
				strth = stritt[litt+1:]
			else:
				strtp = stritt
			print("\t发现变量名数据表格式，行值[",strtp,"]，列值[",strth,"]")
			
			lstrp = len(strtp)#20250302
			lstrh = len(strth)
			if(lstrp==0):#20250302当首项为空时
				if(isinstance(self.FDataList,list)):
					lp = len(self.FDataList)#获取数据表行数
					if(lstrh==0):#如没有行号（一级数组号）
						if(comaP):#如有'，'，就返回文件表数组项数
							print("\t‘[]，’符时，返回数据文件表一级项数(",lp,")")
							alti = str(lp)
						else:#如果没有'，'，即纯‘[]’，打印整个表
							print("\t纯[]符时，打印整个数据文件表")
							for ilp in range(lp):
								print("\t\t",self.FDataList[ilp])
							
			elif(lstrp>0):#20250302当首项不空时				
				if(strtp.find('(')>=0):#括号预处理
					strtp = self.AltStr(strtp,0,MenuScreen.Expbnow)
					print("\t行值经过变量代换后成为[",strtp,"]")
				if(comaP):
					if(strth.find('(')>=0):
						strth = self.AltStr(strth,0,MenuScreen.Expbnow)
						print("\t行值经过变量代换后成为[",strth,"]")
						
				if(isinstance(self.FDataList,list)):#如果存在数据文件读入表
					lp = len(self.FDataList)#获取数据表行数
#					if(len(stritt)==0):#20250226如果表无行号
#						alti = str(lp)#返回行数值
#					else:
					if(strtp[0]=='-'):#20250226如果行号有负号
						if(strtp[1:].isdigit()):#且负号以后是数字
							strtp = str(lp+int(strtp))#将负行号转化为正和号
					elif(strtp[0]=='+'):
						print("\t\tFData模块发现+号，表示追加")
						if(strtp[1:].isdigit()):#且正号以后是数字
							strtp = str(lp-1+int(strtp))#将正列号转化为延展列表后的列号
					
					if(strtp.isdigit()):
						print("\t\t\t操作变量名行值[",strtp,"]是数字")
						vp = int(strtp)
						if(vp < lp):#如果行号小于行数（一级数组项数）
							print("\t\t\t\t变量名行值[",strtp,"]小于总项数(",lp,")")
							if(isinstance(self.FDataList[vp],list)):
								lh = len(self.FDataList[vp])#获取数据表该行的项数
								if(comaP):#20250225
									if(lstrh == 0):#2025302if(not comaP):#20250225
										alti = str(lh)#‘[]3，’无列值但有全角逗号时，返回二级项数值
									elif(strth[0]=='='):#202503032[](运行初环行号)-1+(abs(内环号))，=(管号)		返回列号
										strth = strth[1:]
										if(self.IsNumber(strth)):#如果是数字
											for ih in range(lh):#逐列比较数值大小
												if(math.fabs(math.fabs(float(self.FDataList[vp][ih]))-math.fabs(float(strth)))<fmin):
													alti = ih
													break
										else:#如果为字符
											for ih in range(lh):#逐列比较数值大小
												if(self.FDataList[vp][ih]==strth):
													alti = ih
													break
													
									else:#20250302如果‘，’后不空有非‘=’首字的内容
										if(strth[0]=='-'):#20250226如果列号有负号
											if(strth[1:].isdigit()):#且负号以后是数字
												strth = str(lh+int(strth))#将负列号转化为正列号
										elif(strth[0]=='+'):
											if(strth[1:].isdigit()):#且正号以后是数字
												strth = str(lh-1+int(strth[1:]))#将正列号转化为延展列表后的列号
												print("\t\t\t\t\t变量名+数字列值[",strth,"]")
								
										if(strth.isdigit()):
											print("\t\t\t\t\t变量名列值[",strth,"]是数字")
											vh = int(strth)
											if(vh<lh):#判断列号在指定行子表范围内时#直接将数值赋给文件表
												print("\t\t\t\t\t\t\t变量名列值[",strth,"]小于二级项数(",lh,")")
												if(n==0):
													alti = self.FDataList[vp][vh]
													print("\t\t\t\t\t\t\t\tFData模块[",strit,"]之数据表值提取为[",alti,"]")	
												else:#当n!=0时，准备替换文件表字符
													self.FDataList[vp][vh] = alti
													print("\t\t\t\t\t\t\t\tFData模块[",strit,"]之数据表值已用[",alti,"]覆盖子表(",vh,")项")								
											else:#如果列号不小于项数时，且未超10时，补足项数来赋值
												if(n==0):#如果读入时，返回空串	#行最后值
													alti = ""#20250225self.FDataList[vp][-1]
												else:
													if(vh-lh< Dlta):
														for idlta in range(lh,vh+1):
															if(idlta<vh):
																self.FDataList[vp].append("")
															elif(idlta==vh):
																self.FDataList[vp].append(alti)
																print("\t\t\t\tFData模块[",strit,"]之数据表值超额(",vh-lh+1,")项，填充追加[",alti,"]后成为：",self.FDataList[vp])
										else:#20250302如果‘，’之后不是数字
											print("\t\t\t\t\t‘，’之后应是数字，请更正")
							else:#当一级数组提取项不是表时（即只是字串时），返回行值
								if(n==0):#如果读入时，返回行值	#返回空串
									alti = self.FDataList[vp]#20250302""
								else:#当n!=0写入时，准备替换文件表字符
									self.FDataList[vp] = alti
									print("\t\t\t\t\tFData模块[",strit,"]之数据表值已用[",alti,"]覆盖主表(",vp,")项")								
									
						else:#20250226如果行号不小于项数时，且未超10时，补足项数来赋值
							if(n==0):#如果读入时，返回空串	#行最后值
								alti = ""#20250225self.FDataList[vp][-1]
							else:#如果n!=0写入时
								listP = False#是否插入表判断
								if(alti[-1]==' '):#检测写入内容的末字是否空格
									listP = True
								if(vp-lp< Dlta):
									for idlta in range(lp,vp+1):
										if(idlta<vp):
											self.FDataList.append("")
										elif(idlta==vp):
											if listP:#如果写入项末字为空格
												if(alti.strip()):#如果写入项有内容，用空格进行分割
													altil = alti.split(' ')
													self.FDataList.append(altil)
												else:#如果写入项无内容时，创建空表
													altil = []
													self.FDataList.append(altil)
													
											else:#如果写入项末字非空格
												self.FDataList.append(alti)
											print("\t\t\t\tFData模块[",strit,"]之数据表值超额(",vp-lp+1,")项，填充追加[",alti,"]后成为：",self.FDataList)
				else:#当提取项不是表时，返回空字符
					if(n==0):#如果读入时，返回空串	#返回行值
						alti = ""#20250225self.FDataList[vp]
						
			if(n==0):
				print("\tFData模块准备返回[",strit,"]之数据表值[",alti,"]\n")
				return alti

	
	
	
#  162 46            (14822 0)

	def AltPara (self,parastr):#20250208搜索代换变量，摘自altstr
		print("\n进入变量置换模块AltPara，变量名[",parastr,"]")
		Indexpath=os.path.join(os.getcwd(),MenuScreen.IndexFile)#20250319 self.
		fh1=open(Indexpath,mode='r',encoding='UTF-8')
		if fh1:
			data=fh1.read()
			filelist=data.split("\n")
			fh1.close()
			print("parastr[",parastr,"]准备搜索摘引文件变量")
		if(data.find(parastr)>=0):
			print("\t\tAltStr搜寻索引文件:",Indexpath,"扫描发现待确认赋值变量字串[",parastr,"]")
			parap=False
			lf=len(filelist)
			for il in range(lf-1,0,-1):#
				linedata=filelist[il]
				lls=len(linedata.split())
				if(lls>3):
					print("\t扫描",il,"行[",linedata,"]")
					if(linedata.split()[3].find(parastr)>=0):
						loclist=self.psplit(linedata,'"','"')
						llsp=len(loclist)
						print("\t\t双引号分割成的列表项数:",llsp)
						if(llsp>=3):
							if(loclist[2].find(parastr)>=0):
								if(loclist[1][1:-1].strip()):
									parap=True
									strt=loclist[1][1:-1]#parastr
									if(strt[-1]=='⌇'):
										strt=strt[:-1]
									print("\t\t搜索摘引文件",il,"行",loclist[2],"中发现字串[",parastr,"]->变量值确认为[",strt,"]")
									break
		#		else:
		#			print("\t\t双引号拆分列表项数小于3")
			if parap:
				print("返回值[",strt,"]")
				return strt
				#midstr=strt
			else:
				print("返回值[]")
				return ""





#   46 135            (14985 0)

	def StepCalcu (self,fstring,LessP):#20250205进入试算模块Lessp=True表示试算值小于0时退出
		print("\n进入试算模块StepCalcu(",fstring,")试算小于0退出判断：",LessP)
		rlist = []
		vstrfromE = 0#试算初值
		vpass = 0 #当通过计算结果判断时，值增加1
		if(len(fstring)>0):#20250215多条件试算
			fstrl = fstring.split("；")
			lf =len(fstrl)
		for ic in range(lf):#根据条件数循环
			fto = fstrl[ic].find('～')
			if(fto>=0):
#				nloop = -1 #20250218
				strfrom = ""
				vstrfrom = 0
				for ifrm in range(fto-1,0,-1):#从～逆向搜索获取试算初值
#					print("\tifrm(",ifrm,")",fstrl[ic][ifrm],end="")
					if(fstrl[ic][fto-1]==')'):#20250208处理可能的变量
						if(fstrl[ic][ifrm]=='('):
							lfrom = ifrm+1
							strt = fstrl[ic][lfrom:fto-1]
							if(len(strt)>0):
								strfrom = self.AltPara(strt)
								strpre = fstrl[ic][:ifrm-1]
								print("\t试算初值(",strfrom,")接前字串[",strpre,"]<")
								break
					else:
						if(fstrl[ic][ifrm]=='('):
							lfrom = ifrm+1
							strfrom = fstrl[ic][lfrom:fto]
							strpre = fstrl[ic][:ifrm]
							print("\t试算初值(",strfrom,")接前字串[",strpre,"]<")
							break
				
				for jto in range(fto+1,len(fstrl[ic])):#从～顺向搜索获取试算初值
#					print("\tjto(",jto,")",fstrl[ic][jto],end="")
					if(fstrl[ic][fto+1]=='('):#20250208处理可能的变量
						if(fstrl[ic][jto]==')'):
							lto = jto
							strt = fstrl[ic][fto+2:lto]
							if(len(strt)>0):
								strto = self.AltPara(strt)
								strend = fstrl[ic][jto+2:]
								print("\t试算终值(",strto,")>后接字串[",strend,"]")
								break
					else:
						if(fstrl[ic][jto]==')'):
							lto = jto
							strto = fstrl[ic][fto+1:lto]
							strend = fstrl[ic][jto+1:]
							print("\t试算终值(",strto,")>后接字串[",strend,"]")
							break
							
				if(len(strfrom)>0):
					fmt = self.floatfmt (strfrom)
					step = round(float(1.0/10.0**(fmt)),(fmt+1))
#					print("\t\t小数位数为(",fmt,")Step=(",step,")")
					if(len(strto)>0):
						vstrto = float(strto)
						vstrfrom = round(float(strfrom),fmt)
						if(step>0):
							vend = float(self.AltStr(strpre+strto+strend,8,MenuScreen.Expbnow))
							if(LessP):
								if(vend >= 0.0):#当终值都不满足要求时返0退出
									print("\t\t\t试算终值不满足<0，返回'未找到适当试算值'后退出")
									rlist = []#20250218
									rlist.append("未找到适当试算值")
									print(rlist)
									return rlist
								else:
									print("\t\t\t＝＝＝试算终值满足<0，试算终值(",vend,")符合要求，下开始细分试算＝＝＝\n")
							else:
								if(vend < 0.0):#当终值都不满足要求时返0退出
									print("\t\t\t试算终值不满足>=0，返回'未找到适当试算值'后退出")
									rlist = []#20250218
									rlist.append("未找到适当试算值")
									print(rlist)
									return rlist
								else:
									print("\t\t\t＝＝＝试算终值满足>=0，试算终值(",vend,")符合要求，下开始细分试算＝＝＝\n")
							
							nloop = int((vstrto-vstrfrom)/step)
							print("\t\t试算初值为(",strfrom,"),终值为(",strto,")步长为(",step,")最大步数(",nloop,")")
							for itest in range(nloop+1):
								strformular =strpre+str(round(vstrfrom,fmt+1))+strend
								valt = float(self.AltStr(strformular,8,MenuScreen.Expbnow))
								print("\t\t\t试算式为[",strformular,"]试算值为(",round(vstrfrom,fmt+1),")结果(",valt,")")	
								if(LessP):
									if(valt<0.0):#当结果满足<0要求时返回试算参数，多条件时选大者？
										altstr = str(round(valt,fmt))
										if(vstrfrom >= vstrfromE ):#20250213
											print("\t\t\t\t新试算参数值(",vstrfrom,")>=原试算参数为(",vstrfromE,"),置新")
											vstrfromE = round(vstrfrom,fmt)
											strfrom = str(vstrfromE)
											print("＊＊＊试算参数[",strfrom,"]结果(",altstr,")满足小于等于零条件，记录参数，退出试算(",ic,")")	
											rlist = []
											
											rlist.append(altstr)
											rlist.append(strfrom)
											print(rlist)
										else:
											print("\t\t\t\t试算参数[",strfrom,"]结果(",altstr,")满足小零条件，不记录参数退出试算")
										vpass += 1
										break
#											return rlist
								else:
									if(valt>=0.0):#当结果满足>=0要求时返回试算参数，多条件时仍选大者？
										altstr = str(round(valt,fmt))
										if(vstrfrom > vstrfromE ):#20250213
											print("\t\t\t\t新试算参数值(",vstrfrom,")>原试算参数为(",vstrfromE,"),置新")
											vstrfromE = round(vstrfrom,fmt)
											strfrom = str(vstrfromE)
											print("＊＊＊试算参数[",strfrom,"]结果(",altstr,")满足大于等于零条件，返回参数，退出试算(",ic,")")
											rlist = []
											
											rlist.append(altstr)
											rlist.append(strfrom)
											print(rlist)
										else:
											print("\t\t\t\t试算参数[",strfrom,"]结果(",altstr,")满足大于等于零条件，不记录参数退出试算")
										vpass += 1
										break
#											return rlist
								vstrfrom += step
		print("试算共(",lf,")轮，通过了(",vpass,")轮")
		if(vpass == lf):#当通过的必选结果，与必选条件数相等
			return rlist#返回结果
		else:
			return ["未找到适当试算值"]#返回错误
			
	
	
	


#  135 76            (57)

	def AltCond (self,strt):#20250227
		print("\n进入三元条件判断模块AltCond，字串[",strt,"]")
		while (strt[0]=='?'):
			strt = strt[1:]
		strtt = strt
		fmin = 1e-5#定义‘实数相等’的最小精度
		print("\t输入字串转化为[",strtt,"]")
		rstrt = "三元格式分支结果错误，请检查逻辑及对应结果，不能为空"
		if(len(strtt)>0):
			lq = strtt.find(':')
			if(lq>0):
				strttl = strtt.split(':')#用:分割三元表达式
				ltt = len(strttl)
				if(ltt>0):#当存在三元条件时
					if(strttl[0].find('=')>0):#如果条件时检测‘相等’
						strtl = strttl[0].split('=')
						if(len(strtl)>1):#如果能分割成双项
							altp = self.AltStr(strtl[0],8,MenuScreen.Expbnow)
							alth = self.AltStr(strtl[1],8,MenuScreen.Expbnow)
							if(self.IsNumber(altp)):#如果条件项是实数
								dlta = math.fabs(float(altp)-float(alth))
								if( dlta < fmin):
									if(ltt>1):#分割项不小于二项
										print("\t条件为等于的实数三元判断，差值(",dlta,")，返回字串[",strttl[1],"]")
										rstrt = strttl[1]
								else:
									if(ltt>2):
										print("\t条件为等于的三元判断，差值(",dlta,")，返回字串[",strttl[2],"]")
										rstrt = strttl[2]
							else:#如果条件项不是实数（是字串）	
								if(altp == alth):
									if(ltt>1):#分割项不小于二项
										print("\t条件为等于的三元判断，返回字串[",strttl[1],"]")
										rstrt = strttl[1]
								else:
									if(ltt>2):
										print("\t条件为等于的三元判断，返回字串[",strttl[2],"]")
										rstrt = strttl[2]
					elif(strttl[0].find('>')>0):
						strtl = strttl[0].split('>')
						if(len(strtl)>1):#如果能分割成双项
							altp = self.AltStr(strtl[0],8,MenuScreen.Expbnow)
							alth = self.AltStr(strtl[1],8,MenuScreen.Expbnow)
							if(float(altp) > float(alth)):
								if(ltt>1):#分割项不小于二项
									print("\t条件为大于的三元判断，返回字串[",strttl[1],"]")
									rstrt = strttl[1]
							else:
								if(ltt>2):
									print("\t条件为不大于的三元判断，返回字串[",strttl[2],"]")
									rstrt = strttl[2]
									
					elif(strttl[0].find('<')>0):
						strtl = strttl[0].split('<')
						if(len(strtl)>1):#如果能分割成双项
							altp = self.AltStr(strtl[0],8,MenuScreen.Expbnow)
							alth = self.AltStr(strtl[1],8,MenuScreen.Expbnow)
							if(self.IsNumber(altp) and self.IsNumber(alth)):#20250322
							
								if(float(altp) < float(alth)):
									if(ltt>1):#分割项不小于二项
										print("\t条件为小于的三元判断，返回字串[",strttl[1],"]")
										rstrt = strttl[1]
								else:
									if(ltt>2):
										print("\t条件为不小于的三元判断，返回字串[",strttl[2],"]")
										rstrt = strttl[2]
		print("\t三元条件判断模块AltCond返回[",rstrt,"]")
		return rstrt
			





# 76 24            (15168 0)

	def JFileP (self,mylist):#20250421判断是否笈文件格式
		print("\n进入文件列表是否笈格式判断JFileP，表首行「",mylist[0],"」")		
		ExpMode = False
		Ignore=self.DLFmt(mylist)#求出‘0’所在的词序号，推导出笈格式位
		lie=mylist[0].split()
		lcol=len(lie)
		if(lcol>=2):
			if(lie[Ignore+1][-1]=='0' and lie[Ignore+2].isdigit()):
				#如果笈格式位是‘0 数字’
				if(len(mylist)>Ignore+3):#行数必须大于一个数字括号所需
					lstrt =mylist[Ignore+3].split()
					lenl =len(lstrt)
					if(lenl>=Ignore+2):#下个格式行项数如果符合笈格式
						if(lstrt[Ignore+1]==lie[Ignore+2]):
							ExpMode=True
		print("\tJFileP返回是否笈格式判断：",ExpMode)		
		return ExpMode






# 101 293  (15168 0)

	def SearchFile (self,lpath,ss):#在主目录所勾选的文件内，搜索内容
		print("\n进入SearchFile搜索主目录所选文件中含「",ss,"」的内容\t当前搜索打开文件[",lpath,"]")#202504202MenuScreen.fileName_choose
		CheckedRow = SelectableLabel.SelectedLines#20250420
		
		bratio=0.05 #0.49空行比，决定搜索结果是否扩展至空行
		Fruitpath=os.path.join(os.getcwd(),'src',MenuScreen.FruitFile)#20250420	self.WinPath,
		#os.getcwd()0430Fruitpath摘要文件路径；lapth为读入文件路径
		if((ss[0]=='`') or (ss[0]=='｀')) :#有界搜索，即以数字、文字的变化作为边界
			Ltdp=True#v0.54
			ss=ss[1:]	
#			print("首字为`或｀进入有界搜索，关键字->",ss)
		else:
			Ltdp=False#v0.54
			
		sslist2=[]
#		v0.54由空格及'、'表解构并行（可选条件）搜索项数；再解构‘；’分隔的必选条件
		sslistt=[]
		sslist1=[]
		sym=[' ','、']
		sslistt.extend(ss.split(sym[0]))
		i=0
		li=len(sslistt)
		for sp in  sym[1:]:
			for i in range(len(sslistt)):
				ss1=sslistt[i]
				if(ss1.find(sp)>=0):
					sslist1.extend(ss1.split(sp))
				else:
					if ss1.strip():
						sslist1.append(ss1)
				if(i==li-1):
					sslistt=sslist1
					li=len(sslistt)
					sslist1=[]
#				print("i=",i,"\t列表变化：",sslist1)
		sslist1=sslistt
#		print("\t关键字'、'拆分后列表结果：",sslist1)

		lenl1=len(sslist1)
		for i1 in range(lenl1):
			if(sslist1[i1].find(";")>=0):
#				print("搜索关键字中含';'")
				sslist2=sslist1[i1].split(";")#"；"解构多条件（必选条件）搜索	
#				print("\n多条件关键字集sslist2=",sslist2)
			elif(sslist1[i1].find("；")>=0):
#				print("搜索关键字中含中文'；'")
				sslist2=sslist1[i1].split("；")#中文"；"解构多条件搜索	#20241125"，"
#				print("\n多条件关键字集sslist2=",sslist2)
		lenl2=len(sslist2)
		fh2=open(Fruitpath,mode='a+t',encoding='UTF-8')#写入摘要文件
#		fh2=TemporaryFile('w+t',encoding='utf-8' )
		if fh2:
			fh2.close
			fh2=open(Fruitpath,mode='w+t',encoding='UTF-8')
			fh2.write("搜索关键字：\t"+ss+"\n")
		fh1=open(lpath,mode='r+t',encoding='UTF-8')#读取目录文件
		if fh1:#目录文件
			fh1.seek(0)#文件指针指向首位
			data=fh1.read()#202504203消除尾空行[:-1]
			mylist = data.split("\n")#含相对文件路径
			if(len(mylist[-1])==0):#202504203消除尾空行
				mylist.pop()
			print("\t\t目录文件表前三项为",mylist[:3],"……")
			fh1.close()
		it=len(mylist)#目录文件行数
		nti = int(self.PickMName("Test1.txt")[2])#20250420model.rowCount()#202504174界面列表行数#20250420
		print("\t目录页列表共(",nti,")行，目录页文件共（",it,"）行，显示（",int(it/2),"）行，相差（",nti-int(it/2),"）")
		
		for it1 in range(0,it,2):#按序打开文件#202501132 1,it
			nt = int((it1)/2)#20241125文件行号的一半对应it1的界面选中行+1#202504174
			if(nt<nti):#202504174
#				print("\t\t当前遍历第(",nt,")行，检测选中否")#20250420
				srchP = False#202504202搜索操作判断
				if(len(CheckedRow)==1):#如果只勾选顶行，将搜索所有文件
					srchP = True#202504202
				else:
					if str(nt+1) in CheckedRow:#202504202如选中行数大于1，只搜索选中的文档
						srchP = True#202504202
				if srchP:
				
#				if self.model.item(nt+1).checkState():#202501132item(it1)#202504174	item(nt)目录行对应选中表行号大1
					print("\t\t遍历目录页选中的第(",nt,")行")
					if(mylist[it1].strip()):#202501132[it1-1]
						print("\t\t\t该行非空")
						if(it1+1<it):
							lmylist = mylist[it1+1].split(' ')
							if(len(lmylist)>=1):#202504192 =
								lfilename=os.path.join(os.getcwd(),"src",lmylist[0])#20250420
#								lfilename=os.path.join(self.WinPath,"src",mylist[it1+1])#20250419 it1-1
								print("\t\t\t\tSearchFile未达目录页末行，文件名为[",lfilename,"]")
								if(os.path.isfile(lfilename)):#20250419下增二档，遍历目录文件首词
									fh1=open(lfilename,mode='r+t',encoding='UTF-8')
									if fh1:
										print("\t\t\t\t\tSearchFile打开主目录下文件[",lfilename,"]")
										fh1.seek(0)
										data=fh1.read()
										listt = data.split("\n")#含完整的文件路径
										fh1.close()#202504174
										it2=len(listt)#202504174每个文件中的表项数，下增一档
		
										blinecount=0#空行数初值
										for data in listt:#统计空行数
											if data=="":
												blinecount+=1

										srchexpand = False#搜索结果是否上下扩展至空行的判断
										ib=0#记录空行号始值
										if(blinecount/it2>bratio):#空行比较大时，说明是简单用空行分隔过的文档
											if(ss[-1] == ' '):#20250421增加约束条件，当搜索的关键词尾带空格时，才扩展
												if(not self.JFileP(listt)):#20250421增加'非笈格式文件'约束条件
													srchexpand=True#对加工文本可扩展搜索结果，到上一个空行
#										else:
#											srchexpand=False
										print("\t\t文件「",lfilename,"」共(",it2,")行，含空行(",blinecount,")行，空行比(",blinecount/it2,")>.05，扩选至前后空行判断：",srchexpand)

										iscan=0
										ifirst=0
										slestate=False
										while (iscan<it2):#扫描遍历各行
											sa =listt[iscan]#获取行内容#202504174将变量s替换为sa
#											print("第(",iscan,")行[",sa ,"]\t\t")
				
											if not sa.strip():#检测是空行
												ib=iscan#记录始行号
											if slestate:#未到末行时，不记录；到选择的末行时，标记完成选中
#												print("入选[",sa ,"]")
												if not sa.strip():#检测下个空行结束选择
#													fh2.write(sa +"\n")#202504174	不记录结束空行
													slestate=False
													print("入选字符已至空行(",iscan,")选择中止")#202504174	i换为iscan
#											else:
#												print("未入选字符：\t",sa )
											if slestate:
												fh2.write(sa +' ' +str(iscan)+"\n")#20250418增加行号
												print("\t\t\t\t[",sa ,"]第(",iscan,")行入选")
#												fh2.write(sa +"\n")
											else:	
												printedP = False
												for i1 in range(lenl1):#遍历可选关键词
													if(lenl2>0):#对于有必选关键字的＃202504202 if(sslist2)
														print("有必选关键词搜索")
														i2p=0
														FoundP = False#20250421
														for i2 in range(lenl2):
															newpos2 = -1
															if(len(sslist2[i2])>0):
																newpos2=sa.find(sslist2[i2])
															if (newpos2>=0):
																#v0.54有界搜索，数字、文字转变为界
																print("以关键词[",sslist2[i2],"]搜索(",i2,")行『",sa,"』，在位置newpos2(",newpos2,")处找到")
																if Ltdp:
																	newpos2e=newpos2+len(sslist2[i2])-1
																	if(newpos2==0):
																		if(newpos2e<len(sa )-1):
																			if not (sa [newpos2e].isdigit() and sa [newpos2e+1].isdigit()):
																				#print(iscan,"行右界数文转变")
																				i2p+=1
																		elif (newpos2e==len(sa )-1):
																			#print(iscan,"右界尽")
																			i2p+=1
																	else:
																		if(newpos2e<len(sa )-1):
																			if not (sa [newpos2e].isdigit() and sa [newpos2e+1].isdigit()):
																				#print(iscan,"行右界数文转变")
																				if not (sa [newpos2].isdigit() and sa [newpos2-1].isdigit()):
																					#print(iscan,"行左界数文转变")
																					i2p+=1
																		elif (newpos2e==len(sa )-1):
																			#print(iscan,"右界尽")
																			if not (sa [newpos2].isdigit() and sa [newpos2-1].isdigit()):
																				#print(iscan,"行左界数文转变")
																				i2p+=1
																else:
																	#print("\t\t\t(",iscan,")行发现不分数字文字边界地搜索关键词字->\t",sslist2[i2])
																	i2p+=1
															if(i2p>=lenl2):
																print("\n\t本行[",sa ,"]匹配多条件")
																PosFound=iscan+1
																FoundP = True#20250421
																print("搜索关键词[",ss,"]于(",PosFound,")行发现,写入文件->",Fruitpath)	
															if(srchexpand):
																slestate=True
															if((not printedP) and FoundP):#20250421
																if(ifirst==0):
																	fh2.write(os.path.basename(lfilename)+"\n")#202504174 与comments.txt格式操持统一
#																	fh2.write("「 "+os.path.split(lfilename)[1]+" 」\t文件中搜索结果：\n")	
																	ifirst=1
																if slestate:
																	fh2.write("\n")#202504174
																	for i3 in range(ib,iscan-1):#20250418 i改为iscan
																		if(len(listt[i3])>0):
																			fh2.write(listt[i3]+' ' + str(i3)+"\n")#20250418 文字末增加行号，使末项为行号，与comments.txt格式操持统一
#																		fh2.write(listt[i3]+"\n")
																	fh2.write("\n")#202504174
#																	fh2.write("＝＝＝＝＝＝\n")
					
																if(len(sa)>0):#20250421增此行，加一档解决笈格式选中太多
																	fh2.write(sa+' ' + str(iscan) +"\n")#20250418
#																	fh2.write(sa +"\n")
																	print("\t\t\t\t\t必选关键字[",sa,"]位于(",iscan,")行发现关键词")
					
																if slestate:
																	fh2.write("\n")#202504174
#																	fh2.write("＝＝＝＝＝＝\n")
																printedP=True#0.52
														
													else:#对于无必选关键字的
														newpos1=sa.find(sslist1[i1])
														#print("搜索关键字中不含中英文'；'，字串[",sa ,"]位置",newpos1,"关键字：",sslist1[i1],"……开始有界检测")
														if(newpos1>=0):#发现搜索字符
															#v0.54有界搜索
															i2p=0
															FoundP = False#20250421
															if Ltdp:
																newpos1e=newpos1+len(sslist1[i1])-1
																print("\t\t\t\t\t(",iscan,")行",newpos1,"~",newpos1e,"列发现无‘；’（必选条件）有界搜索关键字->\t",sslist1[i1])	
																if(newpos1==0):
#																	print("newpos1==0\tnewpos1e=",newpos1e)
																	if(newpos1e<len(sa )-1):
																		if not (sa [newpos1e].isdigit() and sa [newpos1e+1].isdigit()):
																			#print("右界数文转变")
																			i2p+=1
																	elif (newpos1e==len(sa )-1):
																		#print("右界尽",sa [newpos1e])
																		i2p+=1
																else:
																	if(newpos1e<len(sa )-1):
																		if not (sa [newpos1e].isdigit() and sa [newpos1e+1].isdigit()):
																			#print("右界数文转变")
																			if not (sa [newpos1].isdigit() and sa [newpos1e-1].isdigit()):
																				#print("左界数文转变")
																				i2p+=1
																	elif (newpos1e==len(sa )-1):
																		#print("右界尽",sa [newpos1e])
																		if not (sa [newpos1].isdigit() and sa [newpos1e-1].isdigit()):
																			#print("左界数文转变")
																			i2p+=1
															else:
#																print("\t\t\t\t\t(",iscan,"行发现无‘；’（必选条件）无界搜索关键字->\t",sslist1[i1])
																i2p+=1
															if(i2p>=1):
				
																PosFound=iscan+1
																FoundP = True#20250421
																if(srchexpand):
																	slestate=True
																if((not printedP) and FoundP):#20250421
																	if(ifirst==0):
																		bfname = os.path.basename(lfilename)
																		fh2.write("\n"+bfname+"\n")#20250418 与comments.txt格式操持统一
#																		fh2.write("\n\t「 "+os.path.split(lfilename)[1]+" 」\t文件中搜索结果：\n")			
																		print("\t\t\t\t\t\t打印文件名[",bfname,"]位于(",iscan,")行")
																		ifirst=1
																	print("搜索[",ss,"]字符在(",PosFound,")行发现,写入文件->",Fruitpath)
																	if slestate:
																		fh2.write("\n")#202504174
																		for i3 in range(ib,iscan-1):#20250418 i改为iscan
																			if(len(listt[i3])>0):
																				fh2.write(listt[i3]+' ' + str(i3)+"\n")#20250418 与comments.txt格式操持统一
#																			fh2.write(listt[i3]+"\n")
																		fh2.write("\n")#202504174
#																		fh2.write("＝＝＝＝＝＝\n")
																	if(len(sa)>0):#20250421增此行，加一档解决笈格式选中太多
#																		fh2.write(sa +' ' + str(PosFound)+"\n")#202504174
																		fh2.write(sa +' '+str(iscan)+"\n\n")#20250418
#																		fh2.write(sa +"\n")
																		print("\t\t\t\t\t无必选关键字[",sa,"]位于(",iscan,")行发现关键词")
						
																	if slestate:
																		fh2.write("\n")#202504174
#																		fh2.write("＝＝＝＝＝＝\n")
																	printedP=True#0.52
#															else:
#																print("无‘有界搜索’结果，i2p=",i2p)
		
											iscan+=1
										if(iscan==it2):
											PosFound=1
											print("\n***搜索文件：",lfilename,"到达尾部***\n")
	
		print("\nSearchFile搜索主目录所勾选文件模块准备显示\n")
		if fh2:
			fh2.close()
		self.displayextract()








# 293 50  (15270 0)

	def PickMName (self,filename):#20250420提取列表框标题、序号
		print("\n进入提取列表框标题模块PickMName，文件名[",filename,"]")
		rlist = []
		path=os.path.join(os.getcwd(),MenuScreen.OftenFiles)
		with open(path,mode='r+t',encoding='UTF-8') as f:
			data = f.read()
			dlist = data.split("\n")
			if(len(dlist[-1])==0):
				dlist.pop()
			ld = len(dlist)
			tline = int(ld/2)
			for id in range(ld):
				if(dlist[id].find(filename)>=0):#如果发现文件名
					MNamestr = dlist[id-1]
					if(len(MNamestr)>0):
						MName = MNamestr.split(' ')[0]
						rlist.append(MName)
						SeN = int((id+1)/2)+1
						rlist.append(str(SeN))
						rlist.append(str(tline))
						print("\t\t\t准备返回主目录标题、序号、主页行数表",rlist)
		return rlist
						






	def DissBgp(self):#202504224关闭主窗口编辑框背景图片
		print("进入关闭主窗口编辑框背景图片显示模块")
		self.menu_screen.ids.Text_Edit.background_normal  = "sty/textinput_disabled.png"





	def DissBgp2(self):#202504224关闭主窗口编辑行背景图片
		print("进入关闭主窗口编辑行背景图片显示模块")
		self.menu_screen.ids.Line_Edit.background_normal  = "sty/textinput_disabled.png"



	def DissBgp3(self):#202504235关闭文本窗口编辑框背景图片#202505013
		print("进入关闭文本窗口编辑框背景图片显示模块")
		self.text_screen.ids.Enlarge_Edit.background_normal  = "sty/textinput_disabled.png"



# 50 7         (15781)

if __name__ == '__main__':#主程序类入口
	app=MainApp()#202409222增加app=，以响应调出窗口管理器app.sm.current
	app.run()



# 7 0
