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;
}
}
