public override ITypeInfoWrapper GetItemByIndex(int index) { _parent.GetRefTypeOfImplType(index, out var href); _parent.GetRefTypeInfo(href, out var ti); return(TypeApiFactory.GetTypeInfoWrapper(ti)); }
/// <summary> /// </summary> /// <param name="typeinfo"></param> /// <returns></returns> internal static COM.ITypeInfo GetDispatchTypeInfoFromCustomInterfaceTypeInfo(COM.ITypeInfo typeinfo) { int href; COM.ITypeInfo dispinfo = null; try { // We need the typeinfo for Dispatch Interface typeinfo.GetRefTypeOfImplType(-1, out href); typeinfo.GetRefTypeInfo(href, out dispinfo); } catch (COMException ce) { // check if the error code is TYPE_E_ELEMENTNOTFOUND. // This error code is thrown when we can't IDispatch interface. if (ce.HResult != ComUtil.TYPE_E_ELEMENTNOTFOUND) { // For other codes, rethrow the exception. throw; } } return(dispinfo); }
internal static IEnumerable <ComTypes.ITypeInfo> GetInheritedTypeInfos(ComTypes.ITypeInfo typeInfo, ComTypes.TYPEATTR typeAttr) { for (var iImplType = 0; iImplType < typeAttr.cImplTypes; iImplType++) { int href; typeInfo.GetRefTypeOfImplType(iImplType, out href); ComTypes.ITypeInfo implTypeInfo; typeInfo.GetRefTypeInfo(href, out implTypeInfo); yield return(implTypeInfo); } }
internal ComTypeClassDesc(ComTypes.ITypeInfo typeInfo, ComTypeLibDesc typeLibDesc) : base(typeInfo, typeLibDesc) { ComTypes.TYPEATTR typeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(typeInfo); Guid = typeAttr.guid; for (int i = 0; i < typeAttr.cImplTypes; i++) { typeInfo.GetRefTypeOfImplType(i, out int hRefType); typeInfo.GetRefTypeInfo(hRefType, out ComTypes.ITypeInfo currentTypeInfo); typeInfo.GetImplTypeFlags(i, out ComTypes.IMPLTYPEFLAGS implTypeFlags); bool isSourceItf = (implTypeFlags & ComTypes.IMPLTYPEFLAGS.IMPLTYPEFLAG_FSOURCE) != 0; AddInterface(currentTypeInfo, isSourceItf); } }
/// <summary> /// Get the IDispatch Typeinfo from CoClass typeinfo. /// </summary> /// <param name="typeinfo">Reference to the type info to which the type descriptor belongs.</param> /// <returns>ITypeInfo reference to the Dispatch interface.</returns> internal static COM.ITypeInfo GetDispatchTypeInfoFromCoClassTypeInfo(COM.ITypeInfo typeinfo) { // Get the number of interfaces implemented by this CoClass. COM.TYPEATTR typeattr = GetTypeAttr(typeinfo); int count = typeattr.cImplTypes; int href; COM.ITypeInfo interfaceinfo = null; // For each interface implemented by this coclass for (int i = 0; i < count; i++) { // Get the type information? typeinfo.GetRefTypeOfImplType(i, out href); typeinfo.GetRefTypeInfo(href, out interfaceinfo); typeattr = GetTypeAttr(interfaceinfo); // Is this interface IDispatch compatible interface? if (typeattr.typekind == COM.TYPEKIND.TKIND_DISPATCH) { return(interfaceinfo); } // Nope. Is this a dual interface if ((typeattr.wTypeFlags & COM.TYPEFLAGS.TYPEFLAG_FDUAL) != 0) { interfaceinfo = GetDispatchTypeInfoFromCustomInterfaceTypeInfo(interfaceinfo); typeattr = GetTypeAttr(interfaceinfo); if (typeattr.typekind == COM.TYPEKIND.TKIND_DISPATCH) { return(interfaceinfo); } } } return(null); }
private void EnsureScanDefinedEvents() { // _comTypeDesc.Events is null if we have not yet attempted // to scan the object for events. if (_comTypeDesc != null && _comTypeDesc.Events != null) { return; } // // Demand Full Trust to proceed with the operation. // new PermissionSet(PermissionState.Unrestricted).Demand(); // check type info in the type descriptions cache ComTypes.ITypeInfo typeInfo = ComRuntimeHelpers.GetITypeInfoFromIDispatch(_dispatchObject, true); if (typeInfo == null) { _comTypeDesc = ComTypeDesc.CreateEmptyTypeDesc(); return; } ComTypes.TYPEATTR typeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(typeInfo); if (_comTypeDesc == null) { lock (_CacheComTypeDesc) { if (_CacheComTypeDesc.TryGetValue(typeAttr.guid, out _comTypeDesc) == true && _comTypeDesc.Events != null) { return; } } } ComTypeDesc typeDesc = ComTypeDesc.FromITypeInfo(typeInfo, typeAttr); ComTypes.ITypeInfo classTypeInfo = null; Dictionary <string, ComEventDesc> events = null; var cpc = RuntimeCallableWrapper as ComTypes.IConnectionPointContainer; if (cpc == null) { // No ICPC - this object does not support events events = ComTypeDesc.EmptyEvents; } else if ((classTypeInfo = GetCoClassTypeInfo(this.RuntimeCallableWrapper, typeInfo)) == null) { // no class info found - this object may support events // but we could not discover those events = ComTypeDesc.EmptyEvents; } else { events = new Dictionary <string, ComEventDesc>(); ComTypes.TYPEATTR classTypeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(classTypeInfo); for (int i = 0; i < classTypeAttr.cImplTypes; i++) { int hRefType; classTypeInfo.GetRefTypeOfImplType(i, out hRefType); ComTypes.ITypeInfo interfaceTypeInfo; classTypeInfo.GetRefTypeInfo(hRefType, out interfaceTypeInfo); ComTypes.IMPLTYPEFLAGS flags; classTypeInfo.GetImplTypeFlags(i, out flags); if ((flags & ComTypes.IMPLTYPEFLAGS.IMPLTYPEFLAG_FSOURCE) != 0) { ScanSourceInterface(interfaceTypeInfo, ref events); } } if (events.Count == 0) { events = ComTypeDesc.EmptyEvents; } } lock (_CacheComTypeDesc) { ComTypeDesc cachedTypeDesc; if (_CacheComTypeDesc.TryGetValue(typeAttr.guid, out cachedTypeDesc)) { _comTypeDesc = cachedTypeDesc; } else { _comTypeDesc = typeDesc; _CacheComTypeDesc.Add(typeAttr.guid, _comTypeDesc); } _comTypeDesc.Events = events; } }