public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta)
{
Parent = parent;
_ta = ta;
_ti = ti;
string prefix = string.Empty;
if (VarEnum.VT_ARRAY == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_ARRAY))
{
var oad = ta.tdescAlias.lpadesc;
_ti.GetRefTypeInfo(oad.tdescElem.hreftype, out _oti);
prefix = _oti.GetName() + " ";
}
else
{
TmpIdlFormatter tmp = new TmpIdlFormatter();
_ta.tdescAlias.ComTypeNameAsString(ti, tmp);
prefix = tmp.data + " ";
if (VarEnum.VT_USERDEFINED == (VarEnum)_ta.tdescAlias.vt)
{
_ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out _oti);
}
}
_name = prefix + ti.GetName();
_data = new IDLData(this);
}
public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta)
{
Parent = parent;
_ta = ta;
_ti = ti;
string prefix = string.Empty;
if (VarEnum.VT_PTR == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_PTR))
{
var otd = _ta.tdescAlias.lptdsec;
_ti.GetRefTypeInfo(otd.hreftype, out _oti);
prefix = _oti.GetName() + " ";
}
else if (VarEnum.VT_ARRAY == ((VarEnum)_ta.tdescAlias.vt & VarEnum.VT_ARRAY))
{
var oad = ta.tdescAlias.lpadesc;
_ti.GetRefTypeInfo(oad.tdescElem.hreftype, out _oti);
prefix = _oti.GetName() + " ";
}
else
{
_ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out _oti);
prefix = _oti.GetName() + " ";
}
_name = prefix + ti.GetName();
_data = new IDLData(this);
}
public override List <ITlibNode> GenChildren()
{
var res = new List <ITlibNode>();
for (var x = 0; x < _ta.cImplTypes; ++x)
{
_ti.GetRefTypeOfImplType(x, out var href);
_ti.GetRefTypeInfo(href, out var ti2);
CommonBuildTlibNode(this, ti2, false, false, res);
}
return(res);
}
private string GetTypeName(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
return(GetTypeName(tdesc, info));
case VarEnum.VT_USERDEFINED:
unchecked
{
var href = desc.lpValue.ToInt32();
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
return(GetTypeName(refTypeInfo));
}
case VarEnum.VT_CARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
return(GetTypeName(tdesc, info) + "()");
default:
string result;
if (TypeNames.TryGetValue(vt, out result))
{
return(result);
}
break;
}
return("UNKNOWN");
}
internal static ITypeInfo GetDispatchTypeInfoFromCoClassTypeInfo(ITypeInfo typeinfo)
{
int cImplTypes = (int)ComTypeInfo.GetTypeAttr(typeinfo).cImplTypes;
ITypeInfo ppTI = (ITypeInfo)null;
for (int index = 0; index < cImplTypes; ++index)
{
int href;
typeinfo.GetRefTypeOfImplType(index, out href);
typeinfo.GetRefTypeInfo(href, out ppTI);
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = ComTypeInfo.GetTypeAttr(ppTI);
if (typeAttr.typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return(ppTI);
}
if ((typeAttr.wTypeFlags & System.Runtime.InteropServices.ComTypes.TYPEFLAGS.TYPEFLAG_FDUAL) != (System.Runtime.InteropServices.ComTypes.TYPEFLAGS) 0)
{
ppTI = ComTypeInfo.GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ppTI);
if (ComTypeInfo.GetTypeAttr(ppTI).typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return(ppTI);
}
}
}
return((ITypeInfo)null);
}
public override void BuildIDLInto(IDLFormatter ih)
{
EnterElement();
ih.AppendLine("[");
var lprops = _data.Attributes;
for (var i = 0; i < lprops.Count; ++i)
{
ih.AppendLine(" " + lprops[i] + (i < (lprops.Count - 1) ? "," : ""));
}
ih.AppendLine("]");
if (_ta.cImplTypes > 0)
{
_ti.GetRefTypeOfImplType(0, out var href);
_ti.GetRefTypeInfo(href, out var ti2);
ih.AddString($"{_data.Name} : ");
ih.AddLink(ti2.GetName(), "i");
ih.AppendLine(" {");
}
else
{
ih.AppendLine("interface " + _data.Name + " {");
}
using (new IDLHelperTab(ih))
{
Children.ForEach(x => x.BuildIDLInto(ih));
}
ih.AppendLine("};");
ExitElement();
}
internal static ITypeInfo GetDispatchTypeInfoFromCoClassTypeInfo(ITypeInfo typeinfo)
{
int cImplTypes = GetTypeAttr(typeinfo).cImplTypes;
ITypeInfo ppTI = null;
for (int i = 0; i < cImplTypes; i++)
{
int num2;
typeinfo.GetRefTypeOfImplType(i, out num2);
typeinfo.GetRefTypeInfo(num2, out ppTI);
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = GetTypeAttr(ppTI);
if (typeAttr.typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return(ppTI);
}
if (((short)(typeAttr.wTypeFlags & System.Runtime.InteropServices.ComTypes.TYPEFLAGS.TYPEFLAG_FDUAL)) != 0)
{
ppTI = GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ppTI);
if (GetTypeAttr(ppTI).typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return(ppTI);
}
}
}
return(null);
}
public override List <ITlibNode> GenChildren()
{
var res = new List <ITlibNode>();
_ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out var oti);
CommonBuildTlibNode(this, oti, false, false, res);
return(res);
}
public OWTypeDef(ITlibNode parent, ITypeInfo ti, TypeAttr ta)
{
Parent = parent;
_ta = ta;
_ti = ti;
_ti.GetRefTypeInfo(_ta.tdescAlias.hreftype, out var oti);
_name = oti.GetName() + " " + ti.GetName();
}
private void GetParameterType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
GetParameterType(tdesc, info);
IsByRef = true;
break;
case VarEnum.VT_USERDEFINED:
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
IntPtr attribPtr;
refTypeInfo.GetTypeAttr(out attribPtr);
var attribs = (TYPEATTR)Marshal.PtrToStructure(attribPtr, typeof(TYPEATTR));
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_enumGuid = attribs.guid;
}
_type = new ComDocumentation(refTypeInfo, -1).Name;
refTypeInfo.ReleaseTypeAttr(attribPtr);
}
catch (COMException) { }
break;
case VarEnum.VT_SAFEARRAY:
case VarEnum.VT_CARRAY:
case VarEnum.VT_ARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
GetParameterType(tdesc, info);
IsArray = true;
break;
default:
string result;
if (ComVariant.TypeNames.TryGetValue(vt, out result))
{
_type = result;
}
break;
}
}
public override void BuildIDLInto(IDLFormatter ih)
{
ih.AppendLine("[");
var lprops = new List <string> {
$"uuid({_ta.guid})"
};
var help = _ti.GetHelpDocumentationById(-1, out var context);
AddHelpStringAndContext(lprops, help, context);
if (0 != (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FHIDDEN))
{
lprops.Add("hidden");
}
if (0 != (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FDUAL))
{
lprops.Add("dual");
}
if (0 != (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FRESTRICTED))
{
lprops.Add("restricted");
}
if (0 != (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FNONEXTENSIBLE))
{
lprops.Add("nonextensible");
}
if (0 != (_ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FOLEAUTOMATION))
{
lprops.Add("oleautomation");
}
for (var i = 0; i < lprops.Count; ++i)
{
ih.AppendLine(" " + lprops[i] + (i < (lprops.Count - 1) ? "," : ""));
}
ih.AppendLine("]");
if (_ta.cImplTypes > 0)
{
_ti.GetRefTypeOfImplType(0, out var href);
_ti.GetRefTypeInfo(href, out var ti2);
ih.AddString($"interface {_name} : ");
ih.AddLink(ti2.GetName(), "i");
ih.AppendLine(" {");
}
else
{
ih.AppendLine("interface " + _name + " {");
}
using (new IDLHelperTab(ih))
{
Children.ForEach(x => x.BuildIDLInto(ih));
}
ih.AppendLine("};");
}
protected string GetComType(ITypeInfo typeInfo, TYPEDESC typeDesc)
{
VarEnum varEnum = (VarEnum)typeDesc.vt;
switch (varEnum)
{
case VarEnum.VT_PTR:
TYPEDESC ptrTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(GetComType(typeInfo, ptrTypedesc) + "*");
case VarEnum.VT_SAFEARRAY:
TYPEDESC arrayTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(ComBrowserSettings.GetKeyword(VarEnum.VT_SAFEARRAY) + "("
+ GetComType(typeInfo, arrayTypedesc) + ")");
case VarEnum.VT_CARRAY:
TYPEDESC carrayTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(GetComType(typeInfo, carrayTypedesc) + "[]");
case VarEnum.VT_USERDEFINED:
// The .NET definition of GetRefTypeInfo() incorrectly takes an int instead of IntPtr, which fails
// on 64-bit machines. At least don't throw an unhandled exception here.
if ((long)typeDesc.lpValue > int.MaxValue)
{
return("<GetRefTypeInfo bug>");
}
int hreftype = (int)typeDesc.lpValue;
ITypeInfo refTypeInfo;
try
{
typeInfo.GetRefTypeInfo(hreftype, out refTypeInfo);
}
catch (COMException)
{
return("<GetRefTypeInfo failed>");
}
try
{
return(Marshal.GetTypeInfoName(refTypeInfo));
}
finally
{
Marshal.ReleaseComObject(refTypeInfo);
}
default:
return(GetComType(varEnum));
}
}
private PropertyBag AddEnumTypeInfoInternal(ITypeInfo typeInfo)
{
using (var attrScope = typeInfo.CreateAttrScope())
{
if (attrScope.Value.typekind == TYPEKIND.TKIND_ALIAS)
{
ITypeInfo refTypeInfo;
typeInfo.GetRefTypeInfo(unchecked ((int)attrScope.Value.tdescAlias.lpValue.ToInt64()), out refTypeInfo);
var node = AddEnumTypeInfoInternal(refTypeInfo);
if (node != null)
{
var locator = typeInfo.GetManagedName();
var segments = locator.Split('.');
if (segments.Length > 0)
{
var namespaceNode = GetOrCreateNamespaceNode(locator);
if (namespaceNode != null)
{
namespaceNode.SetPropertyNoCheck(segments.Last(), node);
return(node);
}
}
}
}
else if (attrScope.Value.typekind == TYPEKIND.TKIND_ENUM)
{
var node = GetOrCreateEnumTypeInfoNode(typeInfo);
if (node != null)
{
var count = attrScope.Value.cVars;
for (var index = 0; index < count; index++)
{
using (var varDescScope = typeInfo.CreateVarDescScope(index))
{
if (varDescScope.Value.varkind == VARKIND.VAR_CONST)
{
var name = typeInfo.GetMemberName(varDescScope.Value.memid);
node.SetPropertyNoCheck(name, Marshal.GetObjectForNativeVariant(varDescScope.Value.desc.lpvarValue));
}
}
}
return(node);
}
}
}
return(null);
}
private IEnumerable <string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITypeInfo info)
{
var output = new List <string>();
for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
{
int href;
info.GetRefTypeOfImplType(implIndex, out href);
ITypeInfo implTypeInfo;
info.GetRefTypeInfo(href, out implTypeInfo);
IntPtr typeAttributesPointer;
implTypeInfo.GetTypeAttr(out typeAttributesPointer);
var typeAttributes = (TYPEATTR)Marshal.PtrToStructure(typeAttributesPointer, typeof(TYPEATTR));
IMPLTYPEFLAGS flags = 0;
try
{
info.GetImplTypeFlags(implIndex, out flags);
}
catch (COMException) { }
var implTypeName = GetTypeName(implTypeInfo);
if (implTypeName != "IDispatch" && implTypeName != "IUnknown")
{
// skip IDispatch.. just about everything implements it and RD doesn't need to care about it; don't care about IUnknown either
output.Add(implTypeName);
}
if (flags != 0)
{
ComInformation comInfo;
if (_comInformation.TryGetValue(typeAttributes.guid, out comInfo))
{
_comInformation[typeAttributes.guid].ImplTypeFlags =
_comInformation[typeAttributes.guid].ImplTypeFlags | flags;
}
else
{
_comInformation.Add(typeAttributes.guid,
new ComInformation(typeAttributes, flags, implTypeInfo, implTypeName, new QualifiedModuleName(), null, 0));
}
}
info.ReleaseTypeAttr(typeAttributesPointer);
}
return(output);
}
private void GetFieldType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
if (vt == VarEnum.VT_PTR)
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetFieldType(tdesc, info);
}
else if (vt == VarEnum.VT_USERDEFINED)
{
int href;
unchecked
{
//The href is a long, but the size of lpValue depends on the platform, so truncate it after the lword.
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo);
refTypeInfo.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_enumGuid = attribs.guid;
}
IsReferenceType = ReferenceTypeKinds.Contains(attribs.typekind);
_valueType = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name;
}
}
catch (COMException) { }
}
else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY))
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetFieldType(tdesc, info);
IsArray = true;
}
else
{
if (ComVariant.TypeNames.TryGetValue(vt, out string result))
{
_valueType = result;
}
}
}
private ComParameter GetParameterInfo(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
var pointer = GetParameterInfo(tdesc, info);
pointer.IsByRef = true;
return(pointer);
case VarEnum.VT_USERDEFINED:
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
return(new ComParameter(GetTypeName(refTypeInfo), false));
}
catch (Exception)
{
return(new ComParameter("Object", false));
}
case VarEnum.VT_SAFEARRAY:
case VarEnum.VT_CARRAY:
case VarEnum.VT_ARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
var array = GetParameterInfo(tdesc, info);
array.IsArray = true;
array.Name += "()";
return(array);
default:
string result;
if (TypeNames.TryGetValue(vt, out result))
{
return(new ComParameter(result, false));
}
break;
}
return(new ComParameter("Object", false));
}
private static string GetStringFromCustomType(ITypeInfo typeinfo, IntPtr refptr)
{
int hRef = (int)(long)refptr;
ITypeInfo ppTI;
typeinfo.GetRefTypeInfo(hRef, out ppTI);
if (ppTI == null)
{
return("UnknownCustomtype");
}
string strName;
ppTI.GetDocumentation(-1, out strName, out string _, out int _, out string _);
return(strName);
}
private static IEnumerable <ITypeInfo> GetReferencedEnums(ITypeLib typeLib, ITypeInfo typeInfo, TYPEDESC typeDesc, Dictionary <Guid, ITypeInfo> processedTypeInfo)
{
if ((typeDesc.vt == (short)VarEnum.VT_PTR) || (typeDesc.vt == (short)VarEnum.VT_CARRAY))
{
return(GetReferencedEnums(typeLib, typeInfo, (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC)), processedTypeInfo));
}
if (typeDesc.vt == (short)VarEnum.VT_USERDEFINED)
{
typeInfo.GetRefTypeInfo(unchecked ((int)typeDesc.lpValue.ToInt64()), out var refTypeInfo);
return(GetReferencedEnums(typeLib, refTypeInfo, processedTypeInfo));
}
return(Enumerable.Empty <ITypeInfo>());
}
public unsafe void GetFunctionDescriptionsForIUnknown()
{
TypeLibTests.LoadStdOle2(out ITypeLib typeLib);
ITypeInfo typeInfo = typeLib.GetTypeInfoByName("IUnknown");
// From OleView:
//
// [restricted]
// HRESULT _stdcall QueryInterface(
// [in] GUID* riid,
// [out] void** ppvObj);
HResult result = typeInfo.GetFuncDesc(0, out FUNCDESC * description);
result.Should().Be(HResult.S_OK);
description->cParams.Should().Be(2);
description->cParamsOpt.Should().Be(0);
description->cScodes.Should().Be(0);
description->callconv.Should().Be(CallConvention.StdCall);
description->funckind.Should().Be(FunctionKind.PureVirtual);
description->invkind.Should().Be(InvokeKind.Function);
description->wFuncFlags.Should().Be(FunctionFlags.Restricted);
// Return type
description->elemdescFunc.tdesc.vt.Should().Be(VariantType.HResult);
// First arg GUID*
ELEMDESC *element = description->lprgelemdescParam;
element->tdesc.vt.Should().Be(VariantType.Pointer);
element->Union.paramdesc.wParamFlags.Should().Be(ParameterFlags.In);
element->tdesc.Union.lptdesc->vt.Should().Be(VariantType.UserDefined);
RefTypeHandle handle = element->tdesc.Union.lptdesc->Union.hreftype;
result = typeInfo.GetRefTypeInfo(handle, out ITypeInfo userDefined);
result.Should().Be(HResult.S_OK);
userDefined.GetMemberName(MemberId.Nil).Should().Be("GUID");
// Second arg void**
element++;
element->tdesc.vt.Should().Be(VariantType.Pointer);
element->Union.paramdesc.wParamFlags.Should().Be(ParameterFlags.Out);
element->tdesc.Union.lptdesc->vt.Should().Be(VariantType.Pointer);
element->tdesc.Union.lptdesc->Union.lptdesc->vt.Should().Be(VariantType.Void);
typeInfo.ReleaseFuncDesc(description);
}
public override List <ITlibNode> GenChildren()
{
var res = new List <ITlibNode>();
if (_ta.cImplTypes > 0)
{
if (_ta.cImplTypes > 1)
{
throw new Exception("Multiple inheritance!?");
}
_ti.GetRefTypeOfImplType(0, out var href);
_ti.GetRefTypeInfo(href, out var ti2);
CommonBuildTlibNode(this, ti2, false, true, res);
}
return(res);
}
private static string GetStringFromCustomType(ITypeInfo typeinfo, IntPtr refptr)
{
ITypeInfo info;
int hRef = (int)((long)refptr);
typeinfo.GetRefTypeInfo(hRef, out info);
if (info != null)
{
string str;
string str2;
string str3;
int num2;
info.GetDocumentation(-1, out str, out str2, out num2, out str3);
return(str);
}
return("UnknownCustomtype");
}
public static bool SwapForInterface(ref ITypeInfo ti, ref TypeAttr ta)
{
try
{
if (ta.typekind == TypeAttr.TypeKind.TKIND_DISPATCH && 0 != (ta.wTypeFlags & TypeAttr.TypeFlags.TYPEFLAG_FDUAL))
{
ti.GetRefTypeOfImplType(-1, out var href);
ti.GetRefTypeInfo(href, out ti);
ta = new TypeAttr(ti);
return(true);
}
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
return(false);
}
public static bool IsEnum(this ITypeInfo typeInfo)
{
using (var attrScope = typeInfo.CreateAttrScope())
{
if (attrScope.Value.typekind == TYPEKIND.TKIND_ENUM)
{
return(true);
}
if (attrScope.Value.typekind == TYPEKIND.TKIND_ALIAS)
{
typeInfo.GetRefTypeInfo(unchecked ((int)attrScope.Value.tdescAlias.lpValue.ToInt64()), out var refTypeInfo);
return(refTypeInfo.IsEnum());
}
return(false);
}
}
internal static ITypeInfo GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ITypeInfo typeinfo)
{
ITypeInfo ppTI = null;
try
{
int num;
typeinfo.GetRefTypeOfImplType(-1, out num);
typeinfo.GetRefTypeInfo(num, out ppTI);
}
catch (COMException exception)
{
if (exception.ErrorCode != -2147319765)
{
throw;
}
}
return(ppTI);
}
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr)
{
IsExtensible = !typeAttr.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FNONEXTENSIBLE);
for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
{
info.GetRefTypeOfImplType(implIndex, out int href);
info.GetRefTypeInfo(href, out ITypeInfo implemented);
implemented.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, implemented.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
ComProject.KnownTypes.TryGetValue(attribs.guid, out ComType inherited);
var intface = inherited as ComInterface ?? new ComInterface(Project, implemented, attribs);
_inherited.Add(intface);
ComProject.KnownTypes.TryAdd(attribs.guid, intface);
}
}
}
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr)
{
for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
{
info.GetRefTypeOfImplType(implIndex, out int href);
info.GetRefTypeInfo(href, out ITypeInfo implemented);
implemented.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, info.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
ComProject.KnownTypes.TryGetValue(attribs.guid, out ComType inherited);
var intface = inherited as ComInterface ?? new ComInterface(Project, implemented, attribs);
ComProject.KnownTypes.TryAdd(attribs.guid, intface);
IMPLTYPEFLAGS flags = 0;
try
{
info.GetImplTypeFlags(implIndex, out flags);
}
catch (COMException) { }
if (flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FSOURCE))
{
_events.Add(intface);
}
else
{
DefaultInterface = flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FDEFAULT) ? intface : DefaultInterface;
}
_interfaces.Add(intface, flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FRESTRICTED));
}
}
if (DefaultInterface == null)
{
DefaultInterface = VisibleInterfaces.FirstOrDefault();
}
}
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr)
{
for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
{
int href;
info.GetRefTypeOfImplType(implIndex, out href);
ITypeInfo implemented;
info.GetRefTypeInfo(href, out implemented);
IntPtr attribPtr;
implemented.GetTypeAttr(out attribPtr);
var attribs = (TYPEATTR)Marshal.PtrToStructure(attribPtr, typeof(TYPEATTR));
ComType inherited;
ComProject.KnownTypes.TryGetValue(attribs.guid, out inherited);
var intface = inherited as ComInterface ?? new ComInterface(implemented, attribs);
ComProject.KnownTypes.TryAdd(attribs.guid, intface);
IMPLTYPEFLAGS flags = 0;
try
{
info.GetImplTypeFlags(implIndex, out flags);
}
catch (COMException) { }
if (flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FSOURCE))
{
_events.Add(intface);
}
else
{
DefaultInterface = flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FDEFAULT) ? intface : DefaultInterface;
}
_interfaces.Add(intface, flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FRESTRICTED));
info.ReleaseTypeAttr(attribPtr);
}
}
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr)
{
IsExtensible = !typeAttr.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FNONEXTENSIBLE);
for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
{
int href;
info.GetRefTypeOfImplType(implIndex, out href);
ITypeInfo implemented;
info.GetRefTypeInfo(href, out implemented);
IntPtr attribPtr;
implemented.GetTypeAttr(out attribPtr);
var attribs = (TYPEATTR)Marshal.PtrToStructure(attribPtr, typeof(TYPEATTR));
ComType inherited;
ComProject.KnownTypes.TryGetValue(attribs.guid, out inherited);
var intface = inherited as ComInterface ?? new ComInterface(implemented, attribs);
_inherited.Add(intface);
ComProject.KnownTypes.TryAdd(attribs.guid, intface);
info.ReleaseTypeAttr(attribPtr);
}
}
internal static ITypeInfo GetDispatchTypeInfoFromCoClassTypeInfo(ITypeInfo typeinfo)
{
int cImplTypes = GetTypeAttr(typeinfo).cImplTypes;
ITypeInfo ppTI = null;
for (int i = 0; i < cImplTypes; i++)
{
int num2;
typeinfo.GetRefTypeOfImplType(i, out num2);
typeinfo.GetRefTypeInfo(num2, out ppTI);
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = GetTypeAttr(ppTI);
if (typeAttr.typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return ppTI;
}
if (((short) (typeAttr.wTypeFlags & System.Runtime.InteropServices.ComTypes.TYPEFLAGS.TYPEFLAG_FDUAL)) != 0)
{
ppTI = GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ppTI);
if (GetTypeAttr(ppTI).typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH)
{
return ppTI;
}
}
}
return null;
}
private void GetParameterType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
if (vt == VarEnum.VT_PTR)
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetParameterType(tdesc, info);
IsByRef = true;
}
else if (vt == VarEnum.VT_USERDEFINED)
{
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo);
refTypeInfo.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
var type = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name;
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_typeName = new ComTypeName(Project, type, attribs.guid, Guid.Empty);
}
else if (attribs.typekind == TYPEKIND.TKIND_ALIAS)
{
_typeName = new ComTypeName(Project, type, Guid.Empty, attribs.guid);
}
else
{
_typeName = new ComTypeName(Project, type);
}
}
}
catch (COMException)
{
_typeName = new ComTypeName(Project, Tokens.Object);
}
}
else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY))
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetParameterType(tdesc, info);
IsArray = true;
}
else if (vt == VarEnum.VT_HRESULT)
{
_typeName = new ComTypeName(Project, Tokens.Long);
}
else
{
_typeName = new ComTypeName(Project, (ComVariant.TypeNames.TryGetValue(vt, out string result)) ? result : Tokens.Object);
}
}
private static string GetStringFromCustomType(ITypeInfo typeinfo, IntPtr refptr)
{
ITypeInfo info;
int hRef = (int) ((long) refptr);
typeinfo.GetRefTypeInfo(hRef, out info);
if (info != null)
{
string str;
string str2;
string str3;
int num2;
info.GetDocumentation(-1, out str, out str2, out num2, out str3);
return str;
}
return "UnknownCustomtype";
}
private static IEnumerable <ITypeInfo> GetReferencedEnums(ITypeLib typeLib, ITypeInfo typeInfo, Dictionary <Guid, ITypeInfo> processedTypeInfo)
{
if (typeInfo == null)
{
yield break;
}
var guid = typeInfo.GetOrCreateGuid();
if (processedTypeInfo.ContainsKey(guid))
{
yield break;
}
processedTypeInfo.Add(guid, typeInfo);
if (typeInfo.IsEnum())
{
yield return(typeInfo);
yield break;
}
if (typeInfo.GetContainingTypeLib().GetGuid() != typeLib.GetGuid())
{
yield break;
}
using (var typeAttrScope = typeInfo.CreateAttrScope())
{
for (var funcIndex = 0; funcIndex < typeAttrScope.Value.cFuncs; funcIndex++)
{
using (var funcDescScope = typeInfo.CreateFuncDescScope(funcIndex))
{
foreach (var enumTypeInfo in GetReferencedEnums(typeLib, typeInfo, funcDescScope.Value, processedTypeInfo))
{
yield return(enumTypeInfo);
}
}
}
for (var varIndex = 0; varIndex < typeAttrScope.Value.cVars; varIndex++)
{
using (var varDescScope = typeInfo.CreateVarDescScope(varIndex))
{
foreach (var enumTypeInfo in GetReferencedEnums(typeLib, typeInfo, varDescScope.Value, processedTypeInfo))
{
yield return(enumTypeInfo);
}
}
}
for (var implTypeIndex = 0; implTypeIndex < typeAttrScope.Value.cImplTypes; implTypeIndex++)
{
typeInfo.GetRefTypeOfImplType(implTypeIndex, out var href);
typeInfo.GetRefTypeInfo(href, out var refTypeInfo);
var refGuid = refTypeInfo.GetGuid();
if ((refGuid == typeof(IDispatch).GUID) || (refGuid == typeof(IDispatchEx).GUID))
{
continue;
}
foreach (var enumTypeInfo in GetReferencedEnums(typeLib, refTypeInfo, processedTypeInfo))
{
yield return(enumTypeInfo);
}
}
}
}
internal static ITypeInfo GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ITypeInfo typeinfo)
{
ITypeInfo ppTI = null;
try
{
int num;
typeinfo.GetRefTypeOfImplType(-1, out num);
typeinfo.GetRefTypeInfo(num, out ppTI);
}
catch (COMException exception)
{
if (exception.ErrorCode != -2147319765)
{
throw;
}
}
return ppTI;
}
