aview-app 1.0.2

package/aardio/lib/thread/command.aardio

@@ -0,0 +1,315 @@
+//command 线程命令
+import win.ui;
+import thread.table;
+namespace thread;
+
+class command{ 
+	ctor( winform ){  
+		if(!winform){
+			winform = ..win.form( {} );
+			winform.messageOnly();
+		}
+		this._form = winform;
+		this.hwnd = winform.hwnd;
+		this._commands = {};
+		
+		if( winform.__onThreadCommand ){
+			error("目标窗口已绑定线程命令,禁止重复绑定!",2)
+		}
+		
+		winform.__onThreadCommand  = function( cmdId ){
+        	return receive( this._commands,cmdId);
+		}
+		
+		..table.gc(this,function(){
+			for(name in this._commands ){
+				 this[name] = null;
+			} 
+		});
+	};
+	subscribe = function(k,f){
+		if( type(f) != "function" ) error("参数@2必须是函数对象",2);
+		if( type(k) != "string" ) error("参数@1必须是字符串",2);
+		
+		var list = this._commands[k];
+		var tl = type(list);
+		if( tl= "function"){
+			list = {list};
+		}
+		elseif( tl != "table") {
+			list = {};
+		}
+		
+		if( ..table.find(list,f) ) return;
+		..table.push(list,f);
+		 
+		this[k] = f;
+		this._commands[k] = list;
+		return;	
+	};
+	unsubscribe = function(k,f){
+		if( type(f) != "function" ) error("参数@2必须是函数对象",2);
+		if( type(k) != "string" ) error("参数@1必须是字符串",2);
+		var list = this._commands[k];
+		var tl = type(list);
+		if( tl == "table") { 
+			var idx = ..table.find(list,f)  
+			if(idx ) ..table.remove(list,idx ); 
+		}
+		else if( list == f ){
+			this[k] = null;
+		} 
+	};
+	invoke = function( tfunc,...){
+		..thread.invoke( tfunc ,this._form.hwnd,... );
+	};
+	@_meta;
+}
+ 
+namespace command {  
+	var commandTable = ..thread.table("{3EA9E65D-B101-42AF-93D7-08522F8841CD}.commands"); 
+ 	var commandRet = ..thread.table("{89ACA2D9-FC21-4834-8C70-0FDFD267EB27}.return"); 
+ 	
+ 	_meta = {
+		_set = function(k,v){ 
+			commandTable.setByNamespace("subscribe['"+k+"'][" + owner._form.hwnd + "]",v?true:null)
+			owner._commands[k] = v;
+		};
+		_get = function(k,ownerCall){
+			if(ownerCall) {
+				if(k[1]=='$'#){
+					return function(...){
+						return self.post(owner._form.hwnd,k,...);
+					} 		
+				} 
+				
+				return function(...){
+					return self.send(owner._form.hwnd,k,...);
+				} 	
+			}
+		};
+		_serialize = function(kernelCall){
+			if(kernelCall){
+				return ..string.format(`global.import('thread.command') : ..thread.command.bind(%d)`,owner._form.hwnd); 	
+			} 
+		}
+	};
+	
+	receive = function( methodTable,wParam ){ 
+		var args = commandTable.get(wParam) 
+		commandTable.set(wParam,null); 
+		if(!args) error("错误的递归触发线程命令被中止,请检查是否在线程命令中调用了消息分发函数",2);
+		
+		var method = methodTable[ args[1] ]
+		var tm = type(method); 
+		var _,argc = ..table.range(args); 
+		if( tm =="function" ){ 
+			var ret = invoke(method,methodTable, ..table.unpack( args,2,argc) );
+			if( ret !== null ) return commandRet.push(ret);  
+		}
+		elseif( tm == "table" ){
+			var ret;
+			for(i=1;#method){
+				 ret = invoke(method[i],methodTable, ..table.unpack( args,2,argc) );
+				 if( ret !== null ) return commandRet.push(ret);
+			}
+		}
+	};
+
+ 	send = function( hwnd,method,... ){  
+ 		var t = type(hwnd);
+ 		var bindargs;
+ 		if(t == "table" ){
+ 			bindargs = hwnd;
+			hwnd = bindargs[1];
+			t = type(hwnd);
+			if(t != "number" ) error("绑定的线程命令参数第一个参数必须是窗口句柄",2);
+		} 
+		
+		if( t == "string" ){  
+			var sendTable;
+			sendTable = {hwnd;method;...};
+			method = hwnd;
+			var subscribe = commandTable.getByNamespace("subscribe['"+method+"']");
+			
+			var ret;
+			for(hwnd in subscribe){
+				var id = commandTable.push(sendTable); 
+				ret = ::SendMessageInt(hwnd,0xACCC/*_WM_THREAD_COMMAND*/,id,0);
+				if( ret ) { var r = commandRet.get(ret); commandRet.set(ret, null); return r; } 
+			}
+		}
+		elseif(t == "number" ){
+			var sendTable = {method;...}; 
+			if( bindargs ) ..table.spliceArgs(sendTable,2,0,bindargs,2)
+			var id = commandTable.push( sendTable ); 
+			var ret = ::SendMessageInt( hwnd,0xACCC/*_WM_THREAD_COMMAND*/,id,0);
+			if( ret ) { var r = commandRet.get(ret); commandRet.set(ret, null); return r; }  
+		};  
+	};
+	
+	post = function( hwnd,method,... ){  
+ 		var t = type(hwnd); 
+ 		var bindargs;
+ 		if(t == "table" ){
+ 			bindargs = hwnd;
+			hwnd = bindargs[1];
+			t = type(hwnd);
+		} 
+		
+		if( t == "string" ){
+			var sendTable;
+			sendTable = {hwnd;method;...};
+			method = hwnd; 
+			var subscribe = commandTable.getByNamespace("subscribe['"+method+"']");
+			
+			var ret;
+			for(hwnd in subscribe){
+				var id = commandTable.push(sendTable); 
+				if( !::PostMessage(hwnd,0xACCC/*_WM_THREAD_COMMAND*/,id,0) ){
+					commandTable.set(id,null); //避免有进无出
+				}
+			} 
+		}
+		elseif(t == "number" ){
+			var sendTable = {method;...}; 
+			if( bindargs ) ..table.spliceArgs(sendTable,2,0,bindargs,2)
+			var id = commandTable.push( sendTable ); 
+			if(! ::PostMessage( hwnd,0xACCC/*_WM_THREAD_COMMAND*/,id,0) ){
+				//超过消息队列上限(10,000),此函数返回0表示丢失消息发送失败
+				commandTable.set(id,null); //避免有进无出
+				return false;
+			}
+			return true;
+		}; 
+	};
+	 
+	
+	var tickIdle = 0;
+	var time_tick = ..time.tick;
+	sendIdle = function(delay,...){
+		var tick = time_tick();
+		if( tick - tickIdle > delay ){
+			tickIdle = tick
+			return send(...);
+		}
+	};
+	
+	postIdle = function(delay,...){
+		var tick = time_tick();
+		if( tick - tickIdle > delay ){
+			tickIdle = tick
+			return post(...);
+		}
+	};
+	
+	self.invoke = function( id,f,... ){
+		..raw.closehandle( ..thread.create(
+			function(id,f,...){ 
+				import thread.command; 
+				thread.command.post(id,f(...) ) 
+			},id,f,...) );   
+	};
+	
+	sendInvoke = function(hwnd,method,...){
+		return ..thread.invokeAndWait(
+			function(hwnd,method,...){
+				import thread.command;
+				return thread.command.send(hwnd,method,...)
+			},hwnd,method,...
+		)
+	};
+	
+	instance = function(){
+		if( ! self[["_instance"]] ){
+			self[["_instance"]] =  ..thread.command(); 
+		}
+		return self[["_instance"]];
+	}
+	
+	bind = function(hwndListener,...){
+		if( type(hwndListener) != type.number ){
+			error("参数@1必须指定命令处理窗口句柄",2)
+		}
+		
+		if( ... ) { hwndListener = {hwndListener;...};}
+
+		return { 
+			send = function(...){
+				return self.send(hwndListener,...);
+			}
+			post = function(...){
+				self.post(hwndListener,...);
+			} 
+			sendIdle = function(delay,...){
+				self.sendIdle(delay,hwndListener,...);
+			}
+			postIdle = function(delay,...){
+				self.postIdle(delay,hwndListener,...);
+			} 
+			@{
+				_get = function(k){
+					if(k[1]=='$'#){
+						return function(...){
+							return self.post(hwndListener,k,...);
+						} 		
+					} 
+					
+					return function(...){
+						return self.send(hwndListener,k,...);
+					} 
+				} 
+			}
+		}
+	}
+	
+	self@ = {
+		_get = function(k){
+			if(k[1]=='$'#){
+				return function(...){
+					return owner.post(k,...);
+				} 		
+			}
+					
+			return function(...){
+				return owner.send(k,...);
+			} 
+		} 
+	}
+}
+
+/**intellisense()
+thread.command.post(.(窗口句柄,"命令函数名",其他参数) = 不阻塞调用跨线程命令,\n参数@1指定句柄时,超过消息队列限制发送失败返回false,否则返回true
+thread.command.post(.("命令函数名",其他参数) = 不阻塞调用跨线程命令,不接收返回值\n不指定窗口句柄,所有同名的线程命令函数都会被调用\n函数无返回值
+thread.command.send(.(窗口句柄,"命令函数名",其他参数) = 阻塞调用跨线程命令,\n注意send函数发送的消息有可能比之前post函数发送的消息更早被接收\n可获取回调函数的返回值,默认返回空值
+thread.command.send(.("命令函数名",其他参数) = 阻塞调用跨线程命令,\n注意send函数发送的消息有可能比之前post函数发送的消息更早被接收\n不指定窗口句柄,所有同名的线程命令函数都会被调用,\n可获取回调函数的返回值,默认返回空值
+thread.command.sendInvoke(.(窗口句柄,"命令函数名",其他参数) = 调用线程命令并等待返回值,等待过程中不卡界面,\n注意sendInvoke函数发送的消息有可能比之前post函数发送的消息更早被接收\n可获取回调函数的返回值,默认返回空值
+thread.command.sendInvoke(.("命令函数名",其他参数) = 调用线程命令并等待返回值,等待过程中不卡界面,\n注意sendInvoke函数发送的消息有可能比之前post函数发送的消息更早被接收\n不指定窗口句柄,所有同名的线程命令函数都会被调用,\n可获取回调函数的返回值,默认返回空值
+thread.command.sendIdle(.(延时值,窗口句柄,"命令函数名",其他参数) = 在指定的延时值内忽略部分消息\n其他同send函数
+thread.command.sendIdle(.(延时值,"命令函数名",其他参数) = 在指定的延时值内忽略部分消息\n其他同send函数
+thread.command.postIdle(.(延时值,窗口句柄,"命令函数名",其他参数) = 在指定的延时值内忽略部分消息\n其他同post函数
+thread.command.postIdle(.(延时值,"命令函数名",其他参数) = 在指定的延时值内忽略部分消息\n其他同post函数
+thread.command.命令函数名() = 如果命令函数名首字符为$以post模式异步调用命令，\n否则以send模式同步调用该命令,\n传入参数应与该命令定义时预设的形参一致,\nsend模式调用可获取回调函数的返回值,默认返回空值
+thread.command( = 创建线程命令订阅对象,返回对象可传入其他线程使用。\n返回对象添加的成员函数,都可在其他线程中调用。
+thread.command(.(窗口对象) = 创建线程命令订阅对象,\n省略窗口对象则创建 message only window
+thread.command() = !thread_command.
+thread.command.instance() = 全局单实例线程命令订阅对象\n!thread_command.
+!thread_command.? = @.__/*订阅命令函数名字,支持不定个数参数\n如果同一个名字要注册多个回调函数请使用subscribe函数,\n使用"."成员操作符可获取命令调用函数,不可使用下标,\n默认以send模式同步调用，函数名首字符为$以post模式异步调用\nsend模式下返回值可阻止命令继续传递*/ = function( ... ){
+	
+}
+!thread_command.subscribe(  = 订阅指定的命令
+!thread_command.subscribe(.("订阅命令名字",回调函数对象) = 同一个名字可以多此调用此函数添加多个不同的关注回调函数\n回调函数如果返回值可阻止命令继续传递
+!thread_command.unsubscribe( = 取消订阅指定的命令
+!thread_command.unsubscribe(.("订阅命令名字",回调函数对象) = 函数无返回值
+!thread_command.invoke( 线程函数,->->-> ) = @.invoke(\n    function( hwndListener,... ){\n        import thread.command;\n        var notifier = thread.command.bind(hwndListener);\n        \n        notifier.post("begin") \n        notifier.post("end") \n    },...\n)
+thread.command.invoke("命令名",线程函数,调用参数) = @.invoke(  \n	"__/*创建线程\n使用线程函数的返回值作为参数触发该命令*/" ,function( ... ){\n		\n	}, \n)
+!thread_command._form = 窗体对象\n!winform.
+!thread_command.hwnd = 绑定监听对象窗体句柄
+thread.command.bind(hwndListener) = 绑定监听对象窗体句柄\n可添加绑定任意个默认调用参数
+thread.command.bind() = !thread_command_bind.
+!thread_command_bind.send("__/*命令函数名*/",) = 不阻塞调用跨线程命令
+!thread_command_bind.post("__/*命令函数名*/",) = 不阻塞调用跨线程命令
+!thread_command_bind.sendIdle(1000,"__/*命令函数名*/",) = 阻塞调用跨线程命令,\n在参数@1指定的延时值内忽略部分消息
+!thread_command_bind.postIdle(1000,"__/*命令函数名*/",) = 阻塞调用跨线程命令,\n在参数@1指定的延时值内忽略部分消息
+!thread_command_bind.? = 调用send函数发送该命令,\n传入参数应与该命令定义时预设的形参一致\n可获取回调函数的返回值,默认返回空值
+end intellisense**/

package/aardio/lib/thread/dlManager.aardio

@@ -0,0 +1,211 @@
+//dlManager 下载线程管理器
+import fsys;
+import thread.works;
+import thread.event;
+import thread.command;
+import util.metaProperty;
+
+namespace thread;
+class dlManager {
+
+	ctor( limit,waitTime ){
+		
+		this.works = ..thread.works( limit : 3, 
+			function( args ) {
+				if( ! args.id) return; //取消任务
+				
+				var eventId = ..string.format("thread/download/%s",tostring(args.id ));
+				var event = thread.event(eventId,true);//参数2为真避免线程自动切换信号
+				
+				var id = args.id;
+				var hwndCommand = args.hwndCommand;
+				var savepath = args.savedir;
+				if( args.filename ) savepath =  ..fsys.joinpath( savepath,args.filename )  
+	 		
+	 			var send = ..thread.command.send;
+	 			var post = ..thread.command.post;
+				var remoteFile = inet.httpFile(args.url,savepath,args.resumePath,args.userAgent,args.proxy,args.proxyBypass,args.httpFlags);
+				if( !remoteFile ){
+					send( hwndCommand,"onError",id,"参数错误");
+					return;
+				}
+				
+				var totalSize = 0;
+				var filename = io.splitpath(remoteFile.path).file;
+				remoteFile.onReceiveBegin = function(statusCode,contentLength,fileSize){
+					if( statusCode == 206/*断点续传*/ ){
+						send( hwndCommand,"onReceiveBegin",id,threadId,args.url,filename,"断点续传",statusCode,contentLength+fileSize,fileSize)
+						totalSize = fileSize;
+					}
+					elseif(fileSize){ 
+						send( hwndCommand,"onReceiveBegin",id,threadId,args.url,filename,"重新下载",statusCode,contentLength,0)
+					}
+					else {
+						send( hwndCommand,"onReceiveBegin",id,threadId,args.url,filename,"开始下载",statusCode,contentLength,0)
+					}
+				}
+				
+	
+				var time_tick = ..time.tick;
+				var tkPrev = 0;
+				var sizePs = 0;
+				remoteFile.onReceive = function(str,size,contentLength){ 
+					totalSize = totalSize + size;
+					sizePs = sizePs + size; 
+					var tkCurrent = time_tick();
+					var ms = tkCurrent - tkPrev;
+					if( ms > 1000 ){
+						post( hwndCommand,"onReceive",id,sizePs/(ms/1000),totalSize);
+						sizePs = 0;
+						tkPrev = tkCurrent;
+					}
+					
+					return ! event.wait(1) /*检测主线程是否发出停止信号*/;
+				}
+		 		
+				var ok,err,fileSize = remoteFile.download(args.headers,args.referer,args.accept,args.flags,args.postData);
+				
+				if( ok ){
+					send( hwndCommand,"onEnd",id,remoteFile.path,remoteFile.resumePath,remoteFile.contentLength  ) 
+				}
+				else {
+					if( err )  send( hwndCommand,"onError",id,err );
+					else send( hwndCommand,"onEnd",id  );
+				} 
+				
+				remoteFile.close();
+				event.close();
+			},waitTime : 200,function(){
+				import fsys;
+				import inet.http
+				import inet.httpFile;
+				import thread.command;
+				import thread.event; 
+				
+				..threadId = ..thread.getId();
+			}
+		) 
+		
+		this.threadIds = {};
+		this.listener = ..thread.command();
+		this.listener.onReceiveBegin = function(id,threadId,url,filename,statusText,httpStatusCode,contentLength,fileSize){
+			this.threadIds[threadId] = id;//线程正在下载的任务ID
+			if( this.onReceiveBegin ){
+				this.onReceiveBegin(id,url,filename,statusText,httpStatusCode,contentLength,fileSize);
+			}
+		}
+		
+		..table.gc(this,"quit");
+	}; 
+	cancel = function(id){
+		if( !id ) error("请指定id参数",2);
+		
+		//取消待执行任务 
+		for( idx,args in this.works.each() ){
+			if( args.id == id ){
+				this.works.update(idx,{} );//取消下载
+				this.works.resume();
+				return;
+			}
+		} 
+		
+		//取消正在执行任务
+		var eventId = ..string.format("thread/download/%s",tostring(id));
+		var event = ..thread.event(eventId,true);
+		event.set();
+		event.close();
+	};
+	quit = function(){
+
+		for( idx,args in this.works.each() ){
+			this.works.update(idx,{} );
+		}
+		for(tid,id in this.threadIds ){
+			var eventId = ..string.format("thread/download/%s",tostring(id));
+			var event = ..thread.event(eventId,true);
+			event.set();
+			event.close();
+		}
+
+		var r = this.works.wait();
+		this.works.quit();
+		return r;
+	};
+	push = function(args){
+		if( !args[["id"]] ){
+			error("参数必须指定 id 属性",2)
+		}
+		if( !args[["url"]] ){
+			error("必须指定 url 属性",2)
+		}
+		if( !args[["savedir"]] ){
+			error("必须指定 savedir 属性",2)
+		}
+		
+		if( !args[["hwndCommand"]] ){
+			args[["hwndCommand"]] = this.listener._form.hwnd;
+		}
+		
+		for( idx,args2 in this.works.each() ){
+			if( args2.url == args.url ){ 
+				return;
+			}
+		} 
+		this.works.push( args );
+		return args;
+	}
+	@_metaProperty;
+	
+}
+namespace dlManager{
+	_metaProperty = ..util.metaProperty(
+		onReceive = {
+			_get = function(){ 
+				return owner.listener.onReceive;
+			}
+			_set = function( value ){
+				owner.listener.onReceive = value;
+			} 	
+		};
+		onEnd = {
+			_get = function(){ 
+				return owner.listener.onEnd;
+			}
+			_set = function( value ){
+				owner.listener.onEnd = value;
+			} 	
+		}; 
+		onError = {
+			_get = function(){ 
+				return owner.listener.onError;
+			}
+			_set = function( value ){
+				owner.listener.onError = value;
+			} 	
+		};
+	)
+}
+
+/**intellisense()
+thread.dlManager = 多线程下载管理器
+thread.dlManager(.(线程数,等待延时) = 创建下载管理器\n参数@省略则默认创建2个下载线程可选用\n参数@2指定线程每次任务完成后的等待延时,默认为200毫秒
+thread.dlManager() = !thread_dlManager.
+!thread_dlManager.push() = !thread_dlManager_task.
+!thread_dlManager_task.id = 任务id
+!thread_dlManager.push( 任务配置 ) = @.push( \n    id = __/*必须指定任务唯一标志\n参数表也是此函数的返回值*/;\n    url = "下载网址,重复的下载网址将被自动忽略";/;\n    referer = "引用网址";\n    savedir = "/download/";\n    filename = 可选参数;  \n)
+!thread_dlManager.cancel(.(任务ID) = 取消指定的下载任务
+!thread_dlManager.quit() = 关闭全部下载线程
+!thread_dlManager.works = !thread_work.
+!thread_dlManager.onReceiveBegin = @.onReceiveBegin = function(id,url,filename,statusText,httpStatusCode,totalSize,downSize){
+    __/*开始下载触发此事件*/
+}
+!thread_dlManager.onReceive = @.onReceive = function(id,sizePs,downSize){
+    __/*下载触发此事件*/
+}
+!thread_dlManager.onEnd = @.onEnd = function(id,savepath,resumePath,contentLength){
+    __/*下载完成触发此事件\n下载成功则savepath为存储路径,否则该参数为空\nresumePath为续传配置文件路径*/
+}
+!thread_dlManager.onError = @.onError = function(id,err){
+    __/*下载错到错误触发此事件\n出错则err参数为错误信息,用户取消则err参数为空*/
+}
+end intellisense**/

package/aardio/lib/thread/event.aardio

@@ -0,0 +1,97 @@
+//event 事件同步对象
+namespace thread;
+
+class event {
+	ctor( eventName,manualReset,initialState){ {
+	
+		var tArg1 = type(eventName);
+		if( tArg1 == "pointer" )   {
+			this.handle	= eventName;
+			if(manualReset===true)..table.gc( this,"close" );
+		}
+		else{
+			if( tArg1 == "string" ){  
+				this.handle  =  ::Kernel32.OpenEvent( 0x1F0003/*_EVENT_ALL_ACCESS*/,false ,eventName); 
+			} 
+			
+			if(! this.handle ) {  
+				this.handle  =  ::Kernel32.CreateEvent(null,manualReset,initialState,eventName); 
+				
+				if( tArg1 == "string" ){  
+					if(!this.handle) {
+						this.handle  =  ::Kernel32.OpenEvent( 0x1F0003/*_EVENT_ALL_ACCESS*/,false ,eventName); 
+						if( this.handle ) this.conflict = "事件对象已存在"; 
+					}
+					elseif(::GetLastError()==0xB7/*_ERROR_ALREADY_EXISTS*/){
+						this.conflict = "事件对象已存在";
+					}
+				}
+			} 
+			else {
+				this.conflict = "事件对象已存在";
+			}
+			
+			if(!this.handle) {
+				return null,..lasterr();
+			}
+			
+			this.handle = topointer(this.handle);
+			..table.gc( this,"close" );
+		}
+	} };
+	close = function(){ 
+		if( this.handle ){
+			..raw.closehandle(this.handle);
+			this.handle = null;
+		}
+	};
+	@_metaProperty; 
+}
+
+namespace event{
+	import util.metaProperty;
+	_metaProperty = util.metaProperty(
+ 
+		_topointer = function(){
+			return owner.handle;
+		}; 
+		_serialize = function(kernelCall){
+			if(kernelCall) return ..raw.serializeDupHandle("thread.event",owner.handle);
+		};
+		set = function(){
+			return !!Kernel32.SetEvent( owner.handle );  
+		};
+		
+		reset = function(){
+			return !!Kernel32.ResetEvent( owner.handle ); 
+		};
+		
+		pulse = function(){
+			return !!Kernel32.PulseEvent( owner.handle ); 
+		};
+		
+		wait = function(timeout){
+			return ..thread.wait(owner.handle,timeout)
+		};  
+		
+		waitOne = function(timeout){
+			return ..thread.waitOne(owner.handle,timeout)
+		};  
+	)
+}
+
+/**intellisense()
+thread.event( = 创建或打开事件对象,\n返回对象可传入其他线程使用。
+thread.event(.(事件对象句柄) = 直接打开事件对象
+thread.event(.(事件对象句柄,true) = 直接打开事件对象\n添加析构函数负责释放句柄
+thread.event(.("事件对象名称",是否手动复原,初始状态) = 名称不能包含反斜杠,不能超过260个字符\nthread.event,process.mutex,fsys.mmap等命名不能相同,\n省略名称创建匿名对象,\n参数@2,@3仅在创建新的事件对象是有效\n这两个参数都是可选参数默认为false\n初始状成默认为无信号状态\n手动复原指wait函数等到信号是否硕要手动reset到无信号状态
+!thread_event.close() = 关闭事件对象\n该函数并不关闭信号量内核对象\n当所有引用内核对象的对象关闭,内核对象自动释放\n如果没有手工调用此函数,则线程结束时自动调用.
+!thread_event.conflict = 如果事件对象已存在,此属性为真值\n否则为空值
+!thread_event.set() = 设置事件的状态为有信号状态,\n退出等待该事件对象信号的函数\n类似交通信号灯切换到绿灯放行等待线程
+!thread_event.reset() = 事件对象设置为无信号状态\n类似交通信号灯切换到红灯阻塞等待线程\n如果创建事件对象时并未设定手动复位,此函数不需要手动调用
+!thread_event.pulse() = 该函数主要用于手动复原事件对象\n设置事件对象为有信号状态,并释放某些等待线程\n然后自动到无信号状态
+!thread_event.wait() = 等待事件切换到有信号状态,\n可选增加一个参数指定超时,以毫秒为单位\n在UI线程中应使用非阻塞的waitOne函数替代\n如果未指定手工复原、等待成功则自动复原为无信号状态
+!thread_event.waitOne() = 等待事件切换到有信号状态,\n可选增加一个参数指定超时,以毫秒为单位\n如果未指定手工复原、等待成功则自动复原为无信号状态
+?thread.event = !thread_event.
+thread.event = 事件对象可用于线程或进程间同步
+end intellisense**/