Update checker

ASUSWmi.cs

@@ -1,6 +1,7 @@
-using System.Management;
+using System.Diagnostics;
+using System.Management;
 using System.Runtime.InteropServices;
-using System.Diagnostics;
+
 
 public class ASUSWmi
 {
@@ -25,6 +26,13 @@ public class ASUSWmi
     public const uint DevsCPUFanCurve = 0x00110024;
     public const uint DevsGPUFanCurve = 0x00110025;
 
+    public const int PPT_TotalA0 = 0x001200A0;
+    public const int PPT_TotalA1 = 0x001200A1;
+
+    public const int PPT_CPUB0 = 0x001200B0;
+    public const int PPT_CPUB1 = 0x001200B1;
+    public const int PPT_CPUA2 = 0x001200A2;
+
     public const int PerformanceBalanced = 0;
     public const int PerformanceTurbo = 1;
     public const int PerformanceSilent = 2;
@@ -34,6 +42,15 @@ public class ASUSWmi
     public const int GPUModeUltimate = 2;
 
 
+    public const int MaxTotal = 150;
+    public const int MinTotal = 15;
+    public const int DefaultTotal = 125;
+
+    public const int MaxCPU = 90;
+    public const int MinCPU = 15;
+    public const int DefaultCPU = 80;
+
+
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     private static extern IntPtr CreateFile(
         string lpFileName,
@@ -162,9 +179,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;
+
+        Debug.WriteLine(BitConverter.ToString(curve));
+
+        if (device == 1)
             DeviceSet(DevsGPUFanCurve, curve);
-        else 
+        else
             DeviceSet(DevsCPUFanCurve, curve);
     }
 
@@ -175,19 +197,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}].");
+            }
+        }
+    }
+}

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,18 +3,18 @@
 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 = 0;
-    public const int SpeedMedium = 1;
-    public const int SpeedHigh = 2;
+    public const int SpeedSlow = 0xe1;
+    public const int SpeedMedium = 0xeb;
+    public const int SpeedHigh = 0xf5;
 
     public static int Mode = Static;
     public static Color Color1 = Color.White;
@@ -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

@@ -29,97 +29,375 @@
         private void InitializeComponent()
         {
             System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
-            System.Windows.Forms.DataVisualization.Charting.Legend legend1 = new System.Windows.Forms.DataVisualization.Charting.Legend();
-            System.Windows.Forms.DataVisualization.Charting.Series series1 = new System.Windows.Forms.DataVisualization.Charting.Series();
             System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea2 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
-            System.Windows.Forms.DataVisualization.Charting.Legend legend2 = new System.Windows.Forms.DataVisualization.Charting.Legend();
-            System.Windows.Forms.DataVisualization.Charting.Series series2 = new System.Windows.Forms.DataVisualization.Charting.Series();
-            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
-            buttonApply = new Button();
-            buttonReset = new Button();
+            panelFans = new Panel();
+            checkBoost = new CheckBox();
+            labelFans = new Label();
+            checkAuto = new CheckBox();
             chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
-            ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
+            buttonReset = new Button();
+            buttonApply = new Button();
+            chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
+            panelPower = new Panel();
+            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)chartGPU).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
+            panelPower.SuspendLayout();
+            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);
-            legend1.Name = "Legend1";
-            chartCPU.Legends.Add(legend1);
-            chartCPU.Location = new Point(16, 13);
-            chartCPU.Name = "chartCPU";
-            series1.ChartArea = "ChartArea1";
-            series1.Legend = "Legend1";
-            series1.Name = "Series1";
-            chartCPU.Series.Add(series1);
-            chartCPU.Size = new Size(900, 446);
-            chartCPU.TabIndex = 0;
-            chartCPU.Text = "chartCPU";
+            panelFans.AutoSize = true;
+            panelFans.Controls.Add(checkBoost);
+            panelFans.Controls.Add(labelFans);
+            panelFans.Controls.Add(checkAuto);
+            panelFans.Controls.Add(chartGPU);
+            panelFans.Controls.Add(buttonReset);
+            panelFans.Controls.Add(buttonApply);
+            panelFans.Controls.Add(chartCPU);
+            panelFans.Dock = DockStyle.Left;
+            panelFans.Location = new Point(363, 0);
+            panelFans.Margin = new Padding(10);
+            panelFans.MinimumSize = new Size(872, 1089);
+            panelFans.Name = "panelFans";
+            panelFans.Padding = new Padding(10);
+            panelFans.Size = new Size(872, 1089);
+            panelFans.TabIndex = 12;
             // 
-            // buttonApply
+            // checkBoost
             // 
-            buttonApply.Location = new Point(662, 944);
-            buttonApply.Name = "buttonApply";
-            buttonApply.Size = new Size(254, 46);
-            buttonApply.TabIndex = 1;
-            buttonApply.Text = "Apply Fan Curve";
-            buttonApply.UseVisualStyleBackColor = true;
+            checkBoost.AutoSize = true;
+            checkBoost.ForeColor = SystemColors.ControlText;
+            checkBoost.Location = new Point(512, 15);
+            checkBoost.Margin = new Padding(4, 2, 4, 2);
+            checkBoost.Name = "checkBoost";
+            checkBoost.Size = new Size(320, 36);
+            checkBoost.TabIndex = 35;
+            checkBoost.Text = "CPU Turbo Boost enabled";
+            checkBoost.UseVisualStyleBackColor = true;
             // 
-            // buttonReset
+            // labelFans
             // 
-            buttonReset.Location = new Point(402, 944);
-            buttonReset.Name = "buttonReset";
-            buttonReset.Size = new Size(254, 46);
-            buttonReset.TabIndex = 2;
-            buttonReset.Text = "Factory Defaults";
-            buttonReset.UseVisualStyleBackColor = true;
+            labelFans.AutoSize = true;
+            labelFans.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelFans.Location = new Point(24, 15);
+            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(411, 1030);
+            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;
             // 
             // chartGPU
             // 
-            chartArea2.Name = "ChartArea1";
-            chartGPU.ChartAreas.Add(chartArea2);
-            legend2.Name = "Legend1";
-            chartGPU.Legends.Add(legend2);
-            chartGPU.Location = new Point(16, 477);
+            chartGPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            chartArea1.Name = "ChartArea1";
+            chartGPU.ChartAreas.Add(chartArea1);
+            chartGPU.Location = new Point(22, 547);
+            chartGPU.Margin = new Padding(4, 2, 4, 2);
             chartGPU.Name = "chartGPU";
-            series2.ChartArea = "ChartArea1";
-            series2.Legend = "Legend1";
-            series2.Name = "Series1";
-            chartGPU.Series.Add(series2);
-            chartGPU.Size = new Size(900, 448);
-            chartGPU.TabIndex = 3;
+            chartGPU.Size = new Size(810, 460);
+            chartGPU.TabIndex = 16;
             chartGPU.Text = "chart1";
             // 
+            // buttonReset
+            // 
+            buttonReset.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
+            buttonReset.Location = new Point(22, 1025);
+            buttonReset.Margin = new Padding(4, 2, 4, 2);
+            buttonReset.Name = "buttonReset";
+            buttonReset.Size = new Size(231, 44);
+            buttonReset.TabIndex = 15;
+            buttonReset.Text = "Factory Defaults";
+            buttonReset.UseVisualStyleBackColor = true;
+            // 
+            // buttonApply
+            // 
+            buttonApply.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            buttonApply.Location = new Point(584, 1025);
+            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;
+            // 
+            // chartCPU
+            // 
+            chartCPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
+            chartArea2.Name = "ChartArea1";
+            chartCPU.ChartAreas.Add(chartArea2);
+            chartCPU.Location = new Point(22, 66);
+            chartCPU.Margin = new Padding(10);
+            chartCPU.Name = "chartCPU";
+            chartCPU.Size = new Size(810, 460);
+            chartCPU.TabIndex = 13;
+            chartCPU.Text = "chartCPU";
+            // 
+            // panelPower
+            // 
+            panelPower.Controls.Add(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.Name = "panelPower";
+            panelPower.Size = new Size(363, 1089);
+            panelPower.TabIndex = 13;
+            // 
+            // labelPowerLimits
+            // 
+            labelPowerLimits.AutoSize = true;
+            labelPowerLimits.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelPowerLimits.Location = new Point(23, 15);
+            labelPowerLimits.Name = "labelPowerLimits";
+            labelPowerLimits.Size = new Size(229, 32);
+            labelPowerLimits.TabIndex = 26;
+            labelPowerLimits.Text = "Power Limits (PPT)";
+            // 
+            // checkApplyPower
+            // 
+            checkApplyPower.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
+            checkApplyPower.AutoSize = true;
+            checkApplyPower.Location = new Point(21, 982);
+            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(17, 1025);
+            buttonApplyPower.Margin = new Padding(4, 2, 4, 2);
+            buttonApplyPower.Name = "buttonApplyPower";
+            buttonApplyPower.Size = new Size(321, 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, 89);
+            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(43, 41);
+            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(45, 7);
+            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(47, 89);
+            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(17, 89);
+            panelTotal.Name = "panelTotal";
+            panelTotal.Size = new Size(160, 511);
+            panelTotal.TabIndex = 22;
+            // 
+            // labelTotal
+            // 
+            labelTotal.AutoSize = true;
+            labelTotal.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelTotal.Location = new Point(46, 41);
+            labelTotal.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, 7);
+            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, 89);
+            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(23, 51);
+            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.Bottom | AnchorStyles.Left | AnchorStyles.Right;
+            pictureFine.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureFine.Image = Properties.Resources.everything_is_fine_itsfine;
+            pictureFine.Location = new Point(17, 671);
+            pictureFine.Margin = new Padding(4, 2, 4, 2);
+            pictureFine.Name = "pictureFine";
+            pictureFine.Size = new Size(327, 254);
+            pictureFine.SizeMode = PictureBoxSizeMode.Zoom;
+            pictureFine.TabIndex = 20;
+            pictureFine.TabStop = false;
+            pictureFine.Visible = false;
+            // 
+            // labelInfo
+            // 
+            labelInfo.Location = new Point(17, 603);
+            labelInfo.Margin = new Padding(4, 0, 4, 0);
+            labelInfo.Name = "labelInfo";
+            labelInfo.Size = new Size(327, 330);
+            labelInfo.TabIndex = 19;
+            labelInfo.Text = "label";
+            // 
             // Fans
             // 
-            AutoScaleDimensions = new SizeF(13F, 32F);
-            AutoScaleMode = AutoScaleMode.Font;
-            ClientSize = new Size(940, 1020);
-            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(1220, 1089);
+            Controls.Add(panelFans);
+            Controls.Add(panelPower);
+            Margin = new Padding(4, 2, 4, 2);
             MaximizeBox = false;
             MdiChildrenMinimizedAnchorBottom = false;
             MinimizeBox = false;
+            MinimumSize = new Size(0, 1160);
             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)chartGPU).EndInit();
+            ((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
+            panelPower.ResumeLayout(false);
+            panelPower.PerformLayout();
+            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);
+            PerformLayout();
         }
 
         #endregion
-
-        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
-        private Button buttonApply;
-        private Button buttonReset;
+        private Panel panelFans;
+        private CheckBox checkAuto;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
+        private Button buttonReset;
+        private Button buttonApply;
+        private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
+        private Panel panelPower;
+        private CheckBox checkApplyPower;
+        private Button buttonApplyPower;
+        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 Label labelFans;
+        private CheckBox checkBoost;
     }
 }

Fans.cs

@@ -18,30 +18,47 @@ namespace GHelper
 
             if (device == 1)
                 title = "GPU Fan Profile";
-            else 
+            else
                 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;
             else
                 chart.Titles.Add(title);
 
+            chart.ChartAreas[0].AxisX.MajorGrid.LineColor = Color.LightGray;
+            chart.ChartAreas[0].AxisY.MajorGrid.LineColor = Color.LightGray;
+
             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.Legends[0].Enabled = false;
+
+            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)
+                chart.Legends[0].Enabled = false;
 
         }
 
         private void Fans_Shown(object? sender, EventArgs e)
         {
             Top = Program.settingsForm.Top;
-            Left = Program.settingsForm.Left - Width - 10;
+            Left = Program.settingsForm.Left - Width - 5;
         }
 
         public Fans()
@@ -49,14 +66,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;
 
@@ -66,41 +83,167 @@ 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();
+
+            checkBoost.Click += CheckBoost_Click;
+
             Shown += Fans_Shown;
 
         }
 
-        public void LoadFans()
+
+        public void InitBoost()
+        {
+            int boost = NativeMethods.GetCPUBoost();
+            checkBoost.Checked = (boost > 0);
+        }
+
+        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 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)
+        {
+
+            panelPower.Visible = (Program.wmi.DeviceGet(ASUSWmi.PPT_TotalA0) >= 0);
+            panelCPU.Visible = (Program.wmi.DeviceGet(ASUSWmi.PPT_CPUB0) >= 0);
+
+            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);
-            SetChart(chartGPU, 0);
+            SetChart(chartGPU, 1);
 
             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)
         {
@@ -112,15 +255,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.Length != 16 || curve.All(singleByte => singleByte == 0))
+                curve = Program.config.getDefaultCurve(device);
 
             //Debug.WriteLine(BitConverter.ToString(curve));
 
@@ -145,10 +286,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);
 
         }
@@ -162,9 +300,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)
@@ -192,18 +340,33 @@ namespace GHelper
 
                 if (curPoint != null)
                 {
+
                     Series s = hit.Series;
-                    double dx = ax.PixelPositionToValue(e.X);
-                    double dy = ay.PixelPositionToValue(e.Y);
+                    double dx, dy, dymin;
 
-                    if (dx < 0) dx = 0;
-                    if (dx > 100) dx = 100;
+                    try
+                    {
+                        dx = ax.PixelPositionToValue(e.X);
+                        dy = ay.PixelPositionToValue(e.Y);
 
-                    if (dy < 0) dy = 0;
-                    if (dy > 100) dy = 100;
+                        if (dx < 20) dx = 20;
+                        if (dx > 100) dx = 100;
 
-                    curPoint.XValue = dx;
-                    curPoint.YValues[0] = dy;
+                        if (dy < 0) dy = 0;
+                        if (dy > 100) dy = 100;
+
+                        dymin = (dx - 60) * 1.2;
+
+                        if (dy < dymin) dy = dymin;
+
+                        curPoint.XValue = dx;
+                        curPoint.YValues[0] = dy;
+
+                    }
+                    catch
+                    {
+                        Debug.WriteLine(e.Y);
+                    }
                 }
             }
         }

GHelper.csproj

@@ -13,7 +13,10 @@
     <Platforms>AnyCPU;x64</Platforms>
     <SupportedOSPlatformVersion>8.0</SupportedOSPlatformVersion>
     <AssemblyName>GHelper</AssemblyName>
-    <PlatformTarget>AnyCPU</PlatformTarget>
+    <PlatformTarget>x64</PlatformTarget>
+    <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
+    <AssemblyVersion>0.21</AssemblyVersion>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
@@ -35,6 +38,7 @@
 
   <ItemGroup>
     <PackageReference Include="hidlibrary" Version="3.3.40" />
+    <PackageReference Include="HidSharpCore" Version="1.2.1.1" />
     <PackageReference Include="System.Management" Version="7.0.0" />
     <PackageReference Include="TaskScheduler" Version="2.10.1" />
     <PackageReference Include="WinForms.DataVisualization" Version="1.7.0" />
@@ -97,4 +101,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="screenshots\" />
+  </ItemGroup>
+
 </Project>

GHelper.sln

@@ -18,12 +18,12 @@ Global
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.Build.0 = Debug|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.ActiveCfg = Release|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Release|x64
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.ActiveCfg = Release|x64
+		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.Build.0 = Release|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|x64.ActiveCfg = Release|x64
 		{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection

Keyboard.Designer.cs

@@ -0,0 +1,173 @@
+namespace GHelper
+{
+    partial class Keyboard
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            groupBox1 = new GroupBox();
+            textM4 = new TextBox();
+            textM3 = new TextBox();
+            comboM4 = new ComboBox();
+            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);
+            groupBox1.Controls.Add(labelM4);
+            groupBox1.Controls.Add(comboM3);
+            groupBox1.Controls.Add(labelM3);
+            groupBox1.Dock = DockStyle.Top;
+            groupBox1.Location = new Point(10, 10);
+            groupBox1.Name = "groupBox1";
+            groupBox1.Size = new Size(751, 242);
+            groupBox1.TabIndex = 0;
+            groupBox1.TabStop = false;
+            groupBox1.Text = "Key Bindings";
+            // 
+            // textM4
+            // 
+            textM4.Location = new Point(411, 113);
+            textM4.Name = "textM4";
+            textM4.PlaceholderText = "action";
+            textM4.Size = new Size(320, 39);
+            textM4.TabIndex = 5;
+            // 
+            // textM3
+            // 
+            textM3.Location = new Point(411, 54);
+            textM3.Name = "textM3";
+            textM3.PlaceholderText = "notepad /p \"file.txt\"";
+            textM3.Size = new Size(320, 39);
+            textM3.TabIndex = 4;
+            // 
+            // comboM4
+            // 
+            comboM4.FormattingEnabled = true;
+            comboM4.Items.AddRange(new object[] { "Performance Mode", "Open G-Helper window", "Custom" });
+            comboM4.Location = new Point(93, 112);
+            comboM4.Name = "comboM4";
+            comboM4.Size = new Size(312, 40);
+            comboM4.TabIndex = 3;
+            // 
+            // labelM4
+            // 
+            labelM4.AutoSize = true;
+            labelM4.Location = new Point(25, 116);
+            labelM4.Name = "labelM4";
+            labelM4.Size = new Size(54, 32);
+            labelM4.TabIndex = 2;
+            labelM4.Text = "M4:";
+            // 
+            // comboM3
+            // 
+            comboM3.FormattingEnabled = true;
+            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);
+            comboM3.TabIndex = 1;
+            // 
+            // labelM3
+            // 
+            labelM3.AutoSize = true;
+            labelM3.Location = new Point(25, 58);
+            labelM3.Name = "labelM3";
+            labelM3.Size = new Size(54, 32);
+            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);
+            AutoScaleMode = AutoScaleMode.Font;
+            ClientSize = new Size(771, 858);
+            Controls.Add(groupBox1);
+            FormBorderStyle = FormBorderStyle.FixedSingle;
+            MaximizeBox = false;
+            MdiChildrenMinimizedAnchorBottom = false;
+            MinimizeBox = false;
+            Name = "Keyboard";
+            Padding = new Padding(10);
+            ShowIcon = false;
+            ShowInTaskbar = false;
+            Text = "Keyboard";
+            groupBox1.ResumeLayout(false);
+            groupBox1.PerformLayout();
+            ResumeLayout(false);
+        }
+
+        #endregion
+
+        private GroupBox groupBox1;
+        private Label labelM3;
+        private ComboBox comboM3;
+        private ComboBox comboM4;
+        private Label labelM4;
+        private TextBox textM4;
+        private TextBox textM3;
+        private TextBox textFNF4;
+        private ComboBox comboFNF4;
+        private Label labelFNF4;
+    }
+}

Keyboard.cs

@@ -0,0 +1,69 @@
+namespace GHelper
+{
+    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();
+
+            SetKeyCombo(comboM3, textM3, "m3");
+            SetKeyCombo(comboM4, textM4, "m4");
+            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
+
+            Shown += Keyboard_Shown;
+        }
+
+
+        private void Keyboard_Shown(object? sender, EventArgs e)
+        {
+            Top = Program.settingsForm.Top;
+            Left = Program.settingsForm.Left - Width - 5;
+        }
+    }
+}

NativeMethods.cs

@@ -1,10 +1,334 @@
-using System.Diagnostics;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Management;
 using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using Tools;
+using static Tools.ScreenInterrogatory;
+
+namespace Tools
+{
+    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
 {
 
 
+    public const int KEYEVENTF_EXTENDEDKEY = 1;
+    public const int KEYEVENTF_KEYUP = 2;
+
+    public const int VK_MEDIA_NEXT_TRACK = 0xB0;
+    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);
+
+    public static void KeyPress(int key = VK_MEDIA_PLAY_PAUSE)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+    }
+
+
     [DllImport("user32.dll")]
     public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
     public const int SW_RESTORE = 9;
@@ -143,11 +467,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();
@@ -157,34 +476,55 @@ 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();
+            int count = 0, displayNum = -1;
+
+            foreach (var device in devices)
             {
-                laptopScreen = screen;
+                if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL)
+                    displayNum = count;
+                count++;
+                //Debug.WriteLine(device.outputTechnology);
+                //Debug.WriteLine(device.monitorFriendlyDeviceName);
             }
+
+            count = 0;
+            foreach (var screen in Screen.AllScreens)
+            {
+                if (count == displayNum)
+                    laptopScreen = screen.DeviceName;
+                //Debug.WriteLine(screen.DeviceName);
+                count++;
+            }
+        } catch
+        {
+            Debug.WriteLine("Can't find internal screen");
         }
 
-        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;
         }
@@ -195,15 +535,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;
         }
 

OSDBase.cs

@@ -0,0 +1,463 @@
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+
+namespace OSD
+{
+
+    class OSDNativeForm : NativeWindow, IDisposable
+    {
+
+        private bool _disposed = false;
+        private byte _alpha = 250;
+        private Size _size = new Size(350, 50);
+        private Point _location = new Point(50, 50);
+
+
+        protected virtual void PerformPaint(PaintEventArgs e)
+        {
+        }
+
+        protected internal void Invalidate()
+        {
+            this.UpdateLayeredWindow();
+        }
+        private void UpdateLayeredWindow()
+        {
+            Bitmap bitmap1 = new Bitmap(this.Size.Width, this.Size.Height, PixelFormat.Format32bppArgb);
+            using (Graphics graphics1 = Graphics.FromImage(bitmap1))
+            {
+                Rectangle rectangle1;
+                SIZE size1;
+                POINT point1;
+                POINT point2;
+                BLENDFUNCTION blendfunction1;
+                rectangle1 = new Rectangle(0, 0, this.Size.Width, this.Size.Height);
+                PerformPaint(new PaintEventArgs(graphics1, rectangle1));
+                IntPtr ptr1 = User32.GetDC(IntPtr.Zero);
+                IntPtr ptr2 = Gdi32.CreateCompatibleDC(ptr1);
+                IntPtr ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
+                IntPtr ptr4 = Gdi32.SelectObject(ptr2, ptr3);
+                size1.cx = this.Size.Width;
+                size1.cy = this.Size.Height;
+                point1.x = this.Location.X;
+                point1.x = this.Location.X;
+                point1.y = this.Location.Y;
+                point2.x = 0;
+                point2.y = 0;
+                blendfunction1 = new BLENDFUNCTION();
+                blendfunction1.BlendOp = 0;
+                blendfunction1.BlendFlags = 0;
+                blendfunction1.SourceConstantAlpha = this._alpha;
+                blendfunction1.AlphaFormat = 1;
+                User32.UpdateLayeredWindow(base.Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
+                Gdi32.SelectObject(ptr2, ptr4);
+                User32.ReleaseDC(IntPtr.Zero, ptr1);
+                Gdi32.DeleteObject(ptr3);
+                Gdi32.DeleteDC(ptr2);
+            }
+        }
+
+        public virtual void Show()
+        {
+            if (base.Handle == IntPtr.Zero) //if handle don't equal to zero - window was created and just hided
+                this.CreateWindowOnly();
+            User32.ShowWindow(base.Handle, User32.SW_SHOWNOACTIVATE);
+        }
+
+
+        public virtual void Hide()
+        {
+            if (base.Handle == IntPtr.Zero)
+                return;
+            User32.ShowWindow(base.Handle, User32.SW_HIDE);
+            this.DestroyHandle();
+        }
+
+
+        public virtual void Close()
+        {
+            this.Hide();
+            this.Dispose();
+        }
+
+        private void CreateWindowOnly()
+        {
+
+            CreateParams params1 = new CreateParams();
+            params1.Caption = "FloatingNativeWindow";
+            int nX = this._location.X;
+            int nY = this._location.Y;
+            Screen screen1 = Screen.FromHandle(base.Handle);
+            if ((nX + this._size.Width) > screen1.Bounds.Width)
+            {
+                nX = screen1.Bounds.Width - this._size.Width;
+            }
+            if ((nY + this._size.Height) > screen1.Bounds.Height)
+            {
+                nY = screen1.Bounds.Height - this._size.Height;
+            }
+            this._location = new Point(nX, nY);
+            Size size1 = this._size;
+            Point point1 = this._location;
+            params1.X = nX;
+            params1.Y = nY;
+            params1.Height = size1.Height;
+            params1.Width = size1.Width;
+            params1.Parent = IntPtr.Zero;
+            uint ui = User32.WS_POPUP;
+            params1.Style = (int)ui;
+            params1.ExStyle = User32.WS_EX_TOPMOST | User32.WS_EX_TOOLWINDOW | User32.WS_EX_LAYERED | User32.WS_EX_NOACTIVATE | User32.WS_EX_TRANSPARENT;
+            this.CreateHandle(params1);
+            this.UpdateLayeredWindow();
+        }
+
+
+
+        protected virtual void SetBoundsCore(int x, int y, int width, int height)
+        {
+            if (((this.X != x) || (this.Y != y)) || ((this.Width != width) || (this.Height != height)))
+            {
+                if (base.Handle != IntPtr.Zero)
+                {
+                    int num1 = 20;
+                    if ((this.X == x) && (this.Y == y))
+                    {
+                        num1 |= 2;
+                    }
+                    if ((this.Width == width) && (this.Height == height))
+                    {
+                        num1 |= 1;
+                    }
+                    User32.SetWindowPos(base.Handle, IntPtr.Zero, x, y, width, height, (uint)num1);
+                }
+                else
+                {
+                    this.Location = new Point(x, y);
+                    this.Size = new Size(width, height);
+                }
+            }
+        }
+
+
+
+
+        #region #  Properties  #
+        /// <summary>
+        /// Get or set position of top-left corner of floating native window in screen coordinates
+        /// </summary>
+        public virtual Point Location
+        {
+            get { return this._location; }
+            set
+            {
+                if (base.Handle != IntPtr.Zero)
+                {
+                    this.SetBoundsCore(value.X, value.Y, this._size.Width, this._size.Height);
+                    RECT rect = new RECT();
+                    User32.GetWindowRect(base.Handle, ref rect);
+                    this._location = new Point(rect.left, rect.top);
+                    this.UpdateLayeredWindow();
+                }
+                else
+                {
+                    this._location = value;
+                }
+            }
+        }
+        /// <summary>
+        /// Get or set size of client area of floating native window
+        /// </summary>
+        public virtual Size Size
+        {
+            get { return this._size; }
+            set
+            {
+                if (base.Handle != IntPtr.Zero)
+                {
+                    this.SetBoundsCore(this._location.X, this._location.Y, value.Width, value.Height);
+                    RECT rect = new RECT();
+                    User32.GetWindowRect(base.Handle, ref rect);
+                    this._size = new Size(rect.right - rect.left, rect.bottom - rect.top);
+                    this.UpdateLayeredWindow();
+                }
+                else
+                {
+                    this._size = value;
+                }
+            }
+        }
+        /// <summary>
+        /// Gets or sets the height of the floating native window
+        /// </summary>
+		public int Height
+        {
+            get { return this._size.Height; }
+            set
+            {
+                this._size = new Size(this._size.Width, value);
+            }
+        }
+        /// <summary>
+        /// Gets or sets the width of the floating native window
+        /// </summary>
+        public int Width
+        {
+            get { return this._size.Width; }
+            set
+            {
+                this._size = new Size(value, this._size.Height);
+            }
+        }
+        /// <summary>
+        /// Get or set x-coordinate of top-left corner of floating native window in screen coordinates
+        /// </summary>
+		public int X
+        {
+            get { return this._location.X; }
+            set
+            {
+                this.Location = new Point(value, this.Location.Y);
+            }
+        }
+        /// <summary>
+        /// Get or set y-coordinate of top-left corner of floating native window in screen coordinates
+        /// </summary>
+        public int Y
+        {
+            get { return this._location.Y; }
+            set
+            {
+                this.Location = new Point(this.Location.X, value);
+            }
+        }
+        /// <summary>
+        /// Get rectangle represented client area of floating native window in client coordinates(top-left corner always has coord. 0,0)
+        /// </summary>
+		public Rectangle Bound
+        {
+            get
+            {
+                return new Rectangle(new Point(0, 0), this._size);
+            }
+        }
+        /// <summary>
+        /// Get or set full opacity(255) or full transparency(0) or any intermediate state for floating native window transparency
+        /// </summary>
+		public byte Alpha
+        {
+            get { return this._alpha; }
+            set
+            {
+                if (this._alpha == value) return;
+                this._alpha = value;
+                this.UpdateLayeredWindow();
+            }
+        }
+        #endregion
+
+        #region IDisposable Members
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+        private void Dispose(bool disposing)
+        {
+            if (!this._disposed)
+            {
+                this.DestroyHandle();
+                this._disposed = true;
+            }
+        }
+        #endregion
+    }
+
+    #region #  Win32  #
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct POINT
+    {
+        public int x;
+        public int y;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct RECT
+    {
+        public int left;
+        public int top;
+        public int right;
+        public int bottom;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct SIZE
+    {
+        public int cx;
+        public int cy;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct TRACKMOUSEEVENTS
+    {
+        public uint cbSize;
+        public uint dwFlags;
+        public IntPtr hWnd;
+        public uint dwHoverTime;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct MSG
+    {
+        public IntPtr hwnd;
+        public int message;
+        public IntPtr wParam;
+        public IntPtr lParam;
+        public int time;
+        public int pt_x;
+        public int pt_y;
+    }
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    internal struct BLENDFUNCTION
+    {
+        public byte BlendOp;
+        public byte BlendFlags;
+        public byte SourceConstantAlpha;
+        public byte AlphaFormat;
+    }
+    internal class User32
+    {
+        public const uint WS_POPUP = 0x80000000;
+        public const int WS_EX_TOPMOST = 0x8;
+        public const int WS_EX_TOOLWINDOW = 0x80;
+        public const int WS_EX_LAYERED = 0x80000;
+        public const int WS_EX_TRANSPARENT = 0x20;
+        public const int WS_EX_NOACTIVATE = 0x08000000;
+        public const int SW_SHOWNOACTIVATE = 4;
+        public const int SW_HIDE = 0;
+        public const uint AW_HOR_POSITIVE = 0x1;
+        public const uint AW_HOR_NEGATIVE = 0x2;
+        public const uint AW_VER_POSITIVE = 0x4;
+        public const uint AW_VER_NEGATIVE = 0x8;
+        public const uint AW_CENTER = 0x10;
+        public const uint AW_HIDE = 0x10000;
+        public const uint AW_ACTIVATE = 0x20000;
+        public const uint AW_SLIDE = 0x40000;
+        public const uint AW_BLEND = 0x80000;
+        // Methods
+        private User32()
+        {
+        }
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool AnimateWindow(IntPtr hWnd, uint dwTime, uint dwFlags);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT pt);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool DispatchMessage(ref MSG msg);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool DrawFocusRect(IntPtr hWnd, ref RECT rect);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr GetDC(IntPtr hWnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr GetFocus();
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern ushort GetKeyState(int virtKey);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool GetMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr GetParent(IntPtr hWnd);
+        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
+        public static extern bool GetClientRect(IntPtr hWnd, [In, Out] ref RECT rect);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr GetWindow(IntPtr hWnd, int cmd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool HideCaret(IntPtr hWnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool InvalidateRect(IntPtr hWnd, ref RECT rect, bool erase);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr LoadCursor(IntPtr hInstance, uint cursor);
+        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
+        public static extern int MapWindowPoints(IntPtr hWndFrom, IntPtr hWndTo, [In, Out] ref RECT rect, int cPoints);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool PeekMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax, uint wFlag);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool PostMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool ReleaseCapture();
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool ScreenToClient(IntPtr hWnd, ref POINT pt);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern uint SendMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr SetCursor(IntPtr hCursor);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr SetFocus(IntPtr hWnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int newLong);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern int SetWindowPos(IntPtr hWnd, IntPtr hWndAfter, int X, int Y, int Width, int Height, uint flags);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool ShowCaret(IntPtr hWnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool SetCapture(IntPtr hWnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern int ShowWindow(IntPtr hWnd, short cmdShow);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool SystemParametersInfo(uint uiAction, uint uiParam, ref int bRetValue, uint fWinINI);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool TrackMouseEvent(ref TRACKMOUSEEVENTS tme);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool TranslateMessage(ref MSG msg);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref POINT pptDst, ref SIZE psize, IntPtr hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool UpdateWindow(IntPtr hwnd);
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool WaitMessage();
+        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
+        public static extern bool AdjustWindowRectEx(ref RECT lpRect, int dwStyle, bool bMenu, int dwExStyle);
+    }
+
+    internal class Gdi32
+    {
+        // Methods
+        private Gdi32()
+        {
+        }
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr CreateBrushIndirect(ref LOGBRUSH brush);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr CreateCompatibleDC(IntPtr hDC);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr CreateRectRgnIndirect(ref RECT rect);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool DeleteDC(IntPtr hDC);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr DeleteObject(IntPtr hObject);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern int GetClipBox(IntPtr hDC, ref RECT rectBox);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern bool PatBlt(IntPtr hDC, int x, int y, int width, int height, uint flags);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
+        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
+        internal static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    public struct LOGBRUSH
+    {
+        public uint lbStyle;
+        public uint lbColor;
+        public uint lbHatch;
+    }
+
+    #endregion
+}

Program.cs

@@ -1,202 +1,297 @@
 using Microsoft.Win32;
+using System;
 using System.Diagnostics;
 using System.Management;
-using System.Security.Principal;
-using System.Text;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Text.Json;
 
-
-public class AppConfig
-{
-
-    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)
-    {
-        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 float? cpuTemp = -1;
-    public float? gpuTemp = -1;
-    public float? batteryDischarge = -1;
-    public float? batteryCharge = -1;
 
-    public static bool IsAdministrator()
+    public static void ReadSensors()
     {
-        return (new WindowsPrincipal(WindowsIdentity.GetCurrent()))
-                  .IsInRole(WindowsBuiltInRole.Administrator);
-    }
-
-    public HardwareMonitor()
-    {
-
-    }
-
-    public void ReadSensors()
-    {
-
         cpuTemp = -1;
-        gpuTemp = -1;
         batteryDischarge = -1;
 
         try
         {
+            var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
+            cpuTemp = ct.NextValue() - 273;
+            ct.Dispose();
 
-            if (cpuTemp < 0)
-            {
-                var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
-                cpuTemp = ct.NextValue() - 273;
-                ct.Dispose();
-            }
-
-            if (batteryDischarge < 0)
-            {
-                var ct = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
-                batteryDischarge = ct.NextValue() / 1000;
-                ct.Dispose();
-            }
-
-
-        } catch
+            var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
+            batteryDischarge = cb.NextValue() / 1000;
+            cb.Dispose();
+        }
+        catch
         {
             Debug.WriteLine("Failed reading sensors");
         }
-
-
-    }
-
-    public void StopReading()
-    {
-        //computer.Close();
     }
 
 }
 
-
-
 namespace GHelper
 {
     static class Program
     {
-        public static NotifyIcon trayIcon = new NotifyIcon
-            {
-                Text = "G-Helper",
-                Icon = Properties.Resources.standard,
-                Visible = true
-            };
 
-        public static ASUSWmi wmi = new ASUSWmi();
+        // Native methods for sleep detection
+
+        [DllImport("Powrprof.dll", SetLastError = true)]
+        static extern uint PowerRegisterSuspendResumeNotification(uint flags, ref DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS receipient, ref IntPtr registrationHandle);
+
+
+        private const int WM_POWERBROADCAST = 536; // (0x218)
+        private const int PBT_APMPOWERSTATUSCHANGE = 10; // (0xA) - Power status has changed.
+        private const int PBT_APMRESUMEAUTOMATIC = 18; // (0x12) - Operation is resuming automatically from a low-power state.This message is sent every time the system resumes.
+        private const int PBT_APMRESUMESUSPEND = 7; // (0x7) - Operation is resuming from a low-power state.This message is sent after PBT_APMRESUMEAUTOMATIC if the resume is triggered by user input, such as pressing a key.
+        private const int PBT_APMSUSPEND = 4; // (0x4) - System is suspending operation.
+        private const int PBT_POWERSETTINGCHANGE = 32787; // (0x8013) - A power setting change event has been received.
+        private const int DEVICE_NOTIFY_CALLBACK = 2;
+
+        [StructLayout(LayoutKind.Sequential)]
+        struct DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS
+        {
+            public DeviceNotifyCallbackRoutine Callback;
+            public IntPtr Context;
+        }
+
+        public delegate int DeviceNotifyCallbackRoutine(IntPtr context, int type, IntPtr setting);
+
+        //
+
+        public static NotifyIcon trayIcon = new NotifyIcon
+        {
+            Text = "G-Helper",
+            Icon = Properties.Resources.standard,
+            Visible = true
+        };
+
+        public static ASUSWmi wmi;
         public static AppConfig config = new AppConfig();
 
         public static SettingsForm settingsForm = new SettingsForm();
-        public static HardwareMonitor hwmonitor = new HardwareMonitor();
+        public static ToastForm toast = new ToastForm();
 
         // 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;
+
+            }
+
 
             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();
+
+            IntPtr registrationHandle = new IntPtr();
+            DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS recipient = new DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS();
+            recipient.Callback = new DeviceNotifyCallbackRoutine(DeviceNotifyCallback);
+            recipient.Context = IntPtr.Zero;
+
+            IntPtr pRecipient = Marshal.AllocHGlobal(Marshal.SizeOf(recipient));
+            Marshal.StructureToPtr(recipient, pRecipient, false);
+
+            uint result = PowerRegisterSuspendResumeNotification(DEVICE_NOTIFY_CALLBACK, ref recipient, ref registrationHandle);
 
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
 
-            IntPtr dummy = settingsForm.Handle;
+            IntPtr ds = settingsForm.Handle;
+
+            CheckForUpdates();
 
             Application.Run();
 
         }
 
+
+        private static int DeviceNotifyCallback(IntPtr context, int type, IntPtr setting)
+        {
+            //Debug.WriteLine($"Power callback type: {type}");
+            switch (type)
+            {
+                case PBT_APMRESUMEAUTOMATIC:
+                    settingsForm.BeginInvoke(delegate
+                    {
+                        // Setting "other" mode to prevent bios bugging with PPTs after wake up from sleep
+                        wmi.DeviceSet(ASUSWmi.PerformanceMode, config.getConfig("performance_mode"));
+                        Thread.Sleep(1000);
+
+                        SetAutoModes();
+                    });
+                    break;
+            }
+
+            return 0;
+        }
+
+
+        static async void CheckForUpdates()
+        {
+
+            settingsForm.SetVersionLabel("Version: " + Assembly.GetExecutingAssembly().GetName().Version.ToString());
+
+            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 assembly = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+
+                    var gitVersion = new Version(tag);
+                    var appVersion = new Version();
+
+                    var result = appVersion.CompareTo(gitVersion);
+                    if (result > 0)
+                    {
+                        settingsForm.SetVersionLabel("Download Update: " + tag, url);
+                    }
+
+                }
+            } catch {
+                Debug.WriteLine("Failed to get update");
+            }
+
+        }
+
+
+        private static void SetAutoModes()
+        {
+            PowerLineStatus isPlugged = SystemInformation.PowerStatus.PowerLineStatus;
+
+            Debug.WriteLine(isPlugged.ToString());
+
+            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
+            settingsForm.AutoPerformance(isPlugged);
+            settingsForm.AutoScreen(isPlugged);
+
+            settingsForm.AutoGPUMode(isPlugged);
+
+            settingsForm.SetMatrix(isPlugged);
+
+        }
+
         private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
         {
-            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
+            SetAutoModes();
         }
 
+
+        static void LaunchProcess(string fileName = "")
+        {
+            ProcessStartInfo start = new ProcessStartInfo();
+            start.FileName = fileName;
+            start.WindowStyle = ProcessWindowStyle.Hidden;
+            start.CreateNoWindow = true;
+            try
+            {
+                Process proc = Process.Start(start);
+            }
+            catch
+            {
+                Debug.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;
@@ -209,54 +304,42 @@ namespace GHelper
 
             switch (EventID)
             {
-                case 56:    // Rog button
+                case 124:    // M3
+                    KeyProcess("m3");
+                    return;
+                case 56:    // M4 / Rog button
+                    KeyProcess("m4");
+                    return;
                 case 174:   // FN+F5
-
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.CyclePerformanceMode();
-                    });
-
+                    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.AutoGPUMode(1);
-                        settingsForm.AutoScreen(1);
-                    });
-                    return;
-
             }
 
 
         }
 
+        static void SettingsToggle()
+        {
+            if (settingsForm.Visible)
+                settingsForm.Hide();
+            else
+            {
+                settingsForm.Show();
+                settingsForm.Activate();
+            }
+
+            settingsForm.VisualiseGPUMode();
+
+        }
+
         static void TrayIcon_MouseClick(object? sender, MouseEventArgs e)
         {
             if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right)
             {
-                if (settingsForm.Visible)
-                    settingsForm.Hide();
-                else
-                {
-                    settingsForm.Show();
-                    settingsForm.Activate();
-                }
-
-                trayIcon.Icon = trayIcon.Icon; // refreshing icon as it get's blurred when screen resolution changes
+                SettingsToggle();
             }
         }
 

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>
@@ -80,6 +90,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_fan_head_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-fan-head-96", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -100,6 +120,16 @@ 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>

Properties/Resources.resx

@@ -133,16 +133,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-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 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>
 </root>

README.md

@@ -1,55 +1,68 @@
-# G-Helper (For G14, G15, ROG FLOW, and others)
+# G-Helper / GHelper for Asus ROG Zephyrus G14, G15, Flow X13, Flow X16, and other models
 
-A tiny system tray utility that allows you set performance and GPU profiles for your laptop. Same as ASUS Armory Crate does but without it completely!. 
+A small utility that allows you do almost everyting you could do with Armory Crate but without extra bloat and unnecessary services.
 
-Designed 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.
+## NEW (and experimental) features
 
-![Screenshot](https://github.com/seerge/g14-helper/blob/main/screenshot.png)
+1. Set Power limits (PPT) for Total (APU + dGPU) and CPU. 
+2. Anime matrix control thanks to https://github.com/vddCore/Starlight
+
+## Main features
+
+1. Switch between built-in system **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 **auto apply** custom ones 
+5. Control keyboard backlit animation and colors
+6. Set battery charge limit to preserve battery health
+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 FN+F5 to cycle through performance modes (with OSD notification) and FN+F4 to cycle through keeyboard animation modes
+10. Basic keybindings for M3 and M4 keys
+11. Turn cpu turbo boost on/off with one checkbox to keep temps cooler
+
+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.
+
+To keep autoswitching and hotkeys work app needs to stay in running in tray. It doesn't consume any resources. 
+
+I recommend to keep "Asus Optimization Service" running, as it keeps basic laptop hotkeys such as screen or keyboard brightness adjustment working. If you have (or had) MyASUS app installed, that service is most probably still up an running even after MyASUS uninstall. It's part of [Asus System Controll Interface](https://www.asus.com/support/FAQ/1047338/). You can install it, and later disable / remove unnecesarily services by running [this bat file](https://raw.githubusercontent.com/seerge/g-helper/main/stop-asus-sv.bat ) as admin.
+
+### [Download latest release](https://github.com/seerge/g-helper/releases)
+
+![Screenshot](https://github.com/seerge/g-helper/blob/main/screenshot.png)
 
 ## Performance Profile switching 
 
-Profiles are **same** as in Armory Crate, including default fan curves
+Profiles 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)
 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) 
 
-## GPU Mode switching
+PPTs are shown for G14 2022, for other models PPTs will be different as they are set in bios.
 
-1. Eco mode : only low power iGPU (Radeon 680u) enabled, iGPU drives built in display
-2. Standard mode (Windows Hybrid) : iGPU and dGPU (Radeon 6700s/6800s) enabled, iGPU drives built in display
-3. Ultimate mode: iGPU and dGPU enabled, but dGPU drives built in display
-4. **Custom fan profiles** for any mode!
+## GPU Modes
 
-## Extras
-
-1. Keyboard backlight control (basic aura modes and colors)
-2. **Maximum battery charge rate** limit (60% / 80% / 100%) to preserve your battery
-3. CPU and GPU relative fan speed monitoring 
-4. Automatic switching of Standard/Eco GPU modes when laptop is plugged / unplugged!
-5. FN+F5 an M4 (Rog) keys cycle through Performance modes
-6. Screen resolution and display overdrive switching
-7. CPU turbo boost switching
-8. CPU & dGPU temperature monitoring in Celsius, battery charge / discharge rates in Watts
-
-## Things still missing
-
-1. Anime matrix control
+1. Eco mode : only low power integrated GPU enabled, iGPU drives built in display
+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)
 
 ## How to install
 
-1. Download latest release from https://github.com/seerge/g14-helper/releases
+1. Download latest release from 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)!
+Note: Uses low level ASUS ACPI commands and doens't require Armory Crate to be installed at all!  Doesn't need administrator privileges to run!
 
-I don`t have Microsoft certificate to sign app yet, so if you set a warning from Windows Defender on launch (Windows Protected your PC), click More Info -> Run anyway.
+I don`t have Microsoft certificate to sign app yet, so if you get a warning from Windows Defender on launch (Windows Protected your PC), click More Info -> Run anyway. Alternatively you can compile and run project by yourself using Visual Studio :)
 
-Alternatively you can comile and run project by yourself :)
-
-Settings file is storer at %AppData%\GHelper
+Settings file is stored at %AppData%\GHelper
 
 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
+
+------------------
+
+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)

Settings.cs

@@ -1,7 +1,8 @@
-using System.Diagnostics;
+using Starlight.AnimeMatrix;
+using System.Diagnostics;
+using System.Drawing.Imaging;
 using System.Timers;
 
-
 namespace GHelper
 {
 
@@ -16,10 +17,16 @@ namespace GHelper
         static int buttonActive = 5;
 
         static System.Timers.Timer aTimer = default!;
+        static System.Timers.Timer matrixTimer = default!;
 
-        public string perfName;
+        public string versionUrl = "http://github.com/seerge/g-helper/releases";
+
+        public string perfName = "Balanced";
 
         Fans fans;
+        Keyboard keyb;
+
+        static AnimeMatrixDevice mat;
 
         public SettingsForm()
         {
@@ -53,23 +60,277 @@ namespace GHelper
 
             buttonQuit.Click += ButtonQuit_Click;
 
-            checkBoost.Click += CheckBoost_Click;
 
             checkScreen.CheckedChanged += checkScreen_CheckedChanged;
 
             comboKeyboard.DropDownStyle = ComboBoxStyle.DropDownList;
             comboKeyboard.SelectedIndex = 0;
-
             comboKeyboard.SelectedValueChanged += ComboKeyboard_SelectedValueChanged;
 
             buttonKeyboardColor.Click += ButtonKeyboardColor_Click;
 
             buttonFans.Click += ButtonFans_Click;
+            buttonKeyboard.Click += ButtonKeyboard_Click;
+
+            pictureColor.Click += PictureColor_Click;
+            pictureColor2.Click += PictureColor2_Click;
+
+            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();
 
+        }
+
+        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 ButtonMatrix_Click(object? sender, EventArgs e)
+        {
+            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)
+        {
+
+            ColorDialog colorDlg = new ColorDialog();
+            colorDlg.AllowFullOpen = false;
+            colorDlg.Color = pictureColor2.BackColor;
+
+            if (colorDlg.ShowDialog() == DialogResult.OK)
+            {
+                SetAuraColor(color2: colorDlg.Color);
+            }
+        }
+
+        private void PictureColor_Click(object? sender, EventArgs e)
+        {
+            buttonKeyboardColor.PerformClick();
+        }
+
+        private void ButtonKeyboard_Click(object? sender, EventArgs e)
+        {
+            if (keyb == null || keyb.Text == "")
+            {
+                keyb = new Keyboard();
+                keyb.Show();
+            }
+            else
+            {
+                keyb.Close();
+            }
         }
 
         private void ButtonFans_Click(object? sender, EventArgs e)
@@ -77,13 +338,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)
@@ -96,11 +363,11 @@ namespace GHelper
 
             ColorDialog colorDlg = new ColorDialog();
             colorDlg.AllowFullOpen = false;
-            colorDlg.Color = but.FlatAppearance.BorderColor;
+            colorDlg.Color = pictureColor.BackColor;
 
             if (colorDlg.ShowDialog() == DialogResult.OK)
             {
-                SetAuraColor(colorDlg.Color);
+                SetAuraColor(color1: colorDlg.Color);
             }
         }
 
@@ -108,9 +375,12 @@ namespace GHelper
         {
             int mode = Program.config.getConfig("aura_mode");
             int colorCode = Program.config.getConfig("aura_color");
+            int colorCode2 = Program.config.getConfig("aura_color2");
+
             int speed = Program.config.getConfig("aura_speed");
 
             Color color = Color.FromArgb(255, 255, 255);
+            Color color2 = Color.FromArgb(0, 0, 0);
 
             if (mode == -1)
                 mode = 0;
@@ -118,24 +388,63 @@ namespace GHelper
             if (colorCode != -1)
                 color = Color.FromArgb(colorCode);
 
+            if (colorCode2 != -1)
+                color2 = Color.FromArgb(colorCode2);
 
-            SetAuraColor(color, false);
+            SetAuraColor(color, color2, false);
             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 color, bool apply = true)
+
+        public void SetAuraColor(Color? color1 = null, Color? color2 = null, bool apply = true)
         {
-            Aura.Color1 = color;
-            Program.config.setConfig("aura_color", color.ToArgb());
+
+            if (color1 is not null)
+            {
+                Aura.Color1 = (Color)color1;
+                Program.config.setConfig("aura_color", Aura.Color1.ToArgb());
+
+            }
+
+            if (color2 is not null)
+            {
+                Aura.Color2 = (Color)color2;
+                Program.config.setConfig("aura_color2", Aura.Color2.ToArgb());
+            }
 
             if (apply)
                 Aura.ApplyAura();
 
-            buttonKeyboardColor.FlatAppearance.BorderColor = color;
+            pictureColor.BackColor = Aura.Color1;
+            pictureColor2.BackColor = Aura.Color2;
         }
 
         public void SetAuraMode(int mode = 0, bool apply = true)
@@ -143,11 +452,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;
@@ -173,19 +485,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(3);
-            else
-                NativeMethods.SetCPUBoost(0);
-        }
-
         private void Button120Hz_Click(object? sender, EventArgs e)
         {
             SetScreen(1000, 1);
@@ -228,13 +527,6 @@ namespace GHelper
             InitScreen();
         }
 
-
-        public void InitBoost()
-        {
-            int boost = NativeMethods.GetCPUBoost();
-            checkBoost.Checked = (boost > 0);
-        }
-
         public void InitScreen()
         {
 
@@ -332,35 +624,32 @@ 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) + "%";
+
+            string cpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan));
+            string gpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan));
 
             string cpuTemp = "";
             string gpuTemp = "";
             string battery = "";
 
-            try
-            {
-                Program.hwmonitor.ReadSensors();
-            }
-            catch
-            {
-                Debug.WriteLine("Failed reading sensors");
-            }
+            HardwareMonitor.ReadSensors();
 
-            if (Program.hwmonitor.cpuTemp > 0)
-                cpuTemp = ": " + Math.Round((decimal)Program.hwmonitor.cpuTemp).ToString() + "°C - ";
+            if (HardwareMonitor.cpuTemp > 0)
+                cpuTemp = ": " + Math.Round((decimal)HardwareMonitor.cpuTemp).ToString() + "°C - ";
 
-            if (Program.hwmonitor.gpuTemp > 0)
-                gpuTemp = ": " + Math.Round((decimal)Program.hwmonitor.gpuTemp).ToString() + "°C - ";
-
-            if (Program.hwmonitor.batteryDischarge > 0)
-                battery = "Discharging: " + Math.Round((decimal)Program.hwmonitor.batteryDischarge, 1).ToString() + "W";
-
-            if (Program.hwmonitor.batteryCharge > 0)
-                battery = "Charging: " + Math.Round((decimal)Program.hwmonitor.batteryCharge, 1).ToString() + "W";
+            if (HardwareMonitor.batteryDischarge > 0)
+                battery = "Discharging: " + Math.Round((decimal)HardwareMonitor.batteryDischarge, 1).ToString() + "W";
 
             Program.settingsForm.BeginInvoke(delegate
             {
@@ -382,18 +671,53 @@ namespace GHelper
             {
                 InitScreen();
 
-                this.Left = Screen.FromControl(this).Bounds.Width - 10 - this.Width;
+                this.Left = Screen.FromControl(this).WorkingArea.Width - 10 - this.Width;
                 this.Top = Screen.FromControl(this).WorkingArea.Height - 10 - this.Height;
                 this.Activate();
 
-                aTimer.Interval = 500;
+                aTimer.Interval = 300;
                 aTimer.Enabled = true;
 
             }
             else
             {
                 aTimer.Enabled = false;
-                Program.hwmonitor.StopReading();
+            }
+        }
+
+        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;
+
+            Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA0, limit_total);
+            Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA1, limit_total);
+            Program.wmi.DeviceSet(ASUSWmi.PPT_CPUB0, limit_cpu);
+
+            Debug.WriteLine(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)
+            {
+                SetPower();
             }
         }
 
@@ -421,19 +745,34 @@ 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);
+            Debug.WriteLine("Perf:" + PerformanceMode);
+
+            if (notify && (oldMode != PerformanceMode))
             {
-                Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
-            }
-            catch
-            {
-                labelPerf.Text = "Performance Mode: not supported";
+                try
+                {
+                    Program.toast.RunToast(perfName);
+                }
+                catch
+                {
+                    Debug.WriteLine("Toast error");
+                }
             }
 
+            AutoFansAndPower();
+
             if (fans != null && fans.Text != "")
-                fans.LoadFans();
+            {
+                fans.InitFans();
+                fans.InitPower();
+            }
+
+
 
         }
 
@@ -443,12 +782,22 @@ 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);
@@ -457,7 +806,7 @@ namespace GHelper
 
         }
 
-        public void AutoGPUMode(int Plugged = 1)
+        public void AutoGPUMode(PowerLineStatus Plugged = PowerLineStatus.Online)
         {
 
             int GpuAuto = Program.config.getConfig("gpu_auto");
@@ -471,12 +820,12 @@ namespace GHelper
                 return;
             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();
                 }
-                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();
@@ -580,9 +929,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;
@@ -638,71 +992,40 @@ namespace GHelper
         {
             checkStartup.Checked = status;
         }
-        private void checkStartup_CheckedChanged(object sender, EventArgs e)
-        {
-            CheckBox chk = (CheckBox)sender;
-            if (chk.Checked)
-            {
-                Startup.Schedule();
-            }
-            else
-            {
-                Startup.UnSchedule();
-            }
-        }
 
-        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);
+            if (sender is null) return;
+            CheckBox check = (CheckBox)sender;
+            Program.config.setConfig("gpu_auto", check.Checked ? 1 : 0);
         }
 
 
         private void checkScreen_CheckedChanged(object? sender, EventArgs e)
         {
-
-            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));
     }
 

ToastForm.Designer.cs

@@ -1,85 +0,0 @@
-namespace GHelper
-{
-    partial class ToastForm
-    {
-        /// <summary>
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary>
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing && (components != null))
-            {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Windows Form Designer generated code
-
-        /// <summary>
-        /// Required method for Designer support - do not modify
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent()
-        {
-            this.pictureIcon = new System.Windows.Forms.PictureBox();
-            this.labelMode = new System.Windows.Forms.Label();
-            ((System.ComponentModel.ISupportInitialize)(this.pictureIcon)).BeginInit();
-            this.SuspendLayout();
-            // 
-            // pictureIcon
-            // 
-            this.pictureIcon.BackgroundImage = global::GHelper.Properties.Resources.icons8_speed_96;
-            this.pictureIcon.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom;
-            this.pictureIcon.Location = new System.Drawing.Point(21, 21);
-            this.pictureIcon.Name = "pictureIcon";
-            this.pictureIcon.Size = new System.Drawing.Size(82, 80);
-            this.pictureIcon.TabIndex = 0;
-            this.pictureIcon.TabStop = false;
-            // 
-            // labelMode
-            // 
-            this.labelMode.AutoSize = true;
-            this.labelMode.Font = new System.Drawing.Font("Segoe UI", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
-            this.labelMode.Location = new System.Drawing.Point(127, 32);
-            this.labelMode.Name = "labelMode";
-            this.labelMode.Size = new System.Drawing.Size(195, 59);
-            this.labelMode.TabIndex = 1;
-            this.labelMode.Text = "Balanced";
-            this.labelMode.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
-            // 
-            // ToastForm
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(13F, 32F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.BackColor = System.Drawing.SystemColors.ControlLightLight;
-            this.ClientSize = new System.Drawing.Size(356, 122);
-            this.Controls.Add(this.labelMode);
-            this.Controls.Add(this.pictureIcon);
-            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
-            this.MaximizeBox = false;
-            this.MdiChildrenMinimizedAnchorBottom = false;
-            this.MinimizeBox = false;
-            this.Name = "ToastForm";
-            this.ShowIcon = false;
-            this.ShowInTaskbar = false;
-            this.Text = "ToastForm";
-            this.TopMost = true;
-            ((System.ComponentModel.ISupportInitialize)(this.pictureIcon)).EndInit();
-            this.ResumeLayout(false);
-            this.PerformLayout();
-
-        }
-
-        #endregion
-
-        private PictureBox pictureIcon;
-        private Label labelMode;
-    }
-}

ToastForm.cs

@@ -1,68 +1,94 @@
-using System.Runtime.InteropServices;
+using System.Drawing.Drawing2D;
+using OSD;
 
 
 namespace GHelper
 {
-    public partial class ToastForm : Form
+
+    static class Drawing
     {
 
-        private System.Windows.Forms.Timer timer = default!;
-
-        private const int SW_SHOWNOACTIVATE = 4;
-        private const int HWND_TOPMOST = -1;
-        private const uint SWP_NOACTIVATE = 0x0010;
-
-        [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
-        static extern bool SetWindowPos(
-             int hWnd,             // Window handle
-             int hWndInsertAfter,  // Placement-order handle
-             int X,                // Horizontal position
-             int Y,                // Vertical position
-             int cx,               // Width
-             int cy,               // Height
-             uint uFlags);         // Window positioning flags
-
-        [DllImport("user32.dll")]
-        static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
-
-        static void ShowInactiveTopmost(Form frm)
+        public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
         {
-            ShowWindow(frm.Handle, SW_SHOWNOACTIVATE);
-            SetWindowPos(frm.Handle.ToInt32(), HWND_TOPMOST,
-            frm.Left, frm.Top, frm.Width, frm.Height,
-            SWP_NOACTIVATE);
+            int diameter = radius * 2;
+            Size size = new Size(diameter, diameter);
+            Rectangle arc = new Rectangle(bounds.Location, size);
+            GraphicsPath path = new GraphicsPath();
+
+            if (radius == 0)
+            {
+                path.AddRectangle(bounds);
+                return path;
+            }
+
+            path.AddArc(arc, 180, 90);
+            arc.X = bounds.Right - diameter;
+            path.AddArc(arc, 270, 90);
+            arc.Y = bounds.Bottom - diameter;
+            path.AddArc(arc, 0, 90);
+            arc.X = bounds.Left;
+            path.AddArc(arc, 90, 90);
+            path.CloseFigure();
+            return path;
         }
 
-        public ToastForm()
+        public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
         {
-            InitializeComponent();
+            using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
+            {
+                graphics.FillPath(brush, path);
+            }
+        }
+    }
+
+    class  ToastForm : OSDNativeForm
+    {
+
+        protected static string toastText = "Balanced";
+        protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
+
+        protected override void PerformPaint(PaintEventArgs e)
+        {
+            Brush brush = new SolidBrush(Color.FromArgb(150,Color.Black));
+            Drawing.FillRoundedRectangle(e.Graphics, brush, this.Bound, 10);
+
+            StringFormat format = new StringFormat();
+            format.LineAlignment = StringAlignment.Center;
+            format.Alignment = StringAlignment.Center;
+
+            e.Graphics.DrawString(toastText, 
+                new Font("Segoe UI", 16f, FontStyle.Bold), 
+                new SolidBrush(Color.White), 
+                new PointF(this.Bound.Width/2, this.Bound.Height / 2), 
+                format);
         }
 
         public void RunToast(string text)
         {
 
-            Top = Screen.FromControl(this).WorkingArea.Height - this.Height - 100;
-            Left = (Screen.FromControl(this).Bounds.Width - this.Width) / 2;
+            toastText = text;
+            Screen screen1 = Screen.FromHandle(base.Handle);
 
-            ShowInactiveTopmost(this);
+            Width = 300;
+            Height = 100;
+            X = (screen1.Bounds.Width - this.Width)/2;
+            Y = screen1.Bounds.Height - 300 - this.Height;
 
-            labelMode.Text = text;
+            Show();
 
-            timer = new System.Windows.Forms.Timer();
-            timer.Tick += new EventHandler(timer_Tick);
+            timer.Stop();
+            timer.Tick -= timer_Tick;
+
+            timer.Tick += timer_Tick;
             timer.Enabled = true;
-            timer.Interval = 1000;
+            timer.Interval = 2000;
             timer.Start();
         }
 
-        private void ToastForm_Show(object? sender, EventArgs e)
-        {
-        }
-
-        private void timer_Tick(object sender, EventArgs e)
+        private void timer_Tick(object? sender, EventArgs e)
         {
             timer.Stop();
-            Close();
+            Hide();
         }
     }
 }

app.manifest

@@ -16,7 +16,6 @@
             Remove this element if your application requires this virtualization for backwards
             compatibility.
         -->
-        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
       </requestedPrivileges>
     </security>
   </trustInfo>
@@ -56,7 +55,6 @@
 		<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>
 		</windowsSettings>
 	</application>
 

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