Merge pull request #5 from sMkTools/rel/3.2.0

Author: creizlein

README.md

@@ -1,9 +1,9 @@
 <div align="center">
-  <img alt="GitHub Latest Release" src="https://img.shields.io/github/v/release/sMkTools/sMkTaskManager?label=Latest%20Release" />
-  <img alt="GitHub License" src="https://img.shields.io/github/license/sMkTools/sMkTaskManager?label=License" />
-  <img alt="GitHub Downloads" src="https://img.shields.io/github/downloads/sMkTools/sMkTaskManager/total?label=Downloads" />
-  <img alt="WinForms Badge" src="https://img.shields.io/badge/Win-Forms-purple" />
-  <img alt="Admin Badge" src="https://img.shields.io/badge/Admin-Only-red" />
+  <a href="#"><img alt="GitHub Latest Release" src="https://img.shields.io/github/v/release/sMkTools/sMkTaskManager?label=Latest%20Release" /></a>
+  <a href="#"><img alt="GitHub License" src="https://img.shields.io/github/license/sMkTools/sMkTaskManager?label=License" /></a>
+  <a href="#"><img alt="GitHub Downloads" src="https://img.shields.io/github/downloads/sMkTools/sMkTaskManager/total?label=Downloads" /></a>
+  <a href="#"><img alt="WinForms Badge" src="https://img.shields.io/badge/Win-Forms-purple" /></a>
+  <a href="#"><img alt="Admin Badge" src="https://img.shields.io/badge/Admin-Only-red" /></a>
 </div>
 
 # sMk Task Manager
@@ -25,16 +25,17 @@ Most likely you will see pieces of code that are UGLY for experienced programmer
 
 ## Main Features
 
++ A very nostalgic but extremly cool System Properties pages.
 + Detailed overview of all running processes activity with highlighting.
 + System performance metrics, CPU, Memory, I/O, Disk, Network.
 + GPU performance metrics, Engines, Memory, Power, Temperatures.
 + Network usage statistics, global and per network interface.
-+ List of active connections by process, and traffic.
++ List of active connections by process and their traffic usage.
 + List of listening ports, and which processes is holding it.
 + List and control services pretty much as services.msc.
-+ Device Manager, pretty much as devmgr.msc.
++ Hardware Device Manager, pretty much as devmgr.msc.
 + List of user and windows terminal services sessions.
-+ Intuitive to legacy users (not millennials) as a default Task Manager.
++ Intuitive to legacy users (not millennials) as a legacy Task Manager.
 + Customizable graphs, column details and layouts.
 + Small, portable, fast-ish, and 100% Free to use and modify.
 
@@ -55,7 +56,8 @@ Most likely you will see pieces of code that are UGLY for experienced programmer
 ## System requirements
 
 It seems odd to talk about requirements nowadays but let’s keep it simple and basic.  
-**Windows 10 or higher - 64 Bits.** - I have ditched and no longer test it on 32 Bits.  
+**[Windows 10 or higher - 64 Bits](https://www.microsoft.com/software-download/windows11)** - I have ditched and no longer test it on 32 Bits.  
+**[.NET Desktop Runtime 7.0](https://dotnet.microsoft.com/en-us/download/dotnet/7.0)** - Currently targeting .NET Desktop 7.0.*  
 On the other hand, if you really like this application and need to run on older legacy systems, I can provide you with the old version which stills runs on Windows XP onwards.
 
 ## Administrative Privileges
@@ -82,7 +84,7 @@ These features were originally implemented on older versions, but I removed the
 ## Future Features
 
 + DarkMode (someday, when WinForms properly supports it).
-+ Better Graphs customization and profiles.
++ Better graphs customization and profiles.
 + WSL Instances lists and control.
 + Hyper-V Machine lists and control.
 + More detailed Disk Performance and Usage monitor.

src/Classes/APIs.cs

@@ -1350,6 +1350,8 @@ public DEVPROPKEY(string strGuid, int pid) {
     internal static extern unsafe NTSTATUS NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass, ref SYSTEM_PERFORMANCE_INFORMATION SystemInformation, int SystemInformationLength, out int returnLength);
     [System.Security.SuppressUnmanagedCodeSecurity()] [DllImport("ntdll.dll", SetLastError = true)]
     internal static extern unsafe NTSTATUS NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, out int returnLength);
+    [System.Security.SuppressUnmanagedCodeSecurity()] [DllImport("kernel32.dll", SetLastError = true)]
+    internal static extern bool GetPhysicallyInstalledSystemMemory(out long TotalMemoryInKilobytes);
     [System.Security.SuppressUnmanagedCodeSecurity()] [DllImport("psapi.dll", CharSet = CharSet.Auto, SetLastError = true)] 
     internal static extern unsafe bool EnumPageFiles(EnumPageFilesProc proc, IntPtr lpContext);
     internal delegate bool EnumPageFilesProc(IntPtr lpContext, ref PAGE_FILE_INFORMATION Info, string Name);

src/Classes/TaskManagerConnection.cs

@@ -52,7 +52,7 @@ public TaskManagerConnection(string connIdent) : this() {
     public IPEndPoint Local { get => _Local; set { SetField(ref _Local, value, nameof(Local), new[] { nameof(LocalAddr), nameof(LocalPort) }); } }
     public IPEndPoint Remote { get => _Remote; set { SetField(ref _Remote, value, nameof(Remote), new[] { nameof(RemoteAddr), nameof(RemotePort) }); } }
     public string LocalAddr { get => isIPv6 ? "[" + _Local.Address.ToString() + "]" : _Local.Address.ToString(); }
-    public string LocalPort { get => _Remote.Port.ToString(); }
+    public string LocalPort { get => _Local.Port.ToString(); }
     public string RemoteAddr { get => isIPv6 ? "[" + _Remote.Address.ToString() + "]" : _Remote.Address.ToString(); }
     public string RemotePort { get => _Remote.Port.ToString(); }
     public ConnectionState State { get => _State; set { SetField(ref _State, value, nameof(State), new[] { nameof(StateString) }); } }

src/Classes/TaskManagerProcess.cs

@@ -451,16 +451,16 @@ private string FormatValue(ulong value, FormatValueTypes format, bool skipBPI =
             case FormatValueTypes.Literal: return value.ToString();
             case FormatValueTypes.Number: return string.Format("{0:#,0}", value);
             case FormatValueTypes.Bytes: return string.Format("{0:#,0}", value) + " B";
-            case FormatValueTypes.KBytes: return string.Format("{0:#,0}", value / 1024) + " K";
-            case FormatValueTypes.MBytes: return string.Format("{0:#,0}", value / 1024 / 1024) + " M";
-            case FormatValueTypes.Kbps: return string.Format("{0:#,0.0}", value / 1024) + " Kb/s";
+            case FormatValueTypes.KBytes: return string.Format("{0:#,0}", value / 1024d) + " K";
+            case FormatValueTypes.MBytes: return string.Format("{0:#,0}", value / 1024d / 1024d) + " M";
+            case FormatValueTypes.Kbps: return string.Format("{0:#,0.0}", value / 1024d) + " Kb/s";
             case FormatValueTypes.AutoBytes:
                 if (value < 10240) {
                     return string.Format("{0:#,0}", value) + " B";
                 } else if (value < 1024000) {
-                    return string.Format("{0:#,0}", value / 1024) + " K";
+                    return string.Format("{0:#,0.0}", value / 1024d) + " K";
                 } else {
-                    return string.Format("{0:#,0}", value / 1024 / 1024) + " M";
+                    return string.Format("{0:#,0.0}", (value / 1024d / 1024d)) + " M";
                 }
             default: return value.ToString();
         }

src/Classes/TaskManagerService.cs

@@ -8,13 +8,12 @@ namespace sMkTaskManager.Classes;
 
 [SupportedOSPlatform("windows")]
 internal class TaskManagerService : IEquatable<TaskManagerService>, INotifyPropertyChanged {
-
     private ServiceController _BaseService;
     private ServiceControllerStatus _StatusCode;
     private ServiceStartMode _StartupCode;
     private readonly string _Ident;
     private string _PID = "", _Name = "", _Description = "", _Logon = "", _ImagePath = "", _CommandLine = "";
-    private Color _BackColor = Color.Empty;
+    private Color _ForeColor = Color.Empty, _BackColor = Color.Empty;
     private int _ImageIndex = 0;
 
     public TaskManagerService(string serviceIdent) {
@@ -50,6 +49,7 @@ public string Logon {
     public ServiceControllerStatus StatusCode { get => _StatusCode; set { SetField(ref _StatusCode, value, nameof(Status)); } }
     public string Startup => _StartupCode.ToString();
     public ServiceStartMode StartupCode { get => _StartupCode; set { SetField(ref _StartupCode, value, nameof(Startup)); } }
+    public Color ForeColor { get => _ForeColor; set { SetField(ref _ForeColor, value); } }
     public Color BackColor { get => _BackColor; set { SetField(ref _BackColor, value); } }
     public int ImageIndex { get => _ImageIndex; set { SetField(ref _ImageIndex, value); } }
     public ServiceController[] DependentServices => (_BaseService == null) ? Array.Empty<ServiceController>() : _BaseService.DependentServices;
@@ -89,6 +89,7 @@ public void Update() {
             ImageIndex = (si.StartType == ServiceStartMode.Disabled) ? 2 : ((_BaseService.Status == ServiceControllerStatus.Running) ? 0 : 1);
             if (si.Description != "") { Description = si.Description!; }
             PID = (si.ProcessID == 0) ? "" : si.ProcessID.ToString();
+            ForeColor = StartupCode == ServiceStartMode.Disabled ? SystemColors.GrayText : Color.Empty;
 
             if (NotifyChanges && LastUpdated <= LastChanged) {
                 BackColor = Settings.Highlights.ChangingItems ? Settings.Highlights.ChangingColor : Color.Empty;
@@ -201,6 +202,9 @@ public struct SERVICE_INFO {
     private void MyPropertyChanged(object? sender, PropertyChangedEventArgs e) {
         if (!NotifyChanges) return;
         if (e.PropertyName == null) return;
+        if (e.PropertyName.Equals("LastChanged")) return;
+        if (e.PropertyName.Equals("LastUpdated")) return;
+        if (e.PropertyName.Equals("PreviousUpdate")) return;
         LastChanged = LastUpdated;
     }
     private void OnPropertyChanged(PropertyChangedEventArgs e) { if (NotifyChanges) PropertyChanged?.Invoke(this, e); }
@@ -364,5 +368,6 @@ public bool Contains(string serviceIdent) {
         }
         return null;
     }
+    public TaskManagerService? this[string serviceIdent] => Items.Where(_ => _.Ident == serviceIdent).FirstOrDefault();
 
 }

src/Classes/TaskManagerSystemProps.cs

@@ -0,0 +1,117 @@
+using System.Collections;
+using System.Runtime.Versioning;
+using Microsoft.Win32;
+namespace sMkTaskManager.Classes;
+
+[SupportedOSPlatform("windows")]
+internal class TaskManagerSystemProps {
+    public string WindowsName { get; private set; }
+    public string WindowsEdition { get; private set; }
+    public string WindowsVersion { get; private set; }
+    public DateTime InstallDate { get; private set; }
+    public string RegisterUser { get; private set; }
+    public string RegisterCompany { get; private set; }
+    public string RegisterKey { get; private set; }
+    public string SystemManufacturer { get; private set; }
+    public string SystemProductName { get; private set; }
+    public string ProcessorVendor { get; private set; }
+    public string ProcessorName { get; private set; }
+    public string ProcessorFamily { get; private set; }
+    public int ProcessorCount { get; private set; }
+    public string ProcessorSpeed { get; private set; }
+    public int TotalMemory { get; private set; }
+    public bool OEMInfo { get; private set; } = false;
+    public Image? OEMLogo { get; private set; }
+    public string OEMManufacturer { get; private set; }
+    public string OEMSupportPhone { get; private set; }
+    public string OEMSupportHours { get; private set; }
+    public string OEMSupportURL { get; private set; }
+
+    public void Refresh() {
+        // Get Windows Version Information
+        RegistryKey? rk = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", false);
+        if (rk != null) {
+            try { WindowsName = $"Microsoft {rk.GetValue("ProductName")}"; } catch { }
+            try { WindowsEdition = $"{rk.GetValue("EditionID")} Edition"; } catch { }
+            try { WindowsVersion = $"{rk.GetValue("DisplayVersion")} - Build: {rk.GetValue("CurrentBuild")}.{rk.GetValue("UBR")}"; } catch { }
+            try { InstallDate = DateTime.UnixEpoch.AddSeconds(Convert.ToInt64(rk.GetValue("InstallDate"))).ToLocalTime(); } catch { }
+            try { RegisterUser = rk.GetValue("RegisteredOwner")?.ToString()!; } catch { }
+            try { RegisterCompany = rk.GetValue("RegisteredOrganization")?.ToString()!; } catch { }
+            try { RegisterKey = DecodeProductKey((byte[])rk.GetValue("DigitalProductId")!); } catch { }
+        }
+        rk?.Close();
+        // Get Processor Information
+        RegistryKey? rk2 = Registry.LocalMachine.OpenSubKey(@"HARDWARE\DESCRIPTION\System\CentralProcessor\0", false);
+        if (rk2 != null) {
+            try { ProcessorVendor = rk2.GetValue("VendorIdentifier")?.ToString()!; } catch { }
+            try { ProcessorName = rk2.GetValue("ProcessorNameString")?.ToString()!; } catch { }
+            try { ProcessorFamily = rk2.GetValue("Identifier")?.ToString()!; } catch { }
+            try { ProcessorSpeed = rk2.GetValue("~MHz")?.ToString()!; } catch { }
+        }
+        rk2?.Close();
+        // Get System Information
+        RegistryKey? rk3 = Registry.LocalMachine.OpenSubKey(@"HARDWARE\DESCRIPTION\System\BIOS", false);
+        if (rk3 != null) {
+            try { SystemManufacturer = rk3.GetValue("SystemManufacturer")?.ToString()!; } catch { }
+            try { SystemProductName = rk3.GetValue("SystemProductName")?.ToString()!; } catch { }
+        }
+        rk3?.Close();
+        // Get OEM Information
+        RegistryKey? rk4 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\OEMInformation", false);
+        if (rk4 != null) {
+            if (File.Exists(rk4.GetValue("Logo")?.ToString()!)) {
+                try { OEMLogo = Image.FromFile(rk4.GetValue("Logo")?.ToString()!); } catch { OEMLogo = null; }
+            }
+            try { OEMManufacturer = rk4.GetValue("Manufacturer")?.ToString()!; } catch { }
+            try { OEMSupportPhone = rk4.GetValue("SupportPhone")?.ToString()!; } catch { }
+            try { OEMSupportHours = rk4.GetValue("SupportHours")?.ToString()!; } catch { }
+            try { OEMSupportURL = rk4.GetValue("SupportURL")?.ToString()!; } catch { }
+            OEMInfo = (OEMManufacturer != "" || OEMSupportPhone != "" || OEMSupportURL != "");
+        } else { OEMInfo = false; }
+        rk4?.Close();
+        // Get Total Memory
+        if (API.GetPhysicallyInstalledSystemMemory(out long memKb)) {
+            TotalMemory = (int)(memKb / 1024 / 1024);
+        } else { TotalMemory = 0; }
+
+    }
+    private static string DecodeProductKey(byte[] digitalProductId) {
+        if (digitalProductId == null) return string.Empty;
+        if (digitalProductId.Length < 20) return string.Empty;
+        // Offset of first byte of encoded product key in 'DigitalProductIdxxx" REG_BINARY value. Offset = 34H.
+        const int keyStartIndex = 52;
+        // Offset of last byte of encoded product key in 'DigitalProductIdxxx" REG_BINARY value. Offset = 43H.
+        const int keyEndIndex = keyStartIndex + 15;
+        // Possible alpha-numeric characters in product key.
+        char[] digits = new char[] { 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'M', 'P', 'Q', 'R', 'T', 'V', 'W', 'X', 'Y', '2', '3', '4', '6', '7', '8', '9', };
+        // Length of decoded product key
+        const int decodeLength = 29;
+        // Length of decoded product key in byte-form.
+        // Each byte represents 2 chars.
+        const int decodeStringLength = 15;
+        // Array of containing the decoded product key.
+        char[] decodedChars = new char[decodeLength];
+        // Extract byte 52 to 67 inclusive.
+        ArrayList hexPid = new();
+        for (int i = keyStartIndex; i <= keyEndIndex; i++) {
+            hexPid.Add(digitalProductId[i]);
+        }
+        for (int i = decodeLength - 1; i >= 0; i--) {
+            // Every sixth char is a separator.
+            if ((i + 1) % 6 == 0) {
+                decodedChars[i] = '-';
+            } else {
+                // Do the actual decoding.
+                int digitMapIndex = 0;
+                for (int j = decodeStringLength - 1; j >= 0; j--) {
+                    int byteValue = (digitMapIndex << 8) | (byte)hexPid[j]!;
+                    hexPid[j] = (byte)(byteValue / 24);
+                    digitMapIndex = byteValue % 24;
+                    decodedChars[i] = digits[digitMapIndex];
+                }
+            }
+        }
+        return new string(decodedChars);
+    }
+
+}