Create LICENSE

fix: improved GPU temperature reliability

ASUSWmi.cs

@@ -1,6 +1,8 @@
-using System.Management;
-using System.Runtime.InteropServices;
+using GHelper;
 using System.Diagnostics;
+using System.Management;
+using System.Runtime.InteropServices;
+
 
 public class ASUSWmi
 {
@@ -25,6 +27,17 @@ public class ASUSWmi
     public const uint DevsCPUFanCurve = 0x00110024;
     public const uint DevsGPUFanCurve = 0x00110025;
 
+    public const int PPT_TotalA0 = 0x001200A0;  // Total PPT on 2022 and CPU PPT on 2021
+    public const int PPT_EDCA1 = 0x001200A1;  // CPU EDC
+    public const int PPT_TDCA2 = 0x001200A2;  // CPU TDC
+    public const int PPT_APUA3 = 0x001200A3;  // APU PPT ON 2021, doesn't work on 2022
+
+    public const int PPT_CPUB0 = 0x001200B0;  // CPU PPT on 2022
+    public const int PPT_CPUB1 = 0x001200B1;  // APU PPT on 2022
+
+    public const int PPT_APUC1 = 0x001200C1;  
+    public const int PPT_APUC2 = 0x001200C2;  
+
     public const int PerformanceBalanced = 0;
     public const int PerformanceTurbo = 1;
     public const int PerformanceSilent = 2;
@@ -34,6 +47,15 @@ public class ASUSWmi
     public const int GPUModeUltimate = 2;
 
 
+    public const int MaxTotal = 150;
+    public const int MinTotal = 5;
+    public const int DefaultTotal = 125;
+
+    public const int MaxCPU = 90;
+    public const int MinCPU = 5;
+    public const int DefaultCPU = 80;
+
+
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     private static extern IntPtr CreateFile(
         string lpFileName,
@@ -162,9 +184,14 @@ public class ASUSWmi
     public void SetFanCurve(int device, byte[] curve)
     {
 
-        if (device == 1) 
+        if (curve.Length != 16) return;
+        if (curve.All(singleByte => singleByte == 0)) return;
+
+        Logger.WriteLine("Fans" + ((device == 1)?"GPU":"CPU") + " " + BitConverter.ToString(curve));
+
+        if (device == 1)
             DeviceSet(DevsGPUFanCurve, curve);
-        else 
+        else
             DeviceSet(DevsCPUFanCurve, curve);
     }
 
@@ -175,19 +202,18 @@ public class ASUSWmi
         // because it's asus, and modes are swapped here
         switch (mode)
         {
-            case 1:fan_mode = 2; break;
+            case 1: fan_mode = 2; break;
             case 2: fan_mode = 1; break;
             default: fan_mode = 0; break;
         }
 
-        if (device == 1) 
+        if (device == 1)
             return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
-        else 
+        else
             return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
 
     }
 
-
     public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)
     {
         ManagementEventWatcher watcher = new ManagementEventWatcher();

AnimeMatrix/AnimeMatrixDevice.cs

@@ -0,0 +1,324 @@
+// Source thanks to https://github.com/vddCore/Starlight with some adjustments from me
+
+using Starlight.Communication;
+using System.Diagnostics;
+using System.Text;
+using System.Management;
+
+namespace Starlight.AnimeMatrix
+{
+    public class BuiltInAnimation
+    {
+        public enum Startup
+        {
+            GlitchConstruction,
+            StaticEmergence
+        }
+
+        public enum Shutdown
+        {
+            GlitchOut,
+            SeeYa
+        }
+
+        public enum Sleeping
+        {
+            BannerSwipe,
+            Starfield
+        }
+
+        public enum Running
+        {
+            BinaryBannerScroll,
+            RogLogoGlitch
+        }
+
+        public byte AsByte { get; }
+
+        public BuiltInAnimation(
+            Running running,
+            Sleeping sleeping,
+            Shutdown shutdown,
+            Startup startup
+        )
+        {
+            AsByte |= (byte)(((int)running & 0x01) << 0);
+            AsByte |= (byte)(((int)sleeping & 0x01) << 1);
+            AsByte |= (byte)(((int)shutdown & 0x01) << 2);
+            AsByte |= (byte)(((int)startup & 0x01) << 3);
+        }
+    }
+
+    internal class AnimeMatrixPacket : Packet
+    {
+        public AnimeMatrixPacket(byte[] command)
+            : base(0x5E, 640, command)
+        {
+        }
+    }
+
+    public enum BrightnessMode : byte
+    {
+        Off = 0,
+        Dim = 1,
+        Medium = 2,
+        Full = 3
+    }
+
+
+    public class AnimeMatrixDevice : Device
+    {
+        private const int UpdatePageLength = 0x0278;
+
+        public int LedCount => 1450;
+
+        private byte[] _displayBuffer = new byte[UpdatePageLength * 3];
+        private List<byte[]> frames = new List<byte[]>();
+
+        private int pages = 3;
+
+        public int MaxColumns = 34;
+        public int MaxRows = 61;
+
+        public int FullRows = 11;
+
+        private int frameIndex = 0;
+
+        public AnimeMatrixDevice()
+            : base(0x0B05, 0x193B, 640)
+        {
+            string model = GetModel();
+            Debug.WriteLine(model);
+            if (model is not null && model.Contains("401"))
+            {
+                pages = 2;
+
+                FullRows = 6;
+                MaxColumns = 33;
+                MaxRows = 55;
+            }
+        }
+
+
+        public string GetModel()
+        {
+            using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_ComputerSystem"))
+            {
+                foreach (var process in searcher.Get())
+                    return process["Model"].ToString();
+            }
+
+            return null;
+
+        }
+
+        public byte[] GetBuffer()
+        {
+            return _displayBuffer;
+        }
+
+        public void PresentNextFrame()
+        {
+            //Debug.WriteLine(frameIndex);
+            if (frameIndex >= frames.Count) frameIndex = 0;
+            _displayBuffer = frames[frameIndex];
+            Present();
+            frameIndex++;
+        }
+
+        public void ClearFrames()
+        {
+            frames.Clear();
+            frameIndex = 0;
+        }
+
+        public void AddFrame()
+        {
+            frames.Add(_displayBuffer.ToArray());
+        }
+
+        public void SendRaw(params byte[] data)
+        {
+            Set(Packet<AnimeMatrixPacket>(data));
+        }
+
+
+        public int EmptyColumns(int row)
+        {
+            return (int)Math.Ceiling(Math.Max(0, row - FullRows) / 2.0);
+        }
+        public int Columns(int row)
+        {
+            EnsureRowInRange(row);
+            return MaxColumns - EmptyColumns(row);
+        }
+
+        public int RowToLinearAddress(int row)
+        {
+            EnsureRowInRange(row);
+
+            var ret = 0;
+
+            if (row > 0)
+            {
+                for (var i = 0; i < row; i++)
+                    ret += Columns(i);
+            }
+
+            return ret;
+        }
+
+        public void WakeUp()
+        {
+            Set(Packet<AnimeMatrixPacket>(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")));
+        }
+
+        public void SetLedLinear(int address, byte value)
+        {
+            EnsureAddressableLed(address);
+            _displayBuffer[address] = value;
+        }
+
+        public void SetLedLinearImmediate(int address, byte value)
+        {
+            EnsureAddressableLed(address);
+            _displayBuffer[address] = value;
+
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
+                .AppendData(BitConverter.GetBytes((ushort)(address + 1)))
+                .AppendData(BitConverter.GetBytes((ushort)0x0001))
+                .AppendData(value)
+            );
+
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x03));
+        }
+
+        public void SetLedPlanar(int x, int y, byte value)
+        {
+            EnsureRowInRange(y);
+            var start = RowToLinearAddress(y) - EmptyColumns(y);
+
+            if (x > EmptyColumns(y))
+                SetLedLinear(start + x, value);
+        }
+
+        public void Clear(bool present = false)
+        {
+            for (var i = 0; i < _displayBuffer.Length; i++)
+                _displayBuffer[i] = 0;
+
+            if (present)
+                Present();
+        }
+
+        public void Present()
+        {
+
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
+                .AppendData(BitConverter.GetBytes((ushort)(UpdatePageLength * 0 + 1)))
+                .AppendData(BitConverter.GetBytes((ushort)UpdatePageLength))
+                .AppendData(_displayBuffer[(UpdatePageLength * 0)..(UpdatePageLength * 1)])
+            );
+
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
+                .AppendData(BitConverter.GetBytes((ushort)(UpdatePageLength * 1 + 1)))
+                .AppendData(BitConverter.GetBytes((ushort)UpdatePageLength))
+                .AppendData(_displayBuffer[(UpdatePageLength * 1)..(UpdatePageLength * 2)])
+            );
+
+            if (pages > 2)
+                Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
+                    .AppendData(BitConverter.GetBytes((ushort)(UpdatePageLength * 2 + 1)))
+                    .AppendData(BitConverter.GetBytes((ushort)(LedCount - UpdatePageLength * 2)))
+                    .AppendData(
+                        _displayBuffer[(UpdatePageLength * 2)..(UpdatePageLength * 2 + (LedCount - UpdatePageLength * 2))])
+                );
+
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x03));
+        }
+
+        public void SetDisplayState(bool enable)
+        {
+            if (enable)
+            {
+                Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
+                    .AppendData(0x00));
+            }
+            else
+            {
+                Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
+                    .AppendData(0x80));
+            }
+        }
+
+        public void SetBrightness(BrightnessMode mode)
+        {
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x04)
+                .AppendData((byte)mode)
+            );
+        }
+
+        public void SetBuiltInAnimation(bool enable)
+        {
+            var enabled = enable ? (byte)0x00 : (byte)0x80;
+            Set(Packet<AnimeMatrixPacket>(0xC4, 0x01, enabled));
+        }
+
+        public void SetBuiltInAnimation(bool enable, BuiltInAnimation animation)
+        {
+            SetBuiltInAnimation(enable);
+            Set(Packet<AnimeMatrixPacket>(0xC5, animation.AsByte));
+        }
+
+        public void GenerateFrame(Image image)
+        {
+
+            int width = MaxColumns * 3;
+            int height = MaxRows;
+            float scale;
+
+            Bitmap canvas = new Bitmap(width, height);
+
+            scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height);
+
+            var graph = Graphics.FromImage(canvas);
+            var scaleWidth = (int)(image.Width * scale);
+            var scaleHeight = (int)(image.Height * scale);
+
+            graph.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
+            graph.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
+            graph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+
+            graph.DrawImage(image, ((int)width - scaleWidth), ((int)height - scaleHeight) / 2, scaleWidth, scaleHeight);
+
+            Bitmap bmp = new Bitmap(canvas, MaxColumns, MaxRows);
+
+            for (int y = 0; y < bmp.Height; y++)
+            {
+                for (int x = 0; x < bmp.Width; x++)
+                {
+                    var pixel = bmp.GetPixel(x, y);
+                    byte color = (byte)(Math.Max((pixel.R + pixel.G + pixel.B) / 3 - 10, 0));
+                    SetLedPlanar(x, y, color);
+                }
+            }
+
+        }
+
+        private void EnsureRowInRange(int row)
+        {
+            if (row < 0 || row >= MaxRows)
+            {
+                throw new IndexOutOfRangeException($"Y-coordinate should fall in range of [0, {MaxRows - 1}].");
+            }
+        }
+
+        private void EnsureAddressableLed(int address)
+        {
+            if (address < 0 || address >= LedCount)
+            {
+                throw new IndexOutOfRangeException($"Linear LED address must be in range of [0, {LedCount - 1}].");
+            }
+        }
+    }
+}

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>
+

AppConfig.cs

@@ -0,0 +1,158 @@
+using System.Text.Json;
+
+public class AppConfig
+{
+
+    public string appPath;
+    string configFile;
+
+    public Dictionary<string, object> config = new Dictionary<string, object>();
+
+    public AppConfig()
+    {
+
+        appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        configFile = appPath + "\\config.json";
+
+        if (!System.IO.Directory.Exists(appPath))
+            System.IO.Directory.CreateDirectory(appPath);
+
+        if (File.Exists(configFile))
+        {
+            string text = File.ReadAllText(configFile);
+            try
+            {
+                config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
+            }
+            catch
+            {
+                initConfig();
+            }
+        }
+        else
+        {
+            initConfig();
+        }
+
+    }
+
+    private void initConfig()
+    {
+        config = new Dictionary<string, object>();
+        config["performance_mode"] = 0;
+        string jsonString = JsonSerializer.Serialize(config);
+        File.WriteAllText(configFile, jsonString);
+    }
+
+    public int getConfig(string name, bool performance = false)
+    {
+
+        if (config.ContainsKey(name))
+            return int.Parse(config[name].ToString());
+        else return -1;
+    }
+
+    public string getConfigString(string name)
+    {
+        if (config.ContainsKey(name))
+            return config[name].ToString();
+        else return null;
+    }
+
+    public void setConfig(string name, int value)
+    {
+        config[name] = value;
+        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(configFile, jsonString);
+    }
+
+    public void setConfig(string name, string value)
+    {
+        config[name] = value;
+        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(configFile, jsonString);
+    }
+
+    public string getParamName(int device, string paramName = "fan_profile")
+    {
+        int mode = getConfig("performance_mode");
+        string name;
+
+        if (device == 1)
+            name = "gpu";
+        else
+            name = "cpu";
+
+        return paramName + "_" + name + "_" + mode;
+    }
+
+    public byte[] getFanConfig(int device)
+    {
+        string curveString = getConfigString(getParamName(device));
+        byte[] curve = { };
+
+        if (curveString is not null)
+            curve = StringToBytes(curveString);
+
+        return curve;
+    }
+
+    public void setFanConfig(int device, byte[] curve)
+    {
+        string bitCurve = BitConverter.ToString(curve);
+        setConfig(getParamName(device), bitCurve);
+    }
+
+
+    public static byte[] StringToBytes(string str)
+    {
+        String[] arr = str.Split('-');
+        byte[] array = new byte[arr.Length];
+        for (int i = 0; i < arr.Length; i++) array[i] = Convert.ToByte(arr[i], 16);
+        return array;
+    }
+
+    public byte[] getDefaultCurve(int device)
+    {
+        int mode = getConfig("performance_mode");
+        byte[] curve;
+
+        switch (mode)
+        {
+            case 1:
+                if (device == 1)
+                    curve = StringToBytes("14-3F-44-48-4C-50-54-62-16-1F-26-2D-39-47-55-5F");
+                else
+                    curve = StringToBytes("14-3F-44-48-4C-50-54-62-11-1A-22-29-34-43-51-5A");
+                break;
+            case 2:
+                if (device == 1)
+                    curve = StringToBytes("3C-41-42-46-47-4B-4C-62-08-11-11-1D-1D-26-26-2D");
+                else
+                    curve = StringToBytes("3C-41-42-46-47-4B-4C-62-03-0C-0C-16-16-22-22-29");
+                break;
+            default:
+                if (device == 1)
+                    curve = StringToBytes("3A-3D-40-44-48-4D-51-62-0C-16-1D-1F-26-2D-34-4A");
+                else
+                    curve = StringToBytes("3A-3D-40-44-48-4D-51-62-08-11-16-1A-22-29-30-45");
+                break;
+        }
+
+        return curve;
+    }
+
+    public int getConfigPerf(string name)
+    {
+        int mode = getConfig("performance_mode");
+        return getConfig(name + "_" + mode);
+    }
+
+    public void setConfigPerf(string name, int value)
+    {
+        int mode = getConfig("performance_mode");
+        setConfig(name + "_" + mode, value);
+    }
+
+
+}

Aura.cs

@@ -3,14 +3,14 @@
 public class Aura
 {
 
-    static byte[] MESSAGE_SET = { 0x5d, 0xb5 };
-    static byte[] MESSAGE_APPLY = { 0x5d, 0xb4 };
+    static byte[] MESSAGE_SET = { 0x5d, 0xb5, 0,0,0 };
+    static byte[] MESSAGE_APPLY = { 0x5d, 0xb4};
 
     public const int Static = 0;
     public const int Breathe = 1;
     public const int Strobe = 2;
     public const int Rainbow = 3;
-    public const int Dingding = 10;
+    public const int Dingding = 4;
 
     public const int SpeedSlow = 0xe1;
     public const int SpeedMedium = 0xeb;
@@ -47,6 +47,20 @@ public class Aura
 
         HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
 
+        if (Mode == Dingding)
+        {
+            Mode = 10;
+            Speed = SpeedMedium;
+        }
+        else if (Mode == Rainbow)
+        {
+            Speed = SpeedMedium;
+        }
+        else
+        {
+            Speed = SpeedSlow;
+        }
+
         foreach (HidDevice device in HidDeviceList)
         {
             if (device.IsConnected)

Communication/Device.cs

@@ -0,0 +1,45 @@
+// Source thanks to https://github.com/vddCore/Starlight :)
+
+using Starlight.Communication.Platform;
+using System.Configuration;
+
+namespace Starlight.Communication
+{
+    public abstract class Device : IDisposable
+    {
+        private static UsbProvider _usbProvider;
+
+        private static ushort _vendorId;
+        private static ushort _productId;
+        private static int _maxFeatureReportLength;
+
+        protected Device(ushort vendorId, ushort productId, int 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
+        {
+            return (T)Activator.CreateInstance(typeof(T), command)!;
+        }
+
+        public void Set(Packet packet)
+            => _usbProvider?.Set(packet.Data);
+
+        public byte[] Get(Packet packet)
+            => _usbProvider?.Get(packet.Data);
+
+        public void Dispose()
+        {
+            _usbProvider?.Dispose();
+        }
+    }
+}

Communication/Packet.cs

@@ -0,0 +1,58 @@
+// Source thanks to https://github.com/vddCore/Starlight :)
+
+namespace Starlight.Communication
+{
+    public abstract class Packet
+    {
+        private int _currentDataIndex = 1;
+
+        public byte[] Data { get; }
+
+        internal Packet(byte reportId, int packetLength, params byte[] data)
+        {
+            if (packetLength < 1)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(packetLength),
+                    "Packet length must be at least 1."
+                );
+            }
+
+            Data = new byte[packetLength];
+            Data[0] = reportId;
+
+            if (data.Length > 0)
+            {
+                if (_currentDataIndex >= Data.Length)
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(data),
+                        "Your packet length does not allow for initial data to be appended."
+                    );
+                }
+
+                AppendData(data);
+            }
+        }
+
+        public Packet AppendData(params byte[] data)
+            => AppendData(out _, data);
+
+        public Packet AppendData(out int bytesWritten, params byte[] data)
+        {
+            bytesWritten = 0;
+
+            for (var i = 0;
+                 i < data.Length && _currentDataIndex < Data.Length - 1;
+                 i++, bytesWritten++, _currentDataIndex++)
+            {
+                if (_currentDataIndex > Data.Length - 1)
+                    break;
+
+                Data[_currentDataIndex] = data[i];
+            }
+
+            return this;
+        }
+    }
+}

Communication/Platform/UsbProvider.cs

@@ -0,0 +1,19 @@
+namespace Starlight.Communication.Platform
+{
+    internal abstract class UsbProvider : IDisposable
+    {
+        protected ushort VendorID { get; }
+        protected ushort ProductID { get; }
+
+        protected UsbProvider(ushort vendorId, ushort productId)
+        {
+            VendorID = vendorId;
+            ProductID = productId;
+        }
+
+        public abstract void Set(byte[] data);
+        public abstract byte[] Get(byte[] data);
+        
+        public abstract void Dispose();
+    }
+}

Communication/Platform/WindowsUsbProvider.cs

@@ -0,0 +1,79 @@
+using System.ComponentModel;
+using HidSharp;
+
+namespace Starlight.Communication.Platform
+{
+    internal class WindowsUsbProvider : UsbProvider
+    {
+        protected HidDevice HidDevice { get; }
+        protected HidStream HidStream { get; }
+
+        public WindowsUsbProvider(ushort vendorId, ushort productId, int maxFeatureReportLength) 
+            : base(vendorId, productId)
+        {
+            try
+            {
+                HidDevice = DeviceList.Local
+                    .GetHidDevices(vendorId, productId)
+                    .First(x => x.GetMaxFeatureReportLength() == maxFeatureReportLength);
+            }
+            catch
+            {
+                throw new IOException("AniMe Matrix control device was not found on your machine.");
+            }
+
+            var config = new OpenConfiguration();
+            config.SetOption(OpenOption.Interruptible, true);
+            config.SetOption(OpenOption.Exclusive, false);
+            config.SetOption(OpenOption.Priority, 10);
+
+            HidStream = HidDevice.Open(config);
+        }
+
+        public override void Set(byte[] data)
+        {
+            WrapException(() =>
+            {
+                HidStream.SetFeature(data);
+                HidStream.Flush();
+            });
+        }
+
+        public override byte[] Get(byte[] data)
+        {
+            var outData = new byte[data.Length];
+            Array.Copy(data, outData, data.Length);
+            
+            WrapException(() =>
+            {
+                HidStream.GetFeature(outData);
+                HidStream.Flush();
+            });
+
+            return data;
+        }
+
+        public override void Dispose()
+        {
+            HidStream.Dispose();
+        }
+        
+        private void WrapException(Action action)
+        {
+            try
+            {
+                action();
+            }
+            catch (IOException e)
+            {
+                if (e.InnerException is Win32Exception w32e)
+                {
+                    if (w32e.NativeErrorCode != 0)
+                    {
+                        throw;
+                    }
+                }
+            }
+        }
+    }
+}

Fans.Designer.cs

@@ -30,80 +30,443 @@
         {
             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();
-            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
-            buttonApply = new Button();
-            buttonReset = new Button();
+            panelFans = new Panel();
+            labelBoost = new Label();
+            comboBoost = new ComboBox();
+            picturePerf = new PictureBox();
+            tableFanCharts = new TableLayoutPanel();
             chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
-            ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
+            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
+            labelFans = new Label();
+            checkAuto = new CheckBox();
+            buttonReset = new Button();
+            buttonApply = new Button();
+            panelPower = new Panel();
+            pictureBox1 = new PictureBox();
+            labelPowerLimits = new Label();
+            checkApplyPower = new CheckBox();
+            buttonApplyPower = new Button();
+            panelCPU = new Panel();
+            labelCPU = new Label();
+            label2 = new Label();
+            trackCPU = new TrackBar();
+            panelTotal = new Panel();
+            labelTotal = new Label();
+            label1 = new Label();
+            trackTotal = new TrackBar();
+            labelApplied = new Label();
+            pictureFine = new PictureBox();
+            labelInfo = new Label();
+            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();
+            ((System.ComponentModel.ISupportInitialize)trackTotal).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)pictureFine).BeginInit();
             SuspendLayout();
             // 
-            // chartCPU
+            // panelFans
             // 
-            chartArea1.Name = "ChartArea1";
-            chartCPU.ChartAreas.Add(chartArea1);
-            chartCPU.Location = new Point(16, 13);
-            chartCPU.Name = "chartCPU";
-            chartCPU.Size = new Size(900, 480);
-            chartCPU.TabIndex = 0;
-            chartCPU.Text = "chartCPU";
+            panelFans.Controls.Add(labelBoost);
+            panelFans.Controls.Add(comboBoost);
+            panelFans.Controls.Add(picturePerf);
+            panelFans.Controls.Add(tableFanCharts);
+            panelFans.Controls.Add(labelFans);
+            panelFans.Controls.Add(checkAuto);
+            panelFans.Controls.Add(buttonReset);
+            panelFans.Controls.Add(buttonApply);
+            panelFans.Dock = DockStyle.Left;
+            panelFans.Location = new Point(364, 0);
+            panelFans.Margin = new Padding(0);
+            panelFans.Name = "panelFans";
+            panelFans.Padding = new Padding(20);
+            panelFans.Size = new Size(824, 1159);
+            panelFans.TabIndex = 12;
             // 
-            // buttonApply
+            // labelBoost
             // 
-            buttonApply.Location = new Point(661, 1016);
-            buttonApply.Name = "buttonApply";
-            buttonApply.Size = new Size(254, 46);
-            buttonApply.TabIndex = 1;
-            buttonApply.Text = "Apply Fan Curve";
-            buttonApply.UseVisualStyleBackColor = true;
+            labelBoost.AutoSize = true;
+            labelBoost.Location = new Point(397, 19);
+            labelBoost.Name = "labelBoost";
+            labelBoost.Size = new Size(125, 32);
+            labelBoost.TabIndex = 39;
+            labelBoost.Text = "CPU Boost";
             // 
-            // buttonReset
+            // comboBoost
             // 
-            buttonReset.Location = new Point(16, 1016);
-            buttonReset.Name = "buttonReset";
-            buttonReset.Size = new Size(254, 46);
-            buttonReset.TabIndex = 2;
-            buttonReset.Text = "Factory Defaults";
-            buttonReset.UseVisualStyleBackColor = true;
+            comboBoost.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            comboBoost.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboBoost.FormattingEnabled = true;
+            comboBoost.Items.AddRange(new object[] { "Disabled", "Enabled", "Aggressive", "Efficient Enabled", "Efficient Aggressive" });
+            comboBoost.Location = new Point(526, 15);
+            comboBoost.Name = "comboBoost";
+            comboBoost.Size = new Size(266, 40);
+            comboBoost.TabIndex = 38;
+            // 
+            // 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, 64);
+            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, 992);
+            tableFanCharts.TabIndex = 36;
             // 
             // chartGPU
             // 
-            chartArea2.Name = "ChartArea1";
-            chartGPU.ChartAreas.Add(chartArea2);
-            chartGPU.Location = new Point(16, 513);
+            chartArea1.Name = "ChartArea1";
+            chartGPU.ChartAreas.Add(chartArea1);
+            chartGPU.Dock = DockStyle.Fill;
+            chartGPU.Location = new Point(2, 506);
+            chartGPU.Margin = new Padding(2, 10, 2, 10);
             chartGPU.Name = "chartGPU";
-            chartGPU.Size = new Size(900, 480);
-            chartGPU.TabIndex = 3;
+            chartGPU.Size = new Size(760, 476);
+            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, 476);
+            chartCPU.TabIndex = 14;
+            chartCPU.Text = "chartCPU";
+            // 
+            // labelFans
+            // 
+            labelFans.AutoSize = true;
+            labelFans.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            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;
+            labelFans.Text = "Fan Curves";
+            // 
+            // checkAuto
+            // 
+            checkAuto.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            checkAuto.AutoSize = true;
+            checkAuto.Location = new Point(377, 1086);
+            checkAuto.Margin = new Padding(4, 2, 4, 2);
+            checkAuto.Name = "checkAuto";
+            checkAuto.Size = new Size(165, 36);
+            checkAuto.TabIndex = 17;
+            checkAuto.Text = "Auto Apply";
+            checkAuto.UseVisualStyleBackColor = true;
+            // 
+            // buttonReset
+            // 
+            buttonReset.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            buttonReset.Location = new Point(30, 1081);
+            buttonReset.Margin = new Padding(4, 2, 4, 2);
+            buttonReset.Name = "buttonReset";
+            buttonReset.Size = new Size(232, 44);
+            buttonReset.TabIndex = 15;
+            buttonReset.Text = "Factory Defaults";
+            buttonReset.UseVisualStyleBackColor = true;
+            // 
+            // buttonApply
+            // 
+            buttonApply.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            buttonApply.Location = new Point(542, 1081);
+            buttonApply.Margin = new Padding(4, 2, 4, 2);
+            buttonApply.Name = "buttonApply";
+            buttonApply.Size = new Size(248, 44);
+            buttonApply.TabIndex = 14;
+            buttonApply.Text = "Apply Fan Curve";
+            buttonApply.UseVisualStyleBackColor = true;
+            // 
+            // panelPower
+            // 
+            panelPower.Controls.Add(pictureBox1);
+            panelPower.Controls.Add(labelPowerLimits);
+            panelPower.Controls.Add(checkApplyPower);
+            panelPower.Controls.Add(buttonApplyPower);
+            panelPower.Controls.Add(panelCPU);
+            panelPower.Controls.Add(panelTotal);
+            panelPower.Controls.Add(labelApplied);
+            panelPower.Controls.Add(pictureFine);
+            panelPower.Controls.Add(labelInfo);
+            panelPower.Dock = DockStyle.Left;
+            panelPower.Location = new Point(0, 0);
+            panelPower.Margin = new Padding(10);
+            panelPower.Name = "panelPower";
+            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(54, 20);
+            labelPowerLimits.Margin = new Padding(4, 0, 4, 0);
+            labelPowerLimits.Name = "labelPowerLimits";
+            labelPowerLimits.Size = new Size(229, 32);
+            labelPowerLimits.TabIndex = 26;
+            labelPowerLimits.Text = "Power Limits (PPT)";
+            // 
+            // checkApplyPower
+            // 
+            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            checkApplyPower.AutoSize = true;
+            checkApplyPower.Location = new Point(27, 1039);
+            checkApplyPower.Margin = new Padding(4, 2, 4, 2);
+            checkApplyPower.Name = "checkApplyPower";
+            checkApplyPower.Size = new Size(165, 36);
+            checkApplyPower.TabIndex = 25;
+            checkApplyPower.Text = "Auto Apply";
+            checkApplyPower.UseVisualStyleBackColor = true;
+            // 
+            // buttonApplyPower
+            // 
+            buttonApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
+            buttonApplyPower.Location = new Point(20, 1081);
+            buttonApplyPower.Margin = new Padding(4, 2, 4, 2);
+            buttonApplyPower.Name = "buttonApplyPower";
+            buttonApplyPower.Size = new Size(324, 44);
+            buttonApplyPower.TabIndex = 24;
+            buttonApplyPower.Text = "Apply Power Limits";
+            buttonApplyPower.UseVisualStyleBackColor = true;
+            // 
+            // panelCPU
+            // 
+            panelCPU.Controls.Add(labelCPU);
+            panelCPU.Controls.Add(label2);
+            panelCPU.Controls.Add(trackCPU);
+            panelCPU.Location = new Point(184, 93);
+            panelCPU.Margin = new Padding(4);
+            panelCPU.Name = "panelCPU";
+            panelCPU.Size = new Size(160, 510);
+            panelCPU.TabIndex = 23;
+            // 
+            // labelCPU
+            // 
+            labelCPU.AutoSize = true;
+            labelCPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelCPU.Location = new Point(44, 40);
+            labelCPU.Margin = new Padding(4, 0, 4, 0);
+            labelCPU.Name = "labelCPU";
+            labelCPU.Size = new Size(61, 32);
+            labelCPU.TabIndex = 13;
+            labelCPU.Text = "CPU";
+            labelCPU.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // label2
+            // 
+            label2.AutoSize = true;
+            label2.Location = new Point(44, 8);
+            label2.Margin = new Padding(4, 0, 4, 0);
+            label2.Name = "label2";
+            label2.Size = new Size(58, 32);
+            label2.TabIndex = 12;
+            label2.Text = "CPU";
+            label2.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // trackCPU
+            // 
+            trackCPU.Location = new Point(48, 88);
+            trackCPU.Margin = new Padding(4, 2, 4, 2);
+            trackCPU.Maximum = 85;
+            trackCPU.Minimum = 15;
+            trackCPU.Name = "trackCPU";
+            trackCPU.Orientation = Orientation.Vertical;
+            trackCPU.Size = new Size(90, 416);
+            trackCPU.TabIndex = 11;
+            trackCPU.TickFrequency = 5;
+            trackCPU.Value = 80;
+            // 
+            // panelTotal
+            // 
+            panelTotal.Controls.Add(labelTotal);
+            panelTotal.Controls.Add(label1);
+            panelTotal.Controls.Add(trackTotal);
+            panelTotal.Location = new Point(16, 93);
+            panelTotal.Margin = new Padding(4);
+            panelTotal.Name = "panelTotal";
+            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, 40);
+            labelTotal.Margin = new Padding(4, 0, 4, 0);
+            labelTotal.Name = "labelTotal";
+            labelTotal.Size = new Size(70, 32);
+            labelTotal.TabIndex = 12;
+            labelTotal.Text = "Total";
+            labelTotal.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // label1
+            // 
+            label1.AutoSize = true;
+            label1.Location = new Point(48, 8);
+            label1.Margin = new Padding(4, 0, 4, 0);
+            label1.Name = "label1";
+            label1.Size = new Size(65, 32);
+            label1.TabIndex = 11;
+            label1.Text = "Total";
+            label1.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // trackTotal
+            // 
+            trackTotal.Location = new Point(44, 88);
+            trackTotal.Margin = new Padding(4, 2, 4, 2);
+            trackTotal.Maximum = 150;
+            trackTotal.Minimum = 15;
+            trackTotal.Name = "trackTotal";
+            trackTotal.Orientation = Orientation.Vertical;
+            trackTotal.Size = new Size(90, 416);
+            trackTotal.TabIndex = 10;
+            trackTotal.TickFrequency = 5;
+            trackTotal.TickStyle = TickStyle.TopLeft;
+            trackTotal.Value = 125;
+            // 
+            // labelApplied
+            // 
+            labelApplied.AutoSize = true;
+            labelApplied.ForeColor = Color.Tomato;
+            labelApplied.Location = new Point(56, 54);
+            labelApplied.Margin = new Padding(4, 0, 4, 0);
+            labelApplied.Name = "labelApplied";
+            labelApplied.Size = new Size(143, 32);
+            labelApplied.TabIndex = 21;
+            labelApplied.Text = "Not Applied";
+            // 
+            // pictureFine
+            // 
+            pictureFine.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            pictureFine.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureFine.Image = Properties.Resources.everything_is_fine_itsfine;
+            pictureFine.Location = new Point(20, 682);
+            pictureFine.Margin = new Padding(4, 2, 4, 2);
+            pictureFine.Name = "pictureFine";
+            pictureFine.Size = new Size(324, 268);
+            pictureFine.SizeMode = PictureBoxSizeMode.Zoom;
+            pictureFine.TabIndex = 20;
+            pictureFine.TabStop = false;
+            pictureFine.Visible = false;
+            // 
+            // labelInfo
+            // 
+            labelInfo.Location = new Point(24, 618);
+            labelInfo.Margin = new Padding(4, 0, 4, 0);
+            labelInfo.Name = "labelInfo";
+            labelInfo.Size = new Size(320, 330);
+            labelInfo.TabIndex = 19;
+            labelInfo.Text = "label";
+            // 
             // Fans
             // 
-            AutoScaleDimensions = new SizeF(13F, 32F);
-            AutoScaleMode = AutoScaleMode.Font;
-            ClientSize = new Size(940, 1089);
-            Controls.Add(chartGPU);
-            Controls.Add(buttonReset);
-            Controls.Add(buttonApply);
-            Controls.Add(chartCPU);
-            FormBorderStyle = FormBorderStyle.FixedSingle;
+            AutoScaleDimensions = new SizeF(192F, 192F);
+            AutoScaleMode = AutoScaleMode.Dpi;
+            AutoSize = true;
+            AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            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(26, 1230);
             Name = "Fans";
             ShowIcon = false;
             ShowInTaskbar = false;
             StartPosition = FormStartPosition.CenterScreen;
-            Text = "Fans";
-            ((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
+            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();
+            panelTotal.ResumeLayout(false);
+            panelTotal.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackTotal).EndInit();
+            ((System.ComponentModel.ISupportInitialize)pictureFine).EndInit();
             ResumeLayout(false);
         }
 
         #endregion
-
-        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
-        private Button buttonApply;
+        private Panel panelFans;
+        private CheckBox checkAuto;
         private Button buttonReset;
+        private Button buttonApply;
+        private Panel panelPower;
+        private CheckBox checkApplyPower;
+        private Button buttonApplyPower;
+        private Panel panelCPU;
+        private Label labelCPU;
+        private Label label2;
+        private TrackBar trackCPU;
+        private Panel panelTotal;
+        private Label labelTotal;
+        private Label label1;
+        private TrackBar trackTotal;
+        private Label labelApplied;
+        private PictureBox pictureFine;
+        private Label labelInfo;
+        private Label labelPowerLimits;
+        private TableLayoutPanel tableFanCharts;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
+        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
+        private Label labelFans;
+        private PictureBox picturePerf;
+        private PictureBox pictureBox1;
+        private ComboBox comboBoost;
+        private Label labelBoost;
     }
 }

Fans.cs

@@ -22,7 +22,7 @@ namespace GHelper
                 title = "CPU Fan Profile";
 
             if (Program.settingsForm.perfName.Length > 0)
-                title += ": " + Program.settingsForm.perfName;
+                labelFans.Text = "Fan Profiles: " + Program.settingsForm.perfName;
 
             if (chart.Titles.Count > 0)
                 chart.Titles[0].Text = title;
@@ -35,10 +35,19 @@ namespace GHelper
             chart.ChartAreas[0].AxisX.Minimum = 10;
             chart.ChartAreas[0].AxisX.Maximum = 100;
             chart.ChartAreas[0].AxisX.Interval = 10;
+
             chart.ChartAreas[0].AxisY.Minimum = 0;
             chart.ChartAreas[0].AxisY.Maximum = 100;
 
-            chart.ChartAreas[0].AxisX.Interval = 10;
+            chart.ChartAreas[0].AxisY.LabelStyle.Font = new Font("Arial", 7F);
+
+            chart.ChartAreas[0].AxisY.CustomLabels.Add(-2, 2, "OFF");
+
+            for (int i = 1; i <= 9; i++)
+                chart.ChartAreas[0].AxisY.CustomLabels.Add(i * 10 - 2, i * 10 + 2, (1800 + 400 * i).ToString());
+
+            chart.ChartAreas[0].AxisY.CustomLabels.Add(98, 102, "RPM");
+
             chart.ChartAreas[0].AxisY.Interval = 10;
 
             if (chart.Legends.Count > 0)
@@ -48,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;
         }
 
@@ -57,14 +77,14 @@ namespace GHelper
 
             InitializeComponent();
 
+            FormClosing += Fans_FormClosing;
+
             seriesCPU = chartCPU.Series.Add("CPU");
             seriesGPU = chartGPU.Series.Add("GPU");
 
             seriesCPU.Color = Color.Blue;
             seriesGPU.Color = Color.Red;
 
-            LoadFans();
-
             chartCPU.MouseMove += ChartCPU_MouseMove;
             chartCPU.MouseUp += ChartCPU_MouseUp;
 
@@ -74,11 +94,158 @@ namespace GHelper
             buttonReset.Click += ButtonReset_Click;
             buttonApply.Click += ButtonApply_Click;
 
+            trackTotal.Maximum = ASUSWmi.MaxTotal;
+            trackTotal.Minimum = ASUSWmi.MinTotal;
+
+            trackCPU.Maximum = ASUSWmi.MaxCPU;
+            trackCPU.Minimum = ASUSWmi.MinCPU;
+
+            trackCPU.Scroll += TrackCPU_Scroll;
+            trackTotal.Scroll += TrackTotal_Scroll;
+
+            buttonApplyPower.Click += ButtonApplyPower_Click;
+
+            checkAuto.Click += CheckAuto_Click;
+            checkApplyPower.Click += CheckApplyPower_Click;
+
+            //labelInfo.MaximumSize = new Size(280, 0);
+            labelInfo.Text = "Power Limits (PPT) is\nexperimental feature.\n\nUse carefully and\non your own risk!";
+
+            InitFans();
+            InitPower();
+            InitBoost();
+
+            comboBoost.SelectedIndexChanged += ComboBoost_Changed;
+
             Shown += Fans_Shown;
 
         }
 
-        public void LoadFans()
+
+        public void InitBoost()
+        {
+            int boost = NativeMethods.GetCPUBoost();
+            if (boost >= 0)
+                comboBoost.SelectedIndex = boost;
+        }
+
+        private void ComboBoost_Changed(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            ComboBox cmb = (ComboBox)sender;
+            NativeMethods.SetCPUBoost(cmb.SelectedIndex);
+        }
+
+        private void CheckApplyPower_Click(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            CheckBox chk = (CheckBox)sender;
+            Program.config.setConfigPerf("auto_apply_power", chk.Checked ? 1 : 0);
+        }
+
+        private void CheckAuto_Click(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            CheckBox chk = (CheckBox)sender;
+            Program.config.setConfigPerf("auto_apply", chk.Checked ? 1 : 0);
+        }
+
+        private void Fans_FormClosing(object? sender, FormClosingEventArgs e)
+        {
+            if (e.CloseReason == CloseReason.UserClosing)
+            {
+                e.Cancel = true;
+                Hide();
+            }
+        }
+
+        private void ButtonApplyPower_Click(object? sender, EventArgs e)
+        {
+            Program.settingsForm.SetPower();
+            ApplyLabel(true);
+        }
+
+        public void InitPower(bool changed = false)
+        {
+
+            bool cpuBmode = (Program.wmi.DeviceGet(ASUSWmi.PPT_CPUB0) >= 0); // 2022 model +
+            bool cpuAmode = (Program.wmi.DeviceGet(ASUSWmi.PPT_TotalA0) >= 0); // 2021 model +
+
+            panelPower.Visible = cpuAmode;
+            panelCPU.Visible = cpuBmode;
+
+            // Yes, that's stupid, but Total slider on 2021 model actually adjusts CPU PPT
+            if (!cpuBmode)
+            {
+                label1.Text = "CPU SPPT";
+            }
+
+            int limit_total;
+            int limit_cpu;
+            bool apply = Program.config.getConfigPerf("auto_apply_power") == 1;
+
+            if (changed)
+            {
+                limit_total = trackTotal.Value;
+                limit_cpu = trackCPU.Value;
+                ApplyLabel(false);
+            }
+            else
+            {
+                limit_total = Program.config.getConfigPerf("limit_total");
+                limit_cpu = Program.config.getConfigPerf("limit_cpu");
+                ApplyLabel(apply);
+            }
+
+            if (limit_total < 0) limit_total = ASUSWmi.DefaultTotal;
+            if (limit_total > ASUSWmi.MaxTotal) limit_total = ASUSWmi.MaxTotal;
+            if (limit_total < ASUSWmi.MinTotal) limit_total = ASUSWmi.MinTotal;
+
+            if (limit_cpu < 0) limit_cpu = ASUSWmi.DefaultCPU;
+            if (limit_cpu > ASUSWmi.MaxCPU) limit_cpu = ASUSWmi.MaxCPU;
+            if (limit_cpu < ASUSWmi.MinCPU) limit_cpu = ASUSWmi.MinCPU;
+            if (limit_cpu > limit_total) limit_cpu = limit_total;
+
+            trackTotal.Value = limit_total;
+            trackCPU.Value = limit_cpu;
+            checkApplyPower.Checked = apply;
+
+            labelTotal.Text = trackTotal.Value.ToString() + "W";
+            labelCPU.Text = trackCPU.Value.ToString() + "W";
+            pictureFine.Visible = (limit_cpu > 85 || limit_total > 145);
+
+            Program.config.setConfigPerf("limit_total", limit_total);
+            Program.config.setConfigPerf("limit_cpu", limit_cpu);
+        }
+
+
+        private void TrackTotal_Scroll(object? sender, EventArgs e)
+        {
+            InitPower(true);
+        }
+
+        private void TrackCPU_Scroll(object? sender, EventArgs e)
+        {
+            InitPower(true);
+        }
+
+
+        public void ApplyLabel(bool applied = false)
+        {
+            if (applied)
+            {
+                labelApplied.ForeColor = Color.Blue;
+                labelApplied.Text = "Applied";
+            }
+            else
+            {
+                labelApplied.ForeColor = Color.Red;
+                labelApplied.Text = "Not Applied";
+
+            }
+        }
+
+        public void InitFans()
         {
 
             SetChart(chartCPU, 0);
@@ -87,28 +254,12 @@ namespace GHelper
             LoadProfile(seriesCPU, 0);
             LoadProfile(seriesGPU, 1);
 
+            int auto_apply = Program.config.getConfigPerf("auto_apply");
+
+            checkAuto.Checked = (auto_apply == 1);
+
         }
 
-        byte[] StringToBytes(string str)
-        {
-            String[] arr = str.Split('-');
-            byte[] array = new byte[arr.Length];
-            for (int i = 0; i < arr.Length; i++) array[i] = Convert.ToByte(arr[i], 16);
-            return array;
-        }
-
-        string GetFanName(int device)
-        {
-            int mode = Program.config.getConfig("performance_mode");
-            string name;
-
-            if (device == 1)
-                name = "gpu";
-            else
-                name = "cpu";
-
-            return "fan_profile_" + name + "_" + mode;
-        }
 
         void LoadProfile(Series series, int device, int def = 0)
         {
@@ -120,42 +271,13 @@ namespace GHelper
             series.Points.Clear();
 
             int mode = Program.config.getConfig("performance_mode");
-            string curveString = Program.config.getConfigString(GetFanName(device));
-            byte[] curve = { };
-
-            if (curveString is not null)
-                curve = StringToBytes(curveString);
+            byte[] curve = Program.config.getFanConfig(device);
 
             if (def == 1 || curve.Length != 16)
                 curve = Program.wmi.GetFanCurve(device, mode);
 
-            if (curve.All(singleByte => singleByte == 0))
-            {
-                switch (mode)
-                {
-                    case 1:
-                        if (device == 1)
-                            curve = StringToBytes("14-3F-44-48-4C-50-54-62-16-1F-26-2D-39-47-55-5F");
-                        else
-                            curve = StringToBytes("14-3F-44-48-4C-50-54-62-11-1A-22-29-34-43-51-5A");
-                        break;
-                    case 2:
-                        if (device == 1)
-                            curve = StringToBytes("3C-41-42-46-47-4B-4C-62-08-11-11-1D-1D-26-26-2D");
-                        else
-                            curve = StringToBytes("3C-41-42-46-47-4B-4C-62-03-0C-0C-16-16-22-22-29");
-                        break;
-                    default:
-                        if (device == 1)
-                            curve = StringToBytes("3A-3D-40-44-48-4D-51-62-0C-16-1D-1F-26-2D-34-4A");
-                        else
-                            curve = StringToBytes("3A-3D-40-44-48-4D-51-62-08-11-16-1A-22-29-30-45");
-                        break;
-                }
-
-            }
-
-
+            if (curve.Length != 16 || curve.All(singleByte => singleByte == 0))
+                curve = Program.config.getDefaultCurve(device);
 
             //Debug.WriteLine(BitConverter.ToString(curve));
 
@@ -180,10 +302,7 @@ namespace GHelper
                 i++;
             }
 
-            string bitCurve = BitConverter.ToString(curve);
-            Debug.WriteLine(bitCurve);
-            Program.config.setConfig(GetFanName(device), bitCurve);
-
+            Program.config.setFanConfig(device, curve);
             Program.wmi.SetFanCurve(device, curve);
 
         }
@@ -197,9 +316,19 @@ namespace GHelper
 
         private void ButtonReset_Click(object? sender, EventArgs e)
         {
+
             LoadProfile(seriesCPU, 0, 1);
             LoadProfile(seriesGPU, 1, 1);
+
+            checkAuto.Checked = false;
+            checkApplyPower.Checked = false;
+
+            Program.config.setConfigPerf("auto_apply", 0);
+            Program.config.setConfigPerf("auto_apply_power", 0);
+
             Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"));
+
+            ApplyLabel(false);
         }
 
         private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)

GHelper.csproj

@@ -15,7 +15,8 @@
     <AssemblyName>GHelper</AssemblyName>
     <PlatformTarget>x64</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
-    <AssemblyVersion>0.9.9.0</AssemblyVersion>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <AssemblyVersion>0.28</AssemblyVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -37,9 +38,10 @@
 
   <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="UToolKit" Version="1.1.0.1" />
     <PackageReference Include="WinForms.DataVisualization" Version="1.7.0" />
   </ItemGroup>
 

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);
+    }
+}

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();
+    }
+}

Gpu/IGpuTemperatureProvider.cs

@@ -0,0 +1,6 @@
+namespace GHelper.Gpu;
+
+public interface IGpuTemperatureProvider : IDisposable {
+    bool IsValid { get; }
+    int? GetCurrentTemperature();
+}

Gpu/NvidiaGpuTemperatureProvider.cs

@@ -0,0 +1,42 @@
+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;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+        IThermalSensor? gpuSensor = 
+            GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
+            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
+
+        return gpuSensor?.CurrentTemperature;
+    }
+
+    public void Dispose() {
+    }
+    
+    private static PhysicalGPU? GetInternalDiscreteGpu() {
+        try {
+            return PhysicalGPU
+                .GetPhysicalGPUs()
+                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
+        } catch {
+            return null;
+        }
+    }
+}

HardwareMonitor.cs

@@ -0,0 +1,86 @@
+using System.Diagnostics;
+using GHelper.Gpu;
+
+public static 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();
+        } catch
+        {
+            Logger.WriteLine("Failed reading CPU temp");
+        }
+
+        try
+        {
+            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
+            batteryDischarge = cb.NextValue() / 1000;
+            cb.Dispose();
+
+        } catch
+        {
+            Logger.WriteLine("Failed reading Battery discharge");
+        }
+
+        try
+        {
+            gpuTemp = GpuTemperatureProvider?.GetCurrentTemperature();
+        } catch (Exception ex) {
+            gpuTemp = null;
+            Logger.WriteLine("Failed reading GPU temp");
+            Logger.WriteLine(ex.ToString());
+        }
+
+    }
+
+    public static void RecreateGpuTemperatureProviderWithRetry() {
+        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));
+            RecreateGpuTemperatureProvider();
+        });
+    }
+
+    public static void RecreateGpuTemperatureProvider() {
+        try {
+            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 {
+            Logger.WriteLine($"GpuTemperatureProvider: {GpuTemperatureProvider?.GetType().Name}");
+        }
+    }
+}

Keyboard.Designer.cs

@@ -35,11 +35,17 @@
             labelM4 = new Label();
             comboM3 = new ComboBox();
             labelM3 = new Label();
+            textFNF4 = new TextBox();
+            comboFNF4 = new ComboBox();
+            labelFNF4 = new Label();
             groupBox1.SuspendLayout();
             SuspendLayout();
             // 
             // groupBox1
             // 
+            groupBox1.Controls.Add(textFNF4);
+            groupBox1.Controls.Add(comboFNF4);
+            groupBox1.Controls.Add(labelFNF4);
             groupBox1.Controls.Add(textM4);
             groupBox1.Controls.Add(textM3);
             groupBox1.Controls.Add(comboM4);
@@ -49,7 +55,7 @@
             groupBox1.Dock = DockStyle.Top;
             groupBox1.Location = new Point(10, 10);
             groupBox1.Name = "groupBox1";
-            groupBox1.Size = new Size(751, 196);
+            groupBox1.Size = new Size(751, 242);
             groupBox1.TabIndex = 0;
             groupBox1.TabStop = false;
             groupBox1.Text = "Key Bindings";
@@ -58,7 +64,7 @@
             // 
             textM4.Location = new Point(411, 113);
             textM4.Name = "textM4";
-            textM4.PlaceholderText = "notepad /p \"file.txt\"";
+            textM4.PlaceholderText = "action";
             textM4.Size = new Size(320, 39);
             textM4.TabIndex = 5;
             // 
@@ -91,7 +97,7 @@
             // comboM3
             // 
             comboM3.FormattingEnabled = true;
-            comboM3.Items.AddRange(new object[] { "Volume Mute", "Play / Pause", "Toggle Aura", "Custom" });
+            comboM3.Items.AddRange(new object[] { "Default", "Volume Mute", "Play / Pause", "PrintScreen", "Toggle Aura", "Custom" });
             comboM3.Location = new Point(93, 54);
             comboM3.Name = "comboM3";
             comboM3.Size = new Size(312, 40);
@@ -106,6 +112,31 @@
             labelM3.TabIndex = 0;
             labelM3.Text = "M3:";
             // 
+            // textFNF4
+            // 
+            textFNF4.Location = new Point(411, 176);
+            textFNF4.Name = "textFNF4";
+            textFNF4.PlaceholderText = "action";
+            textFNF4.Size = new Size(320, 39);
+            textFNF4.TabIndex = 8;
+            // 
+            // comboFNF4
+            // 
+            comboFNF4.FormattingEnabled = true;
+            comboFNF4.Location = new Point(93, 175);
+            comboFNF4.Name = "comboFNF4";
+            comboFNF4.Size = new Size(312, 40);
+            comboFNF4.TabIndex = 7;
+            // 
+            // labelFNF4
+            // 
+            labelFNF4.AutoSize = true;
+            labelFNF4.Location = new Point(2, 178);
+            labelFNF4.Name = "labelFNF4";
+            labelFNF4.Size = new Size(90, 32);
+            labelFNF4.TabIndex = 6;
+            labelFNF4.Text = "FN+F4:";
+            // 
             // Keyboard
             // 
             AutoScaleDimensions = new SizeF(13F, 32F);
@@ -135,5 +166,8 @@
         private Label labelM4;
         private TextBox textM4;
         private TextBox textM3;
+        private TextBox textFNF4;
+        private ComboBox comboFNF4;
+        private Label labelFNF4;
     }
 }

Keyboard.cs

@@ -2,71 +2,68 @@
 {
     public partial class Keyboard : Form
     {
+
+        Dictionary<string, string> customActions = new Dictionary<string, string>
+        {
+          {"","--------------" },
+          {"mute", "Volume Mute"},
+          {"screenshot", "Screenshot"},
+          {"play", "Play/Pause"},
+          {"aura", "Aura"},
+          {"ghelper", "Open GHelper"},
+          {"custom", "Custom"}
+        };
+
+        private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
+        {
+            if (name == "m4")
+                customActions[""] = "Performance";
+
+            if (name == "fnf4")
+            {
+                customActions[""] = "Aura";
+                customActions.Remove("aura");
+            }
+
+            combo.DropDownStyle = ComboBoxStyle.DropDownList;
+            combo.DataSource = new BindingSource(customActions, null);
+            combo.DisplayMember = "Value";
+            combo.ValueMember = "Key";
+
+            string action = Program.config.getConfigString(name);
+
+            combo.SelectedValue = (action is not null) ? action : "";
+            if (combo.SelectedValue is null) combo.SelectedValue = "";
+
+            combo.SelectedValueChanged += delegate
+            {
+                if (combo.SelectedValue is not null)
+                    Program.config.setConfig(name, combo.SelectedValue.ToString());
+            };
+
+            txbox.Text = Program.config.getConfigString(name + "_custom");
+            txbox.TextChanged += delegate
+            {
+                Program.config.setConfig(name + "_custom", txbox.Text);
+            };
+        }
+
         public Keyboard()
         {
             InitializeComponent();
 
-            comboM3.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboM3.SelectedIndex = 0;
-
-            comboM4.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboM4.SelectedIndex = 0;
-
-            comboM3.SelectedValueChanged += ComboM3_SelectedValueChanged;
-            comboM4.SelectedValueChanged += ComboM4_SelectedValueChanged;
-
-            textM3.TextChanged += TextM3_TextChanged;
-            textM4.TextChanged += TextM4_TextChanged;
+            SetKeyCombo(comboM3, textM3, "m3");
+            SetKeyCombo(comboM4, textM4, "m4");
+            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
 
             Shown += Keyboard_Shown;
         }
 
-        private void TextM3_TextChanged(object? sender, EventArgs e)
-        {
-            if (sender is null) return;
-            TextBox tb = (TextBox)sender;
-            Program.config.setConfig("m3_custom", tb.Text);
-        }
-
-        private void TextM4_TextChanged(object? sender, EventArgs e)
-        {
-            if (sender is null) return;
-            TextBox tb = (TextBox)sender;
-            Program.config.setConfig("m4_custom", tb.Text);
-        }
-
-        private void ComboM4_SelectedValueChanged(object? sender, EventArgs e)
-        {
-            if (sender is null) return;
-            ComboBox cmb = (ComboBox)sender;
-            Program.config.setConfig("m4", cmb.SelectedIndex);
-        }
-
-        private void ComboM3_SelectedValueChanged(object? sender, EventArgs e)
-        {
-            if (sender is null) return;
-            ComboBox cmb = (ComboBox)sender;
-            Program.config.setConfig("m3", cmb.SelectedIndex);
-        }
 
         private void Keyboard_Shown(object? sender, EventArgs e)
         {
-
             Top = Program.settingsForm.Top;
             Left = Program.settingsForm.Left - Width - 5;
-
-            int m3 = Program.config.getConfig("m3");
-            int m4 = Program.config.getConfig("m4");
-
-            if (m3 != -1)
-                comboM3.SelectedIndex = m3;
-
-            if (m4 != -1)
-                comboM4.SelectedIndex = m4;
-
-            textM3.Text = Program.config.getConfigString("m3_custom");
-            textM4.Text = Program.config.getConfigString("m4_custom");
-
         }
     }
 }

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Serge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

NativeMethods.cs

@@ -1,9 +1,372 @@
-using System.Diagnostics;
+using System.Collections;
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
+using static Tools.ScreenInterrogatory;
+using System.Windows.Forms;
+
+namespace Tools
+{
+    public static class ScreenInterrogatory
+    {
+        public const int ERROR_SUCCESS = 0;
+
+        #region enums
+
+        public enum QUERY_DEVICE_CONFIG_FLAGS : uint
+        {
+            QDC_ALL_PATHS = 0x00000001,
+            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
+            QDC_DATABASE_CURRENT = 0x00000004
+        }
+
+        public enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY : uint
+        {
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = 0xFFFFFFFF,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_SCANLINE_ORDERING : uint
+        {
+            DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
+            DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST = DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
+            DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_ROTATION : uint
+        {
+            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
+            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
+            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
+            DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
+            DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_SCALING : uint
+        {
+            DISPLAYCONFIG_SCALING_IDENTITY = 1,
+            DISPLAYCONFIG_SCALING_CENTERED = 2,
+            DISPLAYCONFIG_SCALING_STRETCHED = 3,
+            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
+            DISPLAYCONFIG_SCALING_CUSTOM = 5,
+            DISPLAYCONFIG_SCALING_PREFERRED = 128,
+            DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_PIXELFORMAT : uint
+        {
+            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
+            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
+            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
+            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
+            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
+            DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff
+        }
+
+        public enum DISPLAYCONFIG_MODE_INFO_TYPE : uint
+        {
+            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
+            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
+            DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_DEVICE_INFO_TYPE : uint
+        {
+            DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
+            DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
+            DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
+            DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        #endregion
+
+        #region structs
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct LUID
+        {
+            public uint LowPart;
+            public int HighPart;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_SOURCE_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public uint statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_TARGET_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            private DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            private DISPLAYCONFIG_ROTATION rotation;
+            private DISPLAYCONFIG_SCALING scaling;
+            private DISPLAYCONFIG_RATIONAL refreshRate;
+            private DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+            public bool targetAvailable;
+            public uint statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_RATIONAL
+        {
+            public uint Numerator;
+            public uint Denominator;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_INFO
+        {
+            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
+            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
+            public uint flags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_2DREGION
+        {
+            public uint cx;
+            public uint cy;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
+        {
+            public ulong pixelRate;
+            public DISPLAYCONFIG_RATIONAL hSyncFreq;
+            public DISPLAYCONFIG_RATIONAL vSyncFreq;
+            public DISPLAYCONFIG_2DREGION activeSize;
+            public DISPLAYCONFIG_2DREGION totalSize;
+            public uint videoStandard;
+            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_TARGET_MODE
+        {
+            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct POINTL
+        {
+            private int x;
+            private int y;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_SOURCE_MODE
+        {
+            public uint width;
+            public uint height;
+            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
+            public POINTL position;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public struct DISPLAYCONFIG_MODE_INFO_UNION
+        {
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_TARGET_MODE targetMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_MODE_INFO
+        {
+            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
+            public uint id;
+            public LUID adapterId;
+            public DISPLAYCONFIG_MODE_INFO_UNION modeInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
+        {
+            public uint value;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_DEVICE_INFO_HEADER
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
+            public uint size;
+            public LUID adapterId;
+            public uint id;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            public DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
+            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            public ushort edidManufactureId;
+            public ushort edidProductCodeId;
+            public uint connectorInstance;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+            public string monitorFriendlyDeviceName;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            public string monitorDevicePath;
+        }
+
+        #endregion
+
+        #region DLL-Imports
+
+        [DllImport("user32.dll")]
+        public static extern int GetDisplayConfigBufferSizes(
+            QUERY_DEVICE_CONFIG_FLAGS flags, out uint numPathArrayElements, out uint numModeInfoArrayElements);
+
+        [DllImport("user32.dll")]
+        public static extern int QueryDisplayConfig(
+            QUERY_DEVICE_CONFIG_FLAGS flags,
+            ref uint numPathArrayElements, [Out] DISPLAYCONFIG_PATH_INFO[] PathInfoArray,
+            ref uint numModeInfoArrayElements, [Out] DISPLAYCONFIG_MODE_INFO[] ModeInfoArray,
+            IntPtr currentTopologyId
+            );
+
+        [DllImport("user32.dll")]
+        public static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName);
+
+        #endregion
+
+        private static DISPLAYCONFIG_TARGET_DEVICE_NAME DeviceName(LUID adapterId, uint targetId)
+        {
+            var deviceName = new DISPLAYCONFIG_TARGET_DEVICE_NAME
+            {
+                header =
+                {
+                    size = (uint)Marshal.SizeOf(typeof (DISPLAYCONFIG_TARGET_DEVICE_NAME)),
+                    adapterId = adapterId,
+                    id = targetId,
+                    type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
+                }
+            };
+            var error = DisplayConfigGetDeviceInfo(ref deviceName);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            return deviceName;
+        }
+
+        public static IEnumerable<DISPLAYCONFIG_TARGET_DEVICE_NAME> GetAllDevices()
+        {
+            uint pathCount, modeCount;
+            var error = GetDisplayConfigBufferSizes(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS, out pathCount, out modeCount);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            var displayPaths = new DISPLAYCONFIG_PATH_INFO[pathCount];
+            var displayModes = new DISPLAYCONFIG_MODE_INFO[modeCount];
+            error = QueryDisplayConfig(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS,
+                ref pathCount, displayPaths, ref modeCount, displayModes, IntPtr.Zero);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            for (var i = 0; i < modeCount; i++)
+                if (displayModes[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE.DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
+                    yield return DeviceName(displayModes[i].adapterId, displayModes[i].id);
+        }
+
+
+    }
+
+}
 
 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;
 
@@ -11,6 +374,7 @@ public class NativeMethods
     public const int VK_MEDIA_PLAY_PAUSE = 0xB3;
     public const int VK_MEDIA_PREV_TRACK = 0xB1;
     public const int VK_VOLUME_MUTE = 0xAD;
+    public const int VK_SNAPSHOT = 0x2C;
 
     [DllImport("user32.dll", SetLastError = true)]
     public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
@@ -94,6 +458,15 @@ public class NativeMethods
     static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
     static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
 
+    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
+    public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
+
+    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetEffectiveOverlayScheme")]
+    public static extern uint PowerGetEffectiveOverlayScheme(out Guid EffectiveOverlayGuid);
+
+    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerSetActiveOverlayScheme")]
+    public static extern uint PowerSetActiveOverlayScheme(Guid OverlaySchemeGuid);
+
     [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
     public struct DEVMODE
     {
@@ -159,11 +532,6 @@ public class NativeMethods
             string lpszDeviceName, ref DEVMODE lpDevMode, IntPtr hwnd,
             DisplaySettingsFlags dwflags, IntPtr lParam);
 
-
-    public const int ENUM_CURRENT_SETTINGS = -1;
-
-    public const string laptopScreenName = "\\\\.\\DISPLAY1";
-
     public static DEVMODE CreateDevmode()
     {
         DEVMODE dm = new DEVMODE();
@@ -173,34 +541,67 @@ public class NativeMethods
         return dm;
     }
 
-    public static Screen FindLaptopScreen()
-    {
-        var screens = Screen.AllScreens;
-        Screen laptopScreen = null;
+    public const int ENUM_CURRENT_SETTINGS = -1;
+    public const string defaultDevice = "\\\\.\\DISPLAY1";
 
-        foreach (var screen in screens)
+    public static string FindLaptopScreen()
+    {
+        string laptopScreen = null;
+
+        try
         {
-            if (screen.DeviceName == laptopScreenName)
+            var devices = GetAllDevices().ToArray();
+            int count = 0, displayNum = -1;
+
+            foreach (var device in devices)
             {
-                laptopScreen = screen;
+                if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
+                    device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED)
+                {
+                    displayNum = count;
+                }
+                count++;
+                //Logger.WriteLine(device.outputTechnology.ToString());
+                //Logger.WriteLine(device.monitorFriendlyDeviceName);
+            }
+
+            var screens = Screen.AllScreens;
+
+            if (screens.Length != count) return null;
+
+            count = 0;
+            foreach (var screen in screens)
+            {
+                if (count == displayNum)
+                {
+                    laptopScreen = screen.DeviceName;
+                }
+                //Logger.WriteLine(screen.DeviceName);
+                count++;
             }
         }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.ToString());
+            Logger.WriteLine("Can't detect internal screen");
+            //laptopScreen = Screen.PrimaryScreen.DeviceName;
+        }
 
-        if (laptopScreen is null) return null;
-        else return laptopScreen;
+
+        return laptopScreen;
     }
 
     public static int GetRefreshRate()
     {
         DEVMODE dm = CreateDevmode();
 
-        Screen laptopScreen = FindLaptopScreen();
+        string laptopScreen = FindLaptopScreen();
         int frequency = -1;
 
         if (laptopScreen is null)
             return -1;
 
-        if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen.DeviceName, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
+        if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
         {
             frequency = dm.dmDisplayFrequency;
         }
@@ -211,15 +612,15 @@ public class NativeMethods
     public static int SetRefreshRate(int frequency = 120)
     {
         DEVMODE dm = CreateDevmode();
-        Screen laptopScreen = FindLaptopScreen();
+        string laptopScreen = FindLaptopScreen();
 
         if (laptopScreen is null)
             return -1;
 
-        if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen.DeviceName, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
+        if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
         {
             dm.dmDisplayFrequency = frequency;
-            int iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen.DeviceName, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
+            int iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
             return iRet;
         }
 
@@ -262,6 +663,7 @@ public class NativeMethods
 
         PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
 
+        /*
         var hrDC = PowerWriteDCValueIndex(
              IntPtr.Zero,
              activeSchemeGuid,
@@ -270,7 +672,23 @@ public class NativeMethods
              boost);
 
         PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
-
+        */
 
     }
+
+    public static void SetPowerScheme(int mode)
+    {
+        switch (mode)
+        {
+            case 0: // balanced
+                PowerSetActiveOverlayScheme(new Guid("00000000-0000-0000-0000-000000000000"));
+                break;
+            case 1: // turbo
+                PowerSetActiveOverlayScheme(new Guid("ded574b5-45a0-4f42-8737-46345c09c238"));
+                break;
+            case 2: //silent
+                PowerSetActiveOverlayScheme(new Guid("961cc777-2547-4f9d-8174-7d86181b8a7a"));
+                break;
+        }
+    }
 }

Program.cs

@@ -1,109 +1,41 @@
 using Microsoft.Win32;
 using System.Diagnostics;
 using System.Management;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Text.Json;
-
-public class AppConfig
+public static class Logger
 {
+    static string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+    static string logFile = appPath + "\\log.txt";
 
-    string appPath;
-    string configFile;
-
-    public Dictionary<string, object> config = new Dictionary<string, object>();
-
-    public AppConfig()
+    public static void WriteLine(string logMessage)
     {
-
-        appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
-        configFile = appPath + "\\config.json";
-
-        if (!System.IO.Directory.Exists(appPath))
-            System.IO.Directory.CreateDirectory(appPath);
-
-        if (File.Exists(configFile))
-        {
-            string text = File.ReadAllText(configFile);
-            try
-            {
-                config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
-            }
-            catch
-            {
-                initConfig();
-            }
-        }
-        else
-        {
-            initConfig();
-        }
-
-    }
-
-    private void initConfig()
-    {
-        config = new Dictionary<string, object>();
-        config["performance_mode"] = 0;
-        string jsonString = JsonSerializer.Serialize(config);
-        File.WriteAllText(configFile, jsonString);
-    }
-
-    public int getConfig(string name)
-    {
-        if (config.ContainsKey(name))
-            return int.Parse(config[name].ToString());
-        else return -1;
-    }
-
-    public string getConfigString(string name)
-    {
-        if (config.ContainsKey(name))
-            return config[name].ToString();
-        else return null;
-    }
-
-    public void setConfig(string name, int value)
-    {
-        config[name] = value;
-        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(configFile, jsonString);
-    }
-
-    public void setConfig(string name, string value)
-    {
-        config[name] = value;
-        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
-        File.WriteAllText(configFile, jsonString);
-    }
-
-
-}
-
-public class HardwareMonitor
-{
-
-    public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -1;
-
-
-    public static void ReadSensors()
-    {
-        cpuTemp = -1;
-        batteryDischarge = -1;
+        Debug.WriteLine(logMessage);
+        if (!Directory.Exists(appPath)) Directory.CreateDirectory(appPath);
 
         try
         {
-            var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
-            cpuTemp = ct.NextValue() - 273;
-            ct.Dispose();
+            using (StreamWriter w = File.AppendText(logFile))
+            {
+                w.WriteLine($"{DateTime.Now}: {logMessage}");
+                w.Close();
+            }
+        } catch { }
 
-            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
-            batteryDischarge = cb.NextValue() / 1000;
-            cb.Dispose();
-        }
-        catch
+        if (new Random().Next(100) == 1) Cleanup();
+
+
+    }
+
+    public static void Cleanup()
+    {
+        try
         {
-            Debug.WriteLine("Failed reading sensors");
-        }
+            var file = File.ReadAllLines(logFile);
+            int skip = Math.Max(0, file.Count() - 500);
+            File.WriteAllLines(logFile, file.Skip(skip).ToArray());
+        } catch { }
     }
 
 }
@@ -112,6 +44,8 @@ namespace GHelper
 {
     static class Program
     {
+
+
         public static NotifyIcon trayIcon = new NotifyIcon
         {
             Text = "G-Helper",
@@ -119,51 +53,127 @@ namespace GHelper
             Visible = true
         };
 
-        public static ASUSWmi wmi = new ASUSWmi();
+        public static ASUSWmi wmi;
         public static AppConfig config = new AppConfig();
 
         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()
         {
+            try
+            {
+                wmi = new ASUSWmi();
+            }
+            catch
+            {
+                DialogResult dialogResult = MessageBox.Show("Can't connect to ASUS ACPI. Application can't function without it. Try to install Asus System Controll Interface", "Startup Error", MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Process.Start(new ProcessStartInfo("https://www.asus.com/support/FAQ/1047338/") { UseShellExecute = true });
+                }
+
+                Application.Exit();
+                return;
+
+            }
+
+            Application.EnableVisualStyles();
+
+            ds = settingsForm.Handle;
 
             trayIcon.MouseClick += TrayIcon_MouseClick; ;
 
             wmi.SubscribeToEvents(WatcherEventArrived);
 
             settingsForm.InitGPUMode();
-            settingsForm.InitBoost();
             settingsForm.InitAura();
-
-            settingsForm.SetPerformanceMode(config.getConfig("performance_mode"));
-            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
+            settingsForm.InitMatrix();
 
             settingsForm.VisualiseGPUAuto(config.getConfig("gpu_auto"));
             settingsForm.VisualiseScreenAuto(config.getConfig("screen_auto"));
-
             settingsForm.SetStartupCheck(Startup.IsScheduled());
 
-            bool isPlugged = (System.Windows.Forms.SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online);
-            settingsForm.AutoGPUMode(isPlugged ? 1 : 0);
-            settingsForm.AutoScreen(isPlugged ? 1 : 0);
+            SetAutoModes();
+            HardwareMonitor.RecreateGpuTemperatureProvider();
 
+            // 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 void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        static async void CheckForUpdates()
         {
-            bool isPlugged = (System.Windows.Forms.SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online);
-            settingsForm.AutoGPUMode(isPlugged ? 1 : 0);
-            settingsForm.AutoScreen(isPlugged ? 1 : 0);
+
+            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;
+
+            Logger.WriteLine("AutoSetting for " + isPlugged.ToString());
 
             settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
+
+            settingsForm.AutoPerformance(isPlugged);
+            
+            bool switched = settingsForm.AutoGPUMode(isPlugged);
+            if (!switched) settingsForm.AutoScreen(isPlugged);
+
+            settingsForm.SetMatrix(isPlugged);
+        }
+
+        private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        {
+            Logger.WriteLine("Windows - Power Mode Changed");
+            SetAutoModes();
         }
 
 
@@ -176,14 +186,78 @@ namespace GHelper
             try
             {
                 Process proc = Process.Start(start);
-            } catch 
+            }
+            catch
             {
-                Debug.WriteLine("Failed to run " + fileName);
+                Logger.WriteLine("Failed to run " + fileName);
             }
 
 
         }
 
+        static void CustomKey(string configKey = "m3")
+        {
+            string command = config.getConfigString(configKey + "_custom");
+            int intKey;
+
+            try
+            {
+                intKey = Convert.ToInt32(command, 16);
+            }
+            catch
+            {
+                intKey = -1;
+            }
+
+
+            if (intKey > 0)
+                NativeMethods.KeyPress(intKey);
+            else
+                LaunchProcess(command);
+
+        }
+
+        static void KeyProcess(string name = "m3")
+        {
+            string action = config.getConfigString(name);
+
+            if (action is null || action.Length <= 1)
+            {
+                if (name == "m4")
+                    action = "performance";
+                if (name == "fnf4")
+                    action = "aura";
+            }
+
+            switch (action)
+            {
+                case "mute":
+                    NativeMethods.KeyPress(NativeMethods.VK_VOLUME_MUTE);
+                    break;
+                case "play":
+                    NativeMethods.KeyPress(NativeMethods.VK_MEDIA_PLAY_PAUSE);
+                    break;
+                case "screenshot":
+                    NativeMethods.KeyPress(NativeMethods.VK_SNAPSHOT);
+                    break;
+                case "aura":
+                    settingsForm.BeginInvoke(settingsForm.CycleAuraMode);
+                    break;
+                case "performance":
+                    settingsForm.BeginInvoke(settingsForm.CyclePerformanceMode);
+                    break;
+                case "ghelper":
+                    settingsForm.BeginInvoke(SettingsToggle);
+                    break;
+                case "custom":
+                    CustomKey(name);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+
         static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
         {
             var collection = (ManagementEventWatcher)sender;
@@ -192,69 +266,22 @@ namespace GHelper
 
             int EventID = int.Parse(e.NewEvent["EventID"].ToString());
 
-            Debug.WriteLine(EventID);
+            Logger.WriteLine("WMI event " + EventID);
 
             switch (EventID)
             {
                 case 124:    // M3
-                    switch (config.getConfig("m3"))
-                    {
-                        case 1:
-                            NativeMethods.KeyPress(NativeMethods.VK_MEDIA_PLAY_PAUSE);
-                            break;
-                        case 2:
-                            settingsForm.BeginInvoke(settingsForm.CycleAuraMode);
-                            break;
-                        case 3:
-                            LaunchProcess(config.getConfigString("m3_custom"));
-                            break;
-                        default:
-                            NativeMethods.KeyPress(NativeMethods.VK_VOLUME_MUTE);
-                            break;
-                    }
+                    KeyProcess("m3");
                     return;
                 case 56:    // M4 / Rog button
-                    switch (config.getConfig("m4"))
-                    {
-                        case 1:
-                            settingsForm.BeginInvoke(SettingsToggle);
-                            break;
-                        case 2:
-                            LaunchProcess(config.getConfigString("m4_custom"));
-                            break;
-                        default:
-                            settingsForm.BeginInvoke(settingsForm.CyclePerformanceMode);
-                            break;
-                    }
+                    KeyProcess("m4");
                     return;
                 case 174:   // FN+F5
                     settingsForm.BeginInvoke(settingsForm.CyclePerformanceMode);
                     return;
                 case 179:   // FN+F4
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.CycleAuraMode();
-                    });
+                    KeyProcess("fnf4");
                     return;
-                case 87:  // Battery
-                    /*
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.AutoGPUMode(0);
-                        settingsForm.AutoScreen(0);
-                    });
-                    */
-                    return;
-                case 88:  // Plugged
-                    /*
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.AutoScreen(1);
-                        settingsForm.AutoGPUMode(1);
-                    });
-                    */
-                    return;
-
             }
 
 
@@ -269,6 +296,9 @@ namespace GHelper
                 settingsForm.Show();
                 settingsForm.Activate();
             }
+
+            settingsForm.VisualiseGPUMode();
+
         }
 
         static void TrayIcon_MouseClick(object? sender, MouseEventArgs e)
@@ -284,6 +314,7 @@ namespace GHelper
         static void OnExit(object sender, EventArgs e)
         {
             trayIcon.Visible = false;
+            NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotify);
             Application.Exit();
         }
     }

Properties/Resources.Designer.cs

@@ -70,6 +70,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap everything_is_fine_itsfine {
+            get {
+                object obj = ResourceManager.GetObject("everything-is-fine-itsfine", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -110,6 +120,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_matrix_desktop_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-matrix-desktop-48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <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>

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>
@@ -133,19 +136,25 @@
   <data name="icons8-speed-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-speed-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="everything-is-fine-itsfine" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\everything-is-fine-itsfine.gif;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-speed-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-speed-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-video-card-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-video-card-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-fan-head-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-fan-head-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-charging-battery-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-charging-battery-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <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-fan-head-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-fan-head-96.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>

README.md

@@ -1,36 +1,48 @@
-# G-Helper (For G14, G15, ROG FLOW, and others)
+# G-Helper | GHelper 
 
-A small utility that allows you do almost everyting you could do with Armory Crate but without extra bloat and unnecessary services.
+## Open source Armory Crate alternative for Asus ROG Zephyrus G14, G15, Flow X13, Flow X16, and other models
 
-1. Switch between default **Performance modes** - Silent / Balanced / Turbo and apply default fan curves
-2. Switch between Eco / Standard or Ultimate **GPU modes**
-3. Change laptop screen refresh rate - 60hz or your maximum (120hz, 144hz, etc depending on the model) with display overdrive (OD)
-4. View default fan profiles for every mode and apply custom ones
-5. Control keyboard backlit animation and colors
-6. Set battery charge limit to preserve battery
-7. Monitor CPU temperature, fan speeds and battery discharge rate
-8. **Automatically switch to Eco(iGPU)/60hz on battery** and back to Standard(GPU)/120hz modes when plugged
-9. Support for M4 key / FN+F5 to cycle through performance modes (with OSD notification) and FN+F4 to cycle through keeyboard animation modes
-10. Basic keybindings for M3 amd M4 keys
-11. Turn cpu turbo boost on/off with one checkbox to keep temps cooler
+A small utility that allows you to do almost everything you could do with Armory Crate but without extra bloat and unnecessary services.
 
-Designed and developer for Asus Zephyrus G14 2022 (with AMD Radeon iGPU and dGPU). But could and should potentially work for G14 of 2021 and 2020, G15, X FLOW, and other ROG models for relevant and supported features.
+## Main advantages 
 
-To keep autoswitching and hotkeys work app needs to stay in running in tray. It doesn't consume any resources. 
+1. Seamless and automatic GPU switching (without asking you to close all apps, etc)
+2. All performance modes can be fully customized (with fan curves and PPTs)
+3. Very lightweight and consumes almost no resources, doesn't install any services. Just a single exe to run
 
-I also 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. 
+## [Download latest release](https://github.com/seerge/g-helper/releases)
 
-### [Download latest release](https://github.com/seerge/g-helper/releases)
+![Screenshot](https://raw.githubusercontent.com/seerge/g-helper/main/screenshot.png)
 
-![Screenshot](https://github.com/seerge/g-helper/blob/main/screenshot.png)
+## Main features
 
-## Performance Profile switching 
+1. Built-in **Performance modes**: Silent - Balanced - Turbo (with default fan curves)
+2. **GPU modes**: Eco -Standard - Ultimate 
+3. Laptop screen refresh rate 60hz or 120hz (144hz, etc depending on the model) with display overdrive (OD)
+4. Default and custom fan profiles for every performance mode
+5. Power limits (PPT) for every performance mode
+6. CPU urbo boost mode
+7. Keyboard backlit animation and colors
+8. Anime matrix control thanks to [Starlight](https://github.com/vddCore/Starlight) + some tweaks from my side (including animated GIFs)
+9. FN+F5 to cycle through performance modes (with OSD notification) and FN+F4 to cycle through keyboard animation modes
+10. Keybindings for M3 and M4 keys
+11. Battery charge limit to preserve battery health
+12. Monitor CPU / GPU temperature, fan speeds and battery discharge rate
 
-Profiles are **same** as in Armory Crate, including default fan curves
+## Automatic switching of modes when on battery or plugged in
+- Performance modes
+- GPU modes
+- Screen refresh rate
 
-1. Silent (minimal or no fans, 70W PPT total, up to 45W PPT to CPU)
-2. Balanced (balanced fans, 100W PPT total, up to 45W PPT to CPU)
-3. Turbo (intense fans, 125W PPT total, up to 80W PPT to CPU) 
+To keep auto switching and hotkeys working the app needs to stay in running in the tray. It doesn't consume any resources. 
+
+## Performance Modes
+
+Modes are **same** as in Armory Crate (as they are stored in bios), including default fan curves
+
+1. Silent (minimal or no fans, 70W PPT total, up to 45W PPT to CPU) + Best power efficiency setting in windows
+2. Balanced (balanced fans, 100W PPT total, up to 45W PPT to CPU) + Balanced setting in windows
+3. Turbo (intense fans, 125W PPT total, up to 80W PPT to CPU) + Best performance setting in windows
 
 PPTs are shown for G14 2022, for other models PPTs will be different as they are set in bios.
 
@@ -40,29 +52,39 @@ PPTs are shown for G14 2022, for other models PPTs will be different as they are
 2. Standard mode (Windows Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
 3. Ultimate mode: iGPU and dGPU enabled, but dGPU drives built in display (supported only on G14 2022 model)
 
-## Things still missing
-
-1. Anime matrix control
-
 ## 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**
 
-Note: Uses low level ASUS ACPI commands to do switching and doens't require Armory Crate to be isntalled at all. 
-Doesn't require administrator privileges to run (anymore)!
+### Dependencies
 
-I don`t have Microsoft certificate to sign app yet, so if you set a warning from Windows Defender on launch (Windows Protected your PC), click More Info -> Run anyway.
+- 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).
 
-Alternatively you can comile and run project by yourself :)
-Settings file is storer at %AppData%\GHelper
+- I recommend keeping "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 and running even after MyASUS uninstalls. It's part of [Asus System Control Interface](https://www.asus.com/support/FAQ/1047338/). You can install it, and later disable / remove unnecessary services by running [this bat file](https://raw.githubusercontent.com/seerge/g-helper/main/stop-asus-sv.bat) as admin.
 
-P.S.: It's not recommended to use app in combination with Armory Crate, cause they adjust same settings.
-Please keep in mind, that if you also run MyASUS app periodically it will also try to adjust same battery charge settings
+- It's not recommended to use an app in combination with Armory Crate, cause they adjust the same settings. You can [uninstall it using it's own uninstall tool](https://dlcdnets.asus.com/pub/ASUS/mb/14Utilities/Armoury_Crate_Uninstall_Tool.zip?model=armoury%20crate). Just in case, you can always install it back later.
+
+Note: Doesn't need administrator privileges to run!
+
+-------------------------------
+
+Designed and developed for Asus Zephyrus G14 2022 (with AMD Radeon iGPU and dGPU). But could and should potentially work for G14 of 2021 and 2020, G15, X FLOW, and other ROG models for relevant and supported features.
+
+I don't have a Microsoft certificate to sign the 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 :)
+
+Settings file is stored at %AppData%\GHelper
 
 ------------------
 
 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.

Settings.cs

@@ -1,7 +1,8 @@
-using System.Diagnostics;
-using System.Reflection;
+using Starlight.AnimeMatrix;
+using System.Diagnostics;
+using System.Drawing.Imaging;
 using System.Timers;
-using System.Windows.Forms.DataVisualization.Charting;
+
 
 namespace GHelper
 {
@@ -17,12 +18,17 @@ namespace GHelper
         static int buttonActive = 5;
 
         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;
+
         public SettingsForm()
         {
 
@@ -55,13 +61,12 @@ namespace GHelper
 
             buttonQuit.Click += ButtonQuit_Click;
 
-            checkBoost.Click += CheckBoost_Click;
+            checkGPU.CheckedChanged += CheckGPU_CheckedChanged;
 
             checkScreen.CheckedChanged += checkScreen_CheckedChanged;
 
             comboKeyboard.DropDownStyle = ComboBoxStyle.DropDownList;
             comboKeyboard.SelectedIndex = 0;
-
             comboKeyboard.SelectedValueChanged += ComboKeyboard_SelectedValueChanged;
 
             buttonKeyboardColor.Click += ButtonKeyboardColor_Click;
@@ -72,18 +77,270 @@ namespace GHelper
             pictureColor.Click += PictureColor_Click;
             pictureColor2.Click += PictureColor2_Click;
 
-            labelVersion.Text = "Version " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
+            labelCPUFan.Click += LabelCPUFan_Click;
+            labelGPUFan.Click += LabelCPUFan_Click;
+
+            comboMatrix.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboMatrixRunning.DropDownStyle = ComboBoxStyle.DropDownList;
+
+            comboMatrix.DropDownClosed += ComboMatrix_SelectedValueChanged;
+            comboMatrixRunning.DropDownClosed += ComboMatrixRunning_SelectedValueChanged;
+
+            checkMatrix.CheckedChanged += CheckMatrix_CheckedChanged; ;
+
+            buttonMatrix.Click += ButtonMatrix_Click;
+
+            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;
+            CheckBox chk = (CheckBox)sender;
+
+            if (chk.Checked)
+            {
+                Startup.Schedule();
+            }
+            else
+            {
+                Startup.UnSchedule();
+            }
+        }
+
+        private void CheckMatrix_CheckedChanged(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            CheckBox check = (CheckBox)sender;
+            Program.config.setConfig("matrix_auto", check.Checked ? 1 : 0);
+        }
+
+        private static void StartMatrixTimer()
+        {
+            matrixTimer.Enabled = true;
+        }
+
+        private static void StopMatrixTimer()
+        {
+            matrixTimer.Enabled = false;
+        }
+
+        private static void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
+        {
+            if (mat is null) return;
+            mat.PresentNextFrame();
+        }
+
+        void SetMatrixPicture(string fileName)
+        {
+
+            if (mat is null) return;
+
+            StopMatrixTimer();
+
+            Image image;
+
+            try
+            {
+                using (var fs = new FileStream(fileName, FileMode.Open))
+                {
+                    var ms = new MemoryStream();
+                    fs.CopyTo(ms);
+                    ms.Position = 0;
+                    image = Image.FromStream(ms);
+                }
+            }
+            catch
+            {
+                Debug.WriteLine("Error loading picture");
+                return;
+            }
+
+            mat.SetBuiltInAnimation(false);
+            mat.ClearFrames();
+
+            FrameDimension dimension = new FrameDimension(image.FrameDimensionsList[0]);
+            int frameCount = image.GetFrameCount(dimension);
+
+            if (frameCount > 1)
+            {
+                for (int i = 0; i < frameCount; i++)
+                {
+                    image.SelectActiveFrame(dimension, i);
+                    mat.GenerateFrame(image);
+                    mat.AddFrame();
+                }
+
+                StartMatrixTimer();
+            }
+            else
+            {
+                mat.GenerateFrame(image);
+                mat.Present();
+            }
 
 
         }
 
-        private void LabelVersion_Click(object? sender, EventArgs e)
+
+        private void ButtonMatrix_Click(object? sender, EventArgs e)
         {
-            Process.Start(new ProcessStartInfo("http://github.com/seerge/g-helper/releases") { UseShellExecute = true });
+            string fileName = null;
+
+            Thread t = new Thread(() =>
+            {
+                OpenFileDialog of = new OpenFileDialog();
+                of.Filter = "Image Files (*.bmp;*.jpg;*.jpeg,*.png,*.gif)|*.BMP;*.JPG;*.JPEG;*.PNG;*.GIF";
+                if (of.ShowDialog() == DialogResult.OK)
+                {
+                    fileName = of.FileName;
+                }
+                return;
+            });
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+
+            if (fileName is not null)
+            {
+                Program.config.setConfig("matrix_picture", fileName);
+                SetMatrixPicture(fileName);
+                BeginInvoke(delegate
+                {
+                    comboMatrixRunning.SelectedIndex = 2;
+                });
+            }
+
+
+        }
+
+        private void ComboMatrixRunning_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("matrix_running", comboMatrixRunning.SelectedIndex);
+            SetMatrix();
+        }
+
+
+        private void ComboMatrix_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("matrix_brightness", comboMatrix.SelectedIndex);
+            SetMatrix();
+        }
+
+        public void SetMatrix(PowerLineStatus Plugged = PowerLineStatus.Online)
+        {
+
+            if (mat is null) return;
+
+            int brightness = Program.config.getConfig("matrix_brightness");
+            int running = Program.config.getConfig("matrix_running");
+            bool auto = Program.config.getConfig("matrix_auto") == 1;
+
+            if (brightness < 0) brightness = 0;
+            if (running < 0) running = 0;
+
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                BuiltInAnimation.Sleeping.Starfield,
+                BuiltInAnimation.Shutdown.SeeYa,
+                BuiltInAnimation.Startup.StaticEmergence
+            );
+
+            StopMatrixTimer();
+
+            mat.SetProvider();
+
+            if (brightness == 0 || (auto && Plugged != PowerLineStatus.Online))
+            {
+                mat.SetDisplayState(false);
+            }
+            else
+            {
+                mat.SetDisplayState(true);
+                mat.SetBrightness((BrightnessMode)brightness);
+
+                if (running == 2)
+                {
+                    string fileName = Program.config.getConfigString("matrix_picture");
+                    SetMatrixPicture(fileName);
+                }
+                else
+                {
+                    mat.SetBuiltInAnimation(true, animation);
+                }
+
+            }
+
+        }
+
+
+
+        private void LabelCPUFan_Click(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("fan_rpm", (Program.config.getConfig("fan_rpm") == 1) ? 0 : 1);
+            RefreshSensors();
         }
 
         private void PictureColor2_Click(object? sender, EventArgs e)
@@ -122,13 +379,19 @@ namespace GHelper
             if (fans == null || fans.Text == "")
             {
                 fans = new Fans();
-                fans.Show();
+                //Debug.WriteLine("Starting fans");
+            }
+
+            if (fans.Visible)
+            {
+                fans.Hide();
             }
             else
             {
-                fans.Close();
+                fans.Show();
             }
 
+
         }
 
         private void ButtonKeyboardColor_Click(object? sender, EventArgs e)
@@ -173,10 +436,35 @@ namespace GHelper
             SetAuraMode(mode, false);
 
             Aura.Mode = mode;
+        }
+
+        public void InitMatrix()
+        {
+
+            try
+            {
+                mat = new AnimeMatrixDevice();
+                matrixTimer = new System.Timers.Timer(100);
+                matrixTimer.Elapsed += MatrixTimer_Elapsed;
+            }
+            catch
+            {
+                panelMatrix.Visible = false;
+                return;
+            }
+
+            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);
 
 
         }
 
+
         public void SetAuraColor(Color? color1 = null, Color? color2 = null, bool apply = true)
         {
 
@@ -205,14 +493,14 @@ namespace GHelper
 
             //Debug.WriteLine(mode);
 
-            if (mode > 3) mode = 0;
+            if (mode > 4) mode = 0;
 
             pictureColor2.Visible = (mode == Aura.Breathe);
 
             if (Aura.Mode == mode) return; // same mode
 
-
             Aura.Mode = mode;
+
             Program.config.setConfig("aura_mode", mode);
 
             comboKeyboard.SelectedValueChanged -= ComboKeyboard_SelectedValueChanged;
@@ -238,19 +526,6 @@ namespace GHelper
             SetAuraMode(cmb.SelectedIndex);
         }
 
-
-        private void CheckBoost_Click(object? sender, EventArgs e)
-        {
-            if (sender is null)
-                return;
-
-            CheckBox chk = (CheckBox)sender;
-            if (chk.Checked)
-                NativeMethods.SetCPUBoost(2);
-            else
-                NativeMethods.SetCPUBoost(0);
-        }
-
         private void Button120Hz_Click(object? sender, EventArgs e)
         {
             SetScreen(1000, 1);
@@ -266,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)
             {
@@ -276,28 +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 InitBoost()
-        {
-            int boost = NativeMethods.GetCPUBoost();
-            checkBoost.Checked = (boost > 0);
         }
 
         public void InitScreen()
@@ -330,7 +596,7 @@ namespace GHelper
             }
             catch
             {
-                Debug.WriteLine("Screen Overdrive not supported");
+                Logger.WriteLine("Screen Overdrive not supported");
             }
 
             button60Hz.FlatAppearance.BorderSize = buttonInactive;
@@ -397,10 +663,20 @@ namespace GHelper
             aTimer.Enabled = false;
         }
 
+
+        private static string FormatFan(int fan)
+        {
+            if (Program.config.getConfig("fan_rpm") == 1)
+                return " Fan: " + (fan * 100).ToString() + "RPM";
+            else
+                return " Fan: " + Math.Min(Math.Round(fan / 0.6), 100).ToString() + "%"; // relatively to 6000 rpm
+        }
+
         private static void RefreshSensors()
         {
-            string cpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan) / 0.6).ToString() + "%";
-            string gpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan) / 0.6).ToString() + "%";
+
+            string cpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan));
+            string gpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan));
 
             string cpuTemp = "";
             string gpuTemp = "";
@@ -414,6 +690,11 @@ 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;
@@ -438,9 +719,10 @@ namespace GHelper
                 this.Top = Screen.FromControl(this).WorkingArea.Height - 10 - this.Height;
                 this.Activate();
 
-                aTimer.Interval = 500;
+                aTimer.Interval = 300;
                 aTimer.Enabled = true;
 
+                //RefreshSensors();
             }
             else
             {
@@ -448,6 +730,52 @@ namespace GHelper
             }
         }
 
+        public void SetPower()
+        {
+            int limit_total = Program.config.getConfigPerf("limit_total");
+            int limit_cpu = Program.config.getConfigPerf("limit_cpu");
+
+            if (limit_total > ASUSWmi.MaxTotal) return;
+            if (limit_total < ASUSWmi.MinTotal) return;
+
+            if (limit_cpu > ASUSWmi.MaxCPU) return;
+            if (limit_cpu < ASUSWmi.MinCPU) return;
+
+            if (Program.wmi.DeviceGet(ASUSWmi.PPT_TotalA0) >= 0)
+                Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA0, limit_total);
+
+            if (Program.wmi.DeviceGet(ASUSWmi.PPT_CPUB0) >= 0)
+                Program.wmi.DeviceSet(ASUSWmi.PPT_CPUB0, limit_cpu);
+
+            Logger.WriteLine("PowerLimits " + limit_total.ToString() + ", " + limit_cpu.ToString());
+
+
+        }
+
+
+        public void AutoFansAndPower()
+        {
+
+            if (Program.config.getConfigPerf("auto_apply") == 1)
+            {
+                Program.wmi.SetFanCurve(0, Program.config.getFanConfig(0));
+                Program.wmi.SetFanCurve(1, Program.config.getFanConfig(1));
+            }
+
+            if (Program.config.getConfigPerf("auto_apply_power") == 1)
+            {
+                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)
         {
 
@@ -472,21 +800,14 @@ namespace GHelper
                     break;
             }
 
-
+            int oldMode = Program.config.getConfig("performance_mode");
+            Program.config.setConfig("performance_" + (int)SystemInformation.PowerStatus.PowerLineStatus, PerformanceMode);
             Program.config.setConfig("performance_mode", PerformanceMode);
-            try
-            {
-                Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
-            }
-            catch
-            {
-                labelPerf.Text = "Performance Mode: not supported";
-            }
 
-            if (fans != null && fans.Text != "")
-                fans.LoadFans();
+            Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
+            Logger.WriteLine("PerfMode " + perfName + " " + PerformanceMode);
 
-            if (notify)
+            if (notify && (oldMode != PerformanceMode))
             {
                 try
                 {
@@ -498,6 +819,23 @@ namespace GHelper
                 }
             }
 
+            AutoFansAndPower();
+
+            NativeMethods.SetPowerScheme(PerformanceMode);
+
+            if (NativeMethods.PowerGetEffectiveOverlayScheme(out Guid activeScheme) == 0)
+            {
+                Debug.WriteLine("Effective :" + activeScheme);
+            }
+
+            if (fans != null && fans.Text != "")
+            {
+                fans.InitFans();
+                fans.InitPower();
+            }
+
+
+
         }
 
 
@@ -506,46 +844,56 @@ namespace GHelper
             SetPerformanceMode(Program.config.getConfig("performance_mode") + 1, true);
         }
 
-        public void AutoScreen(int Plugged = 1)
+        public void AutoPerformance(PowerLineStatus Plugged = PowerLineStatus.Online)
+        {
+            int mode = Program.config.getConfig("performance_" + (int)Plugged);
+            if (mode != -1)
+                SetPerformanceMode(mode, true);
+            else
+                SetPerformanceMode(Program.config.getConfig("performance_mode"));
+        }
+
+
+        public void AutoScreen(PowerLineStatus Plugged = PowerLineStatus.Online)
         {
             int ScreenAuto = Program.config.getConfig("screen_auto");
             if (ScreenAuto != 1) return;
 
-            if (Plugged == 1)
+            if (Plugged == PowerLineStatus.Online)
                 SetScreen(1000, 1);
             else
                 SetScreen(60, 0);
 
-            InitScreen();
 
         }
 
-        public void AutoGPUMode(int Plugged = 1)
+        public bool AutoGPUMode(PowerLineStatus Plugged = PowerLineStatus.Online)
         {
 
             int GpuAuto = Program.config.getConfig("gpu_auto");
-            if (GpuAuto != 1) return;
+            if (GpuAuto != 1) return false;
 
             int eco = Program.wmi.DeviceGet(ASUSWmi.GPUEco);
             int mux = Program.wmi.DeviceGet(ASUSWmi.GPUMux);
 
-
             if (mux == 0) // GPU in Ultimate, ignore
-                return;
+                return false;
             else
             {
-                if (eco == 1 && Plugged == 1)  // Eco going Standard on plugged
+                if (eco == 1 && Plugged == PowerLineStatus.Online)  // Eco going Standard on plugged
                 {
-                    Program.wmi.DeviceSet(ASUSWmi.GPUEco, 0);
-                    InitGPUMode();
+                    SetEcoGPU(0);
+                    return true;
                 }
-                else if (eco == 0 && Plugged == 0)  // Standard going Eco on plugged
+                else if (eco == 0 && Plugged != PowerLineStatus.Online)  // Standard going Eco on plugged
                 {
-                    Program.wmi.DeviceSet(ASUSWmi.GPUEco, 1);
-                    InitGPUMode();
+                    SetEcoGPU(1);
+                    return true;
                 }
-
             }
+
+            return false;
+
         }
 
         public int InitGPUMode()
@@ -565,10 +913,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);
 
@@ -576,7 +927,32 @@ 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();
+                    HardwareMonitor.RecreateGpuTemperatureProviderWithRetry();
+                    Thread.Sleep(500);
+                    AutoScreen(SystemInformation.PowerStatus.PowerLineStatus);
+                });
+            }).Start();
+
+        }
+
+        public void SetGPUMode(int GPUMode)
         {
 
             int CurrentGPU = Program.config.getConfig("gpu_mode");
@@ -611,19 +987,23 @@ 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;
             }
 
             if (changed)
+            {
                 Program.config.setConfig("gpu_mode", GPUMode);
 
+                HardwareMonitor.RecreateGpuTemperatureProviderWithRetry();
+            }
+
             if (restart)
             {
                 VisualiseGPUMode(GPUMode);
@@ -643,9 +1023,14 @@ namespace GHelper
             checkScreen.Checked = (ScreenAuto == 1);
         }
 
-        public void VisualiseGPUMode(int GPUMode)
+        public void VisualiseGPUMode(int GPUMode = -1)
         {
 
+            if (GPUMode == -1)
+            {
+                GPUMode = Program.config.getConfig("gpu_mode");
+            }
+
             buttonEco.FlatAppearance.BorderSize = buttonInactive;
             buttonStandard.FlatAppearance.BorderSize = buttonInactive;
             buttonUltimate.FlatAppearance.BorderSize = buttonInactive;
@@ -664,10 +1049,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;
             }
+
         }
 
 
@@ -691,81 +1077,45 @@ 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;
-        }
-        private void checkStartup_CheckedChanged(object sender, EventArgs e)
-        {
-            CheckBox chk = (CheckBox)sender;
-            if (chk.Checked)
-            {
-                Startup.Schedule();
-            }
-            else
-            {
-                Startup.UnSchedule();
-            }
+            checkStartup.CheckedChanged += CheckStartup_CheckedChanged;
         }
 
-        public void SetBatteryChargeLimit(int limit = 100)
+        public void SetBatteryChargeLimit(int limit)
         {
 
-            if (limit < 50 || limit > 100) limit = 100;
+            if (limit < 40 || limit > 100) return;
 
             labelBatteryTitle.Text = "Battery Charge Limit: " + limit.ToString() + "%";
             trackBattery.Value = limit;
-            try
-            {
-                Program.wmi.DeviceSet(ASUSWmi.BatteryLimit, limit);
-            }
-            catch
-            {
-                Debug.WriteLine("Can't set battery charge limit");
-            }
+            Program.wmi.DeviceSet(ASUSWmi.BatteryLimit, limit);
+
             Program.config.setConfig("charge_limit", limit);
 
         }
 
         private void trackBatteryChange(object? sender, EventArgs e)
         {
-            if (sender is null)
-                return;
-
+            if (sender is null) return;
             TrackBar bar = (TrackBar)sender;
             SetBatteryChargeLimit(bar.Value);
         }
 
-        private void checkGPU_CheckedChanged(object? sender, EventArgs e)
-        {
-            if (sender is null)
-                return;
-
-            CheckBox chk = (CheckBox)sender;
-            if (chk.Checked)
-                Program.config.setConfig("gpu_auto", 1);
-            else
-                Program.config.setConfig("gpu_auto", 0);
-        }
-
 
         private void checkScreen_CheckedChanged(object? sender, EventArgs e)
         {
-
-            if (sender is null)
-                return;
-
-            CheckBox chk = (CheckBox)sender;
-            if (chk.Checked)
-                Program.config.setConfig("screen_auto", 1);
-            else
-                Program.config.setConfig("screen_auto", 0);
+            if (sender is null) return;
+            CheckBox check = (CheckBox)sender;
+            Program.config.setConfig("screen_auto", check.Checked ? 1 : 0);
         }
 
 

Settings.resx

@@ -69,19 +69,6 @@
         vtSpbWIlX5XHkK/OOiq2RE5+H2ZRgx1v4RpMqBhHG5XElccIHie4EPW9o82fP8yx11SyLuxDm9L38yy8
         gDa8UP+WK+UiLIIXaiZQiduQtYsv9Qme53kn5bWujY3NGqzFtin+5YMgCIIgCP4PVfUNWXMTLz5Z0sYA
         AAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="pictureGPU.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
-        DAAACwwBP0AiyAAAAZVJREFUaEPtmTtOxDAURYcGGtgAsCJo6PisACE2ALTAvvgVsB0KQBRwT2HJGl3y
-        EtloHPCRjiKNfJ/sOLGV8aLT6XSa4Fa+ya/MD3kjm2dNvsq888l3OQu408szkJwlfQCr5k8NoAVZEV/k
-        vhyFK9KKBzLEBVvxWYa4YCuO2ptcsCVDXKim9/JQbst1uSOP5IN07ZcNcaEafspTOcSZpJ3LJ0NcCC8k
-        d8zB75fS5ZJR5xMMwuWTIS6Em3KILelyeCen8ChdHQxxIeQOD83AlXQ55JmfwrF0dTDEhUrlhZ0CL7ar
-        gyEuVOpPM/cTG9LVwRAXKnXqDOxKVwdDXAhLViHW+SmcSFcHQ1wIS1YhNqmx8Jn7JF0dDHEhLFmFkPV9
-        DOfS5ZMhLlRDdthoEHT+13biWrJJsc7zojJzXHnmhx6b3BAXaskQF2rF2X8PzP6LbE+GuOAq5V8J7vyo
-        zkMeniX/ZgB5u5oWM7ZY3q6mxYwtxsuVt61hlTOJdFbAdQjOFWoOglrXshg6xqnNLI6YOp1OZ1UsFt/W
-        cWCm8IATjAAAAABJRU5ErkJggg==
 </value>
   </data>
   <data name="picturePerf.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
@@ -103,6 +90,19 @@
         nbLijqltby+mGSx+Qlk5AtuQ6LdryGR4dcrQliFkF7w6h1E6emm9fZEe+QpopVTDtrysQ1BbzfZJ2v+0
         /N10MWyDnbYUbUVfjr2GO+Eo2o5+I5f5EFWVyj4tKvrQehneibqDZqJ+qDR6EnrhcjZlrVLbOofOVadO
         nTr/fBqNP4sju3bXhjy/AAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="pictureGPU.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        DAAACwwBP0AiyAAAAZVJREFUaEPtmTtOxDAURYcGGtgAsCJo6PisACE2ALTAvvgVsB0KQBRwT2HJGl3y
+        EtloHPCRjiKNfJ/sOLGV8aLT6XSa4Fa+ya/MD3kjm2dNvsq888l3OQu408szkJwlfQCr5k8NoAVZEV/k
+        vhyFK9KKBzLEBVvxWYa4YCuO2ptcsCVDXKim9/JQbst1uSOP5IN07ZcNcaEafspTOcSZpJ3LJ0NcCC8k
+        d8zB75fS5ZJR5xMMwuWTIS6Em3KILelyeCen8ChdHQxxIeQOD83AlXQ55JmfwrF0dTDEhUrlhZ0CL7ar
+        gyEuVOpPM/cTG9LVwRAXKnXqDOxKVwdDXAhLViHW+SmcSFcHQ1wIS1YhNqmx8Jn7JF0dDHEhLFmFkPV9
+        DOfS5ZMhLlRDdthoEHT+13biWrJJsc7zojJzXHnmhx6b3BAXaskQF2rF2X8PzP6LbE+GuOAq5V8J7vyo
+        zkMeniX/ZgB5u5oWM7ZY3q6mxYwtxsuVt61hlTOJdFbAdQjOFWoOglrXshg6xqnNLI6YOp1OZ1UsFt/W
+        cWCm8IATjAAAAABJRU5ErkJggg==
 </value>
   </data>
   <data name="pictureScreen.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">

Startup.cs

@@ -10,17 +10,6 @@ public class Startup
     public static bool IsScheduled()
     {
         TaskService taskService = new TaskService();
-
-        // cleanup of OLD autorun
-        try
-        {
-            taskService.RootFolder.DeleteTask("GSharpHelper");
-        } catch
-        {
-            Debug.WriteLine("Not running as admin");
-        }
-
-
         return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
     }
 
@@ -33,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()

app.manifest

@@ -54,8 +54,8 @@
 	<application xmlns="urn:schemas-microsoft-com:asm.v3">
 		<windowsSettings>
 			<!--<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitor/dpiAwareness>-->
-			<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor, System</dpiAwareness>
 			<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
+			<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">System</dpiAwareness>
 		</windowsSettings>
 	</application>
 

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

stop-asus-sv.bat

@@ -0,0 +1,15 @@
+sc STOP  AsusAppService
+sc STOP  ASUSLinkNear
+sc STOP  ASUSLinkRemote
+sc STOP  ASUSSoftwareManager
+sc STOP  ASUSSwitch
+sc STOP  ASUSSystemAnalysis
+sc STOP  ASUSSystemDiagnosis
+
+sc DELETE  AsusAppService
+sc DELETE  ASUSLinkNear
+sc DELETE  ASUSLinkRemote
+sc DELETE  ASUSSoftwareManager
+sc DELETE  ASUSSwitch
+sc DELETE  ASUSSystemAnalysis
+sc DELETE  ASUSSystemDiagnosis