public async Task HostObject(ICOMClassEntry ent, object obj, bool factory)
{
Dictionary <string, string> props = new Dictionary <string, string>();
if (ent == null)
{
ent = new COMCLSIDEntry(m_registry, Guid.Empty, COMServerType.UnknownServer);
}
props.Add("CLSID", ent.Clsid.FormatGuid());
props.Add("Name", ent.Name);
props.Add("Server", ent.DefaultServer);
/* Need to implement a type library reader */
Type dispType = COMUtilities.GetDispatchTypeInfo(this, obj);
if (!ent.InterfacesLoaded)
{
await ent.LoadSupportedInterfacesAsync(false, null);
}
IEnumerable <COMInterfaceInstance> intfs = factory ? ent.FactoryInterfaces : ent.Interfaces;
ObjectInformation view = new ObjectInformation(m_registry, ent, ent.Name, obj,
props, intfs.Select(i => m_registry.MapIidToInterface(i.Iid)).ToArray());
HostControl(view);
}
/// <summary>
/// Build a tooltip for a CLSID entry
/// </summary>
/// <param name="ent">The CLSID entry to build the tool tip from</param>
/// <returns>A string tooltip</returns>
private static string BuildCLSIDToolTip(COMCLSIDEntry ent)
{
StringBuilder strRet = new StringBuilder();
AppendFormatLine(strRet, "CLSID: {0}", ent.Clsid.ToString("B"));
AppendFormatLine(strRet, "Name: {0}", ent.Name);
AppendFormatLine(strRet, "{0}: {1}", ent.ServerType.ToString(), ent.Server);
IEnumerable <string> progids = ent.ProgIDs;
if (progids.Count() > 0)
{
strRet.AppendLine("ProgIDs:");
foreach (string progid in progids)
{
AppendFormatLine(strRet, "{0}", progid);
}
}
if (ent.AppID != Guid.Empty)
{
AppendFormatLine(strRet, "AppID: {0}", ent.AppID.ToString("B"));
}
if (ent.TypeLib != Guid.Empty)
{
AppendFormatLine(strRet, "TypeLib: {0}", ent.TypeLib.ToString("B"));
}
IEnumerable <COMInterfaceEntry> proxies = ent.Proxies;
if (proxies.Count() > 0)
{
AppendFormatLine(strRet, "Interface Proxies: {0}", proxies.Count());
}
return(strRet.ToString());
}
private async void OpenObjectInformation(object comObj, string defaultName)
{
if (comObj != null)
{
Dictionary <string, string> props = new Dictionary <string, string>();
string strObjName = "";
IEnumerable <COMInterfaceEntry> ints = null;
Guid clsid = COMUtilities.GetObjectClass(comObj);
if (m_registry.Clsids.ContainsKey(clsid))
{
COMCLSIDEntry ent = m_registry.Clsids[clsid];
strObjName = ent.Name;
props.Add("CLSID", ent.Clsid.ToString("B"));
props.Add("Name", ent.Name);
props.Add("Server", ent.Server);
await ent.LoadSupportedInterfacesAsync(false);
ints = ent.Interfaces.Select(i => m_registry.MapIidToInterface(i.Iid));
}
else
{
ints = m_registry.GetInterfacesForObject(comObj);
strObjName = defaultName != null ? defaultName : clsid.ToString("B");
props.Add("CLSID", clsid.ToString("B"));
}
Type dispType = COMUtilities.GetDispatchTypeInfo(comObj);
HostControl(new ObjectInformation(m_registry, strObjName, comObj, props, ints.ToArray()));
}
}
private void viewProxyDefinitionToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
ListView view = GetListViewForMenu(sender);
if (view != null && view.SelectedIndices.Count > 0)
{
ListViewItem item = view.SelectedItems[0];
Tuple <COMInterfaceInstance, COMInterfaceEntry> intf =
item.Tag as Tuple <COMInterfaceInstance, COMInterfaceEntry>;
if (m_registry.Clsids.ContainsKey(intf.Item2.ProxyClsid))
{
COMCLSIDEntry clsid = m_registry.Clsids[intf.Item2.ProxyClsid];
using (var resolver = EntryPoint.GetProxyParserSymbolResolver())
{
EntryPoint.GetMainForm(m_registry).HostControl(new TypeLibControl(m_registry,
Path.GetFileName(clsid.DefaultServer), COMProxyInstance.GetFromCLSID(clsid, resolver), intf.Item1.Iid));
}
}
}
}
catch (Exception ex)
{
EntryPoint.ShowError(this, ex);
}
}
private COMProxyInstance(COMCLSIDEntry clsid)
{
if (!InitFromFile(clsid.DefaultServer, clsid.Clsid))
{
throw new ArgumentException("Can't find proxy information in server DLL");
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="objName">Descriptive name of the object</param>
/// <param name="pObject">Managed wrapper to the object</param>
/// <param name="properties">List of textual properties to display</param>
/// <param name="interfaces">List of available interfaces</param>
public ObjectInformation(COMRegistry registry, COMCLSIDEntry entry, string objName, Object pObject, Dictionary <string, string> properties, COMInterfaceEntry[] interfaces)
{
m_entry = entry;
if (m_entry == null)
{
Guid clsid = COMUtilities.GetObjectClass(pObject);
if (registry.Clsids.ContainsKey(clsid))
{
m_entry = registry.MapClsidToEntry(clsid);
}
}
m_registry = registry;
m_pEntry = ObjectCache.Add(registry, objName, pObject, interfaces);
m_pObject = pObject;
m_properties = properties;
m_interfaces = interfaces;
m_objName = objName;
InitializeComponent();
LoadProperties();
LoadInterfaces();
Text = m_objName;
listViewInterfaces.ListViewItemSorter = new ListItemComparer(0);
}
public ClassFactoryTypeViewer(COMRegistry registry, COMCLSIDEntry entry, string objName, object obj)
{
InitializeComponent();
_obj = obj;
_name = objName;
_registry = registry;
_entry = entry;
Text = objName + " ClassFactory";
}
private void btnProxyProperties_Click(object sender, EventArgs e)
{
if (m_registry.Clsids.ContainsKey(m_interface.ProxyClsid))
{
COMCLSIDEntry entry = m_registry.Clsids[m_interface.ProxyClsid];
EntryPoint.GetMainForm(m_registry).HostControl(new PropertiesControl(m_registry,
entry.Name, entry));
}
}
private async void menuViewCreateInstanceFromCLSID_Click(object sender, EventArgs e)
{
using (CreateCLSIDForm frm = new CreateCLSIDForm())
{
if (frm.ShowDialog() == DialogResult.OK)
{
try
{
Guid g = frm.Clsid;
Dictionary <string, string> props = new Dictionary <string, string>();
object comObj = null;
string strObjName = "";
IEnumerable <COMInterfaceEntry> ints = null;
if (m_registry.Clsids.ContainsKey(g))
{
COMCLSIDEntry ent = m_registry.Clsids[g];
strObjName = ent.Name;
props.Add("CLSID", ent.Clsid.ToString("B"));
props.Add("Name", ent.Name);
props.Add("Server", ent.Server);
comObj = ent.CreateInstanceAsObject(frm.ClsCtx);
await ent.LoadSupportedInterfacesAsync(false);
}
else
{
Guid unk = COMInterfaceEntry.IID_IUnknown;
IntPtr pObj;
if (COMUtilities.CoCreateInstance(ref g, IntPtr.Zero, frm.ClsCtx,
ref unk, out pObj) == 0)
{
ints = m_registry.GetInterfacesForIUnknown(pObj);
comObj = Marshal.GetObjectForIUnknown(pObj);
strObjName = g.ToString("B");
props.Add("CLSID", g.ToString("B"));
Marshal.Release(pObj);
}
}
if (comObj != null)
{
/* Need to implement a type library reader */
Type dispType = COMUtilities.GetDispatchTypeInfo(comObj);
HostControl(new ObjectInformation(m_registry, strObjName, comObj, props, ints.ToArray()));
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
private COMProxyInterfaceInstance(COMCLSIDEntry clsid, ISymbolResolver resolver, COMInterfaceEntry intf, COMRegistry registry)
{
NdrParser parser = new NdrParser(resolver);
Entry = parser.ReadFromComProxyFile(clsid.DefaultServer, clsid.Clsid, new Guid[] { intf.Iid }).FirstOrDefault();
ComplexTypes = parser.ComplexTypes;
OriginalName = intf.Name;
ClassEntry = clsid;
m_registry = registry;
}
private static TreeNode CreateClsidNode(COMCLSIDEntry ent)
{
TreeNode currNode = new TreeNode(ent.Name, ClassIcon, ClassIcon);
currNode.ToolTipText = BuildCLSIDToolTip(ent);
currNode.Tag = ent;
currNode.Nodes.Add("IUnknown");
return(currNode);
}
private TreeNode CreateCLSIDNode(COMCLSIDEntry ent)
{
TreeNode nodeRet = new TreeNode(String.Format("{0} - {1}", ent.Clsid.ToString(), ent.Name), ClassIcon, ClassIcon);
nodeRet.ToolTipText = BuildCLSIDToolTip(ent);
nodeRet.Tag = ent;
nodeRet.Nodes.Add("IUnknown");
return(nodeRet);
}
private void propertiesToolStripMenuItem_Click(object sender, EventArgs e)
{
COMProcessClassRegistration c = GetRegisteredClass();
if (c != null && m_registry.Clsids.ContainsKey(c.Clsid))
{
COMCLSIDEntry clsid = m_registry.MapClsidToEntry(c.Clsid);
EntryPoint.GetMainForm(m_registry).HostControl(new PropertiesControl(m_registry, clsid.Name, clsid));
}
}
public COMInterfaceEntry[] GetProxiesForClsid(COMCLSIDEntry clsid)
{
if (ProxiesByClsid.ContainsKey(clsid.Clsid))
{
return(ProxiesByClsid[clsid.Clsid].ToArray());
}
else
{
return(new COMInterfaceEntry[0]);
}
}
/// <summary>
/// Load CLSID information from the registry key
/// </summary>
/// <param name="rootKey">The root registry key, e.g. HKEY_CLASSES_ROOT</param>
/// <param name="actctx">The system default activation context.</param>
private void LoadCLSIDs(RegistryKey rootKey, ActivationContext actctx)
{
Dictionary <Guid, COMCLSIDEntry> clsids = new Dictionary <Guid, COMCLSIDEntry>();
Dictionary <Guid, List <Guid> > categories = new Dictionary <Guid, List <Guid> >();
if (actctx != null)
{
foreach (var com_server in actctx.ComServers)
{
clsids[com_server.Clsid] = new COMCLSIDEntry(this, com_server);
}
}
using (RegistryKey clsidKey = rootKey.OpenSubKey("CLSID"))
{
if (clsidKey != null)
{
string[] subkeys = clsidKey.GetSubKeyNames();
foreach (string key in subkeys)
{
if (!Guid.TryParse(key, out Guid clsid))
{
continue;
}
if (clsids.ContainsKey(clsid))
{
continue;
}
using (RegistryKey regKey = clsidKey.OpenSubKey(key))
{
if (regKey != null)
{
COMCLSIDEntry ent = new COMCLSIDEntry(this, clsid, regKey);
clsids.Add(clsid, ent);
foreach (Guid catid in ent.Categories)
{
if (!categories.ContainsKey(catid))
{
categories[catid] = new List <Guid>();
}
categories[catid].Add(ent.Clsid);
}
}
}
}
}
}
m_clsids = new SortedDictionary <Guid, COMCLSIDEntry>(clsids);
m_categories = categories.ToSortedDictionary(p => p.Key, p => new COMCategory(this, p.Key, p.Value));
}
public static COMProxyInstance GetFromCLSID(COMCLSIDEntry clsid)
{
if (m_proxies.ContainsKey(clsid.Clsid))
{
return(m_proxies[clsid.Clsid]);
}
else
{
COMProxyInstance proxy = new COMProxyInstance(clsid);
m_proxies[clsid.Clsid] = proxy;
return(proxy);
}
}
public static COMProxyInstance GetFromCLSID(COMCLSIDEntry clsid, ISymbolResolver resolver)
{
if (m_proxies.ContainsKey(clsid.Clsid))
{
return(m_proxies[clsid.Clsid]);
}
else
{
COMProxyInstance proxy = new COMProxyInstance(clsid.DefaultServer, clsid.Clsid, resolver, clsid.Database);
m_proxies[clsid.Clsid] = proxy;
return(proxy);
}
}
private void SetupProperties(object obj)
{
if (obj is COMCLSIDEntry)
{
SetupClsidEntry((COMCLSIDEntry)obj);
}
if (obj is COMProgIDEntry)
{
COMProgIDEntry entry = (COMProgIDEntry)obj;
COMCLSIDEntry clsid_entry = m_registry.MapClsidToEntry(entry.Clsid);
SetupClsidEntry(clsid_entry);
}
if (obj is COMAppIDEntry)
{
SetupAppIdEntry((COMAppIDEntry)obj);
}
if (obj is COMInterfaceEntry)
{
SetupInterfaceEntry((COMInterfaceEntry)obj);
}
if (obj is COMTypeLibVersionEntry)
{
SetupTypeLibVersionEntry((COMTypeLibVersionEntry)obj);
}
if (obj is COMProcessEntry)
{
SetupProcessEntry((COMProcessEntry)obj);
}
if (obj is COMIPIDEntry)
{
SetupIPIDEntry((COMIPIDEntry)obj);
}
if (obj is COMRuntimeClassEntry)
{
SetupRuntimeClassEntry((COMRuntimeClassEntry)obj);
}
if (obj is COMRuntimeServerEntry)
{
SetupRuntimeServerEntry((COMRuntimeServerEntry)obj);
}
}
private void listViewElevationVSOs_DoubleClick(object sender, EventArgs e)
{
if (listViewElevationVSOs.SelectedItems.Count < 1)
{
return;
}
COMCLSIDEntry clsid = listViewElevationVSOs.SelectedItems[0].Tag as COMCLSIDEntry;
if (clsid != null)
{
EntryPoint.GetMainForm(m_registry).HostControl(new PropertiesControl(m_registry,
clsid.Name, clsid));
}
}
private async void btnRefreshInterfaces_Click(object sender, EventArgs e)
{
try
{
COMCLSIDEntry entry = (COMCLSIDEntry)tabPageSupportedInterfaces.Tag;
await entry.LoadSupportedInterfacesAsync(true);
LoadInterfaceList(entry.Interfaces, listViewInterfaces);
LoadInterfaceList(entry.FactoryInterfaces, listViewFactoryInterfaces);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async static Task <COMEnumerateInterfaces> GetInterfacesOOP(COMCLSIDEntry ent)
{
string apartment = "s";
if (ent.DefaultThreadingModel == COMThreadingModel.Both ||
ent.DefaultThreadingModel == COMThreadingModel.Free)
{
apartment = "m";
}
string command_line = string.Format("{0} {1} \"{2}\"", ent.Clsid.ToString("B"), apartment, ent.CreateContext);
var interfaces = await GetInterfacesOOP(command_line, false);
return(new COMEnumerateInterfaces(ent.Clsid, ent.CreateContext, string.Empty, interfaces.Interfaces, interfaces.FactoryInterfaces));
}
public CustomMarshalEditorControl(COMRegistry registry, COMObjRefCustom objref)
{
m_objref = objref;
m_registry = registry;
InitializeComponent();
textBoxClsid.Text = objref.Clsid.FormatGuid();
COMCLSIDEntry ent = registry.MapClsidToEntry(objref.Clsid);
if (ent != null)
{
textBoxName.Text = ent.Name;
}
hexEditor.Bytes = objref.ObjectData;
}
/// <summary>
/// Build a ProgID entry tooltip
/// </summary>
/// <param name="ent">The ProgID entry</param>
/// <returns>The ProgID tooltip</returns>
private string BuildProgIDToolTip(COMProgIDEntry ent)
{
string strRet;
COMCLSIDEntry entry = m_reg.MapClsidToEntry(ent.Clsid);
if (entry != null)
{
strRet = BuildCLSIDToolTip(entry);
}
else
{
strRet = String.Format("CLSID: {0}\n", ent.Clsid.ToString("B"));
}
return(strRet);
}
private async void createInstanceToolStripMenuItem_Click(object sender, EventArgs e)
{
TreeNode node = treeComRegistry.SelectedNode;
if (node != null)
{
COMCLSIDEntry ent = null;
if (node.Tag is COMCLSIDEntry)
{
ent = (COMCLSIDEntry)node.Tag;
}
else if (node.Tag is COMProgIDEntry)
{
ent = m_reg.MapClsidToEntry(((COMProgIDEntry)node.Tag).Clsid);
}
if (ent != null)
{
Dictionary <string, string> props = new Dictionary <string, string>();
try
{
object comObj = ent.CreateInstanceAsObject(CLSCTX.CLSCTX_ALL);
if (comObj != null)
{
props.Add("CLSID", ent.Clsid.ToString("B"));
props.Add("Name", ent.Name);
props.Add("Server", ent.Server);
/* Need to implement a type library reader */
Type dispType = COMUtilities.GetDispatchTypeInfo(comObj);
await ent.LoadSupportedInterfacesAsync(false);
ObjectInformation view = new ObjectInformation(m_reg, ent.Name, comObj,
props, ent.Interfaces.Select(i => m_reg.MapIidToInterface(i.Iid)).ToArray());
Program.GetMainForm().HostControl(view);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
public ElevatedFactoryServerTypeViewer(COMRegistry registry, COMCLSIDEntry entry, string objName, object obj)
{
InitializeComponent();
_obj = obj;
_name = objName;
_registry = registry;
_entry = entry;
if (_entry != null && _entry.Elevation != null)
{
foreach (COMCLSIDEntry vso in _entry.Elevation.VirtualServerObjects.Select(v => registry.MapClsidToEntry(v)))
{
comboBoxClass.Items.Add(vso);
}
if (comboBoxClass.Items.Count > 0)
{
comboBoxClass.SelectedIndex = 0;
}
}
}
private void contextMenuStrip_Opening(object sender, CancelEventArgs e)
{
TreeNode node = treeComRegistry.SelectedNode;
if ((node != null) && (node.Tag != null))
{
contextMenuStrip.Items.Clear();
contextMenuStrip.Items.Add(copyGUIDToolStripMenuItem);
contextMenuStrip.Items.Add(copyGUIDHexStringToolStripMenuItem);
contextMenuStrip.Items.Add(copyGUIDCStructureToolStripMenuItem);
if ((node.Tag is COMCLSIDEntry) || (node.Tag is COMProgIDEntry))
{
contextMenuStrip.Items.Add(copyObjectTagToolStripMenuItem);
contextMenuStrip.Items.Add(createInstanceToolStripMenuItem);
contextMenuStrip.Items.Add(refreshInterfacesToolStripMenuItem);
COMProgIDEntry progid = node.Tag as COMProgIDEntry;
COMCLSIDEntry clsid = node.Tag as COMCLSIDEntry;
if (progid != null)
{
clsid = m_reg.MapClsidToEntry(progid.Clsid);
}
if (clsid != null && m_reg.Typelibs.ContainsKey(clsid.TypeLib))
{
contextMenuStrip.Items.Add(viewTypeLibraryToolStripMenuItem);
}
}
if (node.Tag is COMTypeLibVersionEntry)
{
contextMenuStrip.Items.Add(viewTypeLibraryToolStripMenuItem);
}
if (PropertiesControl.SupportsProperties(node.Tag))
{
contextMenuStrip.Items.Add(propertiesToolStripMenuItem);
}
}
else
{
e.Cancel = true;
}
}
/// <summary>
/// Load CLSID information from the registry key
/// </summary>
/// <param name="rootKey">The root registry key, e.g. HKEY_CLASSES_ROOT</param>
private void LoadCLSIDs(RegistryKey rootKey)
{
Dictionary <Guid, COMCLSIDEntry> clsids = new Dictionary <Guid, COMCLSIDEntry>();
Dictionary <Guid, List <Guid> > categories = new Dictionary <Guid, List <Guid> >();
using (RegistryKey clsidKey = rootKey.OpenSubKey("CLSID"))
{
if (clsidKey != null)
{
string[] subkeys = clsidKey.GetSubKeyNames();
foreach (string key in subkeys)
{
Guid clsid;
if (Guid.TryParse(key, out clsid))
{
if (!clsids.ContainsKey(clsid))
{
using (RegistryKey regKey = clsidKey.OpenSubKey(key))
{
if (regKey != null)
{
COMCLSIDEntry ent = new COMCLSIDEntry(clsid, regKey);
clsids.Add(clsid, ent);
foreach (Guid catid in ent.Categories)
{
if (!categories.ContainsKey(catid))
{
categories[catid] = new List <Guid>();
}
categories[catid].Add(ent.Clsid);
}
}
}
}
}
}
}
}
m_clsids = new SortedDictionary <Guid, COMCLSIDEntry>(clsids);
m_categories = categories.ToSortedDictionary(p => p.Key, p => new COMCategory(p.Key, p.Value));
}
public static COMProxyInterfaceInstance GetFromIID(COMInterfaceEntry intf, ISymbolResolver resolver)
{
if (intf == null || !intf.HasProxy)
{
throw new ArgumentException($"Interface {intf.Name} doesn't have a registered proxy");
}
COMCLSIDEntry clsid = intf.ProxyClassEntry;
if (m_proxies.ContainsKey(intf.Iid))
{
return(m_proxies[intf.Iid]);
}
else
{
var instance = new COMProxyInterfaceInstance(clsid, resolver, intf, clsid.Database);
m_proxies[intf.Iid] = instance;
return(instance);
}
}
private async Task SetupCLSIDNodeTree(TreeNode node, bool bRefresh)
{
COMCLSIDEntry clsid = null;
if (node.Tag is COMCLSIDEntry)
{
clsid = (COMCLSIDEntry)node.Tag;
}
else if (node.Tag is COMProgIDEntry)
{
clsid = m_reg.MapClsidToEntry(((COMProgIDEntry)node.Tag).Clsid);
}
if (clsid != null)
{
node.Nodes.Clear();
TreeNode wait_node = new TreeNode("Please Wait, Populating Interfaces", InterfaceIcon, InterfaceIcon);
node.Nodes.Add(wait_node);
try
{
await clsid.LoadSupportedInterfacesAsync(bRefresh);
if (clsid.Interfaces.Count() > 0)
{
node.Nodes.Remove(wait_node);
foreach (COMInterfaceInstance ent in clsid.Interfaces)
{
node.Nodes.Add(CreateInterfaceNameNode(m_reg.MapIidToInterface(ent.Iid), ent));
}
}
else
{
wait_node.Text = "Error querying COM interfaces - Timeout";
}
}
catch (Win32Exception ex)
{
wait_node.Text = String.Format("Error querying COM interfaces - {0}", ex.Message);
}
}
}
private void SetupProcessEntry(COMProcessEntry obj)
{
m_process = obj;
textBoxProcessExecutablePath.Text = obj.ExecutablePath;
textBoxProcessProcessId.Text = obj.ProcessId.ToString();
textBoxProcessAppId.Text = GetGuidValue(obj.AppId);
textBoxProcessAccessPermissions.Text = GetStringValue(obj.AccessPermissions);
btnProcessViewAccessPermissions.Enabled = !String.IsNullOrWhiteSpace(obj.AccessPermissions);
textBoxProcessLrpcPermissions.Text = GetStringValue(obj.LRpcPermissions);
textBoxProcessUser.Text = GetStringValue(obj.User);
textBoxProcessSecurity.Text = String.Format("Capabilities: {0}, Authn Level: {1}, Imp Level: {2}, Unmarshal Policy: {3}",
obj.Capabilities, obj.AuthnLevel, obj.ImpLevel, obj.UnmarshalPolicy);
textBoxProcessStaHwnd.Text = String.Format("0x{0:X}", obj.STAMainHWnd.ToInt64());
SetupIpidEntries(obj.Ipids, false);
listViewProcessIPids.ListViewItemSorter = new ListItemComparer(0);
lblProcess64bit.Text = COMUtilities.FormatBitness(obj.Is64Bit);
tabControlProperties.TabPages.Add(tabPageProcess);
if (m_registry.AppIDs.ContainsKey(obj.AppId))
{
SetupAppIdEntry((COMAppIDEntry)m_registry.AppIDs[obj.AppId]);
}
if (obj.Classes.Any())
{
tabControlProperties.TabPages.Add(tabPageRegisteredClasses);
foreach (var c in obj.Classes)
{
COMCLSIDEntry clsid = m_registry.MapClsidToEntry(c.Clsid);
ListViewItem item = listViewRegisteredClasses.Items.Add(c.Clsid.FormatGuid());
item.SubItems.Add(clsid.Name);
item.SubItems.Add(c.VTable);
item.SubItems.Add(c.RegFlags.ToString());
item.SubItems.Add(c.Apartment.ToString());
item.SubItems.Add(c.Context.ToString());
item.Tag = c;
}
listViewRegisteredClasses.ListViewItemSorter = new ListItemComparer(0);
listViewRegisteredClasses.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
listViewRegisteredClasses.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
}
