Minor fixes

Merged GPU temp reader
Merge pull request #74 from ZimM-LostPolygon/gpu-temperature
2026-02-23 13:00:52 +01:00 · 2023-03-13 20:25:35 +01:00 · 2023-03-13 20:02:59 +01:00 · 2023-03-13 19:52:33 +01:00 · 2023-03-13 19:38:39 +01:00 · 2023-03-13 18:33:27 +01:00
25 changed files with 1240 additions and 916 deletions
--- a/ASUSWmi.cs
+++ b/ASUSWmi.cs
@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using GHelper;
+using System.Diagnostics;
 using System.Management;
 using System.Runtime.InteropServices;

@@ -182,7 +183,7 @@ public class ASUSWmi
        if (curve.Length != 16) return;
        if (curve.All(singleByte => singleByte == 0)) return;

-        Debug.WriteLine(BitConverter.ToString(curve));
+        Logger.WriteLine("Fans" + ((device == 1)?"GPU":"CPU") + " " + BitConverter.ToString(curve));

        if (device == 1)
            DeviceSet(DevsGPUFanCurve, curve);
--- a/App.config
+++ b/App.config
@@ -3,4 +3,8 @@
 	<System.Windows.Forms.ApplicationConfigurationSection>
 		<add key="DpiAwareness" value="PerMonitorV2" />
 	</System.Windows.Forms.ApplicationConfigurationSection>
-</configuration>
+	<appSettings>
+		<add key="EnableWindowsFormsHighDpiAutoResizing" value="true" />
+	</appSettings>
+</configuration>
+
--- a/Communication/Device.cs
+++ b/Communication/Device.cs
@@ -1,6 +1,7 @@
 // Source thanks to https://github.com/vddCore/Starlight :)

 using Starlight.Communication.Platform;
+using System.Configuration;

 namespace Starlight.Communication
 {
@@ -8,9 +9,21 @@ namespace Starlight.Communication
    {
        private static UsbProvider _usbProvider;

+        private static ushort _vendorId;
+        private static ushort _productId;
+        private static int _maxFeatureReportLength;
+
        protected Device(ushort vendorId, ushort productId, int maxFeatureReportLength)
        {
-            _usbProvider = new WindowsUsbProvider(vendorId, productId, maxFeatureReportLength);
+            _vendorId = vendorId;
+            _productId = productId;
+            _maxFeatureReportLength = maxFeatureReportLength;
+            SetProvider();
+        }
+
+        public void SetProvider()
+        {
+            _usbProvider = new WindowsUsbProvider(_vendorId, _productId, _maxFeatureReportLength);
        }

        protected T Packet<T>(params byte[] command) where T : Packet
--- a/Fans.Designer.cs
+++ b/Fans.Designer.cs
@@ -28,16 +28,20 @@
        /// </summary>
        private void InitializeComponent()
        {
-            System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea3 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
-            System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea4 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
+            System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
+            System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea2 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
            panelFans = new Panel();
+            picturePerf = new PictureBox();
+            tableFanCharts = new TableLayoutPanel();
+            chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
+            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
+            checkBoost = new CheckBox();
            labelFans = new Label();
            checkAuto = new CheckBox();
-            chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
            buttonReset = new Button();
            buttonApply = new Button();
-            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
            panelPower = new Panel();
+            pictureBox1 = new PictureBox();
            labelPowerLimits = new Label();
            checkApplyPower = new CheckBox();
            buttonApplyPower = new Button();
@@ -52,11 +56,13 @@
            labelApplied = new Label();
            pictureFine = new PictureBox();
            labelInfo = new Label();
-            checkBoost = new CheckBox();
            panelFans.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)picturePerf).BeginInit();
+            tableFanCharts.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)chartGPU).BeginInit();
            ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
            panelPower.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureBox1).BeginInit();
            panelCPU.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)trackCPU).BeginInit();
            panelTotal.SuspendLayout();
@@ -66,27 +72,93 @@
            // 
            // panelFans
            // 
+            panelFans.Controls.Add(picturePerf);
+            panelFans.Controls.Add(tableFanCharts);
            panelFans.Controls.Add(checkBoost);
            panelFans.Controls.Add(labelFans);
            panelFans.Controls.Add(checkAuto);
-            panelFans.Controls.Add(chartGPU);
            panelFans.Controls.Add(buttonReset);
            panelFans.Controls.Add(buttonApply);
-            panelFans.Controls.Add(chartCPU);
            panelFans.Dock = DockStyle.Left;
-            panelFans.Location = new Point(363, 0);
-            panelFans.Margin = new Padding(10);
-            panelFans.MinimumSize = new Size(868, 1089);
+            panelFans.Location = new Point(364, 0);
+            panelFans.Margin = new Padding(0);
            panelFans.Name = "panelFans";
-            panelFans.Padding = new Padding(10);
-            panelFans.Size = new Size(872, 1089);
+            panelFans.Padding = new Padding(20);
+            panelFans.Size = new Size(824, 1159);
            panelFans.TabIndex = 12;
            // 
+            // picturePerf
+            // 
+            picturePerf.BackgroundImage = Properties.Resources.icons8_fan_head_96;
+            picturePerf.BackgroundImageLayout = ImageLayout.Zoom;
+            picturePerf.InitialImage = null;
+            picturePerf.Location = new Point(30, 18);
+            picturePerf.Margin = new Padding(4, 2, 4, 2);
+            picturePerf.Name = "picturePerf";
+            picturePerf.Size = new Size(36, 38);
+            picturePerf.TabIndex = 37;
+            picturePerf.TabStop = false;
+            // 
+            // tableFanCharts
+            // 
+            tableFanCharts.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
+            tableFanCharts.ColumnCount = 1;
+            tableFanCharts.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
+            tableFanCharts.Controls.Add(chartGPU, 0, 1);
+            tableFanCharts.Controls.Add(chartCPU, 0, 0);
+            tableFanCharts.Location = new Point(28, 68);
+            tableFanCharts.Margin = new Padding(6);
+            tableFanCharts.Name = "tableFanCharts";
+            tableFanCharts.RowCount = 2;
+            tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Percent, 50F));
+            tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Percent, 50F));
+            tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Absolute, 40F));
+            tableFanCharts.RowStyles.Add(new RowStyle(SizeType.Absolute, 40F));
+            tableFanCharts.Size = new Size(764, 988);
+            tableFanCharts.TabIndex = 36;
+            // 
+            // chartGPU
+            // 
+            chartArea1.Name = "ChartArea1";
+            chartGPU.ChartAreas.Add(chartArea1);
+            chartGPU.Dock = DockStyle.Fill;
+            chartGPU.Location = new Point(2, 504);
+            chartGPU.Margin = new Padding(2, 10, 2, 10);
+            chartGPU.Name = "chartGPU";
+            chartGPU.Size = new Size(760, 474);
+            chartGPU.TabIndex = 17;
+            chartGPU.Text = "chart1";
+            // 
+            // chartCPU
+            // 
+            chartArea2.Name = "ChartArea1";
+            chartCPU.ChartAreas.Add(chartArea2);
+            chartCPU.Dock = DockStyle.Fill;
+            chartCPU.Location = new Point(2, 10);
+            chartCPU.Margin = new Padding(2, 10, 2, 10);
+            chartCPU.Name = "chartCPU";
+            chartCPU.Size = new Size(760, 474);
+            chartCPU.TabIndex = 14;
+            chartCPU.Text = "chartCPU";
+            // 
+            // checkBoost
+            // 
+            checkBoost.AutoSize = true;
+            checkBoost.ForeColor = SystemColors.ControlText;
+            checkBoost.Location = new Point(475, 18);
+            checkBoost.Margin = new Padding(4, 2, 4, 2);
+            checkBoost.Name = "checkBoost";
+            checkBoost.Size = new Size(320, 36);
+            checkBoost.TabIndex = 35;
+            checkBoost.Text = "CPU Turbo Boost enabled";
+            checkBoost.UseVisualStyleBackColor = true;
+            // 
            // labelFans
            // 
            labelFans.AutoSize = true;
            labelFans.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelFans.Location = new Point(24, 15);
+            labelFans.Location = new Point(66, 20);
+            labelFans.Margin = new Padding(4, 0, 4, 0);
            labelFans.Name = "labelFans";
            labelFans.Size = new Size(138, 32);
            labelFans.TabIndex = 28;
@@ -96,7 +168,7 @@
            // 
            checkAuto.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
            checkAuto.AutoSize = true;
-            checkAuto.Location = new Point(411, 1030);
+            checkAuto.Location = new Point(377, 1086);
            checkAuto.Margin = new Padding(4, 2, 4, 2);
            checkAuto.Name = "checkAuto";
            checkAuto.Size = new Size(165, 36);
@@ -104,25 +176,13 @@
            checkAuto.Text = "Auto Apply";
            checkAuto.UseVisualStyleBackColor = true;
            // 
-            // chartGPU
-            // 
-            chartGPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
-            chartArea3.Name = "ChartArea1";
-            chartGPU.ChartAreas.Add(chartArea3);
-            chartGPU.Location = new Point(22, 547);
-            chartGPU.Margin = new Padding(4, 2, 4, 2);
-            chartGPU.Name = "chartGPU";
-            chartGPU.Size = new Size(810, 460);
-            chartGPU.TabIndex = 16;
-            chartGPU.Text = "chart1";
-            // 
            // buttonReset
            // 
            buttonReset.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
-            buttonReset.Location = new Point(22, 1025);
+            buttonReset.Location = new Point(30, 1081);
            buttonReset.Margin = new Padding(4, 2, 4, 2);
            buttonReset.Name = "buttonReset";
-            buttonReset.Size = new Size(231, 44);
+            buttonReset.Size = new Size(232, 44);
            buttonReset.TabIndex = 15;
            buttonReset.Text = "Factory Defaults";
            buttonReset.UseVisualStyleBackColor = true;
@@ -130,7 +190,7 @@
            // buttonApply
            // 
            buttonApply.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
-            buttonApply.Location = new Point(584, 1025);
+            buttonApply.Location = new Point(542, 1081);
            buttonApply.Margin = new Padding(4, 2, 4, 2);
            buttonApply.Name = "buttonApply";
            buttonApply.Size = new Size(248, 44);
@@ -138,20 +198,9 @@
            buttonApply.Text = "Apply Fan Curve";
            buttonApply.UseVisualStyleBackColor = true;
            // 
-            // chartCPU
-            // 
-            chartCPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
-            chartArea4.Name = "ChartArea1";
-            chartCPU.ChartAreas.Add(chartArea4);
-            chartCPU.Location = new Point(22, 66);
-            chartCPU.Margin = new Padding(10);
-            chartCPU.Name = "chartCPU";
-            chartCPU.Size = new Size(810, 460);
-            chartCPU.TabIndex = 13;
-            chartCPU.Text = "chartCPU";
-            // 
            // panelPower
            // 
+            panelPower.Controls.Add(pictureBox1);
            panelPower.Controls.Add(labelPowerLimits);
            panelPower.Controls.Add(checkApplyPower);
            panelPower.Controls.Add(buttonApplyPower);
@@ -162,15 +211,30 @@
            panelPower.Controls.Add(labelInfo);
            panelPower.Dock = DockStyle.Left;
            panelPower.Location = new Point(0, 0);
+            panelPower.Margin = new Padding(10);
            panelPower.Name = "panelPower";
-            panelPower.Size = new Size(363, 1089);
+            panelPower.Padding = new Padding(10);
+            panelPower.Size = new Size(364, 1159);
            panelPower.TabIndex = 13;
            // 
+            // pictureBox1
+            // 
+            pictureBox1.BackgroundImage = Properties.Resources.icons8_processor_96;
+            pictureBox1.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureBox1.InitialImage = null;
+            pictureBox1.Location = new Point(20, 18);
+            pictureBox1.Margin = new Padding(4, 2, 4, 2);
+            pictureBox1.Name = "pictureBox1";
+            pictureBox1.Size = new Size(36, 38);
+            pictureBox1.TabIndex = 38;
+            pictureBox1.TabStop = false;
+            // 
            // labelPowerLimits
            // 
            labelPowerLimits.AutoSize = true;
            labelPowerLimits.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelPowerLimits.Location = new Point(23, 15);
+            labelPowerLimits.Location = new Point(54, 20);
+            labelPowerLimits.Margin = new Padding(4, 0, 4, 0);
            labelPowerLimits.Name = "labelPowerLimits";
            labelPowerLimits.Size = new Size(229, 32);
            labelPowerLimits.TabIndex = 26;
@@ -178,9 +242,9 @@
            // 
            // checkApplyPower
            // 
-            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
            checkApplyPower.AutoSize = true;
-            checkApplyPower.Location = new Point(21, 982);
+            checkApplyPower.Location = new Point(27, 1039);
            checkApplyPower.Margin = new Padding(4, 2, 4, 2);
            checkApplyPower.Name = "checkApplyPower";
            checkApplyPower.Size = new Size(165, 36);
@@ -191,10 +255,10 @@
            // buttonApplyPower
            // 
            buttonApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
-            buttonApplyPower.Location = new Point(17, 1025);
+            buttonApplyPower.Location = new Point(20, 1081);
            buttonApplyPower.Margin = new Padding(4, 2, 4, 2);
            buttonApplyPower.Name = "buttonApplyPower";
-            buttonApplyPower.Size = new Size(321, 44);
+            buttonApplyPower.Size = new Size(324, 44);
            buttonApplyPower.TabIndex = 24;
            buttonApplyPower.Text = "Apply Power Limits";
            buttonApplyPower.UseVisualStyleBackColor = true;
@@ -204,7 +268,8 @@
            panelCPU.Controls.Add(labelCPU);
            panelCPU.Controls.Add(label2);
            panelCPU.Controls.Add(trackCPU);
-            panelCPU.Location = new Point(184, 89);
+            panelCPU.Location = new Point(184, 90);
+            panelCPU.Margin = new Padding(4);
            panelCPU.Name = "panelCPU";
            panelCPU.Size = new Size(160, 510);
            panelCPU.TabIndex = 23;
@@ -213,7 +278,7 @@
            // 
            labelCPU.AutoSize = true;
            labelCPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelCPU.Location = new Point(43, 41);
+            labelCPU.Location = new Point(44, 40);
            labelCPU.Margin = new Padding(4, 0, 4, 0);
            labelCPU.Name = "labelCPU";
            labelCPU.Size = new Size(61, 32);
@@ -224,7 +289,7 @@
            // label2
            // 
            label2.AutoSize = true;
-            label2.Location = new Point(45, 7);
+            label2.Location = new Point(44, 8);
            label2.Margin = new Padding(4, 0, 4, 0);
            label2.Name = "label2";
            label2.Size = new Size(58, 32);
@@ -234,7 +299,7 @@
            // 
            // trackCPU
            // 
-            trackCPU.Location = new Point(47, 89);
+            trackCPU.Location = new Point(48, 88);
            trackCPU.Margin = new Padding(4, 2, 4, 2);
            trackCPU.Maximum = 85;
            trackCPU.Minimum = 15;
@@ -250,16 +315,17 @@
            panelTotal.Controls.Add(labelTotal);
            panelTotal.Controls.Add(label1);
            panelTotal.Controls.Add(trackTotal);
-            panelTotal.Location = new Point(17, 89);
+            panelTotal.Location = new Point(16, 90);
+            panelTotal.Margin = new Padding(4);
            panelTotal.Name = "panelTotal";
-            panelTotal.Size = new Size(160, 511);
+            panelTotal.Size = new Size(160, 512);
            panelTotal.TabIndex = 22;
            // 
            // labelTotal
            // 
            labelTotal.AutoSize = true;
            labelTotal.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelTotal.Location = new Point(46, 41);
+            labelTotal.Location = new Point(46, 40);
            labelTotal.Margin = new Padding(4, 0, 4, 0);
            labelTotal.Name = "labelTotal";
            labelTotal.Size = new Size(70, 32);
@@ -270,7 +336,7 @@
            // label1
            // 
            label1.AutoSize = true;
-            label1.Location = new Point(48, 7);
+            label1.Location = new Point(48, 8);
            label1.Margin = new Padding(4, 0, 4, 0);
            label1.Name = "label1";
            label1.Size = new Size(65, 32);
@@ -280,7 +346,7 @@
            // 
            // trackTotal
            // 
-            trackTotal.Location = new Point(44, 89);
+            trackTotal.Location = new Point(44, 88);
            trackTotal.Margin = new Padding(4, 2, 4, 2);
            trackTotal.Maximum = 150;
            trackTotal.Minimum = 15;
@@ -296,7 +362,7 @@
            // 
            labelApplied.AutoSize = true;
            labelApplied.ForeColor = Color.Tomato;
-            labelApplied.Location = new Point(23, 51);
+            labelApplied.Location = new Point(56, 48);
            labelApplied.Margin = new Padding(4, 0, 4, 0);
            labelApplied.Name = "labelApplied";
            labelApplied.Size = new Size(143, 32);
@@ -305,13 +371,13 @@
            // 
            // pictureFine
            // 
-            pictureFine.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
+            pictureFine.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
            pictureFine.BackgroundImageLayout = ImageLayout.Zoom;
            pictureFine.Image = Properties.Resources.everything_is_fine_itsfine;
-            pictureFine.Location = new Point(17, 671);
+            pictureFine.Location = new Point(20, 682);
            pictureFine.Margin = new Padding(4, 2, 4, 2);
            pictureFine.Name = "pictureFine";
-            pictureFine.Size = new Size(327, 254);
+            pictureFine.Size = new Size(324, 268);
            pictureFine.SizeMode = PictureBoxSizeMode.Zoom;
            pictureFine.TabIndex = 20;
            pictureFine.TabStop = false;
@@ -319,39 +385,27 @@
            // 
            // labelInfo
            // 
-            labelInfo.Location = new Point(17, 603);
+            labelInfo.Location = new Point(24, 618);
            labelInfo.Margin = new Padding(4, 0, 4, 0);
            labelInfo.Name = "labelInfo";
-            labelInfo.Size = new Size(327, 330);
+            labelInfo.Size = new Size(320, 330);
            labelInfo.TabIndex = 19;
            labelInfo.Text = "label";
            // 
-            // checkBoost
-            // 
-            checkBoost.AutoSize = true;
-            checkBoost.ForeColor = SystemColors.ControlText;
-            checkBoost.Location = new Point(512, 15);
-            checkBoost.Margin = new Padding(4, 2, 4, 2);
-            checkBoost.Name = "checkBoost";
-            checkBoost.Size = new Size(320, 36);
-            checkBoost.TabIndex = 35;
-            checkBoost.Text = "CPU Turbo Boost enabled";
-            checkBoost.UseVisualStyleBackColor = true;
-            // 
            // Fans
            // 
            AutoScaleDimensions = new SizeF(192F, 192F);
            AutoScaleMode = AutoScaleMode.Dpi;
            AutoSize = true;
            AutoSizeMode = AutoSizeMode.GrowAndShrink;
-            ClientSize = new Size(1220, 1089);
+            ClientSize = new Size(1178, 1159);
            Controls.Add(panelFans);
            Controls.Add(panelPower);
            Margin = new Padding(4, 2, 4, 2);
            MaximizeBox = false;
            MdiChildrenMinimizedAnchorBottom = false;
            MinimizeBox = false;
-            MinimumSize = new Size(0, 1160);
+            MinimumSize = new Size(26, 1230);
            Name = "Fans";
            ShowIcon = false;
            ShowInTaskbar = false;
@@ -359,10 +413,13 @@
            Text = "Fans and Power";
            panelFans.ResumeLayout(false);
            panelFans.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)picturePerf).EndInit();
+            tableFanCharts.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)chartGPU).EndInit();
            ((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
            panelPower.ResumeLayout(false);
            panelPower.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureBox1).EndInit();
            panelCPU.ResumeLayout(false);
            panelCPU.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)trackCPU).EndInit();
@@ -376,10 +433,8 @@
        #endregion
        private Panel panelFans;
        private CheckBox checkAuto;
-        private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
        private Button buttonReset;
        private Button buttonApply;
-        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
        private Panel panelPower;
        private CheckBox checkApplyPower;
        private Button buttonApplyPower;
@@ -395,7 +450,12 @@
        private PictureBox pictureFine;
        private Label labelInfo;
        private Label labelPowerLimits;
-        private Label labelFans;
+        private TableLayoutPanel tableFanCharts;
+        private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
+        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
        private CheckBox checkBoost;
+        private Label labelFans;
+        private PictureBox picturePerf;
+        private PictureBox pictureBox1;
    }
 }
--- a/Fans.cs
+++ b/Fans.cs
@@ -57,7 +57,18 @@ namespace GHelper

        private void Fans_Shown(object? sender, EventArgs e)
        {
-            Top = Program.settingsForm.Top;
+            if (Height > Program.settingsForm.Height)
+            {
+                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+            }
+            else
+            {
+                MinimumSize = new Size(0, Program.settingsForm.Height);
+                Height = Program.settingsForm.Height;
+                Top = Program.settingsForm.Top;
+            }
+
+
            Left = Program.settingsForm.Left - Width - 5;
        }

--- a/GHelper.csproj
+++ b/GHelper.csproj
@@ -15,8 +15,8 @@
    <AssemblyName>GHelper</AssemblyName>
    <PlatformTarget>x64</PlatformTarget>
    <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
-    <AssemblyVersion>0.20</AssemblyVersion>
    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <AssemblyVersion>0.26</AssemblyVersion>
  </PropertyGroup>

  <ItemGroup>
@@ -39,6 +39,7 @@
  <ItemGroup>
    <PackageReference Include="hidlibrary" Version="3.3.40" />
    <PackageReference Include="HidSharpCore" Version="1.2.1.1" />
+    <PackageReference Include="NvAPIWrapper.Net" Version="0.8.1.101" />
    <PackageReference Include="System.Management" Version="7.0.0" />
    <PackageReference Include="TaskScheduler" Version="2.10.1" />
    <PackageReference Include="WinForms.DataVisualization" Version="1.7.0" />
--- a/Gpu/AmdAdl2.cs
+++ b/Gpu/AmdAdl2.cs
@@ -0,0 +1,485 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace AmdAdl2;
+
+#region Export Struct
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLSingleSensorData {
+    public int Supported;
+    public int Value;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLPMLogDataOutput {
+    int Size;
+
+    [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_PMLOG_MAX_SENSORS)]
+    public ADLSingleSensorData[] Sensors;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLGcnInfo
+{
+    public int CuCount; //Number of compute units on the ASIC.
+    public int TexCount; //Number of texture mapping units.
+    public int RopCount; //Number of Render backend Units.
+    public int ASICFamilyId; //Such SI, VI. See /inc/asic_reg/atiid.h for family ids
+    public int ASICRevisionId; //Such as Ellesmere, Fiji.   For example - VI family revision ids are stored in /inc/asic_reg/vi_id.h
+}
+
+[Flags]
+public enum ADLAsicFamilyType {
+    Undefined = 0,
+    Discrete = 1 << 0,
+    Integrated = 1 << 1,
+    Workstation = 1 << 2,
+    FireMV = 1 << 3,
+    Xgp = 1 << 4,
+    Fusion = 1 << 5,
+    Firestream = 1 << 6,
+    Embedded = 1 << 7,
+}
+
+public enum ADLSensorType {
+    SENSOR_MAXTYPES = 0,
+    PMLOG_CLK_GFXCLK = 1, // Current graphic clock value in MHz
+    PMLOG_CLK_MEMCLK = 2, // Current memory clock value in MHz
+    PMLOG_CLK_SOCCLK = 3,
+    PMLOG_CLK_UVDCLK1 = 4,
+    PMLOG_CLK_UVDCLK2 = 5,
+    PMLOG_CLK_VCECLK = 6,
+    PMLOG_CLK_VCNCLK = 7,
+    PMLOG_TEMPERATURE_EDGE = 8, // Current edge of the die temperature value in C
+    PMLOG_TEMPERATURE_MEM = 9,
+    PMLOG_TEMPERATURE_VRVDDC = 10,
+    PMLOG_TEMPERATURE_VRMVDD = 11,
+    PMLOG_TEMPERATURE_LIQUID = 12,
+    PMLOG_TEMPERATURE_PLX = 13,
+    PMLOG_FAN_RPM = 14, // Current fan RPM value
+    PMLOG_FAN_PERCENTAGE = 15, // Current ratio of fan RPM and max RPM
+    PMLOG_SOC_VOLTAGE = 16,
+    PMLOG_SOC_POWER = 17,
+    PMLOG_SOC_CURRENT = 18,
+    PMLOG_INFO_ACTIVITY_GFX = 19, // Current graphic activity level in percentage
+    PMLOG_INFO_ACTIVITY_MEM = 20, // Current memory activity level in percentage
+    PMLOG_GFX_VOLTAGE = 21, // Current graphic voltage in mV
+    PMLOG_MEM_VOLTAGE = 22,
+    PMLOG_ASIC_POWER = 23, // Current ASIC power draw in Watt
+    PMLOG_TEMPERATURE_VRSOC = 24,
+    PMLOG_TEMPERATURE_VRMVDD0 = 25,
+    PMLOG_TEMPERATURE_VRMVDD1 = 26,
+    PMLOG_TEMPERATURE_HOTSPOT = 27, // Current center of the die temperature value in C
+    PMLOG_TEMPERATURE_GFX = 28,
+    PMLOG_TEMPERATURE_SOC = 29,
+    PMLOG_GFX_POWER = 30,
+    PMLOG_GFX_CURRENT = 31,
+    PMLOG_TEMPERATURE_CPU = 32,
+    PMLOG_CPU_POWER = 33,
+    PMLOG_CLK_CPUCLK = 34,
+    PMLOG_THROTTLER_STATUS = 35, // A bit map of GPU throttle information. If a bit is set, the bit represented type of thorttling occurred in the last metrics sampling period
+    PMLOG_CLK_VCN1CLK1 = 36,
+    PMLOG_CLK_VCN1CLK2 = 37,
+    PMLOG_SMART_POWERSHIFT_CPU = 38,
+    PMLOG_SMART_POWERSHIFT_DGPU = 39,
+    PMLOG_BUS_SPEED = 40, // Current PCIE bus speed running
+    PMLOG_BUS_LANES = 41, // Current PCIE bus lanes using
+    PMLOG_TEMPERATURE_LIQUID0 = 42,
+    PMLOG_TEMPERATURE_LIQUID1 = 43,
+    PMLOG_CLK_FCLK = 44,
+    PMLOG_THROTTLER_STATUS_CPU = 45,
+    PMLOG_SSPAIRED_ASICPOWER = 46, // apuPower
+    PMLOG_SSTOTAL_POWERLIMIT = 47, // Total Power limit    
+    PMLOG_SSAPU_POWERLIMIT = 48, // APU Power limit
+    PMLOG_SSDGPU_POWERLIMIT = 49, // DGPU Power limit
+    PMLOG_TEMPERATURE_HOTSPOT_GCD = 50,
+    PMLOG_TEMPERATURE_HOTSPOT_MCD = 51,
+    PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE = 52,
+    PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE = 53,
+    PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
+    PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
+    PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE = 56,
+    PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE = 57,
+    PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
+    PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
+    PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE = 60,
+    PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
+    PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
+    PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
+    PMLOG_THROTTLER_TDC_GFX_PERCENTAGE = 64,
+    PMLOG_THROTTLER_TDC_SOC_PERCENTAGE = 65,
+    PMLOG_THROTTLER_TDC_USR_PERCENTAGE = 66,
+    PMLOG_THROTTLER_PPT0_PERCENTAGE = 67,
+    PMLOG_THROTTLER_PPT1_PERCENTAGE = 68,
+    PMLOG_THROTTLER_PPT2_PERCENTAGE = 69,
+    PMLOG_THROTTLER_PPT3_PERCENTAGE = 70,
+    PMLOG_THROTTLER_FIT_PERCENTAGE = 71,
+    PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
+    PMLOG_BOARD_POWER = 73,
+    PMLOG_MAX_SENSORS_REAL
+};
+
+//Throttle Status
+[Flags]
+public enum ADL_THROTTLE_NOTIFICATION {
+    ADL_PMLOG_THROTTLE_POWER = 1 << 0,
+    ADL_PMLOG_THROTTLE_THERMAL = 1 << 1,
+    ADL_PMLOG_THROTTLE_CURRENT = 1 << 2,
+};
+
+public enum ADL_PMLOG_SENSORS {
+    ADL_SENSOR_MAXTYPES = 0,
+    ADL_PMLOG_CLK_GFXCLK = 1,
+    ADL_PMLOG_CLK_MEMCLK = 2,
+    ADL_PMLOG_CLK_SOCCLK = 3,
+    ADL_PMLOG_CLK_UVDCLK1 = 4,
+    ADL_PMLOG_CLK_UVDCLK2 = 5,
+    ADL_PMLOG_CLK_VCECLK = 6,
+    ADL_PMLOG_CLK_VCNCLK = 7,
+    ADL_PMLOG_TEMPERATURE_EDGE = 8,
+    ADL_PMLOG_TEMPERATURE_MEM = 9,
+    ADL_PMLOG_TEMPERATURE_VRVDDC = 10,
+    ADL_PMLOG_TEMPERATURE_VRMVDD = 11,
+    ADL_PMLOG_TEMPERATURE_LIQUID = 12,
+    ADL_PMLOG_TEMPERATURE_PLX = 13,
+    ADL_PMLOG_FAN_RPM = 14,
+    ADL_PMLOG_FAN_PERCENTAGE = 15,
+    ADL_PMLOG_SOC_VOLTAGE = 16,
+    ADL_PMLOG_SOC_POWER = 17,
+    ADL_PMLOG_SOC_CURRENT = 18,
+    ADL_PMLOG_INFO_ACTIVITY_GFX = 19,
+    ADL_PMLOG_INFO_ACTIVITY_MEM = 20,
+    ADL_PMLOG_GFX_VOLTAGE = 21,
+    ADL_PMLOG_MEM_VOLTAGE = 22,
+    ADL_PMLOG_ASIC_POWER = 23,
+    ADL_PMLOG_TEMPERATURE_VRSOC = 24,
+    ADL_PMLOG_TEMPERATURE_VRMVDD0 = 25,
+    ADL_PMLOG_TEMPERATURE_VRMVDD1 = 26,
+    ADL_PMLOG_TEMPERATURE_HOTSPOT = 27,
+    ADL_PMLOG_TEMPERATURE_GFX = 28,
+    ADL_PMLOG_TEMPERATURE_SOC = 29,
+    ADL_PMLOG_GFX_POWER = 30,
+    ADL_PMLOG_GFX_CURRENT = 31,
+    ADL_PMLOG_TEMPERATURE_CPU = 32,
+    ADL_PMLOG_CPU_POWER = 33,
+    ADL_PMLOG_CLK_CPUCLK = 34,
+    ADL_PMLOG_THROTTLER_STATUS = 35, // GFX
+    ADL_PMLOG_CLK_VCN1CLK1 = 36,
+    ADL_PMLOG_CLK_VCN1CLK2 = 37,
+    ADL_PMLOG_SMART_POWERSHIFT_CPU = 38,
+    ADL_PMLOG_SMART_POWERSHIFT_DGPU = 39,
+    ADL_PMLOG_BUS_SPEED = 40,
+    ADL_PMLOG_BUS_LANES = 41,
+    ADL_PMLOG_TEMPERATURE_LIQUID0 = 42,
+    ADL_PMLOG_TEMPERATURE_LIQUID1 = 43,
+    ADL_PMLOG_CLK_FCLK = 44,
+    ADL_PMLOG_THROTTLER_STATUS_CPU = 45,
+    ADL_PMLOG_SSPAIRED_ASICPOWER = 46, // apuPower
+    ADL_PMLOG_SSTOTAL_POWERLIMIT = 47, // Total Power limit
+    ADL_PMLOG_SSAPU_POWERLIMIT = 48, // APU Power limit
+    ADL_PMLOG_SSDGPU_POWERLIMIT = 49, // DGPU Power limit
+    ADL_PMLOG_TEMPERATURE_HOTSPOT_GCD = 50,
+    ADL_PMLOG_TEMPERATURE_HOTSPOT_MCD = 51,
+    ADL_PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE = 52,
+    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE = 53,
+    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
+    ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
+    ADL_PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE = 56,
+    ADL_PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE = 57,
+    ADL_PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
+    ADL_PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
+    ADL_PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE = 60,
+    ADL_PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
+    ADL_PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
+    ADL_PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
+    ADL_PMLOG_THROTTLER_TDC_GFX_PERCENTAGE = 64,
+    ADL_PMLOG_THROTTLER_TDC_SOC_PERCENTAGE = 65,
+    ADL_PMLOG_THROTTLER_TDC_USR_PERCENTAGE = 66,
+    ADL_PMLOG_THROTTLER_PPT0_PERCENTAGE = 67,
+    ADL_PMLOG_THROTTLER_PPT1_PERCENTAGE = 68,
+    ADL_PMLOG_THROTTLER_PPT2_PERCENTAGE = 69,
+    ADL_PMLOG_THROTTLER_PPT3_PERCENTAGE = 70,
+    ADL_PMLOG_THROTTLER_FIT_PERCENTAGE = 71,
+    ADL_PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
+    ADL_PMLOG_BOARD_POWER = 73,
+    ADL_PMLOG_MAX_SENSORS_REAL
+}
+
+#region ADLAdapterInfo
+
+/// <summary> ADLAdapterInfo Structure</summary>
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLAdapterInfo {
+    /// <summary>The size of the structure</summary>
+    int Size;
+
+    /// <summary> Adapter Index</summary>
+    public int AdapterIndex;
+
+    /// <summary> Adapter UDID</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string UDID;
+
+    /// <summary> Adapter Bus Number</summary>
+    public int BusNumber;
+
+    /// <summary> Adapter Driver Number</summary>
+    public int DriverNumber;
+
+    /// <summary> Adapter Function Number</summary>
+    public int FunctionNumber;
+
+    /// <summary> Adapter Vendor ID</summary>
+    public int VendorID;
+
+    /// <summary> Adapter Adapter name</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string AdapterName;
+
+    /// <summary> Adapter Display name</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string DisplayName;
+
+    /// <summary> Adapter Present status</summary>
+    public int Present;
+
+    /// <summary> Adapter Exist status</summary>
+    public int Exist;
+
+    /// <summary> Adapter Driver Path</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string DriverPath;
+
+    /// <summary> Adapter Driver Ext Path</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string DriverPathExt;
+
+    /// <summary> Adapter PNP String</summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string PNPString;
+
+    /// <summary> OS Display Index</summary>
+    public int OSDisplayIndex;
+}
+
+/// <summary> ADLAdapterInfo Array</summary>
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLAdapterInfoArray {
+    /// <summary> ADLAdapterInfo Array </summary>
+    [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_MAX_ADAPTERS)]
+    public ADLAdapterInfo[] ADLAdapterInfo;
+}
+
+#endregion ADLAdapterInfo
+
+#region ADLDisplayInfo
+
+/// <summary> ADLDisplayID Structure</summary>
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLDisplayID {
+    /// <summary> Display Logical Index </summary>
+    public int DisplayLogicalIndex;
+
+    /// <summary> Display Physical Index </summary>
+    public int DisplayPhysicalIndex;
+
+    /// <summary> Adapter Logical Index </summary>
+    public int DisplayLogicalAdapterIndex;
+
+    /// <summary> Adapter Physical Index </summary>
+    public int DisplayPhysicalAdapterIndex;
+}
+
+/// <summary> ADLDisplayInfo Structure</summary>
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLDisplayInfo {
+    /// <summary> Display Index </summary>
+    public ADLDisplayID DisplayID;
+
+    /// <summary> Display Controller Index </summary>
+    public int DisplayControllerIndex;
+
+    /// <summary> Display Name </summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string DisplayName;
+
+    /// <summary> Display Manufacturer Name </summary>
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
+    public string DisplayManufacturerName;
+
+    /// <summary> Display Type : < The Display type. CRT, TV,CV,DFP are some of display types,</summary>
+    public int DisplayType;
+
+    /// <summary> Display output type </summary>
+    public int DisplayOutputType;
+
+    /// <summary> Connector type</summary>
+    public int DisplayConnector;
+
+    ///<summary> Indicating the display info bits' mask.<summary>
+    public int DisplayInfoMask;
+
+    ///<summary> Indicating the display info value.<summary>
+    public int DisplayInfoValue;
+}
+
+#endregion ADLDisplayInfo
+
+#endregion Export Struct
+
+public class Adl2 {
+    public const string Atiadlxx_FileName = "atiadlxx.dll";
+
+    #region Internal Constant
+
+    /// <summary> Define the maximum path</summary>
+    public const int ADL_MAX_PATH = 256;
+
+    /// <summary> Define the maximum adapters</summary>
+    public const int ADL_MAX_ADAPTERS = 40 /* 150 */;
+
+    /// <summary> Define the maximum displays</summary>
+    public const int ADL_MAX_DISPLAYS = 40 /* 150 */;
+
+    /// <summary> Define the maximum device name length</summary>
+    public const int ADL_MAX_DEVICENAME = 32;
+
+    /// <summary> Define the successful</summary>
+    public const int ADL_SUCCESS = 0;
+
+    /// <summary> Define the failure</summary>
+    public const int ADL_FAIL = -1;
+
+    /// <summary> Define the driver ok</summary>
+    public const int ADL_DRIVER_OK = 0;
+
+    /// <summary> Maximum number of GL-Sync ports on the GL-Sync module </summary>
+    public const int ADL_MAX_GLSYNC_PORTS = 8;
+
+    /// <summary> Maximum number of GL-Sync ports on the GL-Sync module </summary>
+    public const int ADL_MAX_GLSYNC_PORT_LEDS = 8;
+
+    /// <summary> Maximum number of ADLMOdes for the adapter </summary>
+    public const int ADL_MAX_NUM_DISPLAYMODES = 1024;
+
+    /// <summary> Performance Metrics Log max sensors number </summary>
+    public const int ADL_PMLOG_MAX_SENSORS = 256;
+
+    #endregion Internal Constant
+
+    // ///// <summary> ADL Create Function to create ADL Data</summary>
+    /// <param name="enumConnectedAdapters">If it is 1, then ADL will only return the physical exist adapters </param>
+    ///// <returns> retrun ADL Error Code</returns>
+    public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out IntPtr adlContextHandle) {
+        return NativeMethods.ADL2_Main_Control_Create(ADL_Main_Memory_Alloc_Impl_Reference, enumConnectedAdapters, out adlContextHandle);
+    }
+
+    public static void FreeMemory(IntPtr buffer) {
+        Memory_Free_Impl(buffer);
+    }
+
+    private static bool? isDllLoaded;
+
+    public static bool Load() {
+        if (isDllLoaded != null)
+            return isDllLoaded.Value;
+
+        try {
+            Marshal.PrelinkAll(typeof(Adl2));
+            isDllLoaded = true;
+        } catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException) {
+            Debug.WriteLine(e);
+            isDllLoaded = false;
+        }
+
+        return isDllLoaded.Value;
+    }
+
+    private static NativeMethods.ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
+
+    /// <summary> Build in memory allocation function</summary>
+    /// <param name="size">input size</param>
+    /// <returns>return the memory buffer</returns>
+    private static IntPtr Memory_Alloc_Impl(int size) {
+        return Marshal.AllocCoTaskMem(size);
+    }
+
+    /// <summary> Build in memory free function</summary>
+    /// <param name="buffer">input buffer</param>
+    private static void Memory_Free_Impl(IntPtr buffer) {
+        if (IntPtr.Zero != buffer) {
+            Marshal.FreeCoTaskMem(buffer);
+        }
+    }
+
+    public static class NativeMethods {
+        /// <summary> ADL Memory allocation function allows ADL to callback for memory allocation</summary>
+        /// <param name="size">input size</param>
+        /// <returns> retrun ADL Error Code</returns>
+        public delegate IntPtr ADL_Main_Memory_Alloc(int size);
+
+        // ///// <summary> ADL Create Function to create ADL Data</summary>
+        /// <param name="callback">Call back functin pointer which is ised to allocate memeory </param>
+        /// <param name="enumConnectedAdapters">If it is 1, then ADL will only retuen the physical exist adapters </param>
+        ///// <returns> retrun ADL Error Code</returns>
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out IntPtr adlContextHandle);
+
+        /// <summary> ADL Destroy Function to free up ADL Data</summary>
+        /// <returns> retrun ADL Error Code</returns>
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Main_Control_Destroy(IntPtr adlContextHandle);
+
+        /// <summary> ADL Function to get the number of adapters</summary>
+        /// <param name="numAdapters">return number of adapters</param>
+        /// <returns> retrun ADL Error Code</returns>
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_NumberOfAdapters_Get(IntPtr adlContextHandle, out int numAdapters);
+
+        /// <summary> ADL Function to get the GPU adapter information</summary>
+        /// <param name="info">return GPU adapter information</param>
+        /// <param name="inputSize">the size of the GPU adapter struct</param>
+        /// <returns> retrun ADL Error Code</returns>
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_AdapterInfo_Get(IntPtr adlContextHandle, IntPtr info, int inputSize);
+
+        /// <summary> Function to determine if the adapter is active or not.</summary>
+        /// <remarks>The function is used to check if the adapter associated with iAdapterIndex is active</remarks>  
+        /// <param name="adapterIndex"> Adapter Index.</param>
+        /// <param name="status"> Status of the adapter. True: Active; False: Dsiabled</param>
+        /// <returns>Non zero is successfull</returns> 
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_Active_Get(IntPtr adlContextHandle, int adapterIndex, out int status);
+
+        /// <summary>Get display information based on adapter index</summary>
+        /// <param name="adapterIndex">Adapter Index</param>
+        /// <param name="numDisplays">return the total number of supported displays</param>
+        /// <param name="displayInfoArray">return ADLDisplayInfo Array for supported displays' information</param>
+        /// <param name="forceDetect">force detect or not</param>
+        /// <returns>return ADL Error Code</returns>
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Display_DisplayInfo_Get(
+            IntPtr adlContextHandle,
+            int adapterIndex,
+            out int numDisplays,
+            out IntPtr displayInfoArray,
+            int forceDetect
+        );
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Overdrive_Caps(
+            IntPtr adlContextHandle,
+            int adapterIndex,
+            out int supported,
+            out int enabled,
+            out int version
+        );
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_New_QueryPMLogData_Get(IntPtr adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_ASICFamilyType_Get(IntPtr adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
+    }
+}
--- a/Gpu/AmdGpuTemperatureProvider.cs
+++ b/Gpu/AmdGpuTemperatureProvider.cs
@@ -0,0 +1,92 @@
+using System.Runtime.InteropServices;
+using AmdAdl2;
+
+namespace GHelper.Gpu;
+
+// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
+public class AmdGpuTemperatureProvider : IGpuTemperatureProvider {
+    private bool _isReady;
+    private IntPtr _adlContextHandle;
+    private readonly ADLAdapterInfo _internalDiscreteAdapter;
+
+    public AmdGpuTemperatureProvider() {
+        if (!Adl2.Load())
+            return;
+
+        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
+            return;
+
+        Adl2.NativeMethods.ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
+        if (numberOfAdapters <= 0)
+            return;
+
+        ADLAdapterInfoArray osAdapterInfoData = new();
+        int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
+        IntPtr AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
+        Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
+        if (Adl2.NativeMethods.ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
+            return;
+
+        osAdapterInfoData = (ADLAdapterInfoArray) Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
+
+        const int amdVendorId = 1002;
+        
+        // Determine which GPU is internal discrete AMD GPU
+        ADLAdapterInfo internalDiscreteAdapter = 
+            osAdapterInfoData.ADLAdapterInfo
+                .FirstOrDefault(adapter => {
+                    if (adapter.Exist == 0 || adapter.Present == 0)
+                        return false;
+                    
+                    if (adapter.VendorID != amdVendorId)
+                        return false;
+
+                    if (Adl2.NativeMethods.ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
+                        return false;
+
+                    asicFamilyType = (ADLAsicFamilyType) ((int) asicFamilyType & asicFamilyTypeValids);
+                    
+                    // FIXME: is this correct for G14 2022?
+                    return (asicFamilyType & ADLAsicFamilyType.Discrete) != 0; 
+                });
+        
+        if (internalDiscreteAdapter.Exist == 0)
+            return;
+
+        _internalDiscreteAdapter = internalDiscreteAdapter;
+        _isReady = true;
+    }
+
+    public bool IsValid => _isReady && _adlContextHandle != IntPtr.Zero;
+
+    public int? GetCurrentTemperature() {
+        if (!IsValid)
+            return null;
+        
+        if (Adl2.NativeMethods.ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
+            return null;
+        
+        ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int) ADLSensorType.PMLOG_TEMPERATURE_EDGE];
+        if (temperatureSensor.Supported == 0)
+            return null;
+
+        return temperatureSensor.Value;
+    }
+
+    private void ReleaseUnmanagedResources() {
+        if (_adlContextHandle != IntPtr.Zero) {
+            Adl2.NativeMethods.ADL2_Main_Control_Destroy(_adlContextHandle);
+            _adlContextHandle = IntPtr.Zero;
+            _isReady = false;
+        }
+    }
+
+    public void Dispose() {
+        ReleaseUnmanagedResources();
+        GC.SuppressFinalize(this);
+    }
+
+    ~AmdGpuTemperatureProvider() {
+        ReleaseUnmanagedResources();
+    }
+}
--- a/Gpu/IGpuTemperatureProvider.cs
+++ b/Gpu/IGpuTemperatureProvider.cs
@@ -0,0 +1,6 @@
+namespace GHelper.Gpu;
+
+public interface IGpuTemperatureProvider : IDisposable {
+    bool IsValid { get; }
+    int? GetCurrentTemperature();
+}
--- a/Gpu/NvidiaGpuTemperatureProvider.cs
+++ b/Gpu/NvidiaGpuTemperatureProvider.cs
@@ -0,0 +1,44 @@
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.Exceptions;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.Interfaces.GPU;
+
+namespace GHelper.Gpu; 
+
+public class NvidiaGpuTemperatureProvider : IGpuTemperatureProvider {
+    private readonly PhysicalGPU? _internalGpu;
+
+    public NvidiaGpuTemperatureProvider() {
+        _internalGpu = GetInternalDiscreteGpu();
+    }
+
+    public bool IsValid => _internalGpu != null;
+
+    public int? GetCurrentTemperature() {
+        if (!IsValid)
+            return null;
+
+        IThermalSensor? gpuSensor = 
+            GPUApi.GetThermalSettings(_internalGpu!.Handle).Sensors
+            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
+
+        if (gpuSensor == null)
+            return null;
+
+        return gpuSensor.CurrentTemperature;
+    }
+
+    public void Dispose() {
+    }
+    
+    private static PhysicalGPU? GetInternalDiscreteGpu() {
+        try {
+            return PhysicalGPU
+                .GetPhysicalGPUs()
+                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
+        } catch {
+            return null;
+        }
+    }
+}
--- a/HardwareMonitor.cs
+++ b/HardwareMonitor.cs
@@ -0,0 +1,63 @@
+using System.Diagnostics;
+using GHelper.Gpu;
+
+public class HardwareMonitor
+{
+    private static IGpuTemperatureProvider? GpuTemperatureProvider;
+
+    public static float? cpuTemp = -1;
+    public static float? batteryDischarge = -1;
+    public static int? gpuTemp = null;
+
+    public static void ReadSensors()
+    {
+        cpuTemp = -1;
+        batteryDischarge = -1;
+
+        try
+        {
+            var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
+            cpuTemp = ct.NextValue() - 273;
+            ct.Dispose();
+
+            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
+            batteryDischarge = cb.NextValue() / 1000;
+            cb.Dispose();
+
+            gpuTemp = GpuTemperatureProvider?.GetCurrentTemperature();
+        }
+        catch
+        {
+            Logger.WriteLine("Failed reading sensors");
+        }
+    }
+
+    public static void RecreateGpuTemperatureProvider() {
+        try {
+            if (GpuTemperatureProvider != null) {
+                GpuTemperatureProvider.Dispose();
+            }
+            
+            // Detect valid GPU temperature provider.
+            // We start with NVIDIA because there's always at least an integrated AMD GPU
+            IGpuTemperatureProvider gpuTemperatureProvider = new NvidiaGpuTemperatureProvider();
+            if (gpuTemperatureProvider.IsValid) {
+                GpuTemperatureProvider = gpuTemperatureProvider;
+                return;
+            }
+        
+            gpuTemperatureProvider.Dispose();
+            gpuTemperatureProvider = new AmdGpuTemperatureProvider();
+            if (gpuTemperatureProvider.IsValid) {
+                GpuTemperatureProvider = gpuTemperatureProvider;
+                return;
+            }
+        
+            gpuTemperatureProvider.Dispose();
+        
+            GpuTemperatureProvider = null;
+        } finally {
+            Debug.WriteLine($"GpuTemperatureProvider: {GpuTemperatureProvider?.GetType().Name}");
+        }
+    }
+}
--- a/NativeMethods.cs
+++ b/NativeMethods.cs
@@ -1,9 +1,8 @@
-using System.ComponentModel;
+using System.Collections;
+using System;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Management;
 using System.Runtime.InteropServices;
-using System.Windows.Forms;
-using Tools;
 using static Tools.ScreenInterrogatory;

 namespace Tools
@@ -310,6 +309,62 @@ namespace Tools
 public class NativeMethods
 {

+    // Monitor Power detection
+
+    internal const uint DEVICE_NOTIFY_WINDOW_HANDLE = 0x0;
+    internal const uint DEVICE_NOTIFY_SERVICE_HANDLE = 0x1;
+    internal const int WM_POWERBROADCAST = 0x0218;
+    internal const int PBT_POWERSETTINGCHANGE = 0x8013;
+
+    [DllImport("User32.dll", SetLastError = true)]
+    internal static extern IntPtr RegisterPowerSettingNotification(IntPtr hWnd, [In] Guid PowerSettingGuid, uint Flags);
+
+    [DllImport("User32.dll", SetLastError = true)]
+    internal static extern bool UnregisterPowerSettingNotification(IntPtr hWnd);
+
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    internal struct POWERBROADCAST_SETTING
+    {
+        public Guid PowerSetting;
+        public uint DataLength;
+        public byte Data;
+    }
+
+    public class PowerSettingGuid
+    {
+        // 0=Powered by AC, 1=Powered by Battery, 2=Powered by short-term source (UPC)
+        public Guid AcdcPowerSource { get; } = new Guid("5d3e9a59-e9D5-4b00-a6bd-ff34ff516548");
+        // POWERBROADCAST_SETTING.Data = 1-100
+        public Guid BatteryPercentageRemaining { get; } = new Guid("a7ad8041-b45a-4cae-87a3-eecbb468a9e1");
+        // Windows 8+: 0=Monitor Off, 1=Monitor On, 2=Monitor Dimmed
+        public Guid ConsoleDisplayState { get; } = new Guid("6fe69556-704a-47a0-8f24-c28d936fda47");
+        // Windows 8+, Session 0 enabled: 0=User providing Input, 2=User Idle
+        public Guid GlobalUserPresence { get; } = new Guid("786E8A1D-B427-4344-9207-09E70BDCBEA9");
+        // 0=Monitor Off, 1=Monitor On.
+        public Guid MonitorPowerGuid { get; } = new Guid("02731015-4510-4526-99e6-e5a17ebd1aea");
+        // 0=Battery Saver Off, 1=Battery Saver On.
+        public Guid PowerSavingStatus { get; } = new Guid("E00958C0-C213-4ACE-AC77-FECCED2EEEA5");
+
+        // Windows 8+: 0=Off, 1=On, 2=Dimmed
+        public Guid SessionDisplayStatus { get; } = new Guid("2B84C20E-AD23-4ddf-93DB-05FFBD7EFCA5");
+
+        // Windows 8+, no Session 0: 0=User providing Input, 2=User Idle
+        public Guid SessionUserPresence { get; } = new Guid("3C0F4548-C03F-4c4d-B9F2-237EDE686376");
+        // 0=Exiting away mode 1=Entering away mode
+        public Guid SystemAwaymode { get; } = new Guid("98a7f580-01f7-48aa-9c0f-44352c29e5C0");
+
+        /* Windows 8+ */
+        // POWERBROADCAST_SETTING.Data not used
+        public Guid IdleBackgroundTask { get; } = new Guid(0x515C31D8, 0xF734, 0x163D, 0xA0, 0xFD, 0x11, 0xA0, 0x8C, 0x91, 0xE8, 0xF1);
+
+        public Guid PowerSchemePersonality { get; } = new Guid(0x245D8541, 0x3943, 0x4422, 0xB0, 0x25, 0x13, 0xA7, 0x84, 0xF6, 0x79, 0xB7);
+
+        // The Following 3 Guids are the POWERBROADCAST_SETTING.Data result of PowerSchemePersonality
+        public Guid MinPowerSavings { get; } = new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c");
+        public Guid MaxPowerSavings { get; } = new Guid("a1841308-3541-4fab-bc81-f71556f20b4a");
+        public Guid TypicalPowerSavings { get; } = new Guid("381b4222-f694-41f0-9685-ff5bb260df2e");
+    }
+

    public const int KEYEVENTF_EXTENDEDKEY = 1;
    public const int KEYEVENTF_KEYUP = 2;
@@ -485,27 +540,40 @@ public class NativeMethods

        try
        {
-            var devices = GetAllDevices();
+            var devices = GetAllDevices().ToArray();
            int count = 0, displayNum = -1;

            foreach (var device in devices)
            {
                if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL)
+                {
                    displayNum = count;
+                }
                count++;
                //Debug.WriteLine(device.outputTechnology);
                //Debug.WriteLine(device.monitorFriendlyDeviceName);
            }

+            var screens = Screen.AllScreens;
+
+            if (screens.Length != count)
+            {
+                Debug.WriteLine("Mismatch between enumerated and available screens");
+                return null;
+            }
+
            count = 0;
-            foreach (var screen in Screen.AllScreens)
+            foreach (var screen in screens)
            {
                if (count == displayNum)
+                {
                    laptopScreen = screen.DeviceName;
+                }
                //Debug.WriteLine(screen.DeviceName);
                count++;
            }
-        } catch
+        }
+        catch
        {
            Debug.WriteLine("Can't find internal screen");
        }
--- a/Program.cs
+++ b/Program.cs
@@ -1,34 +1,24 @@
 using Microsoft.Win32;
 using System.Diagnostics;
 using System.Management;
+using System.Reflection;
 using System.Runtime.InteropServices;
-
-public class HardwareMonitor
+using System.Text.Json;
+public static class Logger
 {
-
-    public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -1;
-
-
-    public static void ReadSensors()
+    public static void WriteLine(string logMessage)
    {
-        cpuTemp = -1;
-        batteryDischarge = -1;
+        var appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        var logFile = appPath + "\\log.txt";

-        try
-        {
-            var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
-            cpuTemp = ct.NextValue() - 273;
-            ct.Dispose();
+        if (!Directory.Exists(appPath)) Directory.CreateDirectory(appPath);

-            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
-            batteryDischarge = cb.NextValue() / 1000;
-            cb.Dispose();
-        }
-        catch
+        using (StreamWriter w = File.AppendText(logFile))
        {
-            Debug.WriteLine("Failed reading sensors");
+            Debug.WriteLine(logMessage);
+            w.WriteLine($"{DateTime.Now}: {logMessage}");
        }
+
    }

 }
@@ -38,6 +28,7 @@ namespace GHelper
    static class Program
    {

+
        // Native methods for sleep detection

        [DllImport("Powrprof.dll", SetLastError = true)]
@@ -76,6 +67,11 @@ namespace GHelper
        public static SettingsForm settingsForm = new SettingsForm();
        public static ToastForm toast = new ToastForm();

+        private static IntPtr unRegPowerNotify;
+        private static IntPtr ds;
+
+        private static long lastAuto;
+
        // The main entry point for the application
        public static void Main()
        {
@@ -96,6 +92,9 @@ namespace GHelper

            }

+            Application.EnableVisualStyles();
+
+            ds = settingsForm.Handle;

            trayIcon.MouseClick += TrayIcon_MouseClick; ;

@@ -111,6 +110,9 @@ namespace GHelper

            SetAutoModes();

+            // Subscribing for native power change events
+
+            /*
            IntPtr registrationHandle = new IntPtr();
            DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS recipient = new DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS();
            recipient.Callback = new DeviceNotifyCallbackRoutine(DeviceNotifyCallback);
@@ -120,29 +122,29 @@ namespace GHelper
            Marshal.StructureToPtr(recipient, pRecipient, false);

            uint result = PowerRegisterSuspendResumeNotification(DEVICE_NOTIFY_CALLBACK, ref recipient, ref registrationHandle);
+            */

+            // Subscribing for monitor power on events
+            var settingGuid = new NativeMethods.PowerSettingGuid();
+            unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(ds, settingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
+
+            // Subscribing for system power change events
            SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;

-            IntPtr ds = settingsForm.Handle;

+            CheckForUpdates();
            Application.Run();

        }

-
        private static int DeviceNotifyCallback(IntPtr context, int type, IntPtr setting)
        {
-            //Debug.WriteLine($"Power callback type: {type}");
+            Logger.WriteLine($"Power callback {type}");
            switch (type)
            {
                case PBT_APMRESUMEAUTOMATIC:
                    settingsForm.BeginInvoke(delegate
                    {
-                        // Setting "other" mode to prevent bios bugging with PPTs after wake up from sleep
-                        int PerformanceMode = (config.getConfig("performance_mode") + 1) % 3;
-                        wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
-                        Thread.Sleep(1000);
-                        
                        SetAutoModes();
                    });
                    break;
@@ -151,23 +153,72 @@ namespace GHelper
            return 0;
        }

-        private static void SetAutoModes()
+
+        static async void CheckForUpdates()
        {
+
+            var assembly = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+            settingsForm.SetVersionLabel("Version: " + assembly);
+
+            try
+            {
+                using (var httpClient = new HttpClient())
+                {
+                    httpClient.DefaultRequestHeaders.Add("User-Agent", "C# App");
+                    var json = await httpClient.GetStringAsync("https://api.github.com/repos/seerge/g-helper/releases/latest");
+                    var config = JsonSerializer.Deserialize<JsonElement>(json);
+                    var tag = config.GetProperty("tag_name").ToString().Replace("v", "");
+                    var url = config.GetProperty("assets")[0].GetProperty("browser_download_url").ToString();
+
+                    var gitVersion = new Version(tag);
+                    var appVersion = new Version(assembly);
+
+                    var result = gitVersion.CompareTo(appVersion);
+                    if (result > 0)
+                    {
+                        settingsForm.SetVersionLabel("Download Update: " + tag, url);
+                    }
+
+                }
+            }
+            catch
+            {
+                Logger.WriteLine("Failed to get update");
+            }
+
+        }
+
+
+        public static void SetAutoModes()
+        {
+
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAuto) < 1000) return;
+            lastAuto = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
            PowerLineStatus isPlugged = SystemInformation.PowerStatus.PowerLineStatus;

-            Debug.WriteLine(isPlugged.ToString());
+            Logger.WriteLine("AutoSetting for " + isPlugged.ToString());

            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
-            settingsForm.AutoPerformance(isPlugged);
-            settingsForm.AutoScreen(isPlugged);

+            settingsForm.AutoPerformance(isPlugged);
            settingsForm.AutoGPUMode(isPlugged);
+
            settingsForm.SetMatrix(isPlugged);

+            HardwareMonitor.RecreateGpuTemperatureProvider();
+
+            // Re-enabling the discrete GPU takes a bit of time,
+            // so a simple workaround is to refresh again after that happens
+            Task.Run(async () => {
+                await Task.Delay(TimeSpan.FromSeconds(3));
+                HardwareMonitor.RecreateGpuTemperatureProvider();
+            });
        }

        private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
        {
+            Logger.WriteLine("Windows - Power Mode Changed");
            SetAutoModes();
        }

@@ -184,7 +235,7 @@ namespace GHelper
            }
            catch
            {
-                Debug.WriteLine("Failed to run " + fileName);
+                Logger.WriteLine("Failed to run " + fileName);
            }


@@ -261,7 +312,7 @@ namespace GHelper

            int EventID = int.Parse(e.NewEvent["EventID"].ToString());

-            Debug.WriteLine(EventID);
+            Logger.WriteLine("WMI event " + EventID);

            switch (EventID)
            {
@@ -309,6 +360,7 @@ namespace GHelper
        static void OnExit(object sender, EventArgs e)
        {
            trayIcon.Visible = false;
+            NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotify);
            Application.Exit();
        }
    }
--- a/Properties/Resources.Designer.cs
+++ b/Properties/Resources.Designer.cs
@@ -130,6 +130,16 @@ namespace GHelper.Properties {
            }
        }
        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_processor_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-processor-96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
        /// <summary>
        ///   Looks up a localized resource of type System.Drawing.Bitmap.
        /// </summary>
--- a/Properties/Resources.resx
+++ b/Properties/Resources.resx
@@ -121,6 +121,9 @@
  <data name="eco" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>..\Resources\eco.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
+  <data name="icons8-matrix-desktop-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-matrix-desktop-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
  <data name="icons8-keyboard-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>..\Resources\icons8-keyboard-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
@@ -151,7 +154,7 @@
  <data name="icons8-laptop-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
    <value>..\Resources\icons8-laptop-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
-  <data name="icons8-matrix-desktop-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-matrix-desktop-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-processor-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-processor-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
  </data>
 </root>
--- a/README.md
+++ b/README.md
@@ -2,10 +2,14 @@

 A small utility that allows you do almost everyting you could do with Armory Crate but without extra bloat and unnecessary services.

+### [Download latest release](https://github.com/seerge/g-helper/releases)
+
+![Screenshot](https://raw.githubusercontent.com/seerge/g-helper/main/screenshot.png)
+
 ## NEW (and experimental) features

 1. Set Power limits (PPT) for Total (APU + dGPU) and CPU. 
-2. Anime matrix control thanks to https://github.com/vddCore/Starlight
+2. Anime matrix control thanks to [Starlight](https://github.com/vddCore/Starlight) + some tweaks from my side

 ## Main features

@@ -25,12 +29,6 @@ Designed and developed for Asus Zephyrus G14 2022 (with AMD Radeon iGPU and dGPU

 To keep autoswitching and hotkeys work app needs to stay in running in tray. It doesn't consume any resources. 

-I recommend to keep "Asus Optimization Service" running, as it keeps basic laptop hotkeys such as screen or keyboard brightness adjustment working. If you have (or had) MyASUS app installed, that service is most probably still up an running even after MyASUS uninstall. It's part of [Asus System Controll Interface](https://www.asus.com/support/FAQ/1047338/). You can install it, and later disable / remove unnecesarily services by running [this bat file](https://raw.githubusercontent.com/seerge/g-helper/main/stop-asus-sv.bat ) as admin.
-
-### [Download latest release](https://github.com/seerge/g-helper/releases)
-
-![Screenshot](https://github.com/seerge/g-helper/blob/main/screenshot.png)
-
 ## Performance Profile switching 

 Profiles are **same** as in Armory Crate (as they are stored in bios), including default fan curves
@@ -49,10 +47,14 @@ PPTs are shown for G14 2022, for other models PPTs will be different as they are

 ## How to install

-1. Download latest release from https://github.com/seerge/g-helper/releases
+1. Download latest release from [**Releases Page**](https://github.com/seerge/g-helper/releases)
 2. Unzip to a folder of your choice
 3. Run **GHelper.exe**

+App requires [.NET7](https://dotnet.microsoft.com/en-us/download) to be installed. Most probably you already have it. Otherwise you can [download it](https://dotnet.microsoft.com/en-us/download).
+
+I recommend to keep "Asus Optimization Service" running, as it keeps basic laptop hotkeys such as screen or keyboard brightness adjustment working. If you have (or had) MyASUS app installed, that service is most probably still up an running even after MyASUS uninstall. It's part of [Asus System Controll Interface](https://www.asus.com/support/FAQ/1047338/). You can install it, and later disable / remove unnecesarily services by running [this bat file](https://raw.githubusercontent.com/seerge/g-helper/main/stop-asus-sv.bat) as admin.
+
 Note: Uses low level ASUS ACPI commands and doens't require Armory Crate to be installed at all!  Doesn't need administrator privileges to run!

 I don`t have Microsoft certificate to sign app yet, so if you get a warning from Windows Defender on launch (Windows Protected your PC), click More Info -> Run anyway. Alternatively you can compile and run project by yourself using Visual Studio :)
@@ -66,3 +68,10 @@ P.S.: It's not recommended to use app in combination with Armory Crate, cause th
 Debloating helps to save your battery and keep laptop a bit cooler

 ![Helps to save your battery](https://raw.githubusercontent.com/seerge/g-helper/main/screenshots/screen-5w.png)
+
+---------
+
+**Disclaimers**
+"ROG", "TUF", and "Armoury Crate" are trademarked by and belong to AsusTek Computer, Inc. I make no claims to these or any assets belonging to AsusTek Computer and use them purely for informational purposes only.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. MISUSE OF THIS SOFTWARE COULD CAUSE SYSTEM INSTABILITY OR MALFUNCTION.
--- a/Resources/icons8-processor-96.png
+++ b/Resources/icons8-processor-96.png
--- a/Settings.Designer.cs
+++ b/Settings.Designer.cs
@@ -112,17 +112,17 @@
            panelMatrix.Controls.Add(pictureMatrix);
            panelMatrix.Controls.Add(labelMatrix);
            panelMatrix.Dock = DockStyle.Top;
-            panelMatrix.Location = new Point(16, 806);
+            panelMatrix.Location = new Point(16, 814);
            panelMatrix.Margin = new Padding(4);
            panelMatrix.Name = "panelMatrix";
-            panelMatrix.Size = new Size(722, 156);
+            panelMatrix.Size = new Size(722, 180);
            panelMatrix.TabIndex = 33;
            // 
            // checkMatrix
            // 
            checkMatrix.AutoSize = true;
            checkMatrix.ForeColor = SystemColors.GrayText;
-            checkMatrix.Location = new Point(26, 112);
+            checkMatrix.Location = new Point(28, 109);
            checkMatrix.Margin = new Padding(4, 2, 4, 2);
            checkMatrix.Name = "checkMatrix";
            checkMatrix.Size = new Size(249, 36);
@@ -158,7 +158,7 @@
            buttonMatrix.Name = "buttonMatrix";
            buttonMatrix.Size = new Size(208, 42);
            buttonMatrix.TabIndex = 43;
-            buttonMatrix.Text = "Picture";
+            buttonMatrix.Text = "Picture / Gif";
            buttonMatrix.UseVisualStyleBackColor = false;
            // 
            // comboMatrixRunning
@@ -219,7 +219,7 @@
            panelBattery.Controls.Add(labelBatteryTitle);
            panelBattery.Controls.Add(trackBattery);
            panelBattery.Dock = DockStyle.Top;
-            panelBattery.Location = new Point(16, 962);
+            panelBattery.Location = new Point(16, 994);
            panelBattery.Margin = new Padding(4);
            panelBattery.Name = "panelBattery";
            panelBattery.Size = new Size(722, 148);
@@ -290,7 +290,7 @@
            panelFooter.Controls.Add(buttonQuit);
            panelFooter.Controls.Add(checkStartup);
            panelFooter.Dock = DockStyle.Top;
-            panelFooter.Location = new Point(16, 1110);
+            panelFooter.Location = new Point(16, 1142);
            panelFooter.Margin = new Padding(4);
            panelFooter.Name = "panelFooter";
            panelFooter.Size = new Size(722, 64);
@@ -581,7 +581,7 @@
            // 
            checkScreen.AutoSize = true;
            checkScreen.ForeColor = SystemColors.GrayText;
-            checkScreen.Location = new Point(27, 154);
+            checkScreen.Location = new Point(27, 153);
            checkScreen.Margin = new Padding(4, 2, 4, 2);
            checkScreen.Name = "checkScreen";
            checkScreen.Size = new Size(527, 36);
@@ -669,7 +669,7 @@
            panelKeyboard.Location = new Point(16, 660);
            panelKeyboard.Margin = new Padding(4);
            panelKeyboard.Name = "panelKeyboard";
-            panelKeyboard.Size = new Size(722, 146);
+            panelKeyboard.Size = new Size(722, 154);
            panelKeyboard.TabIndex = 39;
            // 
            // tableLayoutKeyboard
@@ -761,7 +761,7 @@
            buttonKeyboardColor.Name = "buttonKeyboardColor";
            buttonKeyboardColor.Size = new Size(208, 42);
            buttonKeyboardColor.TabIndex = 39;
-            buttonKeyboardColor.Text = "Color  ";
+            buttonKeyboardColor.Text = "Color   ";
            buttonKeyboardColor.UseVisualStyleBackColor = false;
            // 
            // pictureKeyboard
--- a/Settings.cs
+++ b/Settings.cs
@@ -1,9 +1,9 @@
 using Starlight.AnimeMatrix;
 using System.Diagnostics;
 using System.Drawing.Imaging;
-using System.Reflection;
 using System.Timers;

+
 namespace GHelper
 {

@@ -20,14 +20,14 @@ namespace GHelper
        static System.Timers.Timer aTimer = default!;
        static System.Timers.Timer matrixTimer = default!;

+        public string versionUrl = "http://github.com/seerge/g-helper/releases";
+
        public string perfName = "Balanced";

        Fans fans;
        Keyboard keyb;

        static AnimeMatrixDevice mat;
-        static bool matEnabled = false;
-

        public SettingsForm()
        {
@@ -61,6 +61,7 @@ namespace GHelper

            buttonQuit.Click += ButtonQuit_Click;

+            checkGPU.CheckedChanged += CheckGPU_CheckedChanged;

            checkScreen.CheckedChanged += checkScreen_CheckedChanged;

@@ -76,9 +77,6 @@ namespace GHelper
            pictureColor.Click += PictureColor_Click;
            pictureColor2.Click += PictureColor2_Click;

-            labelVersion.Text = "Version " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
-            labelVersion.Click += LabelVersion_Click;
-
            labelCPUFan.Click += LabelCPUFan_Click;
            labelGPUFan.Click += LabelCPUFan_Click;

@@ -94,10 +92,68 @@ namespace GHelper

            checkStartup.CheckedChanged += CheckStartup_CheckedChanged;

+            labelVersion.Click += LabelVersion_Click;
+
            SetTimer();

        }

+
+        protected override void WndProc(ref Message m)
+        {
+            switch (m.Msg)
+            {
+                case NativeMethods.WM_POWERBROADCAST:
+                    if (m.WParam == (IntPtr)NativeMethods.PBT_POWERSETTINGCHANGE)
+                    {
+                        var settings = (NativeMethods.POWERBROADCAST_SETTING)m.GetLParam(typeof(NativeMethods.POWERBROADCAST_SETTING));
+                        switch (settings.Data)
+                        {
+                            case 0:
+                                Logger.WriteLine("Monitor Power Off");
+                                break;
+                            case 1:
+                                Logger.WriteLine("Monitor Power On");
+                                Program.settingsForm.BeginInvoke(delegate
+                                {
+                                    Program.SetAutoModes();
+                                });
+                                break;
+                            case 2:
+                                Logger.WriteLine("Monitor Dimmed");
+                                break;
+                        }
+                    }
+                    m.Result = (IntPtr)1;
+                    break;
+            }
+            base.WndProc(ref m);
+        }
+
+        private void CheckGPU_CheckedChanged(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            CheckBox check = (CheckBox)sender;
+            Program.config.setConfig("gpu_auto", check.Checked ? 1 : 0);
+        }
+
+        public void SetVersionLabel(string label, string url = null)
+        {
+            labelVersion.Text = label;
+            if (url is not null)
+            {
+                versionUrl = url;
+                labelVersion.ForeColor = Color.Red;
+            }
+        }
+
+
+        private void LabelVersion_Click(object? sender, EventArgs e)
+        {
+            Process.Start(new ProcessStartInfo(versionUrl) { UseShellExecute = true });
+        }
+
+
        private void CheckStartup_CheckedChanged(object? sender, EventArgs e)
        {
            if (sender is null) return;
@@ -254,6 +310,8 @@ namespace GHelper

            StopMatrixTimer();

+            mat.SetProvider();
+
            if (brightness == 0 || (auto && Plugged != PowerLineStatus.Online))
            {
                mat.SetDisplayState(false);
@@ -272,6 +330,7 @@ namespace GHelper
                {
                    mat.SetBuiltInAnimation(true, animation);
                }
+
            }

        }
@@ -284,11 +343,6 @@ namespace GHelper
            RefreshSensors();
        }

-        private void LabelVersion_Click(object? sender, EventArgs e)
-        {
-            Process.Start(new ProcessStartInfo("http://github.com/seerge/g-helper/releases") { UseShellExecute = true });
-        }
-
        private void PictureColor2_Click(object? sender, EventArgs e)
        {

@@ -387,36 +441,26 @@ namespace GHelper
        public void InitMatrix()
        {

-            matrixTimer = new System.Timers.Timer();
-            matrixTimer.Enabled = false;
-            matrixTimer.Interval = 100;
-
            try
            {
-                matEnabled = true;
                mat = new AnimeMatrixDevice();
+                matrixTimer = new System.Timers.Timer(100);
                matrixTimer.Elapsed += MatrixTimer_Elapsed;
            }
            catch
-            {
-                matEnabled = false;
-                Debug.WriteLine("Anime Matrix not detected");
-            }
-
-            if (!matEnabled)
            {
                panelMatrix.Visible = false;
+                return;
            }
-            else
-            {
-                int brightness = Program.config.getConfig("matrix_brightness");
-                int running = Program.config.getConfig("matrix_running");

-                comboMatrix.SelectedIndex = (brightness != -1) ? brightness : 0;
-                comboMatrixRunning.SelectedIndex = (running != -1) ? running : 0;
+            int brightness = Program.config.getConfig("matrix_brightness");
+            int running = Program.config.getConfig("matrix_running");
+
+            comboMatrix.SelectedIndex = (brightness != -1) ? brightness : 0;
+            comboMatrixRunning.SelectedIndex = (running != -1) ? running : 0;
+
+            checkMatrix.Checked = (Program.config.getConfig("matrix_auto") == 1);

-                checkMatrix.Checked = (Program.config.getConfig("matrix_auto") == 1);
-            }

        }

@@ -497,8 +541,12 @@ namespace GHelper
        {

            int currentFrequency = NativeMethods.GetRefreshRate();
-            if (currentFrequency < 0)  // Laptop screen not detected or has unknown refresh rate
+            
+            if (currentFrequency < 0) // Laptop screen not detected or has unknown refresh rate
+            {
+                InitScreen();
                return;
+            }

            if (frequency >= 1000)
            {
@@ -507,21 +555,15 @@ namespace GHelper
                    frequency = 120;
            }

-            if (frequency > 0)
-                NativeMethods.SetRefreshRate(frequency);
-
-            try
-            {
-                if (overdrive > 0)
-                    Program.wmi.DeviceSet(ASUSWmi.ScreenOverdrive, overdrive);
-            }
-            catch
-            {
-                Debug.WriteLine("Screen Overdrive not supported");
-            }
+            if (frequency <= 0) return;

+            NativeMethods.SetRefreshRate(frequency);
+            if (overdrive > 0)
+                Program.wmi.DeviceSet(ASUSWmi.ScreenOverdrive, overdrive);

            InitScreen();
+            Logger.WriteLine("Screen "+ frequency.ToString() + "Hz");
+
        }

        public void InitScreen()
@@ -554,7 +596,7 @@ namespace GHelper
            }
            catch
            {
-                Debug.WriteLine("Screen Overdrive not supported");
+                Logger.WriteLine("Screen Overdrive not supported");
            }

            button60Hz.FlatAppearance.BorderSize = buttonInactive;
@@ -648,6 +690,10 @@ namespace GHelper
            if (HardwareMonitor.batteryDischarge > 0)
                battery = "Discharging: " + Math.Round((decimal)HardwareMonitor.batteryDischarge, 1).ToString() + "W";

+            if (HardwareMonitor.gpuTemp != null) {
+                gpuTemp = $": {HardwareMonitor.gpuTemp}°C - ";
+            }
+
            Program.settingsForm.BeginInvoke(delegate
            {
                Program.settingsForm.labelCPUFan.Text = "CPU" + cpuTemp + cpuFan;
@@ -675,6 +721,7 @@ namespace GHelper
                aTimer.Interval = 300;
                aTimer.Enabled = true;

+                //RefreshSensors();
            }
            else
            {
@@ -697,7 +744,7 @@ namespace GHelper
            Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA1, limit_total);
            Program.wmi.DeviceSet(ASUSWmi.PPT_CPUB0, limit_cpu);

-            Debug.WriteLine(limit_total.ToString() + ", " + limit_cpu.ToString());
+            Logger.WriteLine("PowerLimits "+limit_total.ToString() + ", " + limit_cpu.ToString());


        }
@@ -714,8 +761,16 @@ namespace GHelper

            if (Program.config.getConfigPerf("auto_apply_power") == 1)
            {
-                SetPower();
+                var timer = new System.Timers.Timer(1000);
+                timer.Elapsed += delegate
+                {
+                    timer.Stop();
+                    timer.Dispose();
+                    SetPower();
+                };
+                timer.Start();
            }
+
        }

        public void SetPerformanceMode(int PerformanceMode = ASUSWmi.PerformanceBalanced, bool notify = false)
@@ -747,16 +802,7 @@ namespace GHelper
            Program.config.setConfig("performance_mode", PerformanceMode);

            Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
-
-            AutoFansAndPower();
-
-            if (fans != null && fans.Text != "")
-            {
-                fans.InitFans();
-                fans.InitPower();
-            }
-
-            Debug.WriteLine("Perf:" + PerformanceMode);
+            Logger.WriteLine("PerfMode " + perfName + " "+ PerformanceMode);

            if (notify && (oldMode != PerformanceMode))
            {
@@ -770,6 +816,16 @@ namespace GHelper
                }
            }

+            AutoFansAndPower();
+
+            if (fans != null && fans.Text != "")
+            {
+                fans.InitFans();
+                fans.InitPower();
+            }
+
+
+
        }


@@ -798,7 +854,6 @@ namespace GHelper
            else
                SetScreen(60, 0);

-            InitScreen();

        }

@@ -811,23 +866,24 @@ namespace GHelper
            int eco = Program.wmi.DeviceGet(ASUSWmi.GPUEco);
            int mux = Program.wmi.DeviceGet(ASUSWmi.GPUMux);

-
            if (mux == 0) // GPU in Ultimate, ignore
                return;
            else
            {
                if (eco == 1 && Plugged == PowerLineStatus.Online)  // Eco going Standard on plugged
                {
-                    Program.wmi.DeviceSet(ASUSWmi.GPUEco, 0);
-                    InitGPUMode();
+                    SetEcoGPU(0);
                }
                else if (eco == 0 && Plugged != PowerLineStatus.Online)  // Standard going Eco on plugged
                {
-                    Program.wmi.DeviceSet(ASUSWmi.GPUEco, 1);
-                    InitGPUMode();
+                    SetEcoGPU(1);
+                }
+                else
+                {
+                    AutoScreen(Plugged);
                }
-
            }
+
        }

        public int InitGPUMode()
@@ -847,10 +903,13 @@ namespace GHelper
                else
                    GpuMode = ASUSWmi.GPUModeStandard;

-                if (mux != 1)
-                    Disable_Ultimate();
+                buttonUltimate.Visible = (mux == 1);
            }

+            ButtonEnabled(buttonEco, true);
+            ButtonEnabled(buttonStandard, true);
+            ButtonEnabled(buttonUltimate, true);
+
            Program.config.setConfig("gpu_mode", GpuMode);
            VisualiseGPUMode(GpuMode);

@@ -858,7 +917,31 @@ namespace GHelper

        }

-        public void SetGPUMode(int GPUMode = ASUSWmi.GPUModeStandard)
+
+        public void SetEcoGPU(int eco)
+        {
+
+            ButtonEnabled(buttonEco, false);
+            ButtonEnabled(buttonStandard, false);
+            ButtonEnabled(buttonUltimate, false);
+
+            labelGPU.Text = "GPU Mode: Changing ...";
+
+            new Thread(() =>
+            {
+                Thread.CurrentThread.IsBackground = true;
+                Program.wmi.DeviceSet(ASUSWmi.GPUEco, eco);
+                Program.settingsForm.BeginInvoke(delegate
+                {
+                    InitGPUMode();
+                    Thread.Sleep(500);
+                    AutoScreen(SystemInformation.PowerStatus.PowerLineStatus);
+                });
+            }).Start();
+
+        }
+
+        public void SetGPUMode(int GPUMode)
        {

            int CurrentGPU = Program.config.getConfig("gpu_mode");
@@ -893,13 +976,13 @@ namespace GHelper
            else if (GPUMode == ASUSWmi.GPUModeEco)
            {
                VisualiseGPUMode(GPUMode);
-                Program.wmi.DeviceSet(ASUSWmi.GPUEco, 1);
+                SetEcoGPU(1);
                changed = true;
            }
            else if (GPUMode == ASUSWmi.GPUModeStandard)
            {
                VisualiseGPUMode(GPUMode);
-                Program.wmi.DeviceSet(ASUSWmi.GPUEco, 0);
+                SetEcoGPU(0);
                changed = true;
            }

@@ -951,10 +1034,11 @@ namespace GHelper
                    break;
                default:
                    buttonStandard.FlatAppearance.BorderSize = buttonActive;
-                    labelGPU.Text = "GPU Mode: iGPU and dGPU";
+                    labelGPU.Text = "GPU Mode: iGPU + dGPU";
                    Program.trayIcon.Icon = GHelper.Properties.Resources.standard;
                    break;
            }
+
        }


@@ -978,15 +1062,17 @@ namespace GHelper

        }

-        public void Disable_Ultimate()
+        public void ButtonEnabled(Button but, bool enabled)
        {
-            buttonUltimate.Enabled = false;
-            buttonUltimate.BackColor = SystemColors.ControlLight;
+            but.Enabled = enabled;
+            but.BackColor = enabled ? SystemColors.ControlLightLight : SystemColors.ControlLight;
        }

        public void SetStartupCheck(bool status)
        {
+            checkStartup.CheckedChanged -= CheckStartup_CheckedChanged;
            checkStartup.Checked = status;
+            checkStartup.CheckedChanged += CheckStartup_CheckedChanged;
        }

        public void SetBatteryChargeLimit(int limit)
@@ -1009,13 +1095,6 @@ namespace GHelper
            SetBatteryChargeLimit(bar.Value);
        }

-        private void checkGPU_CheckedChanged(object? sender, EventArgs e)
-        {
-            if (sender is null) return;
-            CheckBox check = (CheckBox)sender;
-            Program.config.setConfig("gpu_auto", check.Checked ? 1 : 0);
-        }
-

        private void checkScreen_CheckedChanged(object? sender, EventArgs e)
        {
--- a/Startup.cs
+++ b/Startup.cs
@@ -22,16 +22,26 @@ public class Startup

        var userId = WindowsIdentity.GetCurrent().Name;

-        //Debug.WriteLine(strExeFilePath);
        TaskDefinition td = TaskService.Instance.NewTask();
        td.RegistrationInfo.Description = "GHelper Auto Start";
-        td.Triggers.Add(new LogonTrigger { UserId = userId, });
+        td.Triggers.Add(new LogonTrigger { UserId = userId });
        td.Actions.Add(strExeFilePath);

        td.Settings.StopIfGoingOnBatteries = false;
        td.Settings.DisallowStartIfOnBatteries = false;
+        td.Settings.ExecutionTimeLimit = TimeSpan.Zero;
+
+        Debug.WriteLine(strExeFilePath);
+        Debug.WriteLine(userId);
+
+        try
+        {
+            TaskService.Instance.RootFolder.RegisterTaskDefinition(taskName, td);
+        } catch (Exception e)
+        {
+            MessageBox.Show(e.ToString(), "Scheduler Error", MessageBoxButtons.OK);
+        }

-        TaskService.Instance.RootFolder.RegisterTaskDefinition(taskName, td);
    }

    public static void UnSchedule()
--- a/app.manifest
+++ b/app.manifest
@@ -54,6 +54,7 @@
 	<application xmlns="urn:schemas-microsoft-com:asm.v3">
 		<windowsSettings>
 			<!--<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitor/dpiAwareness>-->
+			<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
 			<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor, System</dpiAwareness>
 		</windowsSettings>
 	</application>
--- a/old-ps1-script/ghelper-compile.ps1
+++ b/old-ps1-script/ghelper-compile.ps1
@@ -1 +0,0 @@
-ps2exe .\ghelper.ps1 g14-helper.exe -title 'G14 Helper' -DPIAware -winFormsDPIAware -requireAdmin -iconFile 'standard.ico' -noConsole -copyright 'G14 Helper Tool' -noOutput
--- a/old-ps1-script/ghelper.ps1
+++ b/old-ps1-script/ghelper.ps1
--- a/old-ps1-script/ghelper.zip
+++ b/old-ps1-script/ghelper.zip
--- a/screenshot.png
+++ b/screenshot.png
Author	SHA1	Message	Date
seerge	223ead2f4e	Minor fixes	2023-03-13 20:25:35 +01:00
seerge	a211dd412f	Merged GPU temp reader	2023-03-13 20:02:59 +01:00
seerge	550e9fc036	Merge pull request #74 from ZimM-LostPolygon/gpu-temperature feat: added GPU temperature indication.	2023-03-13 19:52:33 +01:00
seerge	8fe01e8790	New sleep/wake up detection	2023-03-13 19:38:39 +01:00
seerge	f0abe22b5d	Logger and minor changes	2023-03-13 18:33:27 +01:00
Serhii Yolkin	ef0993e442	fix: fixed crash when launched in Eco mode	2023-03-13 17:47:11 +01:00
Serhii Yolkin	62ac478761	feat: added GPU temperature indication. Supports both NVIDIA and AMD discrete GPUs feat: immediately update sensors when opening GHelper window	2023-03-13 17:35:35 +01:00
seerge	a7e8ba3241	Scheduler warning	2023-03-13 12:10:29 +01:00
seerge	b46f0fb887	Removed scheduler call on each run	2023-03-13 11:38:54 +01:00
seerge	a39c084bdf	Merge branch 'main' of https://github.com/seerge/g14-helper	2023-03-12 16:16:35 +01:00
seerge	f0c291bea4	Minor tweaks	2023-03-12 16:16:32 +01:00
seerge	d04a20367b	Update README.md	2023-03-12 13:36:09 +01:00
seerge	888e49fe40	Update README.md	2023-03-12 13:35:40 +01:00
seerge	4875a22f38	Merge branch 'main' of https://github.com/seerge/g14-helper	2023-03-12 13:27:55 +01:00
seerge	ea2e8a7c24	UI Tweaks	2023-03-12 13:27:44 +01:00
seerge	6ec94e4ac3	Update README.md	2023-03-11 14:28:17 +01:00
seerge	5334d1e4ed	Screenshot	2023-03-11 12:47:17 +01:00
seerge	9f339806d4	UI Fixes	2023-03-11 12:41:34 +01:00
seerge	54a4668e2a	Under the hood changes	2023-03-10 23:32:12 +01:00
seerge	71d2a6ce05	Merge branch 'main' of https://github.com/seerge/g14-helper	2023-03-10 21:50:22 +01:00
seerge	92d1b97b95	Fix for UI lag on GPU switch	2023-03-10 21:50:20 +01:00
seerge	4b9a53cef8	Update README.md	2023-03-10 15:51:20 +01:00
seerge	068694d7d1	Update README.md	2023-03-10 13:45:49 +01:00
seerge	43c6def162	Update checker	2023-03-09 20:54:32 +01:00
				`@@ -1 +0,0 @@`
				`ps2exe .\ghelper.ps1 g14-helper.exe -title 'G14 Helper' -DPIAware -winFormsDPIAware -requireAdmin -iconFile 'standard.ico' -noConsole -copyright 'G14 Helper Tool' -noOutput`