Merge branch 'main' of https://github.com/seerge/g14-helper

ASUSWmi.cs

@@ -1,6 +1,6 @@
-using System.Management;
+using System.Diagnostics;
+using System.Management;
 using System.Runtime.InteropServices;
-using System.Diagnostics;
 
 public class ASUSWmi
 {
@@ -25,6 +25,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;
@@ -162,9 +169,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,14 +187,14 @@ 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);
 
     }

AnimeMatrix/AnimeMatrixDevice.cs

@@ -0,0 +1,228 @@
+// Source thanks to https://github.com/vddCore/Starlight :)
+
+using System.Text;
+using Starlight.Communication;
+
+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;
+        public int Rows => 61;
+
+        private readonly byte[] _displayBuffer = new byte[UpdatePageLength * 3];
+
+        public AnimeMatrixDevice()
+            : base(0x0B05, 0x193B, 640)
+        {
+        }
+        
+        public void SendRaw(params byte[] data)
+        {
+            Set(Packet<AnimeMatrixPacket>(data));
+        }
+
+
+        public int EmptyColumns(int row)
+        {
+            return (int)Math.Ceiling(Math.Max(0, row - 11) / 2.0);
+        }
+        public int Columns(int row)
+        {
+            EnsureRowInRange(row);  
+            return 34 - 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)])
+            );
+
+            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));
+        }
+        
+        private void EnsureRowInRange(int row)
+        {
+            if (row < 0 || row >= Rows)
+            {
+                throw new IndexOutOfRangeException($"Y-coordinate should fall in range of [0, {Rows - 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,143 @@
+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)
+    {
+        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;
+    }
+
+}

Aura.cs

@@ -10,11 +10,11 @@ public class Aura
     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,32 @@
+// Source thanks to https://github.com/vddCore/Starlight :)
+
+using Starlight.Communication.Platform;
+
+namespace Starlight.Communication
+{
+    public abstract class Device : IDisposable
+    {
+        private static UsbProvider _usbProvider;
+
+        protected Device(ushort vendorId, ushort productId, int maxFeatureReportLength)
+        {
+            _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

@@ -34,34 +34,53 @@
             buttonApply = new Button();
             buttonReset = new Button();
             chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
+            groupBox1 = new GroupBox();
+            labelApplied = new Label();
+            pictureFine = new PictureBox();
+            labelInfo = new Label();
+            labelCPU = new Label();
+            labelTotal = new Label();
+            label2 = new Label();
+            label1 = new Label();
+            trackCPU = new TrackBar();
+            trackTotal = new TrackBar();
+            buttonApplyPower = new Button();
+            checkAuto = new CheckBox();
             ((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
             ((System.ComponentModel.ISupportInitialize)chartGPU).BeginInit();
+            groupBox1.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureFine).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)trackCPU).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)trackTotal).BeginInit();
             SuspendLayout();
             // 
             // chartCPU
             // 
             chartArea1.Name = "ChartArea1";
             chartCPU.ChartAreas.Add(chartArea1);
-            chartCPU.Location = new Point(16, 13);
+            chartCPU.Location = new Point(195, 14);
+            chartCPU.Margin = new Padding(2, 1, 2, 1);
             chartCPU.Name = "chartCPU";
-            chartCPU.Size = new Size(900, 446);
+            chartCPU.Size = new Size(416, 218);
             chartCPU.TabIndex = 0;
             chartCPU.Text = "chartCPU";
             // 
             // buttonApply
             // 
-            buttonApply.Location = new Point(662, 944);
+            buttonApply.Location = new Point(473, 476);
+            buttonApply.Margin = new Padding(2, 1, 2, 1);
             buttonApply.Name = "buttonApply";
-            buttonApply.Size = new Size(254, 46);
+            buttonApply.Size = new Size(137, 22);
             buttonApply.TabIndex = 1;
             buttonApply.Text = "Apply Fan Curve";
             buttonApply.UseVisualStyleBackColor = true;
             // 
             // buttonReset
             // 
-            buttonReset.Location = new Point(402, 944);
+            buttonReset.Location = new Point(195, 476);
+            buttonReset.Margin = new Padding(2, 1, 2, 1);
             buttonReset.Name = "buttonReset";
-            buttonReset.Size = new Size(254, 46);
+            buttonReset.Size = new Size(137, 22);
             buttonReset.TabIndex = 2;
             buttonReset.Text = "Factory Defaults";
             buttonReset.UseVisualStyleBackColor = true;
@@ -70,22 +89,176 @@
             // 
             chartArea2.Name = "ChartArea1";
             chartGPU.ChartAreas.Add(chartArea2);
-            chartGPU.Location = new Point(16, 477);
+            chartGPU.Location = new Point(195, 240);
+            chartGPU.Margin = new Padding(2, 1, 2, 1);
             chartGPU.Name = "chartGPU";
-            chartGPU.Size = new Size(900, 448);
+            chartGPU.Size = new Size(416, 225);
             chartGPU.TabIndex = 3;
             chartGPU.Text = "chart1";
             // 
+            // groupBox1
+            // 
+            groupBox1.Controls.Add(labelApplied);
+            groupBox1.Controls.Add(pictureFine);
+            groupBox1.Controls.Add(labelInfo);
+            groupBox1.Controls.Add(labelCPU);
+            groupBox1.Controls.Add(labelTotal);
+            groupBox1.Controls.Add(label2);
+            groupBox1.Controls.Add(label1);
+            groupBox1.Controls.Add(trackCPU);
+            groupBox1.Controls.Add(trackTotal);
+            groupBox1.Location = new Point(6, 6);
+            groupBox1.Margin = new Padding(2, 1, 2, 1);
+            groupBox1.Name = "groupBox1";
+            groupBox1.Padding = new Padding(3, 2, 3, 2);
+            groupBox1.Size = new Size(178, 459);
+            groupBox1.TabIndex = 4;
+            groupBox1.TabStop = false;
+            groupBox1.Text = "Power Limits (PPT)";
+            // 
+            // labelApplied
+            // 
+            labelApplied.AutoSize = true;
+            labelApplied.ForeColor = Color.Tomato;
+            labelApplied.Location = new Point(8, 18);
+            labelApplied.Margin = new Padding(2, 0, 2, 0);
+            labelApplied.Name = "labelApplied";
+            labelApplied.Size = new Size(71, 15);
+            labelApplied.TabIndex = 13;
+            labelApplied.Text = "Not Applied";
+            // 
+            // pictureFine
+            // 
+            pictureFine.Anchor = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
+            pictureFine.BackgroundImage = Properties.Resources.everything_is_fine_itsfine;
+            pictureFine.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureFine.Location = new Point(5, 343);
+            pictureFine.Margin = new Padding(2, 1, 2, 1);
+            pictureFine.Name = "pictureFine";
+            pictureFine.Size = new Size(167, 112);
+            pictureFine.TabIndex = 12;
+            pictureFine.TabStop = false;
+            pictureFine.Visible = false;
+            // 
+            // labelInfo
+            // 
+            labelInfo.AutoSize = true;
+            labelInfo.Dock = DockStyle.Bottom;
+            labelInfo.Location = new Point(3, 442);
+            labelInfo.Margin = new Padding(2, 0, 2, 0);
+            labelInfo.Name = "labelInfo";
+            labelInfo.Size = new Size(32, 15);
+            labelInfo.TabIndex = 11;
+            labelInfo.Text = "label";
+            // 
+            // labelCPU
+            // 
+            labelCPU.AutoSize = true;
+            labelCPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelCPU.Location = new Point(106, 59);
+            labelCPU.Margin = new Padding(2, 0, 2, 0);
+            labelCPU.Name = "labelCPU";
+            labelCPU.Size = new Size(30, 15);
+            labelCPU.TabIndex = 10;
+            labelCPU.Text = "CPU";
+            labelCPU.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // labelTotal
+            // 
+            labelTotal.AutoSize = true;
+            labelTotal.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelTotal.Location = new Point(21, 59);
+            labelTotal.Margin = new Padding(2, 0, 2, 0);
+            labelTotal.Name = "labelTotal";
+            labelTotal.Size = new Size(34, 15);
+            labelTotal.TabIndex = 9;
+            labelTotal.Text = "Total";
+            labelTotal.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // label2
+            // 
+            label2.AutoSize = true;
+            label2.Location = new Point(108, 43);
+            label2.Margin = new Padding(2, 0, 2, 0);
+            label2.Name = "label2";
+            label2.Size = new Size(30, 15);
+            label2.TabIndex = 8;
+            label2.Text = "CPU";
+            label2.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // label1
+            // 
+            label1.AutoSize = true;
+            label1.Location = new Point(22, 43);
+            label1.Margin = new Padding(2, 0, 2, 0);
+            label1.Name = "label1";
+            label1.Size = new Size(32, 15);
+            label1.TabIndex = 7;
+            label1.Text = "Total";
+            label1.TextAlign = ContentAlignment.MiddleCenter;
+            // 
+            // trackCPU
+            // 
+            trackCPU.Location = new Point(109, 83);
+            trackCPU.Margin = new Padding(2, 1, 2, 1);
+            trackCPU.Maximum = 85;
+            trackCPU.Minimum = 15;
+            trackCPU.Name = "trackCPU";
+            trackCPU.Orientation = Orientation.Vertical;
+            trackCPU.Size = new Size(45, 208);
+            trackCPU.TabIndex = 6;
+            trackCPU.TickFrequency = 5;
+            trackCPU.Value = 80;
+            // 
+            // trackTotal
+            // 
+            trackTotal.Location = new Point(23, 83);
+            trackTotal.Margin = new Padding(2, 1, 2, 1);
+            trackTotal.Maximum = 150;
+            trackTotal.Minimum = 15;
+            trackTotal.Name = "trackTotal";
+            trackTotal.Orientation = Orientation.Vertical;
+            trackTotal.Size = new Size(45, 208);
+            trackTotal.TabIndex = 5;
+            trackTotal.TickFrequency = 5;
+            trackTotal.TickStyle = TickStyle.TopLeft;
+            trackTotal.Value = 125;
+            // 
+            // buttonApplyPower
+            // 
+            buttonApplyPower.Location = new Point(8, 476);
+            buttonApplyPower.Margin = new Padding(2, 1, 2, 1);
+            buttonApplyPower.Name = "buttonApplyPower";
+            buttonApplyPower.Size = new Size(176, 22);
+            buttonApplyPower.TabIndex = 11;
+            buttonApplyPower.Text = "Apply Power Limits";
+            buttonApplyPower.UseVisualStyleBackColor = true;
+            // 
+            // checkAuto
+            // 
+            checkAuto.AutoSize = true;
+            checkAuto.Location = new Point(381, 479);
+            checkAuto.Margin = new Padding(2, 1, 2, 1);
+            checkAuto.Name = "checkAuto";
+            checkAuto.Size = new Size(86, 19);
+            checkAuto.TabIndex = 12;
+            checkAuto.Text = "Auto Apply";
+            checkAuto.UseVisualStyleBackColor = true;
+            // 
             // Fans
             // 
-            AutoScaleDimensions = new SizeF(13F, 32F);
+            AutoScaleDimensions = new SizeF(7F, 15F);
             AutoScaleMode = AutoScaleMode.Font;
-            ClientSize = new Size(940, 1020);
+            ClientSize = new Size(621, 510);
+            Controls.Add(checkAuto);
+            Controls.Add(buttonApplyPower);
+            Controls.Add(groupBox1);
             Controls.Add(chartGPU);
             Controls.Add(buttonReset);
             Controls.Add(buttonApply);
             Controls.Add(chartCPU);
             FormBorderStyle = FormBorderStyle.FixedSingle;
+            Margin = new Padding(2, 1, 2, 1);
             MaximizeBox = false;
             MdiChildrenMinimizedAnchorBottom = false;
             MinimizeBox = false;
@@ -93,10 +266,16 @@
             ShowIcon = false;
             ShowInTaskbar = false;
             StartPosition = FormStartPosition.CenterScreen;
-            Text = "Fans";
+            Text = "Fans and Power";
             ((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
             ((System.ComponentModel.ISupportInitialize)chartGPU).EndInit();
+            groupBox1.ResumeLayout(false);
+            groupBox1.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureFine).EndInit();
+            ((System.ComponentModel.ISupportInitialize)trackCPU).EndInit();
+            ((System.ComponentModel.ISupportInitialize)trackTotal).EndInit();
             ResumeLayout(false);
+            PerformLayout();
         }
 
         #endregion
@@ -105,5 +284,17 @@
         private Button buttonApply;
         private Button buttonReset;
         private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
+        private GroupBox groupBox1;
+        private Label labelCPU;
+        private Label labelTotal;
+        private Label label2;
+        private Label label1;
+        private TrackBar trackCPU;
+        private TrackBar trackTotal;
+        private Button buttonApplyPower;
+        private Label labelInfo;
+        private PictureBox pictureFine;
+        private Label labelApplied;
+        private CheckBox checkAuto;
     }
 }

Fans.cs

@@ -11,6 +11,14 @@ namespace GHelper
         Series seriesCPU;
         Series seriesGPU;
 
+        const int MaxTotal = 150;
+        const int MinTotal = 15;
+        const int DefaultTotal = 125;
+
+        const int MaxCPU = 90;
+        const int MinCPU = 15;
+        const int DefaultCPU = 80;
+
         void SetChart(Chart chart, int device)
         {
 
@@ -29,12 +37,27 @@ namespace GHelper
             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.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;
 
@@ -43,7 +66,7 @@ namespace GHelper
         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()
@@ -51,14 +74,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;
 
@@ -68,10 +91,119 @@ namespace GHelper
             buttonReset.Click += ButtonReset_Click;
             buttonApply.Click += ButtonApply_Click;
 
+            trackTotal.Maximum = MaxTotal;
+            trackTotal.Minimum = MinTotal;
+
+            trackCPU.Maximum = MaxCPU;
+            trackCPU.Minimum = MinCPU;
+
+            trackCPU.Scroll += TrackCPU_Scroll;
+            trackTotal.Scroll += TrackTotal_Scroll;
+
+            buttonApplyPower.Click += ButtonApplyPower_Click;
+
+            checkAuto.Click += CheckAuto_Click;
+
+            //labelInfo.MaximumSize = new Size(280, 0);
+            labelInfo.Text = "Power Limits (PPT) is\nexperimental feature.\n\nValues will be applied\nonly after you click 'Apply'\nand reset after performance\nmode changes.\n\nUse carefully and\non your own risk!";
+
+            LoadFans();
+            VisualisePower(true);
+
             Shown += Fans_Shown;
 
         }
 
+        private void CheckAuto_Click(object? sender, EventArgs e)
+        {
+            if (sender is null)
+                return;
+
+            CheckBox chk = (CheckBox)sender;
+
+            Program.config.setConfig("auto_apply_" + Program.config.getConfig("performance_mode"), 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)
+        {
+            int limit_total = trackTotal.Value;
+            int limit_cpu = trackCPU.Value;
+
+            Program.config.setConfig("limit_total", limit_total);
+            Program.config.setConfig("limit_cpu", limit_cpu);
+
+            Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA0, limit_total);
+            Program.wmi.DeviceSet(ASUSWmi.PPT_TotalA1, limit_total);
+
+            Program.wmi.DeviceSet(ASUSWmi.PPT_CPUB0, limit_cpu);
+            Program.wmi.DeviceSet(ASUSWmi.PPT_CPUA2, limit_cpu);
+
+            labelApplied.ForeColor = Color.Blue;
+            labelApplied.Text = "Applied";
+
+        }
+
+        public void VisualisePower(bool init = false)
+        {
+
+            int limit_total;
+            int limit_cpu;
+
+            if (init)
+            {
+                limit_total = Program.config.getConfig("limit_total");
+                limit_cpu = Program.config.getConfig("limit_cpu");
+            }
+            else
+            {
+                limit_total = trackTotal.Value;
+                limit_cpu = trackCPU.Value;
+            }
+
+            if (limit_total < 0) limit_total = DefaultTotal;
+            if (limit_total > MaxTotal) limit_total = MaxTotal;
+            if (limit_total < MinTotal) limit_total = MinTotal;
+
+            if (limit_cpu < 0) limit_cpu = DefaultCPU;
+            if (limit_cpu > MaxCPU) limit_cpu = MaxCPU;
+            if (limit_cpu < MinCPU) limit_cpu = MinCPU;
+
+            if (limit_cpu > limit_total) limit_cpu = limit_total;
+
+            trackTotal.Value = limit_total;
+            trackCPU.Value = limit_cpu;
+
+            labelTotal.Text = trackTotal.Value.ToString() + "W";
+            labelCPU.Text = trackCPU.Value.ToString() + "W";
+
+            pictureFine.Visible = (limit_cpu > 85 || limit_total > 145);
+        }
+
+        private void TrackTotal_Scroll(object? sender, EventArgs e)
+        {
+            VisualisePower();
+        }
+
+        private void TrackCPU_Scroll(object? sender, EventArgs e)
+        {
+            VisualisePower();
+        }
+
+        public void ResetApplyLabel()
+        {
+            labelApplied.ForeColor = Color.Red;
+            labelApplied.Text = "Not Applied";
+        }
+
         public void LoadFans()
         {
 
@@ -81,28 +213,12 @@ namespace GHelper
             LoadProfile(seriesCPU, 0);
             LoadProfile(seriesGPU, 1);
 
+            int auto_apply = Program.config.getConfig("auto_apply_" + Program.config.getConfig("performance_mode"));
+
+            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)
         {
@@ -114,15 +230,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));
 
@@ -147,10 +261,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);
 
         }
@@ -166,7 +277,13 @@ namespace GHelper
         {
             LoadProfile(seriesCPU, 0, 1);
             LoadProfile(seriesGPU, 1, 1);
+
+            checkAuto.Checked = false;
+            Program.config.setConfig("auto_apply_" + Program.config.getConfig("performance_mode"), 0);
+
             Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"));
+
+            ResetApplyLabel();
         }
 
         private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
@@ -194,18 +311,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.15.1</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" />

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,139 @@
+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();
+            groupBox1.SuspendLayout();
+            SuspendLayout();
+            // 
+            // groupBox1
+            // 
+            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, 196);
+            groupBox1.TabIndex = 0;
+            groupBox1.TabStop = false;
+            groupBox1.Text = "Key Bindings";
+            // 
+            // textM4
+            // 
+            textM4.Location = new Point(411, 113);
+            textM4.Name = "textM4";
+            textM4.PlaceholderText = "notepad /p \"file.txt\"";
+            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:";
+            // 
+            // 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;
+    }
+}

Keyboard.cs

@@ -0,0 +1,97 @@
+using System.Diagnostics.Metrics;
+
+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"},
+          {"custom", "Custom"}
+        };
+
+
+        public Keyboard()
+        {
+            InitializeComponent();
+
+            comboM3.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboM3.DataSource = new BindingSource(customActions, null);
+            comboM3.DisplayMember = "Value";
+            comboM3.ValueMember = "Key";
+
+            customActions[""] = "Performance";
+            comboM4.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboM4.DataSource = new BindingSource(customActions, null);
+            comboM4.DisplayMember = "Value";
+            comboM4.ValueMember = "Key";
+
+            comboM3.SelectedValueChanged += ComboM3_SelectedValueChanged;
+            comboM4.SelectedValueChanged += ComboM4_SelectedValueChanged;
+
+            textM3.TextChanged += TextM3_TextChanged;
+            textM4.TextChanged += TextM4_TextChanged;
+
+            Shown += Keyboard_Shown;
+        }
+
+        private void TextM3_TextChanged(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            TextBox tb = (TextBox)sender;
+            Program.config.setConfig("m3_custom", tb.Text);
+        }
+
+        private void TextM4_TextChanged(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            TextBox tb = (TextBox)sender;
+            Program.config.setConfig("m4_custom", tb.Text);
+        }
+
+        private void ComboKeyChanged(object? sender, string name = "m3")
+        {
+            if (sender is null) return;
+            ComboBox cmb = (ComboBox)sender;
+
+            if (cmb.SelectedValue is not null)
+                Program.config.setConfig(name, cmb.SelectedValue.ToString());
+        }
+
+        private void ComboM4_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            ComboKeyChanged(sender, "m4");
+        }
+
+        private void ComboM3_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            ComboKeyChanged(sender, "m3");
+        }
+
+        private void Keyboard_Shown(object? sender, EventArgs e)
+        {
+
+            Top = Program.settingsForm.Top;
+            Left = Program.settingsForm.Left - Width - 5;
+
+            string m3 = Program.config.getConfigString("m3");
+            string m4 = Program.config.getConfigString("m4");
+
+            comboM3.SelectedValue = (m3 is not null) ? m3 : "";
+            comboM4.SelectedValue = (m4 is not null) ? m4 : "";
+
+            if (comboM3.SelectedValue is null) comboM3.SelectedValue = "";
+            if (comboM4.SelectedValue is null) comboM4.SelectedValue = "";
+
+            textM3.Text = Program.config.getConfigString("m3_custom");
+            textM4.Text = Program.config.getConfigString("m4_custom");
+
+        }
+    }
+}

Keyboard.resx

@@ -0,0 +1,60 @@
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

NativeMethods.cs

@@ -4,6 +4,23 @@ using System.Runtime.InteropServices;
 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);

OSDBase.cs

@@ -273,22 +273,7 @@ namespace OSD
     }
 
     #region #  Win32  #
-    internal struct PAINTSTRUCT
-    {
-        public IntPtr hdc;
-        public int fErase;
-        public Rectangle rcPaint;
-        public int fRestore;
-        public int fIncUpdate;
-        public int Reserved1;
-        public int Reserved2;
-        public int Reserved3;
-        public int Reserved4;
-        public int Reserved5;
-        public int Reserved6;
-        public int Reserved7;
-        public int Reserved8;
-    }
+
     [StructLayout(LayoutKind.Sequential)]
     internal struct POINT
     {
@@ -362,16 +347,12 @@ namespace OSD
         [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 IntPtr BeginPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
-        [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 bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
-        [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern IntPtr GetDC(IntPtr hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern IntPtr GetFocus();

Program.cs

@@ -1,85 +1,7 @@
 using Microsoft.Win32;
 using System.Diagnostics;
 using System.Management;
-using System.Runtime.InteropServices;
-using System.Security.Principal;
-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);
-    }
-
-
-}
+using Starlight.AnimeMatrix;
 
 public class HardwareMonitor
 {
@@ -124,7 +46,7 @@ namespace GHelper
 
         public static ASUSWmi wmi = new ASUSWmi();
         public static AppConfig config = new AppConfig();
-        
+
         public static SettingsForm settingsForm = new SettingsForm();
         public static ToastForm toast = new ToastForm();
 
@@ -140,17 +62,11 @@ namespace GHelper
             settingsForm.InitBoost();
             settingsForm.InitAura();
 
-            settingsForm.SetPerformanceMode(config.getConfig("performance_mode"));
-            settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
-
             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();
 
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
 
@@ -160,11 +76,96 @@ namespace GHelper
 
         }
 
-        private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        private static void SetAutoModes()
         {
+            PowerLineStatus isPlugged = SystemInformation.PowerStatus.PowerLineStatus;
+            settingsForm.AutoGPUMode(isPlugged);
+            settingsForm.AutoScreen(isPlugged);
+            settingsForm.AutoPerformance(isPlugged);
             settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
         }
 
+        private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        {
+            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.Length == 0)
+            {
+                if (name == "m4")
+                    action = "performance";
+            }
+
+            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 "custom":
+                    CustomKey(name);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+
         static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
         {
             var collection = (ManagementEventWatcher)sender;
@@ -177,54 +178,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();
-                    });
+                    settingsForm.BeginInvoke(settingsForm.CycleAuraMode);
                     return;
-                case 87:  // Battery
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.AutoGPUMode(0);
-                        settingsForm.AutoScreen(0);
-                    });
-                    return;
-                case 88:  // Plugged
-                    settingsForm.BeginInvoke(delegate
-                    {
-                        settingsForm.AutoScreen(1);
-                        settingsForm.AutoGPUMode(1);
-                    });
-                    return;
-
             }
 
 
         }
 
+        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>
@@ -110,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,19 +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-fan-head-96" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-fan-head-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-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,23 +1,31 @@
-# G-Helper (For G14, G15, ROG FLOW, and others)
+# G-Helper (For Asus ROG Zephyrus G14, G15, Flow X13, Flow X16, and others)
 
 A small utility that allows you do almost everyting you could do with Armory Crate but without extra bloat and unnecessary services.
 
-1. Switch between default **Performance modes** - Silent / Balanced / Turbo and apply default fan curves
+## NEW (and experimental) features
+
+1. Set Power limits (PPT) for Total (APU + dGPU) and CPU. 
+2. Anime matrix control thanks to https://github.com/vddCore/Starlight
+
+## 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 apply custom ones
+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
+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 M4 key / FN+F5 to cycle through performance modes (with OSD notification) and FN+F4 to cycle through keeyboard animation modes
-10. Turn cpu turbo boost on/off with one checkbox to keep temps cooler
+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 developer for Asus Zephyrus G14 2022 (with AMD Radeon iGPU and dGPU). But could and should potentially work for G14 of 2021 and 2020, G15, X FLOW, and other ROG models for relevant and supported features.
+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 also recommend to keep "Asus Optimization Service" running , as it keeps basic laptop hotkeys such as screen or keyboard brightness adjustment working. If you have (or had) MyASUS app installed, that service is most probably still up an running even after MyASUS uninstall. 
+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)
 
@@ -25,7 +33,7 @@ I also recommend to keep "Asus Optimization Service" running , as it keeps basic
 
 ## 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)
@@ -39,27 +47,19 @@ PPTs are shown for G14 2022, for other models PPTs will be different as they are
 2. Standard mode (Windows Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
 3. Ultimate mode: iGPU and dGPU enabled, but dGPU drives built in display (supported only on G14 2022 model)
 
-## Things still missing
-
-1. Anime matrix control
-2. Custom bindings for M1-M3 keys
-
 ## How to install
 
 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
 
 ------------------
 

Settings.Designer.cs

@@ -56,12 +56,21 @@
             button60Hz = new Button();
             checkScreen = new CheckBox();
             checkBoost = new CheckBox();
-            pictureBox1 = new PictureBox();
+            pictureKeyboard = new PictureBox();
             label1 = new Label();
             comboKeyboard = new ComboBox();
             buttonKeyboardColor = new Button();
             labelBattery = new Label();
             buttonFans = new Button();
+            buttonKeyboard = new Button();
+            pictureColor = new PictureBox();
+            pictureColor2 = new PictureBox();
+            labelVersion = new Label();
+            pictureMatrix = new PictureBox();
+            labelMatrix = new Label();
+            comboMatrix = new ComboBox();
+            comboMatrixRunning = new ComboBox();
+            buttonMatrix = new Button();
             ((System.ComponentModel.ISupportInitialize)trackBattery).BeginInit();
             ((System.ComponentModel.ISupportInitialize)pictureBattery).BeginInit();
             tableGPU.SuspendLayout();
@@ -70,16 +79,19 @@
             ((System.ComponentModel.ISupportInitialize)picturePerf).BeginInit();
             ((System.ComponentModel.ISupportInitialize)pictureScreen).BeginInit();
             tableScreen.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureBox1).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)pictureKeyboard).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)pictureColor).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)pictureColor2).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)pictureMatrix).BeginInit();
             SuspendLayout();
             // 
             // checkStartup
             // 
             checkStartup.AutoSize = true;
-            checkStartup.Location = new Point(40, 1016);
-            checkStartup.Margin = new Padding(4, 2, 4, 2);
+            checkStartup.Location = new Point(18, 569);
+            checkStartup.Margin = new Padding(2, 1, 2, 1);
             checkStartup.Name = "checkStartup";
-            checkStartup.Size = new Size(206, 36);
+            checkStartup.Size = new Size(105, 19);
             checkStartup.TabIndex = 2;
             checkStartup.Text = "Run on Startup";
             checkStartup.UseVisualStyleBackColor = true;
@@ -89,12 +101,12 @@
             // 
             trackBattery.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
             trackBattery.LargeChange = 20;
-            trackBattery.Location = new Point(20, 908);
-            trackBattery.Margin = new Padding(4, 2, 4, 2);
+            trackBattery.Location = new Point(11, 515);
+            trackBattery.Margin = new Padding(2, 1, 2, 1);
             trackBattery.Maximum = 100;
             trackBattery.Minimum = 50;
             trackBattery.Name = "trackBattery";
-            trackBattery.Size = new Size(676, 90);
+            trackBattery.Size = new Size(341, 45);
             trackBattery.SmallChange = 10;
             trackBattery.TabIndex = 3;
             trackBattery.TickFrequency = 10;
@@ -105,10 +117,10 @@
             // 
             labelBatteryTitle.AutoSize = true;
             labelBatteryTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelBatteryTitle.Location = new Point(76, 870);
-            labelBatteryTitle.Margin = new Padding(4, 0, 4, 0);
+            labelBatteryTitle.Location = new Point(40, 496);
+            labelBatteryTitle.Margin = new Padding(2, 0, 2, 0);
             labelBatteryTitle.Name = "labelBatteryTitle";
-            labelBatteryTitle.Size = new Size(248, 32);
+            labelBatteryTitle.Size = new Size(122, 15);
             labelBatteryTitle.TabIndex = 4;
             labelBatteryTitle.Text = "Battery Charge Limit";
             // 
@@ -116,22 +128,22 @@
             // 
             pictureBattery.BackgroundImage = (Image)resources.GetObject("pictureBattery.BackgroundImage");
             pictureBattery.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureBattery.Location = new Point(32, 868);
-            pictureBattery.Margin = new Padding(4, 2, 4, 2);
+            pictureBattery.Location = new Point(19, 495);
+            pictureBattery.Margin = new Padding(2, 1, 2, 1);
             pictureBattery.Name = "pictureBattery";
-            pictureBattery.Size = new Size(36, 38);
+            pictureBattery.Size = new Size(18, 19);
             pictureBattery.TabIndex = 6;
             pictureBattery.TabStop = false;
             // 
             // labelGPUFan
             // 
             labelGPUFan.Anchor = AnchorStyles.Top | AnchorStyles.Right;
-            labelGPUFan.Location = new Point(410, 262);
-            labelGPUFan.Margin = new Padding(4, 0, 4, 0);
+            labelGPUFan.Location = new Point(172, 131);
+            labelGPUFan.Margin = new Padding(2, 0, 2, 0);
             labelGPUFan.Name = "labelGPUFan";
-            labelGPUFan.Size = new Size(276, 32);
+            labelGPUFan.Size = new Size(174, 16);
             labelGPUFan.TabIndex = 8;
-            labelGPUFan.Text = "GPU Fan : 0%";
+            labelGPUFan.Text = "         ";
             labelGPUFan.TextAlign = ContentAlignment.TopRight;
             // 
             // tableGPU
@@ -144,12 +156,12 @@
             tableGPU.Controls.Add(buttonUltimate, 2, 0);
             tableGPU.Controls.Add(buttonStandard, 1, 0);
             tableGPU.Controls.Add(buttonEco, 0, 0);
-            tableGPU.Location = new Point(22, 304);
-            tableGPU.Margin = new Padding(4, 2, 4, 2);
+            tableGPU.Location = new Point(11, 152);
+            tableGPU.Margin = new Padding(2, 1, 2, 1);
             tableGPU.Name = "tableGPU";
             tableGPU.RowCount = 1;
-            tableGPU.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
-            tableGPU.Size = new Size(676, 108);
+            tableGPU.RowStyles.Add(new RowStyle(SizeType.Absolute, 54F));
+            tableGPU.Size = new Size(341, 54);
             tableGPU.TabIndex = 7;
             // 
             // buttonUltimate
@@ -158,10 +170,10 @@
             buttonUltimate.Dock = DockStyle.Fill;
             buttonUltimate.FlatAppearance.BorderSize = 0;
             buttonUltimate.FlatStyle = FlatStyle.Flat;
-            buttonUltimate.Location = new Point(458, 12);
-            buttonUltimate.Margin = new Padding(8, 12, 8, 12);
+            buttonUltimate.Location = new Point(230, 6);
+            buttonUltimate.Margin = new Padding(4, 6, 4, 6);
             buttonUltimate.Name = "buttonUltimate";
-            buttonUltimate.Size = new Size(210, 84);
+            buttonUltimate.Size = new Size(107, 42);
             buttonUltimate.TabIndex = 2;
             buttonUltimate.Text = "Ultimate";
             buttonUltimate.UseVisualStyleBackColor = false;
@@ -172,10 +184,10 @@
             buttonStandard.Dock = DockStyle.Fill;
             buttonStandard.FlatAppearance.BorderSize = 0;
             buttonStandard.FlatStyle = FlatStyle.Flat;
-            buttonStandard.Location = new Point(233, 12);
-            buttonStandard.Margin = new Padding(8, 12, 8, 12);
+            buttonStandard.Location = new Point(117, 6);
+            buttonStandard.Margin = new Padding(4, 6, 4, 6);
             buttonStandard.Name = "buttonStandard";
-            buttonStandard.Size = new Size(209, 84);
+            buttonStandard.Size = new Size(105, 42);
             buttonStandard.TabIndex = 1;
             buttonStandard.Text = "Standard";
             buttonStandard.UseVisualStyleBackColor = false;
@@ -187,10 +199,10 @@
             buttonEco.Dock = DockStyle.Fill;
             buttonEco.FlatAppearance.BorderSize = 0;
             buttonEco.FlatStyle = FlatStyle.Flat;
-            buttonEco.Location = new Point(8, 12);
-            buttonEco.Margin = new Padding(8, 12, 8, 12);
+            buttonEco.Location = new Point(4, 6);
+            buttonEco.Margin = new Padding(4, 6, 4, 6);
             buttonEco.Name = "buttonEco";
-            buttonEco.Size = new Size(209, 84);
+            buttonEco.Size = new Size(105, 42);
             buttonEco.TabIndex = 0;
             buttonEco.Text = "Eco";
             buttonEco.UseVisualStyleBackColor = false;
@@ -199,10 +211,10 @@
             // 
             labelGPU.AutoSize = true;
             labelGPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelGPU.Location = new Point(76, 264);
-            labelGPU.Margin = new Padding(4, 0, 4, 0);
+            labelGPU.Location = new Point(39, 132);
+            labelGPU.Margin = new Padding(2, 0, 2, 0);
             labelGPU.Name = "labelGPU";
-            labelGPU.Size = new Size(136, 32);
+            labelGPU.Size = new Size(67, 15);
             labelGPU.TabIndex = 9;
             labelGPU.Text = "GPU Mode";
             // 
@@ -210,22 +222,22 @@
             // 
             pictureGPU.BackgroundImage = (Image)resources.GetObject("pictureGPU.BackgroundImage");
             pictureGPU.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureGPU.Location = new Point(32, 262);
-            pictureGPU.Margin = new Padding(4, 2, 4, 2);
+            pictureGPU.Location = new Point(18, 131);
+            pictureGPU.Margin = new Padding(2, 1, 2, 1);
             pictureGPU.Name = "pictureGPU";
-            pictureGPU.Size = new Size(36, 38);
+            pictureGPU.Size = new Size(18, 19);
             pictureGPU.TabIndex = 10;
             pictureGPU.TabStop = false;
             // 
             // labelCPUFan
             // 
             labelCPUFan.Anchor = AnchorStyles.Top | AnchorStyles.Right;
-            labelCPUFan.Location = new Point(410, 38);
-            labelCPUFan.Margin = new Padding(4, 0, 4, 0);
+            labelCPUFan.Location = new Point(163, 19);
+            labelCPUFan.Margin = new Padding(2, 0, 2, 0);
             labelCPUFan.Name = "labelCPUFan";
-            labelCPUFan.Size = new Size(276, 32);
+            labelCPUFan.Size = new Size(183, 16);
             labelCPUFan.TabIndex = 12;
-            labelCPUFan.Text = "CPU Fan : 0%";
+            labelCPUFan.Text = "      ";
             labelCPUFan.TextAlign = ContentAlignment.TopRight;
             // 
             // tablePerf
@@ -238,12 +250,12 @@
             tablePerf.Controls.Add(buttonTurbo, 2, 0);
             tablePerf.Controls.Add(buttonBalanced, 1, 0);
             tablePerf.Controls.Add(buttonSilent, 0, 0);
-            tablePerf.Location = new Point(22, 76);
-            tablePerf.Margin = new Padding(4, 2, 4, 2);
+            tablePerf.Location = new Point(11, 38);
+            tablePerf.Margin = new Padding(2, 1, 2, 1);
             tablePerf.Name = "tablePerf";
             tablePerf.RowCount = 1;
-            tablePerf.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
-            tablePerf.Size = new Size(676, 108);
+            tablePerf.RowStyles.Add(new RowStyle(SizeType.Absolute, 54F));
+            tablePerf.Size = new Size(341, 54);
             tablePerf.TabIndex = 11;
             // 
             // buttonTurbo
@@ -253,10 +265,10 @@
             buttonTurbo.FlatAppearance.BorderColor = Color.FromArgb(192, 0, 0);
             buttonTurbo.FlatAppearance.BorderSize = 0;
             buttonTurbo.FlatStyle = FlatStyle.Flat;
-            buttonTurbo.Location = new Point(458, 12);
-            buttonTurbo.Margin = new Padding(8, 12, 8, 12);
+            buttonTurbo.Location = new Point(230, 6);
+            buttonTurbo.Margin = new Padding(4, 6, 4, 6);
             buttonTurbo.Name = "buttonTurbo";
-            buttonTurbo.Size = new Size(210, 84);
+            buttonTurbo.Size = new Size(107, 42);
             buttonTurbo.TabIndex = 2;
             buttonTurbo.Text = "Turbo";
             buttonTurbo.UseVisualStyleBackColor = false;
@@ -268,10 +280,10 @@
             buttonBalanced.FlatAppearance.BorderColor = Color.FromArgb(0, 0, 192);
             buttonBalanced.FlatAppearance.BorderSize = 0;
             buttonBalanced.FlatStyle = FlatStyle.Flat;
-            buttonBalanced.Location = new Point(233, 12);
-            buttonBalanced.Margin = new Padding(8, 12, 8, 12);
+            buttonBalanced.Location = new Point(117, 6);
+            buttonBalanced.Margin = new Padding(4, 6, 4, 6);
             buttonBalanced.Name = "buttonBalanced";
-            buttonBalanced.Size = new Size(209, 84);
+            buttonBalanced.Size = new Size(105, 42);
             buttonBalanced.TabIndex = 1;
             buttonBalanced.Text = "Balanced";
             buttonBalanced.UseVisualStyleBackColor = false;
@@ -284,10 +296,10 @@
             buttonSilent.FlatAppearance.BorderColor = Color.FromArgb(0, 192, 192);
             buttonSilent.FlatAppearance.BorderSize = 0;
             buttonSilent.FlatStyle = FlatStyle.Flat;
-            buttonSilent.Location = new Point(8, 12);
-            buttonSilent.Margin = new Padding(8, 12, 8, 12);
+            buttonSilent.Location = new Point(4, 6);
+            buttonSilent.Margin = new Padding(4, 6, 4, 6);
             buttonSilent.Name = "buttonSilent";
-            buttonSilent.Size = new Size(209, 84);
+            buttonSilent.Size = new Size(105, 42);
             buttonSilent.TabIndex = 0;
             buttonSilent.Text = "Silent";
             buttonSilent.UseVisualStyleBackColor = false;
@@ -297,10 +309,10 @@
             picturePerf.BackgroundImage = (Image)resources.GetObject("picturePerf.BackgroundImage");
             picturePerf.BackgroundImageLayout = ImageLayout.Zoom;
             picturePerf.InitialImage = null;
-            picturePerf.Location = new Point(32, 36);
-            picturePerf.Margin = new Padding(4, 2, 4, 2);
+            picturePerf.Location = new Point(18, 18);
+            picturePerf.Margin = new Padding(2, 1, 2, 1);
             picturePerf.Name = "picturePerf";
-            picturePerf.Size = new Size(36, 38);
+            picturePerf.Size = new Size(18, 19);
             picturePerf.TabIndex = 14;
             picturePerf.TabStop = false;
             // 
@@ -308,10 +320,10 @@
             // 
             labelPerf.AutoSize = true;
             labelPerf.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelPerf.Location = new Point(76, 38);
-            labelPerf.Margin = new Padding(4, 0, 4, 0);
+            labelPerf.Location = new Point(39, 19);
+            labelPerf.Margin = new Padding(2, 0, 2, 0);
             labelPerf.Name = "labelPerf";
-            labelPerf.Size = new Size(234, 32);
+            labelPerf.Size = new Size(115, 15);
             labelPerf.TabIndex = 13;
             labelPerf.Text = "Performance Mode";
             // 
@@ -319,10 +331,10 @@
             // 
             checkGPU.AutoSize = true;
             checkGPU.ForeColor = SystemColors.GrayText;
-            checkGPU.Location = new Point(32, 412);
-            checkGPU.Margin = new Padding(4, 2, 4, 2);
+            checkGPU.Location = new Point(16, 206);
+            checkGPU.Margin = new Padding(2, 1, 2, 1);
             checkGPU.Name = "checkGPU";
-            checkGPU.Size = new Size(550, 36);
+            checkGPU.Size = new Size(273, 19);
             checkGPU.TabIndex = 15;
             checkGPU.Text = "Set Eco on battery and Standard when plugged";
             checkGPU.UseVisualStyleBackColor = true;
@@ -332,10 +344,10 @@
             // 
             buttonQuit.Anchor = AnchorStyles.Top | AnchorStyles.Right;
             buttonQuit.BackColor = SystemColors.ButtonFace;
-            buttonQuit.Location = new Point(576, 1008);
-            buttonQuit.Margin = new Padding(4, 2, 4, 2);
+            buttonQuit.Location = new Point(292, 565);
+            buttonQuit.Margin = new Padding(2, 1, 2, 1);
             buttonQuit.Name = "buttonQuit";
-            buttonQuit.Size = new Size(120, 48);
+            buttonQuit.Size = new Size(60, 24);
             buttonQuit.TabIndex = 16;
             buttonQuit.Text = "Quit";
             buttonQuit.UseVisualStyleBackColor = false;
@@ -344,10 +356,10 @@
             // 
             pictureScreen.BackgroundImage = (Image)resources.GetObject("pictureScreen.BackgroundImage");
             pictureScreen.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureScreen.Location = new Point(32, 496);
-            pictureScreen.Margin = new Padding(4, 2, 4, 2);
+            pictureScreen.Location = new Point(18, 248);
+            pictureScreen.Margin = new Padding(2, 1, 2, 1);
             pictureScreen.Name = "pictureScreen";
-            pictureScreen.Size = new Size(36, 38);
+            pictureScreen.Size = new Size(18, 19);
             pictureScreen.TabIndex = 18;
             pictureScreen.TabStop = false;
             // 
@@ -355,10 +367,10 @@
             // 
             labelSreen.AutoSize = true;
             labelSreen.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelSreen.Location = new Point(76, 496);
-            labelSreen.Margin = new Padding(4, 0, 4, 0);
+            labelSreen.Location = new Point(39, 248);
+            labelSreen.Margin = new Padding(2, 0, 2, 0);
             labelSreen.Name = "labelSreen";
-            labelSreen.Size = new Size(176, 32);
+            labelSreen.Size = new Size(87, 15);
             labelSreen.TabIndex = 17;
             labelSreen.Text = "Laptop Screen";
             // 
@@ -371,12 +383,12 @@
             tableScreen.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
             tableScreen.Controls.Add(button120Hz, 1, 0);
             tableScreen.Controls.Add(button60Hz, 0, 0);
-            tableScreen.Location = new Point(22, 536);
-            tableScreen.Margin = new Padding(4, 2, 4, 2);
+            tableScreen.Location = new Point(11, 268);
+            tableScreen.Margin = new Padding(2, 1, 2, 1);
             tableScreen.Name = "tableScreen";
             tableScreen.RowCount = 1;
-            tableScreen.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
-            tableScreen.Size = new Size(676, 108);
+            tableScreen.RowStyles.Add(new RowStyle(SizeType.Absolute, 54F));
+            tableScreen.Size = new Size(341, 54);
             tableScreen.TabIndex = 19;
             // 
             // button120Hz
@@ -386,10 +398,10 @@
             button120Hz.FlatAppearance.BorderColor = SystemColors.ActiveBorder;
             button120Hz.FlatAppearance.BorderSize = 0;
             button120Hz.FlatStyle = FlatStyle.Flat;
-            button120Hz.Location = new Point(233, 12);
-            button120Hz.Margin = new Padding(8, 12, 8, 12);
+            button120Hz.Location = new Point(117, 6);
+            button120Hz.Margin = new Padding(4, 6, 4, 6);
             button120Hz.Name = "button120Hz";
-            button120Hz.Size = new Size(209, 84);
+            button120Hz.Size = new Size(105, 42);
             button120Hz.TabIndex = 1;
             button120Hz.Text = "120Hz + OD";
             button120Hz.UseVisualStyleBackColor = false;
@@ -403,10 +415,10 @@
             button60Hz.FlatAppearance.BorderSize = 0;
             button60Hz.FlatStyle = FlatStyle.Flat;
             button60Hz.ForeColor = SystemColors.ControlText;
-            button60Hz.Location = new Point(8, 12);
-            button60Hz.Margin = new Padding(8, 12, 8, 12);
+            button60Hz.Location = new Point(4, 6);
+            button60Hz.Margin = new Padding(4, 6, 4, 6);
             button60Hz.Name = "button60Hz";
-            button60Hz.Size = new Size(209, 84);
+            button60Hz.Size = new Size(105, 42);
             button60Hz.TabIndex = 0;
             button60Hz.Text = "60Hz";
             button60Hz.UseVisualStyleBackColor = false;
@@ -415,10 +427,10 @@
             // 
             checkScreen.AutoSize = true;
             checkScreen.ForeColor = SystemColors.GrayText;
-            checkScreen.Location = new Point(32, 644);
-            checkScreen.Margin = new Padding(4, 2, 4, 2);
+            checkScreen.Location = new Point(16, 322);
+            checkScreen.Margin = new Padding(2, 1, 2, 1);
             checkScreen.Name = "checkScreen";
-            checkScreen.Size = new Size(527, 36);
+            checkScreen.Size = new Size(261, 19);
             checkScreen.TabIndex = 20;
             checkScreen.Text = "Set 60Hz on battery, and back when plugged";
             checkScreen.UseVisualStyleBackColor = true;
@@ -427,47 +439,46 @@
             // 
             checkBoost.AutoSize = true;
             checkBoost.ForeColor = SystemColors.GrayText;
-            checkBoost.Location = new Point(32, 184);
-            checkBoost.Margin = new Padding(4, 2, 4, 2);
+            checkBoost.Location = new Point(16, 92);
+            checkBoost.Margin = new Padding(2, 1, 2, 1);
             checkBoost.Name = "checkBoost";
-            checkBoost.Size = new Size(320, 36);
+            checkBoost.Size = new Size(161, 19);
             checkBoost.TabIndex = 21;
             checkBoost.Text = "CPU Turbo Boost enabled";
             checkBoost.UseVisualStyleBackColor = true;
             // 
-            // pictureBox1
+            // pictureKeyboard
             // 
-            pictureBox1.BackgroundImage = Properties.Resources.icons8_keyboard_48;
-            pictureBox1.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureBox1.Location = new Point(32, 724);
-            pictureBox1.Margin = new Padding(4, 2, 4, 2);
-            pictureBox1.Name = "pictureBox1";
-            pictureBox1.Size = new Size(36, 36);
-            pictureBox1.TabIndex = 23;
-            pictureBox1.TabStop = false;
+            pictureKeyboard.BackgroundImage = Properties.Resources.icons8_keyboard_48;
+            pictureKeyboard.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureKeyboard.Location = new Point(18, 362);
+            pictureKeyboard.Margin = new Padding(2, 1, 2, 1);
+            pictureKeyboard.Name = "pictureKeyboard";
+            pictureKeyboard.Size = new Size(18, 18);
+            pictureKeyboard.TabIndex = 23;
+            pictureKeyboard.TabStop = false;
             // 
             // label1
             // 
             label1.AutoSize = true;
             label1.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            label1.Location = new Point(76, 724);
-            label1.Margin = new Padding(4, 0, 4, 0);
+            label1.Location = new Point(39, 362);
+            label1.Margin = new Padding(2, 0, 2, 0);
             label1.Name = "label1";
-            label1.Size = new Size(210, 32);
+            label1.Size = new Size(101, 15);
             label1.TabIndex = 22;
             label1.Text = "Laptop Keyboard";
             // 
             // comboKeyboard
             // 
-            comboKeyboard.FlatStyle = FlatStyle.Flat;
-            comboKeyboard.Font = new Font("Segoe UI", 10F, FontStyle.Regular, GraphicsUnit.Point);
+            comboKeyboard.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
             comboKeyboard.FormattingEnabled = true;
-            comboKeyboard.ItemHeight = 37;
-            comboKeyboard.Items.AddRange(new object[] { "Static", "Breathe", "Strobe", "Rainbow" });
-            comboKeyboard.Location = new Point(36, 777);
+            comboKeyboard.ItemHeight = 15;
+            comboKeyboard.Items.AddRange(new object[] { "Static", "Breathe", "Strobe", "Rainbow", "Dingding" });
+            comboKeyboard.Location = new Point(15, 385);
             comboKeyboard.Margin = new Padding(0);
             comboKeyboard.Name = "comboKeyboard";
-            comboKeyboard.Size = new Size(200, 45);
+            comboKeyboard.Size = new Size(108, 23);
             comboKeyboard.TabIndex = 24;
             comboKeyboard.TabStop = false;
             // 
@@ -477,23 +488,22 @@
             buttonKeyboardColor.BackColor = SystemColors.ButtonHighlight;
             buttonKeyboardColor.FlatAppearance.BorderColor = Color.Red;
             buttonKeyboardColor.FlatAppearance.BorderSize = 2;
-            buttonKeyboardColor.FlatStyle = FlatStyle.Flat;
             buttonKeyboardColor.ForeColor = SystemColors.ControlText;
-            buttonKeyboardColor.Location = new Point(256, 775);
+            buttonKeyboardColor.Location = new Point(128, 383);
             buttonKeyboardColor.Margin = new Padding(0);
             buttonKeyboardColor.Name = "buttonKeyboardColor";
-            buttonKeyboardColor.Size = new Size(212, 50);
+            buttonKeyboardColor.Size = new Size(106, 25);
             buttonKeyboardColor.TabIndex = 25;
-            buttonKeyboardColor.Text = "Color";
+            buttonKeyboardColor.Text = "Color  ";
             buttonKeyboardColor.UseVisualStyleBackColor = false;
             // 
             // labelBattery
             // 
             labelBattery.Anchor = AnchorStyles.Top | AnchorStyles.Right;
-            labelBattery.Location = new Point(410, 868);
-            labelBattery.Margin = new Padding(4, 0, 4, 0);
+            labelBattery.Location = new Point(210, 496);
+            labelBattery.Margin = new Padding(2, 0, 2, 0);
             labelBattery.Name = "labelBattery";
-            labelBattery.Size = new Size(276, 32);
+            labelBattery.Size = new Size(138, 16);
             labelBattery.TabIndex = 27;
             labelBattery.Text = "                ";
             labelBattery.TextAlign = ContentAlignment.TopRight;
@@ -503,24 +513,137 @@
             buttonFans.Anchor = AnchorStyles.Top | AnchorStyles.Right;
             buttonFans.BackColor = SystemColors.ButtonFace;
             buttonFans.FlatAppearance.BorderSize = 0;
-            buttonFans.Location = new Point(480, 186);
-            buttonFans.Margin = new Padding(4, 2, 4, 2);
+            buttonFans.Location = new Point(243, 93);
+            buttonFans.Margin = new Padding(2, 1, 2, 1);
             buttonFans.Name = "buttonFans";
-            buttonFans.Size = new Size(210, 48);
+            buttonFans.Size = new Size(105, 24);
             buttonFans.TabIndex = 28;
-            buttonFans.Text = "Fan Profile";
+            buttonFans.Text = "Fans and Power";
             buttonFans.UseVisualStyleBackColor = false;
             // 
+            // buttonKeyboard
+            // 
+            buttonKeyboard.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            buttonKeyboard.BackColor = SystemColors.ButtonFace;
+            buttonKeyboard.FlatAppearance.BorderSize = 0;
+            buttonKeyboard.Location = new Point(243, 382);
+            buttonKeyboard.Margin = new Padding(2, 1, 2, 1);
+            buttonKeyboard.Name = "buttonKeyboard";
+            buttonKeyboard.Size = new Size(104, 24);
+            buttonKeyboard.TabIndex = 29;
+            buttonKeyboard.Text = "Extra";
+            buttonKeyboard.UseVisualStyleBackColor = false;
+            // 
+            // pictureColor
+            // 
+            pictureColor.Location = new Point(216, 390);
+            pictureColor.Margin = new Padding(2, 2, 2, 2);
+            pictureColor.Name = "pictureColor";
+            pictureColor.Size = new Size(10, 10);
+            pictureColor.TabIndex = 30;
+            pictureColor.TabStop = false;
+            // 
+            // pictureColor2
+            // 
+            pictureColor2.Location = new Point(202, 390);
+            pictureColor2.Margin = new Padding(2, 2, 2, 2);
+            pictureColor2.Name = "pictureColor2";
+            pictureColor2.Size = new Size(10, 10);
+            pictureColor2.TabIndex = 31;
+            pictureColor2.TabStop = false;
+            // 
+            // labelVersion
+            // 
+            labelVersion.AutoSize = true;
+            labelVersion.Font = new Font("Segoe UI", 9F, FontStyle.Underline, GraphicsUnit.Point);
+            labelVersion.ForeColor = SystemColors.ControlDark;
+            labelVersion.Location = new Point(18, 544);
+            labelVersion.Margin = new Padding(2, 0, 2, 0);
+            labelVersion.Name = "labelVersion";
+            labelVersion.Size = new Size(22, 15);
+            labelVersion.TabIndex = 32;
+            labelVersion.Text = "v.0";
+            // 
+            // pictureMatrix
+            // 
+            pictureMatrix.BackgroundImage = Properties.Resources.icons8_matrix_desktop_48;
+            pictureMatrix.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureMatrix.Location = new Point(18, 429);
+            pictureMatrix.Margin = new Padding(2, 1, 2, 1);
+            pictureMatrix.Name = "pictureMatrix";
+            pictureMatrix.Size = new Size(18, 18);
+            pictureMatrix.TabIndex = 34;
+            pictureMatrix.TabStop = false;
+            // 
+            // labelMatrix
+            // 
+            labelMatrix.AutoSize = true;
+            labelMatrix.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelMatrix.Location = new Point(39, 429);
+            labelMatrix.Margin = new Padding(2, 0, 2, 0);
+            labelMatrix.Name = "labelMatrix";
+            labelMatrix.Size = new Size(83, 15);
+            labelMatrix.TabIndex = 33;
+            labelMatrix.Text = "Anime Matrix";
+            // 
+            // comboMatrix
+            // 
+            comboMatrix.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            comboMatrix.FormattingEnabled = true;
+            comboMatrix.ItemHeight = 15;
+            comboMatrix.Items.AddRange(new object[] { "Off", "Dim", "Medium", "Bright" });
+            comboMatrix.Location = new Point(15, 455);
+            comboMatrix.Margin = new Padding(0);
+            comboMatrix.Name = "comboMatrix";
+            comboMatrix.Size = new Size(108, 23);
+            comboMatrix.TabIndex = 35;
+            comboMatrix.TabStop = false;
+            // 
+            // comboMatrixRunning
+            // 
+            comboMatrixRunning.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            comboMatrixRunning.FormattingEnabled = true;
+            comboMatrixRunning.ItemHeight = 15;
+            comboMatrixRunning.Items.AddRange(new object[] { "Binary Banner", "Rog Logo", "Picture" });
+            comboMatrixRunning.Location = new Point(128, 455);
+            comboMatrixRunning.Margin = new Padding(0);
+            comboMatrixRunning.Name = "comboMatrixRunning";
+            comboMatrixRunning.Size = new Size(108, 23);
+            comboMatrixRunning.TabIndex = 36;
+            comboMatrixRunning.TabStop = false;
+            // 
+            // buttonMatrix
+            // 
+            buttonMatrix.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            buttonMatrix.BackColor = SystemColors.ButtonFace;
+            buttonMatrix.FlatAppearance.BorderSize = 0;
+            buttonMatrix.Location = new Point(243, 452);
+            buttonMatrix.Margin = new Padding(2, 1, 2, 1);
+            buttonMatrix.Name = "buttonMatrix";
+            buttonMatrix.Size = new Size(104, 24);
+            buttonMatrix.TabIndex = 37;
+            buttonMatrix.Text = "Picture";
+            buttonMatrix.UseVisualStyleBackColor = false;
+            // 
             // SettingsForm
             // 
-            AutoScaleDimensions = new SizeF(192F, 192F);
+            AutoScaleDimensions = new SizeF(96F, 96F);
             AutoScaleMode = AutoScaleMode.Dpi;
-            ClientSize = new Size(730, 1086);
+            ClientSize = new Size(368, 602);
+            Controls.Add(buttonMatrix);
+            Controls.Add(comboMatrixRunning);
+            Controls.Add(comboMatrix);
+            Controls.Add(pictureMatrix);
+            Controls.Add(labelMatrix);
+            Controls.Add(labelVersion);
+            Controls.Add(pictureColor2);
+            Controls.Add(pictureColor);
+            Controls.Add(buttonKeyboard);
             Controls.Add(buttonFans);
             Controls.Add(labelBattery);
             Controls.Add(buttonKeyboardColor);
             Controls.Add(comboKeyboard);
-            Controls.Add(pictureBox1);
+            Controls.Add(pictureKeyboard);
             Controls.Add(label1);
             Controls.Add(checkBoost);
             Controls.Add(checkScreen);
@@ -542,12 +665,12 @@
             Controls.Add(trackBattery);
             Controls.Add(checkStartup);
             FormBorderStyle = FormBorderStyle.FixedSingle;
-            Margin = new Padding(4, 2, 4, 2);
+            Margin = new Padding(2, 1, 2, 1);
             MaximizeBox = false;
             MdiChildrenMinimizedAnchorBottom = false;
             MinimizeBox = false;
             Name = "SettingsForm";
-            Padding = new Padding(8, 12, 8, 12);
+            Padding = new Padding(4, 6, 4, 6);
             ShowIcon = false;
             StartPosition = FormStartPosition.CenterScreen;
             Text = "G-Helper";
@@ -560,7 +683,10 @@
             ((System.ComponentModel.ISupportInitialize)picturePerf).EndInit();
             ((System.ComponentModel.ISupportInitialize)pictureScreen).EndInit();
             tableScreen.ResumeLayout(false);
-            ((System.ComponentModel.ISupportInitialize)pictureBox1).EndInit();
+            ((System.ComponentModel.ISupportInitialize)pictureKeyboard).EndInit();
+            ((System.ComponentModel.ISupportInitialize)pictureColor).EndInit();
+            ((System.ComponentModel.ISupportInitialize)pictureColor2).EndInit();
+            ((System.ComponentModel.ISupportInitialize)pictureMatrix).EndInit();
             ResumeLayout(false);
             PerformLayout();
         }
@@ -593,11 +719,20 @@
         private Button button60Hz;
         private CheckBox checkScreen;
         private CheckBox checkBoost;
-        private PictureBox pictureBox1;
+        private PictureBox pictureKeyboard;
         private Label label1;
         private ComboBox comboKeyboard;
         private Button buttonKeyboardColor;
         private Label labelBattery;
         private Button buttonFans;
+        private Button buttonKeyboard;
+        private PictureBox pictureColor;
+        private PictureBox pictureColor2;
+        private Label labelVersion;
+        private PictureBox pictureMatrix;
+        private Label labelMatrix;
+        private ComboBox comboMatrix;
+        private ComboBox comboMatrixRunning;
+        private Button buttonMatrix;
     }
 }

Settings.cs

@@ -1,6 +1,10 @@
-using System.Diagnostics;
+using Starlight.AnimeMatrix;
+using System.Diagnostics;
+using System.Reflection;
 using System.Timers;
-
+using System.Drawing.Imaging;
+using System.CodeDom.Compiler;
+using System.Drawing;
 
 namespace GHelper
 {
@@ -17,9 +21,10 @@ namespace GHelper
 
         static System.Timers.Timer aTimer = default!;
 
-        public string perfName;
+        public string perfName = "Balanced";
 
         Fans fans;
+        Keyboard keyb;
 
         public SettingsForm()
         {
@@ -59,31 +64,232 @@ namespace GHelper
 
             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;
+
+            labelVersion.Text = "Version " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
+            labelVersion.Click += LabelVersion_Click;
+
+            labelCPUFan.Click += LabelCPUFan_Click;
+            labelGPUFan.Click += LabelCPUFan_Click;
+
+
+            InitMatrix();
+
+            comboMatrix.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboMatrixRunning.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboMatrix.SelectedValueChanged += ComboMatrix_SelectedValueChanged;
+            comboMatrixRunning.SelectedValueChanged += ComboMatrixRunning_SelectedValueChanged;
+
+            buttonMatrix.Click += ButtonMatrix_Click;
+
 
             SetTimer();
 
+        }
+
+        void SetMatrixPicture(string fileName)
+        {
+
+            int width = 34 * 3;
+            int height = 61;
+            float scale;
+
+            Bitmap image;
+
+            try
+            {
+                using (var bmpTemp = (Bitmap)Image.FromFile(fileName))
+                {
+                    image = new Bitmap(bmpTemp);
+
+                    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, 34, 61);
+
+                    var mat = new AnimeMatrixDevice();
+                    mat.SetBuiltInAnimation(false);
+
+                    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)((pixel.R + pixel.G + pixel.B) / 3);
+                            mat.SetLedPlanar(x, y, color);
+                        }
+                    }
+
+                    mat.Present();
+                    mat.Dispose();
+                }
+            }
+            catch
+            {
+                Debug.WriteLine("Error loading picture");
+            }
 
 
         }
 
+
+        private void ButtonMatrix_Click(object? sender, EventArgs e)
+        {
+            Thread t = new Thread((ThreadStart)(() =>
+            {
+                OpenFileDialog of = new OpenFileDialog();
+                of.Filter = "Image Files (*.bmp;*.jpg;*.jpeg,*.png)|*.BMP;*.JPG;*.JPEG;*.PNG";
+                if (of.ShowDialog() == DialogResult.OK)
+                {
+                    Program.config.setConfig("matrix_picture", of.FileName);
+                    SetMatrixPicture(of.FileName);
+                    BeginInvoke(delegate
+                    {
+                        comboMatrixRunning.SelectedIndex = 2;
+                    });
+                }
+                return;
+            }));
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+        }
+
+        private void ComboMatrixRunning_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            SetAnimeMatrix();
+        }
+
+
+        private void ComboMatrix_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            SetAnimeMatrix();
+        }
+
+        private void SetAnimeMatrix()
+        {
+
+            int brightness = comboMatrix.SelectedIndex;
+            int running = comboMatrixRunning.SelectedIndex;
+
+            var mat = new AnimeMatrixDevice();
+
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                BuiltInAnimation.Sleeping.Starfield,
+                BuiltInAnimation.Shutdown.SeeYa,
+                BuiltInAnimation.Startup.StaticEmergence
+            );
+
+
+            if (brightness == 0)
+            {
+                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);
+                }
+            }
+
+            mat.Dispose();
+
+            Program.config.setConfig("matrix_brightness", comboMatrix.SelectedIndex);
+            Program.config.setConfig("matrix_running", comboMatrixRunning.SelectedIndex);
+        }
+
+
+
+        private void LabelCPUFan_Click(object? sender, EventArgs e)
+        {
+            Program.config.setConfig("fan_rpm", (Program.config.getConfig("fan_rpm") == 1) ? 0 : 1);
+            RefreshSensors();
+        }
+
+        private void LabelVersion_Click(object? sender, EventArgs e)
+        {
+            Process.Start(new ProcessStartInfo("http://github.com/seerge/g-helper/releases") { UseShellExecute = true });
+        }
+
+        private void PictureColor2_Click(object? sender, EventArgs e)
+        {
+
+            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)
         {
             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 +302,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 +314,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 +327,46 @@ 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 SetAuraColor(Color color, bool apply = true)
+        public void InitMatrix()
         {
-            Aura.Color1 = color;
-            Program.config.setConfig("aura_color", color.ToArgb());
+            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;
+        }
+
+
+        public void SetAuraColor(Color? color1 = null, Color? color2 = null, bool apply = true)
+        {
+
+            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 +374,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;
@@ -181,7 +415,7 @@ namespace GHelper
 
             CheckBox chk = (CheckBox)sender;
             if (chk.Checked)
-                NativeMethods.SetCPUBoost(3);
+                NativeMethods.SetCPUBoost(2);
             else
                 NativeMethods.SetCPUBoost(0);
         }
@@ -332,10 +566,20 @@ namespace GHelper
             aTimer.Enabled = false;
         }
 
+
+        private static string FormatFan(int fan)
+        {
+            if (Program.config.getConfig("fan_rpm") == 1)
+                return " Fan: " + (fan * 100).ToString() + "RPM";
+            else
+                return " Fan: " + Math.Min(Math.Round(fan / 0.6), 100).ToString() + "%"; // relatively to 6000 rpm
+        }
+
         private static void RefreshSensors()
         {
-            string cpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan) / 0.6).ToString() + "%";
-            string gpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan) / 0.6).ToString() + "%";
+
+            string cpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan));
+            string gpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan));
 
             string cpuTemp = "";
             string gpuTemp = "";
@@ -373,7 +617,7 @@ namespace GHelper
                 this.Top = Screen.FromControl(this).WorkingArea.Height - 10 - this.Height;
                 this.Activate();
 
-                aTimer.Interval = 500;
+                aTimer.Interval = 300;
                 aTimer.Enabled = true;
 
             }
@@ -407,31 +651,37 @@ 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);
+
+            if (Program.config.getConfig("auto_apply_" + PerformanceMode) == 1)
             {
-                Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
-            }
-            catch
-            {
-                labelPerf.Text = "Performance Mode: not supported";
+                Program.wmi.SetFanCurve(0, Program.config.getFanConfig(0));
+                Program.wmi.SetFanCurve(1, Program.config.getFanConfig(1));
             }
 
             if (fans != null && fans.Text != "")
+            {
                 fans.LoadFans();
+                fans.ResetApplyLabel();
+            }
 
-            if (notify) {
+            if (notify && (oldMode != PerformanceMode))
+            {
                 try
                 {
                     Program.toast.RunToast(perfName);
-                } catch
+                }
+                catch
                 {
                     Debug.WriteLine("Toast error");
                 }
             }
 
-}
+        }
 
 
         public void CyclePerformanceMode()
@@ -439,12 +689,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);
@@ -453,7 +713,7 @@ namespace GHelper
 
         }
 
-        public void AutoGPUMode(int Plugged = 1)
+        public void AutoGPUMode(PowerLineStatus Plugged = PowerLineStatus.Online)
         {
 
             int GpuAuto = Program.config.getConfig("gpu_auto");
@@ -467,12 +727,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();
@@ -576,9 +836,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;
@@ -650,18 +915,12 @@ namespace GHelper
         public void SetBatteryChargeLimit(int limit = 100)
         {
 
-            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);
 
         }

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

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