private void ScanDefinedFunctions(ITypeInfo typeInfo, System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttributes)
{
for (int i = 0; i < typeAttributes.cFuncs; i++)
{
IntPtr zero = IntPtr.Zero;
try
{
System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc;
ComReference.GetFuncDescForDescIndex(typeInfo, i, out funcdesc, out zero);
int num2 = 0;
for (int j = 0; j < funcdesc.cParams; j++)
{
System.Runtime.InteropServices.ComTypes.ELEMDESC elementDesc = (System.Runtime.InteropServices.ComTypes.ELEMDESC)Marshal.PtrToStructure(new IntPtr(funcdesc.lprgelemdescParam.ToInt64() + num2), typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));
this.AnalyzeElement(typeInfo, elementDesc);
num2 += Marshal.SizeOf(typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));
}
this.AnalyzeElement(typeInfo, funcdesc.elemdescFunc);
}
finally
{
if (zero != IntPtr.Zero)
{
typeInfo.ReleaseFuncDesc(zero);
}
}
}
}
private bool CanSkipType(ITypeInfo typeInfo, ITypeLib typeLib, System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttributes, System.Runtime.InteropServices.ComTypes.TYPELIBATTR typeLibAttributes)
{
if (((typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IUnknown) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IDispatch)) || (((typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IDispatchEx) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IEnumVariant)) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_ITypeInfo)))
{
return(true);
}
if (typeLibAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_StdOle)
{
string str;
string str2;
string str3;
int num;
typeInfo.GetDocumentation(-1, out str, out str2, out num, out str3);
if (string.CompareOrdinal(str, "GUID") == 0)
{
return(true);
}
}
ITypeLib2 lib = typeLib as ITypeLib2;
if (lib != null)
{
object obj2;
lib.GetCustData(ref Microsoft.Build.Tasks.NativeMethods.GUID_ExportedFromComPlus, out obj2);
string str4 = obj2 as string;
if (!string.IsNullOrEmpty(str4))
{
return(true);
}
}
return(false);
}
public ComStruct(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index)
: base(typeLib, attrib, index)
{
_fields = new List <ComField>();
Type = DeclarationType.UserDefinedType;
GetFields(info, attrib);
}
public ComInterfaceType GetInterfaceType()
{
Debug.Assert(m_typeInfo != null, "m_typeInfo != null");
IntPtr ptr = IntPtr.Zero;
m_typeInfo.ComType.GetTypeAttr(out ptr);
try
{
TYPEATTR typeAttr = (TYPEATTR)Marshal.PtrToStructure(ptr, typeof(TYPEATTR));
ObjectType type = GetObjectType(typeAttr);
if (type != ObjectType.Interface)
{
throw new ApplicationException("Unable to get the interface type for type '"
+ DisplayName + "', because its object type is '" + ComBrowserSettings.GetKeyword(type)
+ "', not 'interface'.");
}
return(GetInterfaceType(typeAttr));
}
finally
{
m_typeInfo.ComType.ReleaseTypeAttr(ptr);
}
}
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);
}
private static Guid GetParentLibGuid(object comProxy)
{
Guid returnGuid = Guid.Empty;
IDispatch dispatcher = (IDispatch)comProxy;
COMTypes.ITypeInfo typeInfo = dispatcher.GetTypeInfo(0, 0);
COMTypes.ITypeLib parentTypeLib = null;
int i = 0;
typeInfo.GetContainingTypeLib(out parentTypeLib, out i);
IntPtr attributesPointer = IntPtr.Zero;
parentTypeLib.GetLibAttr(out attributesPointer);
COMTypes.TYPEATTR attributes = (COMTypes.TYPEATTR)Marshal.PtrToStructure(attributesPointer, typeof(COMTypes.TYPEATTR));
returnGuid = attributes.guid;
parentTypeLib.ReleaseTLibAttr(attributesPointer);
Marshal.ReleaseComObject(parentTypeLib);
Marshal.ReleaseComObject(typeInfo);
return(returnGuid);
}
internal static ObjectType GetObjectType(TYPEATTR typeAttr)
{
switch (typeAttr.typekind)
{
case TYPEKIND.TKIND_COCLASS:
return(ObjectType.Class);
case TYPEKIND.TKIND_INTERFACE:
case TYPEKIND.TKIND_DISPATCH:
return(ObjectType.Interface);
case TYPEKIND.TKIND_ENUM:
return(ObjectType.Enum);
case TYPEKIND.TKIND_RECORD:
return(ObjectType.Struct);
case TYPEKIND.TKIND_UNION:
return(ObjectType.Union);
case TYPEKIND.TKIND_MODULE:
return(ObjectType.Module);
case TYPEKIND.TKIND_ALIAS:
return(ObjectType.Alias);
default:
throw new ApplicationException("Unsupported object type: '" + typeAttr.typekind.ToString() + "'.");
}
}
private void Initialize()
{
using (ComTypeInfo.tracer.TraceMethod())
{
if (this.typeinfo == null)
{
return;
}
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = ComTypeInfo.GetTypeAttr(this.typeinfo);
this.guid = typeAttr.guid;
for (int firstUserMethod = ComTypeInfo.FindFirstUserMethod(typeAttr); firstUserMethod < (int)typeAttr.cFuncs; ++firstUserMethod)
{
System.Runtime.InteropServices.ComTypes.FUNCDESC funcDesc = ComTypeInfo.GetFuncDesc(this.typeinfo, firstUserMethod);
string nameFromFuncDesc = ComUtil.GetNameFromFuncDesc(this.typeinfo, funcDesc);
switch (funcDesc.invkind)
{
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_FUNC:
this.AddMethod(nameFromFuncDesc, firstUserMethod);
break;
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYGET:
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYPUT:
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYPUTREF:
this.AddProperty(nameFromFuncDesc, funcDesc, firstUserMethod);
break;
}
}
}
}
internal static ComTypeInfo GetDispatchTypeInfo(object comObject)
{
ComTypeInfo result = null;
IDispatch disp = comObject as IDispatch;
if (disp != null)
{
COM.ITypeInfo typeinfo = null;
disp.GetTypeInfo(0, 0, out typeinfo);
if (typeinfo != null)
{
COM.TYPEATTR typeattr = GetTypeAttr(typeinfo);
if ((typeattr.typekind == COM.TYPEKIND.TKIND_INTERFACE))
{
// We have typeinfo for custom interface. Get typeinfo for Dispatch interface.
typeinfo = GetDispatchTypeInfoFromCustomInterfaceTypeInfo(typeinfo);
}
if ((typeattr.typekind == COM.TYPEKIND.TKIND_COCLASS))
{
// We have typeinfo for the COClass. Find the default interface and get typeinfo for default interface.
typeinfo = GetDispatchTypeInfoFromCoClassTypeInfo(typeinfo);
}
result = new ComTypeInfo(typeinfo);
}
}
return(result);
}
internal ComTypeEnumDesc(ComTypes.ITypeInfo typeInfo, ComTypeLibDesc typeLibDesc) :
base(typeInfo, ComType.Enum, typeLibDesc)
{
ComTypes.TYPEATTR typeAttr = ComRuntimeHelpers.GetTypeAttrForTypeInfo(typeInfo);
string[] memberNames = new string[typeAttr.cVars];
object[] memberValues = new object[typeAttr.cVars];
IntPtr p = IntPtr.Zero;
// For each enum member get name and value.
for (int i = 0; i < typeAttr.cVars; i++)
{
typeInfo.GetVarDesc(i, out p);
// Get the enum member value (as object).
ComTypes.VARDESC varDesc;
try {
varDesc = (ComTypes.VARDESC)Marshal.PtrToStructure(p, typeof(ComTypes.VARDESC));
if (varDesc.varkind == ComTypes.VARKIND.VAR_CONST)
{
memberValues[i] = Marshal.GetObjectForNativeVariant(varDesc.desc.lpvarValue);
}
} finally {
typeInfo.ReleaseVarDesc(p);
}
// Get the enum member name
memberNames[i] = ComRuntimeHelpers.GetNameOfMethod(typeInfo, varDesc.memid);
}
_memberNames = memberNames;
_memberValues = memberValues;
}
public ComInterface(IComBase parent, ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(parent, typeLib, attrib, index)
{
Type = DeclarationType.ClassModule;
GetImplementedInterfaces(info, attrib);
GetComProperties(info, attrib);
GetComMembers(info, attrib);
}
public ComEnumeration(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(typeLib, attrib, index)
{
Members = new List <ComEnumerationMember>();
Type = DeclarationType.Enumeration;
GetEnumerationMembers(info, attrib);
ComProject.KnownEnumerations.TryAdd(Guid, this);
}
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 ComCoClass(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(typeLib, attrib, index)
{
Type = DeclarationType.ClassModule;
GetImplementedInterfaces(info, attrib);
IsControl = attrib.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FCONTROL);
Debug.Assert(attrib.cFuncs == 0);
}
internal static ComTypeInfo GetDispatchTypeInfo(object comObject)
{
ComTypeInfo info = null;
System.Management.Automation.IDispatch dispatch = comObject as System.Management.Automation.IDispatch;
if (dispatch == null)
{
return(info);
}
ITypeInfo ppTInfo = null;
dispatch.GetTypeInfo(0, 0, out ppTInfo);
if (ppTInfo == null)
{
return(info);
}
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = GetTypeAttr(ppTInfo);
if (typeAttr.typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_INTERFACE)
{
ppTInfo = GetDispatchTypeInfoFromCustomInterfaceTypeInfo(ppTInfo);
}
if (typeAttr.typekind == System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_COCLASS)
{
ppTInfo = GetDispatchTypeInfoFromCoClassTypeInfo(ppTInfo);
}
return(new ComTypeInfo(ppTInfo));
}
private void Initialize()
{
if (this.typeinfo != null)
{
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = GetTypeAttr(this.typeinfo);
this.guid = typeAttr.guid;
for (int i = 0; i < typeAttr.cFuncs; i++)
{
string nameFromFuncDesc;
System.Runtime.InteropServices.ComTypes.FUNCDESC funcDesc = GetFuncDesc(this.typeinfo, i);
if ((funcDesc.wFuncFlags & 1) != 1)
{
nameFromFuncDesc = ComUtil.GetNameFromFuncDesc(this.typeinfo, funcDesc);
switch (funcDesc.invkind)
{
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_FUNC:
this.AddMethod(nameFromFuncDesc, i);
break;
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYGET:
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYPUT:
case System.Runtime.InteropServices.ComTypes.INVOKEKIND.INVOKE_PROPERTYPUTREF:
goto Label_0075;
}
}
continue;
Label_0075:
this.AddProperty(nameFromFuncDesc, funcDesc, i);
}
}
}
private void LoadTypes()
{
_typeInfos = new List <ComTypeInfo>();
int count = _typeLib.GetTypeInfoCount();
for (int i = 0; i < count; i++)
{
ITypeInfo typeInfo = null;
_typeLib.GetTypeInfo(i, out typeInfo);
IntPtr pTypeAttr = IntPtr.Zero;
typeInfo.GetTypeAttr(out pTypeAttr);
System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttr = pTypeAttr.ToStructure <System.Runtime.InteropServices.ComTypes.TYPEATTR>();
switch (typeAttr.typekind)
{
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_ALIAS:
_typeInfos.Add(new ComAliasInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_COCLASS:
_typeInfos.Add(new ComCoClassInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_DISPATCH:
_typeInfos.Add(new ComDispatchInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_ENUM:
_typeInfos.Add(new ComEnumInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_INTERFACE:
_typeInfos.Add(new ComInterfaceInfo(this, typeInfo, pTypeAttr));
break;
//case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_MAX:
// _typeInfos.Add(new ComMaxInfo(this, typeInfo, pTypeAttr));
// break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_MODULE:
_typeInfos.Add(new ComModuleInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_RECORD:
_typeInfos.Add(new ComRecordInfo(this, typeInfo, pTypeAttr));
break;
case System.Runtime.InteropServices.ComTypes.TYPEKIND.TKIND_UNION:
_typeInfos.Add(new ComUnionInfo(this, typeInfo, pTypeAttr));
break;
}
}
_typeInfos.Sort(delegate(ComTypeInfo a, ComTypeInfo b)
{
return(a.Name.CompareTo(b.Name));
});
}
public ComTypeInfo(ComTypeLibrary comTypeLibrary, ITypeInfo typeInfo, IntPtr pTypeAttr)
{
_comTypeLibrary = comTypeLibrary;
_typeInfo = typeInfo;
_pTypeAttr = pTypeAttr;
_typeAttr = _pTypeAttr.ToStructure <System.Runtime.InteropServices.ComTypes.TYPEATTR>();
_typeInfo.GetDocumentation(-1, out _name, out _description, out _helpContext, out _helpFile);
}
private static void AppendTypeAttribute(DescriptionBuilder sb, TYPEATTR typeAttr, TYPEFLAGS attribute)
{
if ((typeAttr.wTypeFlags & attribute) == attribute)
{
sb.Append(", ");
sb.Append(ComBrowserSettings.GetKeyword(attribute));
}
}
internal static COM.TYPEATTR GetTypeAttr(COM.ITypeInfo typeinfo)
{
IntPtr pTypeAttr;
typeinfo.GetTypeAttr(out pTypeAttr);
COM.TYPEATTR typeattr = Marshal.PtrToStructure <COM.TYPEATTR>(pTypeAttr);
typeinfo.ReleaseTypeAttr(pTypeAttr);
return(typeattr);
}
internal static System.Runtime.InteropServices.ComTypes.TYPEATTR GetTypeAttr(ITypeInfo typeinfo)
{
IntPtr ptr;
typeinfo.GetTypeAttr(out ptr);
System.Runtime.InteropServices.ComTypes.TYPEATTR typeattr = (System.Runtime.InteropServices.ComTypes.TYPEATTR)Marshal.PtrToStructure(ptr, typeof(System.Runtime.InteropServices.ComTypes.TYPEATTR));
typeinfo.ReleaseTypeAttr(ptr);
return(typeattr);
}
private static int FindFirstUserMethod(System.Runtime.InteropServices.ComTypes.TYPEATTR typeattr)
{
int num = 0;
if (typeattr.cFuncs >= (short)7)
{
num = 7;
}
return(num);
}
private void LoadVars(ITypeInfo typeInfo, TYPEATTR typeAttr)
{
//TODO: Узнать что сюда прилетает
// for (var i = 0; i < typeAttr.cVars; i++)
// {
// typeInfo.GetVarDesc(i, out var ptVarDesc);
// var varDesc = Marshal.PtrToStructure<VARDESC>(ptVarDesc);
//
// Marshal.Release(ptVarDesc);
// }
}
/// <summary>
/// Returns id of an interface
/// </summary>
/// <param name="typeInfo">com type informations</param>
/// <returns>interface id(iid)</returns>
internal static Guid GetTypeGuid(this COMTypes.ITypeInfo typeInfo)
{
IntPtr attribPtr = IntPtr.Zero;
typeInfo.GetTypeAttr(out attribPtr);
COMTypes.TYPEATTR Attributes = (COMTypes.TYPEATTR)Marshal.PtrToStructure(attribPtr, typeof(COMTypes.TYPEATTR));
Guid typeGuid = Attributes.guid;
typeInfo.ReleaseTypeAttr(attribPtr);
return(typeGuid);
}
private void LoadFuncs(ITypeInfo typeInfo, TYPEATTR typeAttr)
{
var skippingFlags = FUNCFLAGS.FUNCFLAG_FRESTRICTED | FUNCFLAGS.FUNCFLAG_FHIDDEN;
for (var i = 0; i < typeAttr.cFuncs; i++)
{
typeInfo.GetFuncDesc(i, out var ptFuncDesc);
var funcDesc = Marshal.PtrToStructure <FUNCDESC>(ptFuncDesc);
var currentFlags = (FUNCFLAGS)funcDesc.wFuncFlags;
if ((currentFlags & skippingFlags) != 0)
{
Marshal.Release(ptFuncDesc);
continue;
}
var arrOfNames = new string[1];
var cNames = arrOfNames.Length;
var dispId = funcDesc.memid;
typeInfo.GetNames(dispId, arrOfNames, cNames, out var names);
if (names == 0)
{
Marshal.Release(ptFuncDesc);
continue;
}
var memberName = arrOfNames[0];
if (funcDesc.invkind == INVOKEKIND.INVOKE_FUNC)
{
var isFunc = funcDesc.elemdescFunc.tdesc.vt != VT_VOID;
AddMethod(memberName, dispId, isFunc);
}
else
{
var prop = GetOrAddProperty(memberName, dispId);
if (funcDesc.invkind == INVOKEKIND.INVOKE_PROPERTYGET)
{
prop.IsReadable = true;
}
else
{
prop.IsWritable = true;
}
}
Marshal.Release(ptFuncDesc);
}
}
public ComModule(IComBase parent, ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(parent, typeLib, attrib, index)
{
Debug.Assert(attrib.cFuncs >= 0 && attrib.cVars >= 0);
Type = DeclarationType.ProceduralModule;
if (attrib.cFuncs > 0)
{
GetComMembers(info, attrib);
}
if (attrib.cVars > 0)
{
GetComFields(info, attrib);
}
}
private void GetEnumerationMembers(ITypeInfo info, TYPEATTR attrib)
{
var count = attrib.cVars;
for (var index = 0; index < count; index++)
{
IntPtr varPtr;
info.GetVarDesc(index, out varPtr);
var desc = (VARDESC)Marshal.PtrToStructure(varPtr, typeof(VARDESC));
Members.Add(new ComEnumerationMember(info, desc));
info.ReleaseVarDesc(varPtr);
}
}
public ComModule(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(typeLib, attrib, index)
{
Type = DeclarationType.ProceduralModule;
if (attrib.cFuncs > 0)
{
Debug.Assert(attrib.cVars == 0);
GetComMembers(info, attrib);
}
else
{
Debug.Assert(attrib.cVars > 0);
GetComFields(info, attrib);
}
}
private void GetEnumerationMembers(ITypeInfo info, TYPEATTR attrib)
{
var count = attrib.cVars;
for (var index = 0; index < count; index++)
{
info.GetVarDesc(index, out IntPtr varPtr);
using (DisposalActionContainer.Create(varPtr, info.ReleaseVarDesc))
{
var desc = Marshal.PtrToStructure <VARDESC>(varPtr);
Members.Add(new ComEnumerationMember(this, info, desc));
}
}
}
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);
}
/// <summary>
/// Helper method for retrieving type attributes for a given type info
/// </summary>
/// <param name="typeInfo"></param>
/// <param name="typeAttr"></param>
/// <returns></returns>
internal static void GetTypeAttrForTypeInfo(ITypeInfo typeInfo, out TYPEATTR typeAttr)
{
IntPtr pAttrs = IntPtr.Zero;
typeInfo.GetTypeAttr(out pAttrs);
// GetTypeAttr should never return null, this is just to be safe
if (pAttrs == IntPtr.Zero)
{
throw new COMException(
ResourceUtilities.FormatResourceString("ResolveComReference.CannotRetrieveTypeInformation"));
}
try
{
typeAttr = (TYPEATTR)Marshal.PtrToStructure(pAttrs, typeof(TYPEATTR));
}
finally
{
typeInfo.ReleaseTypeAttr(pAttrs);
}
}
public ComTypeInfo(ComTypeLibrary comTypeLibrary, ITypeInfo typeInfo, IntPtr pTypeAttr)
{
_comTypeLibrary = comTypeLibrary;
_typeInfo = typeInfo;
_pTypeAttr = pTypeAttr;
_typeAttr = _pTypeAttr.ToStructure<System.Runtime.InteropServices.ComTypes.TYPEATTR>();
_typeInfo.GetDocumentation(-1, out _name, out _description, out _helpContext, out _helpFile);
}
private static string ProgIdFromTypeAttr(TYPEATTR typeattr)
{
string lplpszProgID;
ProgIDFromCLSID(ref typeattr.guid, out lplpszProgID);
return lplpszProgID;
}