mirror of
https://github.com/Hofknecht/SystemTrayMenu.git
synced 2024-05-06 05:22:49 +12:00
846 lines
30 KiB
C#
846 lines
30 KiB
C#
using Microsoft.Win32;
|
|
using System;
|
|
using System.Collections.Specialized;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
|
|
namespace SystemTrayMenu.Controls
|
|
{
|
|
/// <summary>
|
|
/// Generic, self-contained About Box dialog
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Jeff Atwood
|
|
/// http://www.codinghorror.com
|
|
/// converted to C# by Scott Ferguson
|
|
/// http://www.forestmoon.com
|
|
/// </remarks>
|
|
public partial class AboutBox : Form
|
|
{
|
|
public AboutBox()
|
|
{
|
|
InitializeComponent();
|
|
buttonOk.Text = Program.Translate("buttonOk");
|
|
buttonDetails.Text = Program.Translate("buttonDetails");
|
|
buttonSystemInfo.Text = Program.Translate("buttonSystemInfo");
|
|
}
|
|
|
|
private bool _IsPainted = false;
|
|
private string _EntryAssemblyName;
|
|
private string _CallingAssemblyName;
|
|
private string _ExecutingAssemblyName;
|
|
private Assembly _EntryAssembly;
|
|
private NameValueCollection _EntryAssemblyAttribCollection;
|
|
private int _MinWindowHeight;
|
|
|
|
// <summary>
|
|
// returns the entry assembly for the current application domain
|
|
// </summary>
|
|
// <remarks>
|
|
// This is usually read-only, but in some weird cases (Smart Client apps)
|
|
// you won't have an entry assembly, so you may want to set this manually.
|
|
// </remarks>
|
|
public Assembly AppEntryAssembly
|
|
{
|
|
get
|
|
{
|
|
return _EntryAssembly;
|
|
}
|
|
set
|
|
{
|
|
_EntryAssembly = value;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// single line of text to show in the application title section of the about box dialog
|
|
// </summary>
|
|
// <remarks>
|
|
// defaults to "%title%"
|
|
// %title% = Assembly: AssemblyTitle
|
|
// </remarks>
|
|
public string AppTitle
|
|
{
|
|
get
|
|
{
|
|
return AppTitleLabel.Text;
|
|
}
|
|
set
|
|
{
|
|
AppTitleLabel.Text = value;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// single line of text to show in the description section of the about box dialog
|
|
// </summary>
|
|
// <remarks>
|
|
// defaults to "%description%"
|
|
// %description% = Assembly: AssemblyDescription
|
|
// </remarks>
|
|
public string AppDescription
|
|
{
|
|
get
|
|
{
|
|
return AppDescriptionLabel.Text;
|
|
}
|
|
set
|
|
{
|
|
if (value == "")
|
|
{
|
|
AppDescriptionLabel.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
AppDescriptionLabel.Visible = true;
|
|
AppDescriptionLabel.Text = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// single line of text to show in the version section of the about dialog
|
|
// </summary>
|
|
// <remarks>
|
|
// defaults to "Version %version%"
|
|
// %version% = Assembly: AssemblyVersion
|
|
// </remarks>
|
|
public string AppVersion
|
|
{
|
|
get
|
|
{
|
|
return AppVersionLabel.Text;
|
|
}
|
|
set
|
|
{
|
|
if (value == "")
|
|
{
|
|
AppVersionLabel.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
AppVersionLabel.Visible = true;
|
|
AppVersionLabel.Text = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// single line of text to show in the copyright section of the about dialog
|
|
// </summary>
|
|
// <remarks>
|
|
// defaults to "Copyright © %year%, %company%"
|
|
// %company% = Assembly: AssemblyCompany
|
|
// %year% = current 4-digit year
|
|
// </remarks>
|
|
public string AppCopyright
|
|
{
|
|
get
|
|
{
|
|
return AppCopyrightLabel.Text;
|
|
}
|
|
set
|
|
{
|
|
if (value == "")
|
|
{
|
|
AppCopyrightLabel.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
AppCopyrightLabel.Visible = true;
|
|
AppCopyrightLabel.Text = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// intended for the default 32x32 application icon to appear in the upper left of the about dialog
|
|
// </summary>
|
|
// <remarks>
|
|
// if you open this form using .ShowDialog(Owner), the icon can be derived from the owning form
|
|
// </remarks>
|
|
public Image AppImage
|
|
{
|
|
get
|
|
{
|
|
return ImagePictureBox.Image;
|
|
}
|
|
set
|
|
{
|
|
ImagePictureBox.Image = value;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// multiple lines of miscellaneous text to show in rich text box
|
|
// </summary>
|
|
// <remarks>
|
|
// defaults to "%product% is %copyright%, %trademark%"
|
|
// %product% = Assembly: AssemblyProduct
|
|
// %copyright% = Assembly: AssemblyCopyright
|
|
// %trademark% = Assembly: AssemblyTrademark
|
|
// </remarks>
|
|
public string AppMoreInfo
|
|
{
|
|
get
|
|
{
|
|
return MoreRichTextBox.Text;
|
|
}
|
|
set
|
|
{
|
|
if (value == null || value == "")
|
|
{
|
|
MoreRichTextBox.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
MoreRichTextBox.Visible = true;
|
|
MoreRichTextBox.Text = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// determines if the "Details" (advanced assembly details) button is shown
|
|
// </summary>
|
|
public bool AppDetailsButton
|
|
{
|
|
get
|
|
{
|
|
return buttonDetails.Visible;
|
|
}
|
|
set
|
|
{
|
|
buttonDetails.Visible = value;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// exception-safe retrieval of LastWriteTime for this assembly.
|
|
// </summary>
|
|
// <returns>File.GetLastWriteTime, or DateTime.MaxValue if exception was encountered.</returns>
|
|
private DateTime AssemblyLastWriteTime(Assembly a)
|
|
{
|
|
if (a.Location == null || a.Location == "")
|
|
return DateTime.MaxValue;
|
|
try
|
|
{
|
|
return File.GetLastWriteTime(a.Location);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return DateTime.MaxValue;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// returns DateTime this Assembly was last built. Will attempt to calculate from build number, if possible.
|
|
// If not, the actual LastWriteTime on the assembly file will be returned.
|
|
// </summary>
|
|
// <param name="a">Assembly to get build date for</param>
|
|
// <param name="ForceFileDate">Don't attempt to use the build number to calculate the date</param>
|
|
// <returns>DateTime this assembly was last built</returns>
|
|
private DateTime AssemblyBuildDate(Assembly a, bool ForceFileDate)
|
|
{
|
|
Version AssemblyVersion = a.GetName().Version;
|
|
DateTime dt;
|
|
|
|
if (ForceFileDate)
|
|
{
|
|
dt = AssemblyLastWriteTime(a);
|
|
}
|
|
else
|
|
{
|
|
dt = DateTime.Parse("01/01/2000").AddDays(AssemblyVersion.Build).AddSeconds(AssemblyVersion.Revision * 2);
|
|
if (TimeZone.IsDaylightSavingTime(dt, TimeZone.CurrentTimeZone.GetDaylightChanges(dt.Year)))
|
|
{
|
|
dt = dt.AddHours(1);
|
|
}
|
|
if (dt > DateTime.Now || AssemblyVersion.Build < 730 || AssemblyVersion.Revision == 0)
|
|
{
|
|
dt = AssemblyLastWriteTime(a);
|
|
}
|
|
}
|
|
|
|
return dt;
|
|
}
|
|
|
|
// <summary>
|
|
// returns string name / string value pair of all attribs
|
|
// for specified assembly
|
|
// </summary>
|
|
// <remarks>
|
|
// note that Assembly* values are pulled from AssemblyInfo file in project folder
|
|
//
|
|
// Trademark = AssemblyTrademark string
|
|
// Debuggable = true
|
|
// GUID = 7FDF68D5-8C6F-44C9-B391-117B5AFB5467
|
|
// CLSCompliant = true
|
|
// Product = AssemblyProduct string
|
|
// Copyright = AssemblyCopyright string
|
|
// Company = AssemblyCompany string
|
|
// Description = AssemblyDescription string
|
|
// Title = AssemblyTitle string
|
|
// </remarks>
|
|
private NameValueCollection AssemblyAttribs(Assembly a)
|
|
{
|
|
string TypeName;
|
|
string Name;
|
|
string Value;
|
|
NameValueCollection nvc = new NameValueCollection();
|
|
Regex r = new Regex(@"(\.Assembly|\.)(?<Name>[^.]*)Attribute$", RegexOptions.IgnoreCase);
|
|
|
|
foreach (object attrib in a.GetCustomAttributes(false))
|
|
{
|
|
TypeName = attrib.GetType().ToString();
|
|
Name = r.Match(TypeName).Groups["Name"].ToString();
|
|
Value = "";
|
|
switch (TypeName)
|
|
{
|
|
case "System.CLSCompliantAttribute":
|
|
Value = ((CLSCompliantAttribute)attrib).IsCompliant.ToString(); break;
|
|
case "System.Diagnostics.DebuggableAttribute":
|
|
Value = ((System.Diagnostics.DebuggableAttribute)attrib).IsJITTrackingEnabled.ToString(); break;
|
|
case "System.Reflection.AssemblyCompanyAttribute":
|
|
Value = ((AssemblyCompanyAttribute)attrib).Company.ToString(); break;
|
|
case "System.Reflection.AssemblyConfigurationAttribute":
|
|
Value = ((AssemblyConfigurationAttribute)attrib).Configuration.ToString(); break;
|
|
case "System.Reflection.AssemblyCopyrightAttribute":
|
|
Value = ((AssemblyCopyrightAttribute)attrib).Copyright.ToString(); break;
|
|
case "System.Reflection.AssemblyDefaultAliasAttribute":
|
|
Value = ((AssemblyDefaultAliasAttribute)attrib).DefaultAlias.ToString(); break;
|
|
case "System.Reflection.AssemblyDelaySignAttribute":
|
|
Value = ((AssemblyDelaySignAttribute)attrib).DelaySign.ToString(); break;
|
|
case "System.Reflection.AssemblyDescriptionAttribute":
|
|
Value = ((AssemblyDescriptionAttribute)attrib).Description.ToString(); break;
|
|
case "System.Reflection.AssemblyInformationalVersionAttribute":
|
|
Value = ((AssemblyInformationalVersionAttribute)attrib).InformationalVersion.ToString(); break;
|
|
case "System.Reflection.AssemblyKeyFileAttribute":
|
|
Value = ((AssemblyKeyFileAttribute)attrib).KeyFile.ToString(); break;
|
|
case "System.Reflection.AssemblyProductAttribute":
|
|
Value = ((AssemblyProductAttribute)attrib).Product.ToString(); break;
|
|
case "System.Reflection.AssemblyTrademarkAttribute":
|
|
Value = ((AssemblyTrademarkAttribute)attrib).Trademark.ToString(); break;
|
|
case "System.Reflection.AssemblyTitleAttribute":
|
|
Value = ((AssemblyTitleAttribute)attrib).Title.ToString(); break;
|
|
case "System.Resources.NeutralResourcesLanguageAttribute":
|
|
Value = ((System.Resources.NeutralResourcesLanguageAttribute)attrib).CultureName.ToString(); break;
|
|
case "System.Resources.SatelliteContractVersionAttribute":
|
|
Value = ((System.Resources.SatelliteContractVersionAttribute)attrib).Version.ToString(); break;
|
|
case "System.Runtime.InteropServices.ComCompatibleVersionAttribute":
|
|
{
|
|
System.Runtime.InteropServices.ComCompatibleVersionAttribute x;
|
|
x = ((System.Runtime.InteropServices.ComCompatibleVersionAttribute)attrib);
|
|
Value = x.MajorVersion + "." + x.MinorVersion + "." + x.RevisionNumber + "." + x.BuildNumber; break;
|
|
}
|
|
case "System.Runtime.InteropServices.ComVisibleAttribute":
|
|
Value = ((System.Runtime.InteropServices.ComVisibleAttribute)attrib).Value.ToString(); break;
|
|
case "System.Runtime.InteropServices.GuidAttribute":
|
|
Value = ((System.Runtime.InteropServices.GuidAttribute)attrib).Value.ToString(); break;
|
|
case "System.Runtime.InteropServices.TypeLibVersionAttribute":
|
|
{
|
|
System.Runtime.InteropServices.TypeLibVersionAttribute x;
|
|
x = ((System.Runtime.InteropServices.TypeLibVersionAttribute)attrib);
|
|
Value = x.MajorVersion + "." + x.MinorVersion; break;
|
|
}
|
|
case "System.Security.AllowPartiallyTrustedCallersAttribute":
|
|
Value = "(Present)"; break;
|
|
default:
|
|
// debug.writeline("** unknown assembly attribute '" + TypeName + "'")
|
|
Value = TypeName; break;
|
|
}
|
|
|
|
if (nvc[Name] == null)
|
|
{
|
|
nvc.Add(Name, Value);
|
|
}
|
|
}
|
|
|
|
// add some extra values that are not in the AssemblyInfo, but nice to have
|
|
// codebase
|
|
try
|
|
{
|
|
nvc.Add("CodeBase", a.CodeBase.Replace("file:///", ""));
|
|
}
|
|
catch (NotSupportedException)
|
|
{
|
|
nvc.Add("CodeBase", "(not supported)");
|
|
}
|
|
// build date
|
|
DateTime dt = AssemblyBuildDate(a, false);
|
|
if (dt == DateTime.MaxValue)
|
|
{
|
|
nvc.Add("BuildDate", "(unknown)");
|
|
}
|
|
else
|
|
{
|
|
nvc.Add("BuildDate", dt.ToString("yyyy-MM-dd hh:mm tt"));
|
|
}
|
|
// location
|
|
try
|
|
{
|
|
nvc.Add("Location", a.Location);
|
|
}
|
|
catch (NotSupportedException)
|
|
{
|
|
nvc.Add("Location", "(not supported)");
|
|
}
|
|
// version
|
|
try
|
|
{
|
|
if (a.GetName().Version.Major == 0 && a.GetName().Version.Minor == 0)
|
|
{
|
|
nvc.Add("Version", "(unknown)");
|
|
}
|
|
else
|
|
{
|
|
nvc.Add("Version", a.GetName().Version.ToString());
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
nvc.Add("Version", "(unknown)");
|
|
}
|
|
|
|
nvc.Add("FullName", a.FullName);
|
|
|
|
return nvc;
|
|
}
|
|
|
|
// <summary>
|
|
// reads an HKLM Windows Registry key value
|
|
// </summary>
|
|
private string RegistryHklmValue(string KeyName, string SubKeyRef)
|
|
{
|
|
RegistryKey rk;
|
|
try
|
|
{
|
|
rk = Registry.LocalMachine.OpenSubKey(KeyName);
|
|
return (string)rk.GetValue(SubKeyRef, "");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// launch the MSInfo "system information" application (works on XP, 2003, and Vista)
|
|
// </summary>
|
|
private void ShowSysInfo()
|
|
{
|
|
string strSysInfoPath = "";
|
|
|
|
strSysInfoPath = RegistryHklmValue(@"SOFTWARE\Microsoft\Shared Tools Location", "MSINFO");
|
|
if (strSysInfoPath == "")
|
|
{
|
|
strSysInfoPath = RegistryHklmValue(@"SOFTWARE\Microsoft\Shared Tools\MSINFO", "PATH");
|
|
}
|
|
|
|
if (strSysInfoPath == "")
|
|
{
|
|
MessageBox.Show("System Information is unavailable at this time." +
|
|
Environment.NewLine +
|
|
Environment.NewLine +
|
|
"(couldn't find path for Microsoft System Information Tool in the registry.)",
|
|
Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
System.Diagnostics.Process.Start(strSysInfoPath);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
MessageBox.Show("System Information is unavailable at this time." +
|
|
Environment.NewLine +
|
|
Environment.NewLine +
|
|
"(couldn't launch '" + strSysInfoPath + "')",
|
|
Text, MessageBoxButtons.OK, MessageBoxIcon.Stop);
|
|
}
|
|
|
|
}
|
|
|
|
// <summary>
|
|
// populate a listview with the specified key and value strings
|
|
// </summary>
|
|
private void Populate(ListView lvw, string Key, string Value)
|
|
{
|
|
if (Value == "")
|
|
return;
|
|
ListViewItem lvi = new ListViewItem();
|
|
lvi.Text = Key;
|
|
lvi.SubItems.Add(Value);
|
|
lvw.Items.Add(lvi);
|
|
}
|
|
|
|
// <summary>
|
|
// populates the Application Information listview
|
|
// </summary>
|
|
private void PopulateAppInfo()
|
|
{
|
|
AppDomain d = System.AppDomain.CurrentDomain;
|
|
Populate(AppInfoListView, "Application Name", d.SetupInformation.ApplicationName);
|
|
Populate(AppInfoListView, "Application Base", d.SetupInformation.ApplicationBase);
|
|
Populate(AppInfoListView, "Cache Path", d.SetupInformation.CachePath);
|
|
Populate(AppInfoListView, "Configuration File", d.SetupInformation.ConfigurationFile);
|
|
Populate(AppInfoListView, "Dynamic Base", d.SetupInformation.DynamicBase);
|
|
Populate(AppInfoListView, "Friendly Name", d.FriendlyName);
|
|
Populate(AppInfoListView, "License File", d.SetupInformation.LicenseFile);
|
|
Populate(AppInfoListView, "private Bin Path", d.SetupInformation.PrivateBinPath);
|
|
Populate(AppInfoListView, "Shadow Copy Directories", d.SetupInformation.ShadowCopyDirectories);
|
|
Populate(AppInfoListView, " ", " ");
|
|
Populate(AppInfoListView, "Entry Assembly", _EntryAssemblyName);
|
|
Populate(AppInfoListView, "Executing Assembly", _ExecutingAssemblyName);
|
|
Populate(AppInfoListView, "Calling Assembly", _CallingAssemblyName);
|
|
}
|
|
|
|
// <summary>
|
|
// populate Assembly Information listview with ALL assemblies
|
|
// </summary>
|
|
private void PopulateAssemblies()
|
|
{
|
|
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
PopulateAssemblySummary(a);
|
|
}
|
|
AssemblyNamesComboBox.SelectedIndex = AssemblyNamesComboBox.FindStringExact(_EntryAssemblyName);
|
|
}
|
|
|
|
// <summary>
|
|
// populate Assembly Information listview with summary view for a specific assembly
|
|
// </summary>
|
|
private void PopulateAssemblySummary(Assembly a)
|
|
{
|
|
NameValueCollection nvc = AssemblyAttribs(a);
|
|
|
|
string strAssemblyName = a.GetName().Name;
|
|
|
|
ListViewItem lvi = new ListViewItem();
|
|
lvi.Text = strAssemblyName;
|
|
lvi.Tag = strAssemblyName;
|
|
if (strAssemblyName == _CallingAssemblyName)
|
|
{
|
|
lvi.Text += " (calling)";
|
|
}
|
|
if (strAssemblyName == _ExecutingAssemblyName)
|
|
{
|
|
lvi.Text += " (executing)";
|
|
}
|
|
if (strAssemblyName == _EntryAssemblyName)
|
|
{
|
|
lvi.Text += " (entry)";
|
|
}
|
|
lvi.SubItems.Add(nvc["version"]);
|
|
lvi.SubItems.Add(nvc["builddate"]);
|
|
lvi.SubItems.Add(nvc["codebase"]);
|
|
//lvi.SubItems.Add(AssemblyVersion(a))
|
|
//lvi.SubItems.Add(AssemblyBuildDatestring(a, true))
|
|
//lvi.SubItems.Add(AssemblyCodeBase(a))
|
|
AssemblyInfoListView.Items.Add(lvi);
|
|
AssemblyNamesComboBox.Items.Add(strAssemblyName);
|
|
}
|
|
|
|
// <summary>
|
|
// retrieves a cached value from the entry assembly attribute lookup collection
|
|
// </summary>
|
|
private string EntryAssemblyAttrib(string strName)
|
|
{
|
|
if (_EntryAssemblyAttribCollection[strName] == null)
|
|
{
|
|
return "<Assembly: Assembly" + strName + "(\"\")>";
|
|
}
|
|
else
|
|
{
|
|
return _EntryAssemblyAttribCollection[strName].ToString();
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// Populate all the form labels with tokenized text
|
|
// </summary>
|
|
private void PopulateLabels()
|
|
{
|
|
// get entry assembly attribs
|
|
_EntryAssemblyAttribCollection = AssemblyAttribs(_EntryAssembly);
|
|
|
|
// set icon from parent, if present
|
|
if (Owner == null)
|
|
{
|
|
//ImagePictureBox.Visible = false;
|
|
//AppTitleLabel.Left = AppCopyrightLabel.Left;
|
|
//AppDescriptionLabel.Left = AppCopyrightLabel.Left;
|
|
}
|
|
else
|
|
{
|
|
Icon = Owner.Icon;
|
|
ImagePictureBox.Image = Icon.ToBitmap();
|
|
}
|
|
// replace all labels and window title
|
|
Text = ReplaceTokens(Text);
|
|
AppTitleLabel.Text = ReplaceTokens(AppTitleLabel.Text);
|
|
if (AppDescriptionLabel.Visible)
|
|
{
|
|
AppDescriptionLabel.Text = ReplaceTokens(AppDescriptionLabel.Text);
|
|
}
|
|
if (AppCopyrightLabel.Visible)
|
|
{
|
|
AppCopyrightLabel.Text = ReplaceTokens(AppCopyrightLabel.Text);
|
|
}
|
|
if (AppVersionLabel.Visible)
|
|
{
|
|
AppVersionLabel.Text = ReplaceTokens(AppVersionLabel.Text);
|
|
}
|
|
if (AppDateLabel.Visible)
|
|
{
|
|
AppDateLabel.Text = ReplaceTokens(AppDateLabel.Text);
|
|
}
|
|
if (MoreRichTextBox.Visible)
|
|
{
|
|
MoreRichTextBox.Text = ReplaceTokens(MoreRichTextBox.Text);
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// perform assemblyinfo to string replacements on labels
|
|
// </summary>
|
|
private string ReplaceTokens(string s)
|
|
{
|
|
s = s.Replace("%title%", EntryAssemblyAttrib("title"));
|
|
s = s.Replace("%copyright%", EntryAssemblyAttrib("copyright"));
|
|
s = s.Replace("%description%", EntryAssemblyAttrib("description"));
|
|
s = s.Replace("%company%", EntryAssemblyAttrib("company"));
|
|
s = s.Replace("%product%", EntryAssemblyAttrib("product"));
|
|
s = s.Replace("%trademark%", EntryAssemblyAttrib("trademark"));
|
|
s = s.Replace("%year%", DateTime.Now.Year.ToString());
|
|
s = s.Replace("%version%", EntryAssemblyAttrib("version"));
|
|
s = s.Replace("%builddate%", EntryAssemblyAttrib("builddate"));
|
|
return s;
|
|
}
|
|
|
|
// <summary>
|
|
// populate details for a single assembly
|
|
// </summary>
|
|
private void PopulateAssemblyDetails(Assembly a, ListView lvw)
|
|
{
|
|
lvw.Items.Clear();
|
|
|
|
// this assembly property is only available in framework versions 1.1+
|
|
Populate(lvw, "Image Runtime Version", a.ImageRuntimeVersion);
|
|
Populate(lvw, "Loaded from GAC", a.GlobalAssemblyCache.ToString());
|
|
|
|
NameValueCollection nvc = AssemblyAttribs(a);
|
|
foreach (string strKey in nvc)
|
|
{
|
|
Populate(lvw, strKey, nvc[strKey]);
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// matches assembly by Assembly.GetName.Name; returns nothing if no match
|
|
// </summary>
|
|
private Assembly MatchAssemblyByName(string AssemblyName)
|
|
{
|
|
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
if (a.GetName().Name == AssemblyName)
|
|
{
|
|
return a;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// <summary>
|
|
// things to do when form is loaded
|
|
// </summary>
|
|
private void AboutBox_Load(object sender, EventArgs e)
|
|
{
|
|
// if the user didn't provide an assembly, try to guess which one is the entry assembly
|
|
if (_EntryAssembly == null)
|
|
{
|
|
_EntryAssembly = Assembly.GetEntryAssembly();
|
|
}
|
|
if (_EntryAssembly == null)
|
|
{
|
|
_EntryAssembly = Assembly.GetExecutingAssembly();
|
|
}
|
|
|
|
_ExecutingAssemblyName = Assembly.GetExecutingAssembly().GetName().Name;
|
|
_CallingAssemblyName = Assembly.GetCallingAssembly().GetName().Name;
|
|
try
|
|
{
|
|
// for web hosted apps, GetEntryAssembly = nothing
|
|
_EntryAssemblyName = Assembly.GetEntryAssembly().GetName().Name;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
|
|
_MinWindowHeight = AppCopyrightLabel.Top + AppCopyrightLabel.Height + buttonOk.Height + 30;
|
|
|
|
TabPanelDetails.Visible = false;
|
|
if (!MoreRichTextBox.Visible)
|
|
{
|
|
Height = Height - MoreRichTextBox.Height;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// things to do when form is FIRST painted
|
|
// </summary>
|
|
private void AboutBox_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
if (!_IsPainted)
|
|
{
|
|
_IsPainted = true;
|
|
Application.DoEvents();
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
PopulateLabels();
|
|
Cursor.Current = Cursors.Default;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// expand about dialog to show additional advanced details
|
|
// </summary>
|
|
private void DetailsButton_Click(object sender, EventArgs e)
|
|
{
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
buttonDetails.Visible = false;
|
|
SuspendLayout();
|
|
MaximizeBox = true;
|
|
FormBorderStyle = FormBorderStyle.Sizable;
|
|
TabPanelDetails.Dock = DockStyle.Fill;
|
|
tableLayoutPanel1.Dock = DockStyle.Fill;
|
|
this.AutoSize = false;
|
|
SizeGripStyle = SizeGripStyle.Show;
|
|
Size = new Size(580, Size.Height);
|
|
MoreRichTextBox.Visible = false;
|
|
TabPanelDetails.Visible = true;
|
|
buttonSystemInfo.Visible = true;
|
|
PopulateAssemblies();
|
|
PopulateAppInfo();
|
|
CenterToParent();
|
|
ResumeLayout();
|
|
Cursor.Current = Cursors.Default;
|
|
}
|
|
|
|
// <summary>
|
|
// for detailed system info, launch the external Microsoft system info app
|
|
// </summary>
|
|
private void SysInfoButton_Click(object sender, EventArgs e)
|
|
{
|
|
ShowSysInfo();
|
|
}
|
|
|
|
// <summary>
|
|
// if an assembly is double-clicked, go to the detail page for that assembly
|
|
// </summary>
|
|
private void AssemblyInfoListView_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
string strAssemblyName;
|
|
if (AssemblyInfoListView.SelectedItems.Count > 0)
|
|
{
|
|
strAssemblyName = Convert.ToString(AssemblyInfoListView.SelectedItems[0].Tag);
|
|
AssemblyNamesComboBox.SelectedIndex = AssemblyNamesComboBox.FindStringExact(strAssemblyName);
|
|
TabPanelDetails.SelectedTab = TabPageAssemblyDetails;
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// if a new assembly is selected from the combo box, show details for that assembly
|
|
// </summary>
|
|
private void AssemblyNamesComboBox_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
string strAssemblyName = Convert.ToString(AssemblyNamesComboBox.SelectedItem);
|
|
PopulateAssemblyDetails(MatchAssemblyByName(strAssemblyName), AssemblyDetailsListView);
|
|
}
|
|
|
|
// <summary>
|
|
// sort the assembly list by column
|
|
// </summary>
|
|
private void AssemblyInfoListView_ColumnClick(object sender, ColumnClickEventArgs e)
|
|
{
|
|
int intTargetCol = e.Column + 1;
|
|
|
|
if (AssemblyInfoListView.Tag != null)
|
|
{
|
|
if (Math.Abs(Convert.ToInt32(AssemblyInfoListView.Tag)) == intTargetCol)
|
|
{
|
|
intTargetCol = -Convert.ToInt32(AssemblyInfoListView.Tag);
|
|
}
|
|
}
|
|
AssemblyInfoListView.Tag = intTargetCol;
|
|
AssemblyInfoListView.ListViewItemSorter = new ListViewItemComparer(intTargetCol, true);
|
|
}
|
|
|
|
// <summary>
|
|
// launch any http:// or mailto: links clicked in the body of the rich text box
|
|
// </summary>
|
|
private void MoreRichTextBox_LinkClicked(object sender, LinkClickedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
System.Diagnostics.Process.Start(e.LinkText);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
// <summary>
|
|
// things to do when the selected tab is changed
|
|
// </summary>
|
|
class ListViewItemComparer : System.Collections.IComparer
|
|
{
|
|
private int _intCol;
|
|
private bool _IsAscending = true;
|
|
|
|
public ListViewItemComparer()
|
|
{
|
|
_intCol = 0;
|
|
_IsAscending = true;
|
|
}
|
|
|
|
public ListViewItemComparer(int column, bool ascending)
|
|
{
|
|
if (column < 0)
|
|
{
|
|
_IsAscending = false;
|
|
}
|
|
else
|
|
{
|
|
_IsAscending = ascending;
|
|
}
|
|
_intCol = Math.Abs(column) - 1;
|
|
}
|
|
|
|
public int Compare(object x, object y)
|
|
{
|
|
int intResult =
|
|
string.Compare(((ListViewItem)x).SubItems[_intCol].Text, ((ListViewItem)y).SubItems[_intCol].Text);
|
|
|
|
if (_IsAscending)
|
|
{
|
|
return intResult;
|
|
}
|
|
else
|
|
{
|
|
return -intResult;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TabPanelDetails_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if (TabPanelDetails.SelectedTab == TabPageAssemblyDetails)
|
|
AssemblyNamesComboBox.Focus();
|
|
}
|
|
|
|
}
|
|
} |