//com 组件接口
namespace builtin;
self.com = global.com;

namespace com { 
    
    TryCreateObject = function(cls,...){
		var ok,obj = call(CreateObject,self,cls)
		if( ok ) return obj;
		if( !... ) return null,obj;
		return TryCreateObject(...); 
	};
	
	TryGetObject = function(cls,...){
		var ok,obj = call(self.GetObject,self,cls)
		if( ok ) return obj;
		if( !... ) return null,obj;
		return TryGetObject(...); 
	}; 
	
	GetOrCreateObject = function(...){
		return TryGetObject(...) || TryCreateObject(...)
	};
	
	ConnectWeak = function(comObj,realSink){
		return Connect(comObj,{ 
			realSink = realSink;
			@{ 
				_get = realSink; 
				_set = function(k,v){ realSink[[k]] = v };
				_weak="v";
				@{_weak="v"} 
			}  
		}); 	
	};
	
	CreateEmbedEx = function(clsId,ctrl,embed){
		if(ctrl) return ctrl.createEmbedEx(progId,embed);
		if(!embed) embed = {};
		
		embed._object = CreateObject(clsId);
		embed.__event__ = {} 
		
		Connect(embed._object,embed.__event__);
		
		embed@ = {
			_get = embed._object;
			_set = function(k,v){ 
				if(type(v) === "function") owner.__event__[[k]] = v;
				else owner._object[k] = v; 
			}
		};
		
		return embed; 
	};
	
	eachRunning = function(tn,dp){
    	var r = {}
		enumRunning( 
			function(displayName,o){
				if(dp ? !..string.find(displayName,dp) ) return;
				
				try{
					var t = GetTypeInfo(o);
					if(!t){
						if(!tn)..table.push(r,{o,displayName});
					}
					else {
						var typeName = t.GetDocumentation().name;
						if( !tn || typeName == tn ) ..table.push(r,{o,displayName,typeName});	
					}  
				} 
			}
		)
		
		var i,v;
		return function(){
			i,v = ..table.next(r,i);
			if(v) return v[1],v[3],v[2],i
		}
	};
	
	QueryObjectR = function(p){
		var r = ..com.QueryObject(p);
		if(r){ Release(p) };
		return r;
	}
	
	each = function(obj) {
		if (type(obj) == type.function) obj = obj();
		
		var enum;
		if (!IsObject(obj)) {
			if( isEnumerator(obj) ) enum = obj; 
			else error('\n{Bad argument}:@1\n{Expected}:COM object\n{Got}:'+type(obj), 2); 
		}
		else {
			enum = GetEnumerator(obj);
		}

		var index = 0;
		return function() {
			var value = enum.Next();
			if (value) {
				index = index + 1;
				return index,value;
			}
		},function(){
			Release(enum);
			enum = null;
		} 
	};
	 
	first = function(obj){
		var enum = obj ? GetEnumerator(obj);
		if(enum){
			var value = enum.Next();
			Release(enum); 
			return value;
		}  
	};
 
	float = lambda(v,ref) Variant(v,4/*_VT_R4*/,ref); 
	double = lambda(v,ref) Variant(v,5/*_VT_R8*/,ref); 
	byte = lambda(v,ref) Variant(v,0x10/*_VT_I1*/,ref); 
	ubyte = lambda(v,ref) Variant(v,0x11/*_VT_UI1*/,ref); 
	word = lambda(v,ref) Variant(v,2/*_VT_I2*/,ref); 
	uword = lambda(v,ref) Variant(v,0x12/*_VT_UI2*/,ref); 
	int = lambda(v,ref) Variant(v,3/*_VT_I4*/,ref); 
	uint = lambda(v,ref) Variant(v,0x13/*_VT_UI4*/,ref); 
	long = lambda(v,ref) Variant(v,0x14/*_VT_I8*/,ref); 
	ulong = lambda(v,ref) Variant(v,0x15/*_VT_UI8*/,ref);
	
    SafeArrayType = function(v){
    	if( type(v)==="table" ) return v@[["_safearray_type"]];
    };
    
	toSafeArray = function(a,vt){
		var t = type(a);
		if(t==="buffer") return a;
		if(a@[["_safearray_type"]]) return a; 
		if(t==="string") return { _safearray = a;  _type = 0x11/*_VT_UI1*/};
		if(a[["_safearray"]]) return a;
		return { _safearray = a||[];  _type = vt};
	};
	SafeArrayV = toSafeArray;//@Deprecated 
} 
/**intellisense()
com = COM 组件支持库,\n虽然这是内置库，但例外的是这个库不会自动导入,\n如果在已经导入win.ui 的界面线程，win.ui 会负责自动导入 com 库\n[使用手册相关文档](doc://library-guide/builtin/com/com.md)
end intellisense**/

/**intellisense(com)
first(__) = 对传入的 COM对象 调用 com.each 创建迭代器,\n执行该迭代器并返回第一次返回的 COM对象 ,\n如果传入参数为 null 或 false 则直接返回
each = @for index,obj in com.each(__) {\n\n} //迭代遍历com集合对象，参数可以直接传入COM迭代器
DoObjectVerb(.(OLE对象,-1) = 执行OLE对象的动词,\n参数2可使用_OLEIVERB_前缀常量
SafeArrayType(__) = 如果传入参数为 COM 安全数组（SAFEARRAY），\n则返回一个表示 COM 数组元素类型的数值,该值应以 _VT_ 前缀的常量进行比对。\n支持 com.SafeArray 创建的 COM 数组，或 COM 函数返回的数组。\n参数如果是 com.Variant 创建的 Variant 对象，返回 null， \n参数是其他类型值，也返回 null。
toSafeArray(.(值,元素类型) = 转换为 COM 兼容数组，返回对象只能用于 COM 函数。\n\n1. 如果参数 @value 是 `buffer` 类型则直接返回，参数 @variantType 无效。\n2. 如果参数 @value 已经是 com.SafeArray 格式的 COM 数组则直接返回，参数 @variantType 无效。\n3. 如果参数 @value 是 `字符串` 则返回声明为 _VT_UI1 类型 COM 数组的包装对象，参数 @variantType 无效。 \n4. 其他情况下返回 COM 数组的包装对象，value 只能指定表对象或者 null 值（将创建空数组）。\n\n可选用参数 @variantType 指定数组元素的 COM 变体类型。\n如果未指定 @variantType ，则默认设为 _VT_ILLEGAL （自动检测类型）。\n自动检测并设定类型规则：\n字符串数组设为 _VT_BSTR，数值数组设为 _VT_R8，COM 对象数组设为 _VT_DISPATCH，\n其他设为 _VT_VARIANT。\n\n\ncom.toSafeArray 函数不受 com.SetPreferredArrayType 的设置影响。\nVBS 接口应将 @variantType 参数指定为 _VT_VARIANT，否则无法识别数组。
SafeArray( = 创建或获取 COM 安全数组（SAFEARRAY）。
SafeArray(.(variantType,->->->) = 创建 COM 安全数组（SAFEARRAY）。\n在 aardio 中 COM 数组默认存为纯数组对象，但数组元表的 _safearray_type 声明了 COM 数组类型。\nCOM 函数传入传出 COM 数组均默认使用此格式。\n\n参数 @variantType 可指定表示 COM 数组类型的数值，支持 _VT_ 前缀的自动完成常量。\n不指定 @variantType 时默认为 _VT_VARIANT（ 可兼容 VBS 数组）。\n类型为 _VT_ILLEGAL 则单个值与数组元素类型均自动设定，这是调用 COM 接口的默认规则。\n	- 纯字符串数组默认元素类型为 _VT_BSTR,\n	- 纯数值类型默认元素类型为 _VT_R8（double）,\n	- IDispatch 对象数组元素类型为 _VT_DISPATCH，\n	- 其他数组元素类型默认为 _VT_VARIANT\n\n可选增加一个或多个参数指定初始化时添加到数组的成员。
SafeArray(.(ptrSSafeArray,variantType) = 自 SAFEARRAY 内存指针获取 COM 安全数组。\n参数 @ptrSSafeArray 必须指定 pointer 类型指针（C++ 类型声明为 SAFEARRAY*）。\n参数 @variantType 指定元素类型，省略则默认为 _VT_UI1 。\n\n如果 @variantType 为 _VT_UI1 则将数组转换为缓冲区（ buffer ）返回。\n其他类型转换为普通数组，并且数组元表的 _safearray_type 声明了 COM 数组类型。\n与使用 com.SafeArray 函数创建的 COM 安全数组格式相同。
CreateEmbed( = 创建 COM 控件对象,\n通常不会直接使用此函数,\n应改用窗口或控件对象提供的 CreateEmbed 或 CreateEmbedEx 函数,\n或者 com.lite 提供的 CreateEmbed 或 CreateEmbedEx 函数
CreateEmbed(.(embedObject,formOrCtrl,progId,preferredInvokeKind) = 创建 COM 控件对象并嵌入 @formOrCtrl 指定的窗体或控件窗口\n@progId 指定要创建的 COM 控件的 ProgID 或者 CLSID\n@embedObject 用一个表指定容器对象\n容器对象可以是一个空的表用于接管 COM对象。\n@preferredInvokeKind 参数作用与 com.SetPreferredInvokeKind 的参数相同，不必指定。\n\n函数返回该容器对象并添加成员_host,_object,_form\n_object 成员是创建的 COM对象 ,\n_form 是传入参数中的 @formOrCtrl,\n_host 是 COM 控件宿主对象,提供部分 OLE 接口函数,\n\n容器对象可通过添加成员函数响应 COM对象 事件，\n容器对象的另主要作用是充当访问 COM对象 的中间代理对象。\n通常使用 util.metaProperty 为容器对象添加属性元表，\n属性元表可拦截属性、函数调用并调用 _object 对象
CreateEmbed(.(embedObject,formOrCtrl,comObject) = 创建 COM 控件对象并嵌入 @formOrCtrl 指定的窗体或控件窗口\n@comObject 参数指定 com.IDispatch 对象,\n@embedObject 用一个表指定容器对象
CreateObject("__") = 创建并返回 com.IDispatch 对象,参数@1可指定 CLSID 或 ProgID,\n创建失败会抛出异常,使用 com.TryCreateObject 代替不会抛异常
GetObject("__") = 从已运行的实例获取并返回 com.IDispatch 对象,\n参数@1可指定CLSID或ProgID,也可指定打开的文件路径,如 doc 文件,\n获取对象失败会抛出异常,使用 com.TryGetObject 代替不会抛异常。 \n\n如果当前进程与目标 COM 服务进程不具有相同权限，则会报错『无效的操作』。
TryCreateObject(.(cls,->->->) = 参数可指定一个或多个CLSID/ProgID,逐个测试直到创建成功,\n成功返回 com.IDispatch 对象,\n创建失败返回null,错误信息,不会抛出异常,\n参数@1可指定 CLSID或 ProgID 
TryGetObject("__") = 从已运行的实例获取并返回 com.IDispatch 对象,\n参数可指定一个或多个 CLSID/ProgID,也可指定要打开的文件路径,如doc文件,\n\n创建失败返回null,错误信息,不会抛出异常。\n\n如果当前进程与目标 COM 服务进程不具有相同权限，则会返回 null。
GetOrCreateObject("__")  = 参数可指定一个或多个CLSID/ProgID,\n首先调用 com.TryGetObject 尝试获取并返回已运行的实例,\n如果失败则调用 com.TryCreateObject 函数尝试创建并返回对象,\n\n创建失败返回null,错误信息,不会抛出异。\n\n如果当前进程与目标 COM 服务进程不具有相同权限，\n则 TryGetObject 不能获取该进程创建的 COM 对象。 
CreateEmbedEx( = 创建 COM 控件，返回控件容器对象。\n容器对象的 _object 成员是创建的 COM 对象。\n容器对象的 __event__ 成员为 COM 对象默认事件监听器。\n\n返回容器已添加元表，可通过容器对象的成员代理访问 COM 对象成员。\n也可以通过指定容器对象的成员函数响应 COM 对象事件
CreateEmbedEx(.(clsId,ctrlOrForm,embedObject) = 创建 COM 控件,返回控件容器对象。\n此函数返回的容器已添加元表并创建代理以直接访问 COM对象，\n也可以通过指定容器对象的成员函数响应 COM 对象事件。\n@clsId 指定控件 CLSID 或者 ProgID 。\n可选用 @ctrlOrForm 指定宿主窗口，\n如果指定了窗主窗口，在窗口销毁时解除默认事件监听器并释放 COM 对象。\n可选在参数 @embedObjec 中指定 COM对象 绑定的容器对象
QueryObject(__/*IUnknown指针*/ )  = 查询 IDispatch 接口、并创建 com.IDispatch 对象
QueryObjectR(__/*IUnknown指针*/ )  = 查询 IDispatch 接口、并创建 com.IDispatch 对象\n如果成功则调用 com.Release 释放传入的 IUnknown 指针\n使其引用计数减一,释放的指针不应再使用,\n返回的 COM对象 会增加引用计数,\n并在对象释放时自动减一
IsObject(__/*任意对象*/) = 检测参数是否一个动态 COM对象（IDispatch 对象）
IsNetObject(__/*任意对象*/) = 检测参数是否一个 .NET 原生对象，是则返回非 0 值。\n如果是普通 .NET 对象返回 1，如果是 DispatchableObject 对象返回 2
GetPointer(.(COM对象 ) = 获取 IDispatch 指针\n该指针返回前已调用 AddRef 增加 COM 引用计数,\n不再使用时必须及时调用 com.Release 释放
GetPointer(.(COM对象 或指针,GUID) = 使用 GUID 指定接口获取原生指针,\n该指针返回前已调用AddRef增加COM引用计数,\n不再使用时必须及时调用 com.Release 释放,\n参数@1可是 COM对象  、com.IUnknown对象、或可转换为指针的对象\n参数@2可用文本格式表示,省略时默认为IID_IUnknown
GetIUnknown(.(COM对象 或指针,GUID) = 使用 GUID 指定接口获取 com.IUnknown 托管指针\n参数@1可是任何可以转换为指针的对象,与API参数规则相同,\n可选在参数@2使用字符串或GUID指定接口\n该指针自动管理引用计数，无须手动释放
IsIUnknown(.(任意参数)  = 检测参数是否一个托管 com.IUnknown 指针
isEnumerator(__/*对象*/) = 检查并返回参数指定的对象是否 COM 迭代器
ConnectWeak( = 注册弱引用自身的事件接收表\n此函数返回sink,cookie 共2个返回值，\nsink为事件接收器,cookie是一个数字值,用来记录连接点，\n这2个返回值可以用于 com.ReleaseConnection 释放事件表
ConnectWeak(.(COM对象,事件接收表) = 参数@2指定一个table类型的表对象\n该表对象被创建为COM对象的默认事件接口并注册为事件接收器。\n\n在COM对象销毁前，com.Connect绑定的事件接收表会被强引用并被阻止回收，\n如果COM对象与事件接收表存在循环引用自身会导致COM对象无法释放,\ncom.ConnectWeak函数通过创建一个中间代理对象弱引用事件接收表，可以避免该问题，\n但要注意回调事件访问的owner对象是代理对象,使用owner.realSink可以获取真正的事件表
Connect( = 注册事件接收表\n此函数返回sink,cookie 共2个返回值，\nsink为事件接收器,cookie是一个数字值,用来记录连接点，\n这2个返回值可以用于 com.ReleaseConnection 释放事件表。
Connect(.(COM对象,事件监听表) = 参数 @2 指定一个 table 类型的表对象\n该表对象被转换为COM对象的默认事件监听器并实现默认事件接口,\n如果需要显式指定接口类型请使用 com.AddConnection。\n\ncom.Connect 绑定的事件监听表会被强引用到 COM对象 \n如果COM对象与事件接收表存在循环引用自身会导致无法释放,\n可用 com.ReleaseConnection 手动释放事件绑定,\n或者改用 com.ConnectWeak,com.CreateEmbedEx 也可以避免该问题。\n\n参数 @1 指定的对象如果被释放回收，事件监听也会自动解除。\n注意 excel.ActiveWorkbook 这种动态属性应当先保存到变量，再绑定事件
GetEnumerator(__) = 获取枚举对象,\n参数 @1 指定 COM对象 
GetEnumerator() = !comEnumerator.
ShowHelp(__/*COM对象 */) = 显示帮助
RoundTrip() = 将aardio对象转换为COM对象，\n再将该 COM对象 转换为aardio对象
ImplInterface(.(implObject) = 将 aardio 对象转换为支持 IDispatch 接口的 COM对象 ，\n参数@1可以是普通表对象、函数对象、类对象、cdata对象。\n\n如果参数@1是函数或类对象,回调时 owner 参数为 dispIdMember 数值。\n如果参数@1是表对象转换为 COM对象 ，直接作为 COM 函数调用时支持 _call元方法，\n如果未定义 _call元方法则调用表对象中索引为0的函数\n通过 COM 接口调用表的成员函数时支持 _get 元方法，并将 ownerCall 参数设为 true。\n\n表对象或表的成员函数作为COM函数回调时 owner 参数总是指向表对象自身,\ndispIdMember小于0时总是调用表索引中对应的函数,\n\n在与 COM 接口交互时，\n无法自动转换为 COM对象的 aardio 对象也会调用此函数自动转换
ImplInterface(.(implTable,progID,interfaceName) = 使用一个 table 表转换为 @interfaceName 指定的接口对象\n例如：com.ImplInterface( flash.callevent ,"ShockwaveFlash.ShockwaveFlash","_IShockwaveFlashEvents")
ImplInterfaceFromTypelib(.(implTable,typelibPath,interfaceName,coclassNname) = 使用类型库实现com接口
IsMember(.(comObject,memberName) = 返回参数 @memberName 指定的名字是否 @comObject 参数指定 COM 对象的成员。
NewObject(.(tab,progId) = 创建COM对象,可选使用参数@3指定tlb类型库路径\n此函数详细用法请参考标准库com.activeX的源代码
NewControl(.(tab,progId) = 创建COM控件,可选使用参数@3指定tlb类型库路径\n此函数详细用法请参考标准库com.activeX的源代码
Release(__) = 释放 COM 对象、.NET 对象、IUnknown 指针、com.interface 创建的对象。\n如果参数 是 pointer 类型指针调用 IUnknown 接口 Release 函数使引用计数减一\n如果参数是 cdata 内核对象或自元表中返回 cdata,则调用 cdata 的 _gc 析构函数\n\n参数 @1 为 null 抛出异常
AddConnection( = 添加 COM 对象事件接收器。
AddConnection(.(comObject,eventSink) = @添加 COM 对象事件接收器。\n\n参数 @comObject 指定需要监听事件的 COM 对象。\n参数 @comObject 指定的对象如果被释放回收，事件监听也会自动解除。 \n注意 excel.ActiveWorkbook 这种动态属性应当先保存到变量，再绑定事件\n\n参数 @eventSink 支持以下两种事件接收器：\n- 使用 com.ImplInterface 函数创建的动态事件接口。\n- 使用 com.interface 实现的原生静态事件接口。\n\n注册成功返回一个表示事件连接点的 cookie 。\ncookie 可作为释放绑定的 com.ReleaseConnection 函数的参数。
ReleaseConnection( = 释放 COM 对象事件接收器。
ReleaseConnection(.(comObject,eventSink, cookie) = 释放 COM 对象事件接收器。\n\n@comObject 指定要解除事件监听的 COM对象。\n\n参数 @eventSink 支持以下两种事件接收器：\n- 使用 com.ImplInterface 或 com.Connect 函数创建的动态事件接口。\n- 使用 com.interface 实现的原生静态事件接口\n\n@cookie 来自 com.AddConnection 或 com.Connect 的返回值\n\n即使不调用此函数，\n在 COM对象 销毁前也会释放所有事件。
ReleaseConnection(.(comObject) = 释放由 com.Connect 函数绑定的默认事件接口接收器。\n参数 @comObject 指定要解除事件接收器的 COM对象。\n\nn即使不调用此函数，在 COM对象 销毁前会自动释放所有事件接收器。
DumpTypeInfo( = 输出 COM对象  类型信息、成员函数列表，\n输出到控制台可使用 console.dump 函数。\n\n调用 com.tlbDoc.dump 函数可打印 COM对象 更详细的类型库信息
DumpTypeInfo(.(comObject) = 返回一个字符串\n包含 COM对象  类型信息、成员函数列表,\n此函数不会输出到控制台,\n输出到控制台请使用 console.dump 函数
GetTypeInfo(__/*COM对象 */) = 返回类型信息
LoadTypeLibrary(.("->tlb") = 加载类型库\n参数可以是CLSID、类型库路径、或包含类型库资源的组件路径
LoadTypeLibrary() = !comTypeLib.
GetTypeInfo() = !comTypeInfo.
CreateEmbed() = !embedObject.
enumRunning(回调函数) = @.enumRunning( \n	function(displayName,object){  \n		__/*枚举ROT（运行对象表）并获取COM对象,\n此回调函数返回true中止枚举*/\n	}\n)
eachRunning(interface,name) = @for object,interface,name,index in com.eachRunning() {
	__/*遍历ROT（运行对象表）\n参数 @interface 可选限定接口名（完全匹配），参数 @name 可选用模式串限定显示名称。 \n返回 object为 COM 对象 ,interface 为接口名称（可能为 null）,name 为显示名称。index 为序号*/
}
SetPreferredArrayType(__/*COM 对象*/,0xC/*_VT_VARIANT*/) = 设置调用该 COM对象 时 aardio 数组参数转 COM 数组的默认类型，\n参数只能设为 _VT_VARIANT 或 _VT_ILLEGAL,默认已设置为 _VT_ILLEGAL。\n此设置值会自动传递到该 COM对象 返回的其他 COM对象 。\n\n此选项设为 _VT_ILLEGAL 将自动调整为合适的类型,规则如下：\n纯字符串数组类型设为 _VT_BSTR,\n纯数值数组类型设为 _VT_R8（double），\n其他数组类型设为 _VT_VARIANT，\n这也是所有 COM对象 的默认设置。\n\n如果要创建明确指定 COM 类型的数组参数，\n可使用 com.Variant,COM.SafeArray,COM.toSafeArray,com.int ... 等函数
SetPreferredInvokeKind(__/*COM 对象*/,1/*_INVOKE_FUNC*/) = 设置以函数方式调用 COM 对象时，是否总是将 COM 对象作为方法调用。\n此选项会影响到所有通过该 COM 对象创建或返回的其他 COM 对象。\n参数 @2 只能省略（默认自动选择）或者指定为 1/*_INVOKE_FUNC*/。\n\n只有极个别 COM 对象在自动选择时报错（极为罕见）才需要调用此函数。\n在默认设置下，如果无法通过类型信息或 get,set 前缀确定是调用方法还是属性，\n则由目标 COM 对象自动选择调用方式。\n\n如果调用此函数并设参数为 INVOKE_FUNC, 且调用 com.SetPreferredArrayType 并设参数为 VT_ILLEGAL，\n则该 COM 对象所有传入传出的所有时间对象总是自动转换为 UTC 时间（不改变入参）。
Variant( = 创建 VARIANT 变体对象。\n可用于普通 COM对象 传值或传址参数。\n可用于 .NET 普通输入参数，不支持 .NET 输出参数（可改用 dotNet.object）。\n可用于 API 函数中 `VARIANT*` 指针类型参数。
Variant(.(初始值,变体类型,输出引用) = 可选指定一个初始值，可以是任意适用于 COM 参数的值或数组。\n\n参数 @2 可选用一个 _VT_ 前缀的整数常量指定期望的 COM 变体类型。\n变体类型指定数值，且参数 @1 为无元表的空表或非空数组时都会处理为 COM 数组。\n\n若省略类型或设为 _VT_VARIANT，则单值自动选择类型，未明确类型的数组设为 VT_VARIANT。\n如果变体类型为 _VT_ILLEGAL，则单值与数组均自动选择类型，此为 COM 接口默认规则。\n \n单整数默认类型为 _VT_I4（int）,小数默认类型为 _VT_R8（double）,\n纯字符串数组默认为 _VT_BSTR 数组,纯数值类型默认为 _VT_R8（double）数组,\n其他数组类型默认为 _VT_VARIANT 数组。\n\n可选参数 @3 如果设为 true，就可以用于 COM 输出参数。
Variant(.(指针,true) = 创建 VARIANT 变体对象\n如果参数@2为 true ，则参数 @1 必须为 VARIANT 指针。\n调用 VariantCopyInd 函数拷贝参数指定的源 VARIANT 对象
Variant() = !comVariant.
byte(__) = 定义数值类型为 8 位整数，\n作为输入参数可兼容 .NET System.SByte 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
ubyte(__) = 定义数值类型为 8 位无符号整数，兼容 .NET System.Byte 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
word(__) = 定义数值类型为 16 位整数，\n作为输入参数可兼容 .NET System.Int16 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
uword(__) = 定义数值类型为 16 位无符号整数，兼容 .NET System.UInt16 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
int(__) = 定义数值类型为 32 位整数，\n此函数返回 com.Variant 对象。\n作为输入参数可兼容 .NET System.Int32 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n注意普通数值传入 COM 参数时，\n整数默认转为32位整数，小数默认按double类型处理
uint(__) = 定义数值类型为 32 位无符号整数，\n作为输入参数可兼容 .NET System.UInt32 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
long(__) = 定义数值类型为 64 位整数，\n作为输入参数可兼容 .NET System.Int64 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
ulong(__) = 定义数值类型为 64 位无符号整数，\n作为输入参数可兼容 .NET System.UInt64 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
float(__) = 定义数值类型为 32 位浮点数，\n作为输入参数可兼容 .NET System.Single 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n此函数返回 com.Variant 对象。
double(__) = 定义数值类型为 64 位浮点数，\n此函数返回 com.Variant 对象。\n作为输入参数可兼容 .NET System.Double 类型数值。\n参数 @1 可以为数值或数组，\n参数 @2 为 true 则用于 COM 输出引用参数。\n\n注意普通数值传入 COM 参数时，\n整数默认转为32位整数，小数默认按double类型处理
int() = !comVariant.
uint() = !comVariant.
long() = !comVariant.
ulong() = !comVariant.
byte() = !comVariant.
ubyte() = !comVariant.
word() = !comVariant.
uword() = !comVariant.
double() = !comVariant.
end intellisense**/

/**intellisense(!embedObject)
_form = COM 对象的容器窗口。\n这是一个 win.form 对象或者 win.form 对象内部的控件对象。\n!static.
_object = 原生 COM 控件对象。\n原生 COM 控件对象不等于事件监听表，一般不用于直接绑定 COM 事件。\n应当用 com.Connect 绑定事件监听表。\nCreateEmbedEx 或 CreateEmbed 返回的容器对象也可自动绑定 COM 事件。
_host = COM 控件宿主对象。\n提供部分 OLE 接口函数，一般没必要直接使用这个对象。
_host.close() = 关闭 
_host._adjust() = 自动调整控件窗口大小
_host.tranacc(.(MSG消息对象) = 解析快捷键,\n如果是快捷键返回真值
_host.doObjectVerb( _OLEIVERB__ ) = 执行指定的动词命令
end intellisense**/


/**intellisense(!comTypeInfo)
DumpTypeInfo() = 返回一个字符串,\n列出此类型所有的成员
GetTypeLib() = 返回类型库\n!comTypeLib.
GetFuncDesc(__/*索引*/) = 返回函数描述\n注意超始索引为1
GetVarDesc(__/*索引*/) = COM变量/常量描述\n注意超始索引为1
GetTypeAttr() = 返回类型属性\n!comTypeAttr.
GetImplType(__/*索引*/) = 返回实现接口\n注意超始索引为1
GetImplType() = !comTypeInfo.
GetImplTypeFlags(__/*索引*/) = 实现接口类型属性表\n返回表包含字段default,source,restricted,defaultVTable,都是布尔值,\n注意超始索引为1
GetDocumentation() = 返回文档信息\n!comTypeDoc.
GetFuncDesc() = !comTypeFunc.
end intellisense**/

/**intellisense(!comTypeVar)
value = COM常量值
name = COM变量名
end intellisense**/

/**intellisense(!comTypeFunc)
dispatchable = 是否动态接口函数
restricted = 是否不适合动态调用
memid = 成员ID
invkind = 调用类型\n可能的值为"_get","_set","_setByRef","function"
Params = 参数数量
ParamsOpt = 可选参数数量
name = 函数名
description = 描述
helpfile = 帮助
helpcontext = 数值，帮助上下文
parameters = 参数描述数组
parameters.? = !comTypeParameter.
type = 返回值类型，字符串
vt = 返回值类型，数值,\n数值含义与 com.Variant 对象的 vt 字段相同
end intellisense**/

/**intellisense(!comTypeParameter)
default = 参数的默认值
in = 是否输入参数
opt = 是否可选参数
out = 是否输出参数
type = 参数类型，字符串
vt = 参数类型，数值,\n数值含义与 com.Variant 对象的 vt 字段相同
end intellisense**/


/**intellisense(!comTypeDoc)
helpstring = 对象的描述
name = 对象接口名称
end intellisense**/

/**intellisense(!comTypeLib)
ShowHelp() = 显示帮助
GetTypeInfo(__/*索引*/) = 返回类型信息\n注意超始索引为1
GetTypeInfo() = !comTypeInfo.
GetTypeInfoCount() = 类型信息总数
ExportConstants() = 导出常量名值对组成的表。\n可以使用常量名作为 COM 对象的成员名获取常量值
ExportEnumerations() =  导出全部枚举类型，\n返回一个表，键为枚举类型名，值为该类型的枚举名值对组成的表。\n\n通常枚举名值对也是 COM 常量名值对，\n可以使用枚举名字（不用指定枚举类型名）\n作为 COM 对象的成员名获取枚举值
GetDocumentation() = 返回文档信息\n!comTypeDoc.
end intellisense**/

/**intellisense(!comTypeAttr)
Funcs = 函数总数
Vars = 属性值总数
typekind = 类型,\n值为"coclass","enumeration","interface","dispinterface"\n"alias","union","record","module"之一
ImplTypes = 实现接口总数
flags.cancreate = cancreate
flags.dispatchable = dispatchable
flags.control = control
flags.appobject = appobject
flags.hidden = hidden
flags.oleautomation = oleautomation
GUID = GUID  
end intellisense**/

/**intellisense(!comVariant)
vt = Variant类型，数值，\n只读属性，不可修改
clear() = 清空值\n调用VariantClear函数清空值并重新初始化对象\n调用了此函数以后,对象的vt置为0，\n其他所有成员置为null，包括clear函数也置为null，\n除非通过value属性重新赋值,clear函数才会变为可用\n\n即使不调用这个函数，\naardio在析构回收对象时也会自动调用VariantClear函数释放资源
bstrVal = 只读属性,获取BSTR指针
parray = 只读属性,获取SAFEARRAY指针
pdispVal = 只读属性,获取IDispatch指针
punkVal = 只读属性,获取IUnknown指针 
value = 读写值遵守com与aardio间的数据类型转换规则 
end intellisense**/

/**intellisense(!comEnumerator)
Next(.(n) = 向后获取并返回 n 个元素的值
Reset() = 重置到开始位置
Skip(.(n) = 跳过 n 个元素的值,成功返回 true
Clone() = 复制对象\n!comEnumerator.
end intellisense**/