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

New Crowdin updates

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,7 +7,7 @@ about: Create a report to help us improve
 
 ## NOTE
 Bug reports without clear information or scenario to reproduce and logs from ``%AppData%\GHelper`` will be closed without answer. 
-Please respect time of the developer. Thanks.
+Please respect the time of the developer. Thanks.
 
 
 **Describe the bug**
@@ -34,7 +34,7 @@ If applicable, add screenshots to help explain your problem.
  - Laptop model
 
 **Asus software**
-- Armoury crate (or it's services installed)
+- Armoury Crate (or it's services installed)
 - MyASUS installed
 - Other Asus services running in background
 

.github/SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 0.25+   | :white_check_mark: |
-| < 0.24  | :x:                |
+| 0.89+   | :white_check_mark: |
+| < 0.89  | :x:                |
 
 ## Reporting a Vulnerability
 

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: |
+          7.0.x
+    - name: Build
+      run: |
+        dotnet build app/GHelper.sln

.github/workflows/codeql.yml

@@ -0,0 +1,28 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  schedule:
+  - cron: '34 18 * * 3'
+
+permissions:
+  actions: read
+  contents: read
+  security-events: write
+
+jobs:
+  codeql:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: c#
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+    - name: Analyze
+      uses: github/codeql-action/analyze@v2

.github/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Release
+
+on:
+  release:
+    types: [ published ]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v3
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: |
+          7.0.x
+    - name: Publish
+      run: |
+        dotnet publish app/GHelper.sln --configuration Release --runtime win-x64 -p:PublishSingleFile=true --no-self-contained
+        powershell Compress-Archive app/bin/x64/Release/net7.0-windows/win-x64/publish/* GHelper.zip
+    - name: Upload
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        gh release upload ${{ github.ref_name }} GHelper.zip

app/AnimeMatrix/AniMatrixControl.cs

@@ -0,0 +1,388 @@
+using NAudio.CoreAudioApi;
+using NAudio.Wave;
+using Starlight.AnimeMatrix;
+using System.Diagnostics;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Timers;
+
+namespace GHelper.AnimeMatrix
+{
+
+    public class AniMatrixControl
+    {
+
+        SettingsForm settings;
+
+        System.Timers.Timer matrixTimer = default!;
+        public AnimeMatrixDevice? device;
+
+        double[]? AudioValues;
+        WasapiCapture? AudioDevice;
+
+        public bool IsValid => device != null;
+
+        private long lastPresent;
+        private List<double> maxes = new List<double>();
+
+        public AniMatrixControl(SettingsForm settingsForm)
+        {
+            settings = settingsForm;
+
+            try
+            {
+                device = new AnimeMatrixDevice();
+                Task.Run(device.WakeUp);
+                matrixTimer = new System.Timers.Timer(100);
+                matrixTimer.Elapsed += MatrixTimer_Elapsed;
+            }
+            catch
+            {
+                device = null;
+            }
+
+        }
+
+        public void SetMatrix(bool wakeUp = false)
+        {
+
+            if (!IsValid) return;
+
+            int brightness = AppConfig.Get("matrix_brightness");
+            int running = AppConfig.Get("matrix_running");
+
+            bool auto = AppConfig.Is("matrix_auto");
+
+            if (brightness < 0) brightness = 0;
+            if (running < 0) running = 0;
+
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                BuiltInAnimation.Sleeping.Starfield,
+                BuiltInAnimation.Shutdown.SeeYa,
+                BuiltInAnimation.Startup.StaticEmergence
+            );
+
+            StopMatrixTimer();
+            StopMatrixAudio();
+
+            try
+            {
+                device.SetProvider();
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+                return;
+            }
+
+            if (wakeUp && AppConfig.ContainsModel("401")) device.WakeUp();
+
+            if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
+            {
+                device.SetDisplayState(false);
+                device.SetDisplayState(false); // some devices are dumb
+                Logger.WriteLine("Matrix Off");
+            }
+            else
+            {
+                device.SetDisplayState(true);
+                device.SetBrightness((BrightnessMode)brightness);
+
+                switch (running)
+                {
+                    case 2:
+                        SetMatrixPicture(AppConfig.GetString("matrix_picture"));
+                        break;
+                    case 3:
+                        SetMatrixClock();
+                        break;
+                    case 4:
+                        SetMatrixAudio();
+                        break;
+                    default:
+                        device.SetBuiltInAnimation(true, animation);
+                        Logger.WriteLine("Matrix builtin " + animation.AsByte);
+                        break;
+
+                }
+
+                //mat.SetBrightness((BrightnessMode)brightness);
+            }
+
+        }
+        private void StartMatrixTimer(int interval = 100)
+        {
+            matrixTimer.Interval = interval;
+            matrixTimer.Start();
+        }
+
+        private void StopMatrixTimer()
+        {
+            matrixTimer.Stop();
+        }
+
+
+        private void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
+        {
+            //if (!IsValid) return;
+
+            switch (AppConfig.Get("matrix_running"))
+            {
+                case 2:
+                    device.PresentNextFrame();
+                    break;
+                case 3:
+                    device.PresentClock();
+                    break;
+            }
+
+        }
+
+
+        public void SetMatrixClock()
+        {
+            device.SetBuiltInAnimation(false);
+            StartMatrixTimer(1000);
+            Logger.WriteLine("Matrix Clock");
+        }
+
+        public void Dispose()
+        {
+            StopMatrixAudio();
+        }
+
+        void StopMatrixAudio()
+        {
+            if (AudioDevice is not null)
+            {
+                try
+                {
+                    AudioDevice.StopRecording();
+                    AudioDevice.Dispose();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+            }
+        }
+
+        void SetMatrixAudio()
+        {
+            if (!IsValid) return;
+
+            device.SetBuiltInAnimation(false);
+            StopMatrixTimer();
+            StopMatrixAudio();
+
+            try
+            {
+                using (var enumerator = new MMDeviceEnumerator())
+                using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
+                {
+                    AudioDevice = new WasapiLoopbackCapture(device);
+                    WaveFormat fmt = AudioDevice.WaveFormat;
+
+                    AudioValues = new double[fmt.SampleRate / 1000];
+                    AudioDevice.DataAvailable += WaveIn_DataAvailable;
+                    AudioDevice.StartRecording();
+                    Logger.WriteLine("Matrix Audio");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+
+        }
+
+        private void WaveIn_DataAvailable(object? sender, WaveInEventArgs e)
+        {
+            int bytesPerSamplePerChannel = AudioDevice.WaveFormat.BitsPerSample / 8;
+            int bytesPerSample = bytesPerSamplePerChannel * AudioDevice.WaveFormat.Channels;
+            int bufferSampleCount = e.Buffer.Length / bytesPerSample;
+
+            if (bufferSampleCount >= AudioValues.Length)
+            {
+                bufferSampleCount = AudioValues.Length;
+            }
+
+            if (bytesPerSamplePerChannel == 2 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToInt16(e.Buffer, i * bytesPerSample);
+            }
+            else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToInt32(e.Buffer, i * bytesPerSample);
+            }
+            else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
+            {
+                for (int i = 0; i < bufferSampleCount; i++)
+                    AudioValues[i] = BitConverter.ToSingle(e.Buffer, i * bytesPerSample);
+            }
+
+            double[] paddedAudio = FftSharp.Pad.ZeroPad(AudioValues);
+            double[] fftMag = FftSharp.Transform.FFTmagnitude(paddedAudio);
+
+            PresentAudio(fftMag);
+        }
+
+        private void DrawBar(int pos, double h)
+        {
+            int dx = pos * 2;
+            int dy = 20;
+
+            byte color;
+
+            for (int y = 0; y < h - (h % 2); y++)
+                for (int x = 0; x < 2 - (y % 2); x++)
+                {
+                    //color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
+                    device.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
+                    device.SetLedPlanar(x + dx, dy - y, 255);
+                }
+        }
+
+        void PresentAudio(double[] audio)
+        {
+
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
+            lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
+            device.Clear();
+
+            int size = 20;
+            double[] bars = new double[size];
+            double max = 2, maxAverage;
+
+            for (int i = 0; i < size; i++)
+            {
+                bars[i] = Math.Sqrt(audio[i] * 10000);
+                if (bars[i] > max) max = bars[i];
+            }
+
+            maxes.Add(max);
+            if (maxes.Count > 20) maxes.RemoveAt(0);
+            maxAverage = maxes.Average();
+
+            for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i] * 20 / maxAverage);
+
+            device.Present();
+        }
+
+
+        public void OpenMatrixPicture()
+        {
+            string fileName = null;
+
+            Thread t = new Thread(() =>
+            {
+                OpenFileDialog of = new OpenFileDialog();
+                of.Filter = "Image Files (*.bmp;*.jpg;*.jpeg,*.png,*.gif)|*.BMP;*.JPG;*.JPEG;*.PNG;*.GIF";
+                if (of.ShowDialog() == DialogResult.OK)
+                {
+                    fileName = of.FileName;
+                }
+                return;
+            });
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+
+            if (fileName is not null)
+            {
+                AppConfig.Set("matrix_picture", fileName);
+                AppConfig.Set("matrix_running", 2);
+
+                SetMatrixPicture(fileName);
+                settings.SetMatrixRunning(2);
+
+            }
+
+        }
+
+        public void SetMatrixPicture(string fileName, bool visualise = true)
+        {
+
+            if (!IsValid) return;
+            StopMatrixTimer();
+
+            try
+            {
+                using (var fs = new FileStream(fileName, FileMode.Open))
+                //using (var ms = new MemoryStream())
+                {
+                    /*
+                    ms.SetLength(0);
+                    fs.CopyTo(ms);
+                    ms.Position = 0;
+                    */
+                    using (Image image = Image.FromStream(fs))
+                    {
+                        ProcessPicture(image);
+                        Logger.WriteLine("Matrix " + fileName);
+                    }
+
+                    fs.Close();
+                    if (visualise) settings.VisualiseMatrix(fileName);
+                }
+            }
+            catch
+            {
+                Debug.WriteLine("Error loading picture");
+                return;
+            }
+
+        }
+
+        protected void ProcessPicture(Image image)
+        {
+            device.SetBuiltInAnimation(false);
+            device.ClearFrames();
+
+            int matrixX = AppConfig.Get("matrix_x", 0);
+            int matrixY = AppConfig.Get("matrix_y", 0);
+            int matrixZoom = AppConfig.Get("matrix_zoom", 100);
+            int matrixSpeed = AppConfig.Get("matrix_speed", 50);
+
+            InterpolationMode matrixQuality = (InterpolationMode)AppConfig.Get("matrix_quality", 0);
+
+
+            FrameDimension dimension = new FrameDimension(image.FrameDimensionsList[0]);
+            int frameCount = image.GetFrameCount(dimension);
+
+            if (frameCount > 1)
+            {
+                var delayPropertyBytes = image.GetPropertyItem(0x5100).Value;
+                var frameDelay = BitConverter.ToInt32(delayPropertyBytes) * 10;
+
+                for (int i = 0; i < frameCount; i++)
+                {
+                    image.SelectActiveFrame(dimension, i);
+                    device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality);
+                    device.AddFrame();
+                }
+
+
+                Logger.WriteLine("GIF Delay:" + frameDelay);
+                StartMatrixTimer(Math.Max(matrixSpeed, frameDelay));
+
+                //image.SelectActiveFrame(dimension, 0);
+
+            }
+            else
+            {
+                device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality);
+                device.Present();
+            }
+
+        }
+
+
+    }
+}

app/AnimeMatrix/AnimeMatrixDevice.cs

@@ -1,8 +1,9 @@
 // Source thanks to https://github.com/vddCore/Starlight with some adjustments from me
 
-using Starlight.Communication;
+using GHelper.AnimeMatrix.Communication;
 using System.Drawing.Drawing2D;
-using System.Globalization;
+using System.Drawing.Imaging;
+using System.Drawing.Text;
 using System.Management;
 using System.Text;
 
@@ -61,7 +62,8 @@ namespace Starlight.AnimeMatrix
     public enum AnimeType
     {
         GA401,
-        GA402
+        GA402,
+        GU604
     }
 
 
@@ -75,6 +77,7 @@ namespace Starlight.AnimeMatrix
     }
 
 
+
     public class AnimeMatrixDevice : Device
     {
         int UpdatePageLength = 490;
@@ -84,39 +87,75 @@ namespace Starlight.AnimeMatrix
         List<byte[]> frames = new List<byte[]>();
 
         public int MaxRows = 61;
-        //public int FullRows = 11;
-        //public int FullEvenRows = -1;
-
-        public int dx = 0;
         public int MaxColumns = 34;
+        public int LedStart = 0;
+
+        public int TextShift = 8;
 
         private int frameIndex = 0;
 
         private static AnimeType _model = AnimeType.GA402;
 
-        public AnimeMatrixDevice()
-            : base(0x0B05, 0x193B, 640)
+        [System.Runtime.InteropServices.DllImport("gdi32.dll")]
+        private static extern IntPtr AddFontMemResourceEx(IntPtr pbFont, uint cbFont, IntPtr pdv, [System.Runtime.InteropServices.In] ref uint pcFonts);
+        private PrivateFontCollection fonts = new PrivateFontCollection();
+
+        public AnimeMatrixDevice() : base(0x0B05, 0x193B, 640)
         {
             string model = GetModel();
+
             if (model.Contains("401"))
             {
-
                 _model = AnimeType.GA401;
 
                 MaxColumns = 33;
-                dx = 1;
-
                 MaxRows = 55;
                 LedCount = 1245;
 
                 UpdatePageLength = 410;
+
+                TextShift = 11;
+
+                LedStart = 1;
             }
 
+            if (model.Contains("GU604"))
+            {
+                _model = AnimeType.GU604;
+
+                MaxColumns = 39;
+                MaxRows = 92;
+                LedCount = 1711;
+                UpdatePageLength = 630;
+
+                TextShift = 10;
+            }
 
             _displayBuffer = new byte[LedCount];
 
+            /*
+            for (int i = 0; i < MaxRows; i++)
+            {
+                _model = AnimeType.GA401;
+                Logger.WriteLine(FirstX(i) + " " + Pitch(i));
+            }
+            */
+
+            LoadMFont();
+
         }
 
+        private void LoadMFont()
+        {
+            byte[] fontData = GHelper.Properties.Resources.MFont;
+            IntPtr fontPtr = System.Runtime.InteropServices.Marshal.AllocCoTaskMem(fontData.Length);
+            System.Runtime.InteropServices.Marshal.Copy(fontData, 0, fontPtr, fontData.Length);
+            uint dummy = 0;
+
+            fonts.AddMemoryFont(fontPtr, GHelper.Properties.Resources.MFont.Length);
+            AddFontMemResourceEx(fontPtr, (uint)GHelper.Properties.Resources.MFont.Length, IntPtr.Zero, ref dummy);
+            System.Runtime.InteropServices.Marshal.FreeCoTaskMem(fontPtr);
+        }
 
         public string GetModel()
         {
@@ -160,36 +199,43 @@ namespace Starlight.AnimeMatrix
         }
 
 
-        public static int FirstX(int y)
-        {
-            switch (_model)
-            {
-                case AnimeType.GA401:
-                    if (y < 5)
-                    {
-                        return 0;
-                    }
-                    else
-                    {
-                        return (y + 1) / 2 - 3;
-                    }
-                default:
-                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
-            }
-        }
-
-        public static int Width(int y)
+        public int Width()
         {
             switch (_model)
             {
                 case AnimeType.GA401:
                     return 33;
+                case AnimeType.GU604:
+                    return 39;
                 default:
                     return 34;
             }
         }
 
-        public static int Pitch(int y)
+        public int FirstX(int y)
+        {
+            switch (_model)
+            {
+                case AnimeType.GA401:
+                    if (y < 5 && y % 2 == 0)
+                    {
+                        return 1;
+                    }
+                    return (int)Math.Ceiling(Math.Max(0, y - 5) / 2F);
+                case AnimeType.GU604:
+                    if (y < 9 && y % 2 == 0)
+                    {
+                        return 1;
+                    }
+                    return (int)Math.Ceiling(Math.Max(0, y - 9) / 2F);
+
+                default:
+                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
+            }
+        }
+
+
+        public int Pitch(int y)
         {
             switch (_model)
             {
@@ -206,15 +252,38 @@ namespace Starlight.AnimeMatrix
                         default:
                             return 36 - y / 2;
                     }
+
+                case AnimeType.GU604:
+                    switch (y)
+                    {
+                        case 0:
+                        case 2:
+                        case 4:
+                        case 6:
+                        case 8:
+                            return 38;
+
+                        case 1:
+                        case 3:
+                        case 5:
+                        case 7:
+                        case 9:
+                            return 39;
+
+                        default:
+                            return Width() - FirstX(y);
+                    }
+
+
                 default:
-                    return Width(y) - FirstX(y);
+                    return Width() - FirstX(y);
             }
         }
 
 
         public int RowToLinearAddress(int y)
         {
-            int ret = 0;
+            int ret = LedStart;
             for (var i = 0; i < y; i++)
                 ret += Pitch(i);
 
@@ -225,8 +294,8 @@ namespace Starlight.AnimeMatrix
         {
             if (!IsRowInRange(y)) return;
 
-            if (x >= FirstX(y) && x < Width(y))
-                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x + dx, value);
+            if (x >= FirstX(y) && x < Width())
+                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x, value);
         }
 
         public void WakeUp()
@@ -324,14 +393,51 @@ namespace Starlight.AnimeMatrix
 
         public void PresentClock()
         {
-            int second = DateTime.Now.Second;
+            string second = (DateTime.Now.Second % 2 == 0) ? ":" : "  ";
+            string time = DateTime.Now.ToString("HH" + second + "mm");
+
+            Clear();
+            TextDiagonal(time, 15, 12, TextShift + 11);
+            TextDiagonal(DateTime.Now.ToString("yy'. 'MM'. 'dd"), 11.5F, 3, TextShift);
+            Present();
 
-            if (CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern.Contains("H"))
-                PresentTextDiagonal(DateTime.Now.ToString("H" + ((second % 2 == 0) ? ":" : " ") + "mm"));
-            else
-                PresentTextDiagonal(DateTime.Now.ToString("h" + ((second % 2 == 0) ? ":" : " ") + "mmtt"));
         }
 
+        public void TextDiagonal(string text, float fontSize = 10, int deltaX = 0, int deltaY = 10)
+        {
+
+            int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
+            int textHeight;
+
+            using (Bitmap bmp = new Bitmap(maxX, MaxRows))
+            {
+                using (Graphics g = Graphics.FromImage(bmp))
+                {
+                    g.CompositingQuality = CompositingQuality.HighQuality;
+                    g.SmoothingMode = SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
+
+                    using (Font font = new Font(fonts.Families[0], fontSize, FontStyle.Regular, GraphicsUnit.Pixel))
+                    {
+                        SizeF textSize = g.MeasureString(text, font);
+                        textHeight = (int)textSize.Height;
+                        g.DrawString(text, font, Brushes.White, 0, 0);
+                    }
+                }
+
+                for (int y = 0; y < bmp.Height; y++)
+                {
+                    for (int x = 0; x < bmp.Width; x++)
+                    {
+                        var pixel = bmp.GetPixel(x, y);
+                        var color = (pixel.R + pixel.G + pixel.B) / 3;
+                        if (color > 100) SetLedDiagonal(x, y, (byte)color, deltaX, deltaY);
+                    }
+                }
+            }
+        }
+
+
         public void PresentText(string text1, string text2 = "")
         {
             using (Bitmap bmp = new Bitmap(MaxColumns * 3, MaxRows))
@@ -340,15 +446,16 @@ namespace Starlight.AnimeMatrix
                 {
                     g.CompositingQuality = CompositingQuality.HighQuality;
                     g.SmoothingMode = SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
 
-                    using (Font font = new Font("Arial", 24F, GraphicsUnit.Pixel))
+                    using (Font font = new Font("Consolas", 22F, FontStyle.Regular, GraphicsUnit.Pixel))
                     {
                         SizeF textSize = g.MeasureString(text1, font);
-                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -3);
+                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
                     }
 
                     if (text2.Length > 0)
-                        using (Font font = new Font("Arial", 18F, GraphicsUnit.Pixel))
+                        using (Font font = new Font("Consolas", 18F, GraphicsUnit.Pixel))
                         {
                             SizeF textSize = g.MeasureString(text2, font);
                             g.DrawString(text2, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 1, 25);
@@ -356,13 +463,15 @@ namespace Starlight.AnimeMatrix
 
                 }
 
-                GenerateFrame(bmp, InterpolationMode.Bicubic);
+                bmp.Save("test.bmp", ImageFormat.Bmp);
+
+                GenerateFrame(bmp);
                 Present();
             }
 
         }
 
-        public void GenerateFrame(Image image, InterpolationMode interpolation = InterpolationMode.High)
+        public void GenerateFrame(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default)
         {
 
             int width = MaxColumns / 2 * 6;
@@ -374,25 +483,25 @@ namespace Starlight.AnimeMatrix
 
             using (Bitmap bmp = new Bitmap(targetWidth, height))
             {
-                scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height);
+                scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height) * zoom / 100;
 
                 using (var graph = Graphics.FromImage(bmp))
                 {
                     var scaleWidth = (float)(image.Width * scale);
                     var scaleHeight = (float)(image.Height * scale);
 
-                    graph.InterpolationMode = interpolation;
+                    graph.InterpolationMode = quality;
                     graph.CompositingQuality = CompositingQuality.HighQuality;
                     graph.SmoothingMode = SmoothingMode.AntiAlias;
 
-                    graph.DrawImage(image, (float)Math.Round(targetWidth - scaleWidth * targetWidth / width), 0, (float)Math.Round(scaleWidth * targetWidth / width), scaleHeight);
+                    graph.DrawImage(image, (float)Math.Round(targetWidth - (scaleWidth + panX) * targetWidth / width), -panY, (float)Math.Round(scaleWidth * targetWidth / width), scaleHeight);
 
                 }
 
                 for (int y = 0; y < bmp.Height; y++)
                 {
                     for (int x = 0; x < bmp.Width; x++)
-                        if (x % 2 == (y + dx) % 2)
+                        if (x % 2 == y % 2)
                         {
                             var pixel = bmp.GetPixel(x, y);
                             var color = (pixel.R + pixel.G + pixel.B) / 3;
@@ -404,50 +513,16 @@ namespace Starlight.AnimeMatrix
         }
 
 
-        public void SetLedDiagonal(int x, int y, byte color, int delta = 10)
+        public void SetLedDiagonal(int x, int y, byte color, int deltaX = 0, int deltaY = 10)
         {
-            //x+=delta;
-            y -= delta;
+            x += deltaX;
+            y -= deltaY;
 
-            int dx = (x - y) / 2;
-            int dy = x + y;
-            SetLedPlanar(dx, dy, color);
+            int plX = (x - y) / 2;
+            int plY = x + y;
+            SetLedPlanar(plX, plY, color);
         }
 
-        public void PresentTextDiagonal(string text)
-        {
-
-            Clear();
-
-            int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
-
-            using (Bitmap bmp = new Bitmap(maxX, MaxRows))
-            {
-                using (Graphics g = Graphics.FromImage(bmp))
-                {
-                    g.CompositingQuality = CompositingQuality.HighQuality;
-                    g.SmoothingMode = SmoothingMode.AntiAlias;
-
-                    using (Font font = new Font("Calibri", 14F, GraphicsUnit.Pixel))
-                    {
-                        SizeF textSize = g.MeasureString(text, font);
-                        g.DrawString(text, font, Brushes.White, 4, 0);
-                    }
-                }
-
-                for (int y = 0; y < bmp.Height; y++)
-                {
-                    for (int x = 0; x < bmp.Width; x++)
-                    {
-                        var pixel = bmp.GetPixel(x, y);
-                        var color = (pixel.R + pixel.G + pixel.B) / 3;
-                        SetLedDiagonal(x, y, (byte)color);
-                    }
-                }
-            }
-
-            Present();
-        }
 
         private bool IsRowInRange(int row)
         {

app/AnimeMatrix/Communication/Device.cs

@@ -1,17 +1,22 @@
 // Source thanks to https://github.com/vddCore/Starlight :)
 
-using Starlight.Communication.Platform;
-using System.Configuration;
+using GHelper.AnimeMatrix.Communication.Platform;
 
-namespace Starlight.Communication
+namespace GHelper.AnimeMatrix.Communication
 {
     public abstract class Device : IDisposable
     {
-        private static UsbProvider _usbProvider;
+        protected UsbProvider? _usbProvider;
 
-        private static ushort _vendorId;
-        private static ushort _productId;
-        private static int _maxFeatureReportLength;
+        protected ushort _vendorId;
+        protected ushort _productId;
+        protected int _maxFeatureReportLength;
+
+        protected Device(ushort vendorId, ushort productId)
+        {
+            _vendorId = vendorId;
+            _productId = productId;
+        }
 
         protected Device(ushort vendorId, ushort productId, int maxFeatureReportLength)
         {
@@ -21,7 +26,17 @@ namespace Starlight.Communication
             SetProvider();
         }
 
-        public void SetProvider()
+        public ushort VendorID()
+        {
+            return _vendorId;
+        }
+
+        public ushort ProductID()
+        {
+            return _productId;
+        }
+
+        public virtual void SetProvider()
         {
             _usbProvider = new WindowsUsbProvider(_vendorId, _productId, _maxFeatureReportLength);
         }
@@ -37,7 +52,12 @@ namespace Starlight.Communication
         public byte[] Get(Packet packet)
             => _usbProvider?.Get(packet.Data);
 
-        public void Dispose()
+        public void Read(byte[] data)
+            => _usbProvider?.Read(data);
+        public void Write(byte[] data)
+            => _usbProvider?.Write(data);
+
+        public virtual void Dispose()
         {
             _usbProvider?.Dispose();
         }

app/AnimeMatrix/Communication/Packet.cs

@@ -1,6 +1,6 @@
 // Source thanks to https://github.com/vddCore/Starlight :)
 
-namespace Starlight.Communication
+namespace GHelper.AnimeMatrix.Communication
 {
     public abstract class Packet
     {

app/AnimeMatrix/Communication/Platform/UsbProvider.cs

@@ -1,6 +1,6 @@
-namespace Starlight.Communication.Platform
+namespace GHelper.AnimeMatrix.Communication.Platform
 {
-    internal abstract class UsbProvider : IDisposable
+    public abstract class UsbProvider : IDisposable
     {
         protected ushort VendorID { get; }
         protected ushort ProductID { get; }
@@ -13,7 +13,9 @@ namespace Starlight.Communication.Platform
 
         public abstract void Set(byte[] data);
         public abstract byte[] Get(byte[] data);
-        
+        public abstract void Read(byte[] data);
+        public abstract void Write(byte[] data);
+
         public abstract void Dispose();
     }
 }

app/AnimeMatrix/Communication/Platform/WindowsUsbProvider.cs

@@ -1,14 +1,35 @@
 using System.ComponentModel;
 using HidSharp;
 
-namespace Starlight.Communication.Platform
+namespace GHelper.AnimeMatrix.Communication.Platform
 {
     internal class WindowsUsbProvider : UsbProvider
     {
         protected HidDevice HidDevice { get; }
         protected HidStream HidStream { get; }
 
-        public WindowsUsbProvider(ushort vendorId, ushort productId, int maxFeatureReportLength) 
+        public WindowsUsbProvider(ushort vendorId, ushort productId, string path, int timeout = 500) : base(vendorId, productId)
+        {
+            try
+            {
+                HidDevice = DeviceList.Local.GetHidDevices(vendorId, productId)
+                   .First(x => x.DevicePath.Contains(path));
+            }
+            catch
+            {
+                throw new IOException("HID 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);
+            HidStream.ReadTimeout = timeout;
+            HidStream.WriteTimeout = timeout;
+        }
+
+        public WindowsUsbProvider(ushort vendorId, ushort productId, int maxFeatureReportLength)
             : base(vendorId, productId)
         {
             try
@@ -43,7 +64,7 @@ namespace Starlight.Communication.Platform
         {
             var outData = new byte[data.Length];
             Array.Copy(data, outData, data.Length);
-            
+
             WrapException(() =>
             {
                 HidStream.GetFeature(outData);
@@ -53,11 +74,28 @@ namespace Starlight.Communication.Platform
             return data;
         }
 
+        public override void Read(byte[] data)
+        {
+            WrapException(() =>
+            {
+                HidStream.Read(data);
+            });
+        }
+
+        public override void Write(byte[] data)
+        {
+            WrapException(() =>
+            {
+                HidStream.Write(data);
+                HidStream.Flush();
+            });
+        }
+
         public override void Dispose()
         {
             HidStream.Dispose();
         }
-        
+
         private void WrapException(Action action)
         {
             try

app/AppConfig.cs

@@ -1,22 +1,31 @@
-using System.Diagnostics;
+using GHelper.Mode;
+using System.Diagnostics;
 using System.Management;
 using System.Text.Json;
 
-public class AppConfig
+public static class AppConfig
 {
 
-    public string appPath;
-    string configFile;
+    private static string configFile;
+    private static string? _model;
 
-    string _model;
+    private static Dictionary<string, object> config = new Dictionary<string, object>();
 
-    public Dictionary<string, object> config = new Dictionary<string, object>();
-
-    public AppConfig()
+    static AppConfig()
     {
 
-        appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
-        configFile = appPath + "\\config.json";
+        string startupPath = Application.StartupPath.Trim('\\');
+        string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        string configName = "\\config.json";
+
+        if (File.Exists(startupPath + configName))
+        {
+            configFile = startupPath + configName;
+        } else
+        {
+            configFile = appPath + configName;
+        }
+
 
         if (!System.IO.Directory.Exists(appPath))
             System.IO.Directory.CreateDirectory(appPath);
@@ -30,18 +39,19 @@ public class AppConfig
             }
             catch
             {
-                initConfig();
+                Logger.WriteLine("Broken config: " + text);
+                Init();
             }
         }
         else
         {
-            initConfig();
+            Init();
         }
 
     }
 
 
-    public string GetModel()
+    public static string GetModel()
     {
         if (_model is null)
         {
@@ -58,14 +68,23 @@ public class AppConfig
 
         return _model;
     }
-    public bool ContainsModel(string contains)
+
+    public static string GetModelShort()
     {
-
-        GetModel();
-        return (_model is not null && _model.Contains(contains));
-
+        string model = GetModel();
+        int trim = model.LastIndexOf("_");
+        if (trim > 0) model = model.Substring(0, trim);
+        return model;
     }
-    private void initConfig()
+
+    public static bool ContainsModel(string contains)
+    {
+        GetModel();
+        return (_model is not null && _model.ToLower().Contains(contains.ToLower()));
+    }
+
+
+    private static void Init()
     {
         config = new Dictionary<string, object>();
         config["performance_mode"] = 0;
@@ -73,37 +92,39 @@ public class AppConfig
         File.WriteAllText(configFile, jsonString);
     }
 
-    public int getConfig(string name, bool performance = false)
+    public static int Get(string name, int empty = -1)
     {
-
         if (config.ContainsKey(name))
+        {
+            //Debug.WriteLine(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 });
-        try
+        }
+        else
         {
-            File.WriteAllText(configFile, jsonString);
-        } catch (Exception e)
-        {
-            Debug.Write(e.ToString());
+            //Debug.WriteLine(name + "E");
+            return empty;
         }
     }
 
-    public void setConfig(string name, string value)
+    public static bool Is(string name)
+    {
+        return Get(name) == 1;
+    }
+
+    public static bool IsNotFalse(string name)
+    {
+        return Get(name) != 0;
+    }
+
+    public static string GetString(string name, string empty = null)
+    {
+        if (config.ContainsKey(name))
+            return config[name].ToString();
+        else return empty;
+    }
+
+    private static void Write()
     {
-        config[name] = value;
         string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
         try
         {
@@ -115,24 +136,56 @@ public class AppConfig
         }
     }
 
-    public string getParamName(int device, string paramName = "fan_profile")
+    public static void Set(string name, int value)
     {
-        int mode = getConfig("performance_mode");
+        config[name] = value;
+        Write();
+    }
+
+    public static void Set(string name, string value)
+    {
+        config[name] = value;
+        Write();
+    }
+    public static void Remove(string name)
+    {
+        config.Remove(name);
+        Write();
+    }
+
+    public static void RemoveMode(string name)
+    {
+        Remove(name + "_" + Modes.GetCurrent());
+    }
+
+    public static string GgetParamName(AsusFan device, string paramName = "fan_profile")
+    {
+        int mode = Modes.GetCurrent();
         string name;
 
-        if (device == 1)
-            name = "gpu";
-        else if (device == 2)
-            name = "mid";
-        else
-            name = "cpu";
+        switch (device)
+        {
+            case AsusFan.GPU:
+                name = "gpu";
+                break;
+            case AsusFan.Mid:
+                name = "mid";
+                break;
+            case AsusFan.XGM:
+                name = "xgm";
+                break;
+            default:
+                name = "cpu";
+                break;
+
+        }
 
         return paramName + "_" + name + "_" + mode;
     }
 
-    public byte[] getFanConfig(int device)
+    public static byte[] GetFanConfig(AsusFan device)
     {
-        string curveString = getConfigString(getParamName(device));
+        string curveString = GetString(GgetParamName(device));
         byte[] curve = { };
 
         if (curveString is not null)
@@ -141,10 +194,10 @@ public class AppConfig
         return curve;
     }
 
-    public void setFanConfig(int device, byte[] curve)
+    public static void SetFanConfig(AsusFan device, byte[] curve)
     {
         string bitCurve = BitConverter.ToString(curve);
-        setConfig(getParamName(device), bitCurve);
+        Set(GgetParamName(device), bitCurve);
     }
 
 
@@ -156,27 +209,27 @@ public class AppConfig
         return array;
     }
 
-    public byte[] getDefaultCurve(int device)
+    public static byte[] GetDefaultCurve(AsusFan device)
     {
-        int mode = getConfig("performance_mode");
+        int mode = Modes.GetCurrentBase();
         byte[] curve;
 
         switch (mode)
         {
             case 1:
-                if (device == 1)
+                if (device == AsusFan.GPU)
                     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)
+                if (device == AsusFan.GPU)
                     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)
+                if (device == AsusFan.GPU)
                     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");
@@ -186,23 +239,156 @@ public class AppConfig
         return curve;
     }
 
-    public string getConfigPerfString(string name)
+    public static string GetModeString(string name)
     {
-        int mode = getConfig("performance_mode");
-        return getConfigString(name + "_" + mode);
+        return GetString(name + "_" + Modes.GetCurrent());
     }
 
-    public int getConfigPerf(string name)
+    public static int GetMode(string name, int empty = -1)
     {
-        int mode = getConfig("performance_mode");
-        return getConfig(name + "_" + mode);
+        return Get(name + "_" + Modes.GetCurrent(), empty);
     }
 
-    public void setConfigPerf(string name, int value)
+    public static bool IsMode(string name)
     {
-        int mode = getConfig("performance_mode");
-        setConfig(name + "_" + mode, value);
+        return Get(name + "_" + Modes.GetCurrent()) == 1;
     }
 
+    public static void SetMode(string name, int value)
+    {
+        Set(name + "_" + Modes.GetCurrent(), value);
+    }
+
+    public static void SetMode(string name, string value)
+    {
+        Set(name + "_" + Modes.GetCurrent(), value);
+    }
+
+    public static bool IsAlly()
+    {
+        return ContainsModel("RC71");
+    }
+
+    public static bool NoMKeys()
+    {
+        return ContainsModel("Z13") ||
+               ContainsModel("FX706") ||
+               ContainsModel("FA506") ||
+               ContainsModel("FX506") ||
+               ContainsModel("Duo") ||
+               ContainsModel("FX505");
+    }
+
+    public static bool IsTUF()
+    {
+        return ContainsModel("TUF");
+    }
+
+    public static bool IsVivobook()
+    {
+        return ContainsModel("Vivobook");
+    }
+
+    // Devices with bugged bios command to change brightness
+    public static bool SwappedBrightness()
+    {
+        return ContainsModel("FA506IH") || ContainsModel("FX506LU");
+    }
+
+
+    public static bool IsDUO()
+    {
+        return ContainsModel("Duo");
+    }
+
+    // G14 2020 has no aura, but media keys instead
+    public static bool NoAura()
+    {
+        return ContainsModel("GA401I") && !ContainsModel("GA401IHR");
+    }
+
+    public static bool IsSingleColor()
+    {
+        return  ContainsModel("GA401");
+    }
+
+    public static bool IsStrix()
+    {
+        return ContainsModel("Strix") || ContainsModel("Scar");
+    }
+
+    public static bool IsZ13()
+    {
+        return ContainsModel("Z13");
+    }
+
+    public static bool HasTabletMode()
+    {
+        return ContainsModel("X16") || ContainsModel("X13");
+    }
+
+    public static bool IsX13()
+    {
+        return ContainsModel("X13");
+    }
+
+
+    public static bool IsAdvantageEdition()
+    {
+        return ContainsModel("13QY");
+    }
+
+    public static bool NoAutoUltimate()
+    {
+        return ContainsModel("G614") || ContainsModel("GU604") || ContainsModel("FX507") || ContainsModel("G513");
+    }
+
+
+    public static bool IsManualModeRequired()
+    {
+        if (!IsMode("auto_apply_power"))
+            return false;
+
+        return
+            Is("manual_mode") ||
+            ContainsModel("GU604") ||
+            ContainsModel("G733") ||
+            ContainsModel("FX507Z");
+    }
+
+    public static bool IsFanScale()
+    {
+        return ContainsModel("GU604");
+    }
+
+    public static bool IsFanRequired()
+    {
+        return ContainsModel("GA402X") || ContainsModel("G513") || ContainsModel("G713R");
+    }
+
+    public static bool IsPowerRequired()
+    {
+        return ContainsModel("FX507") || ContainsModel("FX517") || ContainsModel("FX707");
+    }
+
+    public static bool IsGPUFixNeeded()
+    {
+        return ContainsModel("GA402X") || ContainsModel("GV302") || ContainsModel("FX506") || ContainsModel("GU603V");
+    }
+
+    public static bool IsGPUFix()
+    {
+        return Is("gpu_fix") || (ContainsModel("GA402X") && IsNotFalse("gpu_fix"));
+    }
+
+    public static bool IsForceSetGPUMode()
+    {
+        return Is("gpu_mode_force_set") || ContainsModel("503");
+    }
+
+    public static bool IsNoGPUModes()
+    {
+        return ContainsModel("GV301RA") || ContainsModel("GV302XA") || IsAlly();
+    }
 
 }

app/AsusACPI.cs

@@ -1,7 +1,30 @@
-using System.Management;
+using GHelper;
+using System.Management;
 using System.Runtime.InteropServices;
 
-public class ASUSWmi
+public enum AsusFan
+{
+    CPU = 0,
+    GPU = 1,
+    Mid = 2,
+    XGM = 3
+}
+
+public enum AsusMode
+{
+    Balanced = 0,
+    Turbo = 1,
+    Silent = 2
+}
+
+public enum AsusGPU
+{
+    Eco = 0,
+    Standard = 1,
+    Ultimate = 2
+}
+
+public class AsusACPI
 {
 
     const string FILE_NAME = @"\\.\\ATKACPI";
@@ -9,10 +32,20 @@ public class ASUSWmi
 
     const uint DSTS = 0x53545344;
     const uint DEVS = 0x53564544;
+    const uint INIT = 0x54494E49;
 
     public const uint UniversalControl = 0x00100021;
+    
     public const int KB_Light_Up = 0xc4;
     public const int KB_Light_Down = 0xc5;
+    public const int Brightness_Down = 0x10;
+    public const int Brightness_Up = 0x20;
+    public const int KB_Sleep = 0x6c;
+    public const int KB_DUO_PgUpDn = 0x4B;
+    public const int KB_DUO_SecondDisplay = 0x6A;
+
+
+    public const int Touchpad_Toggle = 0x6B;
 
     public const int ChargerMode = 0x0012006C;
 
@@ -23,17 +56,23 @@ public class ASUSWmi
     public const uint GPU_Fan = 0x00110014;
     public const uint Mid_Fan = 0x00110031;
 
-    public const uint PerformanceMode = 0x00120075; // Thermal Control
+    public const uint PerformanceMode = 0x00120075; // Performance modes
+    public const uint VivoBookMode = 0x00110019; // Vivobook performance modes
 
     public const uint GPUEco = 0x00090020;
+
     public const uint GPUXGConnected = 0x00090018;
     public const uint GPUXG = 0x00090019;
+
     public const uint GPUMux = 0x00090016;
 
     public const uint BatteryLimit = 0x00120057;
     public const uint ScreenOverdrive = 0x00050019;
     public const uint ScreenMiniled = 0x0005001E;
 
+    public const uint DevsCPUFan = 0x00110022;
+    public const uint DevsGPUFan = 0x00110023;
+
     public const uint DevsCPUFanCurve = 0x00110024;
     public const uint DevsGPUFanCurve = 0x00110025;
     public const uint DevsMidFanCurve = 0x00110032;
@@ -41,37 +80,54 @@ public class ASUSWmi
     public const int Temp_CPU = 0x00120094;
     public const int Temp_GPU = 0x00120097;
 
-    public const int PPT_TotalA0 = 0x001200A0;  // Total PPT on 2022 (PPT_LIMIT_SLOW ) and CPU PPT on 2021
+    public const int PPT_TotalA0 = 0x001200A0;  // SPL (Total limit for all-AMD models) / PL1
     public const int PPT_EDCA1 = 0x001200A1;  // CPU EDC
     public const int PPT_TDCA2 = 0x001200A2;  // CPU TDC
-    public const int PPT_APUA3 = 0x001200A3;  // APU PPT ON 2021, doesn't work on 2022
+    public const int PPT_APUA3 = 0x001200A3;  // sPPT (long boost limit) / PL2
 
     public const int PPT_CPUB0 = 0x001200B0;  // CPU PPT on 2022 (PPT_LIMIT_APU)
     public const int PPT_CPUB1 = 0x001200B1;  // Total PPT on 2022 (PPT_LIMIT_SLOW)
 
     public const int PPT_GPUC0 = 0x001200C0;  // NVIDIA GPU Boost
-    public const int PPT_APUC1 = 0x001200C1;  // Actual Power Limit (PPT_LIMIT_FAST) AND Sustained Power Limit (STAPM_LIMIT)
+    public const int PPT_APUC1 = 0x001200C1;  // fPPT (fast boost limit)
     public const int PPT_GPUC2 = 0x001200C2;  // NVIDIA GPU Temp Target (75.. 87 C) 
 
     public const int TUF_KB_BRIGHTNESS = 0x00050021;
     public const int TUF_KB = 0x00100056;
+    public const int TUF_KB2 = 0x0010005a;
     public const int TUF_KB_STATE = 0x00100057;
 
+    public const int MICMUTE_LED = 0x00040017;
+
+    public const int TabletState = 0x00060077;
+    public const int FnLock = 0x00100023;
+
+    public const int ScreenPadToggle = 0x00050031;
+    public const int ScreenPadBrightness = 0x00050032;
+
+    public const int BootSound = 0x00130022;
+
+    public const int Tablet_Notebook = 0;
+    public const int Tablet_Tablet = 1;
+    public const int Tablet_Tent = 2;
+    public const int Tablet_Rotated = 3;
+
     public const int PerformanceBalanced = 0;
     public const int PerformanceTurbo = 1;
     public const int PerformanceSilent = 2;
+    public const int PerformanceManual = 4;
 
     public const int GPUModeEco = 0;
     public const int GPUModeStandard = 1;
     public const int GPUModeUltimate = 2;
 
-
-    public const int MaxTotal = 250;
     public const int MinTotal = 5;
-    public const int DefaultTotal = 125;
 
-    public const int MaxCPU = 130;
+    public static int MaxTotal = 150;
+    public static int DefaultTotal = 125;
+
     public const int MinCPU = 5;
+    public const int MaxCPU = 100;
     public const int DefaultCPU = 80;
 
     public const int MinGPUBoost = 5;
@@ -116,7 +172,43 @@ public class ASUSWmi
 
     private IntPtr handle;
 
-    public ASUSWmi()
+    // Event handling attempt
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
+
+    private IntPtr eventHandle;
+
+    // still works only with asus optimization service on , if someone knows how to get ACPI events from asus without that - let me know
+    public void RunListener()
+    {
+
+        eventHandle = CreateEvent(IntPtr.Zero, false, false, "ATK4001");
+
+        byte[] outBuffer = new byte[16];
+        byte[] data = new byte[8];
+        bool result;
+
+        data[0] = BitConverter.GetBytes(eventHandle.ToInt32())[0];
+        data[1] = BitConverter.GetBytes(eventHandle.ToInt32())[1];
+
+        Control(0x222400, data, outBuffer);
+        Logger.WriteLine("ACPI :" + BitConverter.ToString(data) + "|" + BitConverter.ToString(outBuffer));
+
+        while (true)
+        {
+            WaitForSingleObject(eventHandle, Timeout.Infinite);
+            Control(0x222408, new byte[0], outBuffer);
+            int code = BitConverter.ToInt32(outBuffer);
+            Logger.WriteLine("ACPI Code: " + code);
+        }
+    }
+
+
+    public AsusACPI()
     {
         handle = CreateFile(
             FILE_NAME,
@@ -127,16 +219,32 @@ public class ASUSWmi
             FILE_ATTRIBUTE_NORMAL,
             IntPtr.Zero
         );
+
         if (handle == new IntPtr(-1))
         {
             throw new Exception("Can't connect to ACPI");
         }
+
+        if (AppConfig.IsAdvantageEdition()) MaxTotal = 250;
+        if (AppConfig.IsX13())
+        {
+            MaxTotal = 75;
+            DefaultTotal = 50;
+        }
+
+        if (AppConfig.IsAlly())
+        {
+            MaxTotal = 50;
+            DefaultTotal = 30;
+        }
+
     }
 
     public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
     {
+
         uint lpBytesReturned = 0;
-        bool result = DeviceIoControl(
+        DeviceIoControl(
             handle,
             dwIoControlCode,
             lpInBuffer,
@@ -157,7 +265,7 @@ public class ASUSWmi
     protected byte[] CallMethod(uint MethodID, byte[] args)
     {
         byte[] acpiBuf = new byte[8 + args.Length];
-        byte[] outBuffer = new byte[20];
+        byte[] outBuffer = new byte[16];
 
         BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
         BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
@@ -171,6 +279,13 @@ public class ASUSWmi
 
     }
 
+    public byte[] DeviceInit()
+    {
+        byte[] args = new byte[8];
+        return CallMethod(INIT, args);
+
+    }
+
     public int DeviceSet(uint DeviceID, int Status, string logName)
     {
         byte[] args = new byte[8];
@@ -204,7 +319,7 @@ public class ASUSWmi
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
         byte[] status = CallMethod(DSTS, args);
-        
+
         return BitConverter.ToInt32(status, 0) - 65536;
 
     }
@@ -214,12 +329,71 @@ public class ASUSWmi
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
         BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
-        
+
         return CallMethod(DSTS, args);
     }
 
+    public int SetGPUEco(int eco)
+    {
+        int ecoFlag = DeviceGet(GPUEco);
+        if (ecoFlag < 0) return -1;
 
-    public int SetFanCurve(int device, byte[] curve)
+        if (ecoFlag == 1 && eco == 0)
+            return DeviceSet(GPUEco, eco, "GPUEco");
+
+        if (ecoFlag == 0 && eco == 1)
+            return DeviceSet(GPUEco, eco, "GPUEco");
+
+        return -1;
+    }
+
+    public int GetFan(AsusFan device)
+    {
+        int fan = -1;
+
+        switch (device)
+        {
+            case AsusFan.GPU:
+                fan = Program.acpi.DeviceGet(GPU_Fan);
+                break;
+            case AsusFan.Mid:
+                fan = Program.acpi.DeviceGet(Mid_Fan);
+                break;
+            default:
+                fan = Program.acpi.DeviceGet(CPU_Fan);
+                break;
+        }
+
+        if (fan < 0)
+        {
+            fan += 65536;
+            if (fan <= 0 || fan > 100) fan = -1;
+        }
+
+        return fan;
+    }
+
+    public int SetFanRange(AsusFan device, byte[] curve)
+    {
+        byte min = (byte)(curve[8] * 255 / 100);
+        byte max = (byte)(curve[15] * 255 / 100);
+        byte[] range = { min, max};
+
+        int result;
+        switch (device)
+        {
+            case AsusFan.GPU:
+                result = DeviceSet(DevsGPUFan, range, "FanRangeGPU");
+                break;
+            default:
+                result = DeviceSet(DevsCPUFan, range, "FanRangeCPU");
+                break;
+        }
+        return result;
+    }
+
+
+    public int SetFanCurve(AsusFan device, byte[] curve)
     {
 
         if (curve.Length != 16) return -1;
@@ -227,17 +401,21 @@ public class ASUSWmi
 
         int result;
 
-        for (int i = 8; i < curve.Length; i++)
-        {
-            curve[i] = Math.Max((byte)0, Math.Min((byte)99, curve[i])); // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
-        }
+        int defaultScale = (AppConfig.IsFanScale() && (device == AsusFan.CPU || device == AsusFan.GPU)) ? 130 : 100;
+        int fanScale = AppConfig.Get("fan_scale", defaultScale);
+
+        if (fanScale != 100 && device == AsusFan.CPU) Logger.WriteLine("Custom fan scale: " + fanScale);
+
+        // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
+
+        for (int i = 8; i < curve.Length; i++) curve[i] = (byte)(Math.Max((byte)0, Math.Min((byte)100, curve[i])) * fanScale / 100); 
 
         switch (device)
         {
-            case 1:
+            case AsusFan.GPU:
                 result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
                 break;
-            case 2:
+            case AsusFan.Mid:
                 result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
                 break;
             default:
@@ -248,7 +426,7 @@ public class ASUSWmi
         return result;
     }
 
-    public byte[] GetFanCurve(int device, int mode = 0)
+    public byte[] GetFanCurve(AsusFan device, int mode = 0)
     {
         uint fan_mode;
 
@@ -262,9 +440,9 @@ public class ASUSWmi
 
         switch (device)
         {
-            case 1:
+            case AsusFan.GPU:
                 return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
-            case 2:
+            case AsusFan.Mid:
                 return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
             default:
                 return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
@@ -272,6 +450,89 @@ public class ASUSWmi
 
     }
 
+    public static bool IsInvalidCurve(byte[] curve)
+    {
+        return curve.Length != 16 || IsEmptyCurve(curve);
+    }
+
+    public static bool IsEmptyCurve(byte[] curve)
+    {
+        return curve.All(singleByte => singleByte == 0);
+    }
+
+    public static byte[] FixFanCurve(byte[] curve)
+    {
+        if (curve.Length != 16) throw new Exception("Incorrect curve");
+
+        var points = new Dictionary<byte, byte>();
+        byte old = 0;
+
+        for (int i = 0; i < 8; i++)
+        {
+            if (curve[i] == old) curve[i]++; // preventing 2 points in same spot from default asus profiles
+            points[curve[i]] = curve[i + 8];
+            old = curve[i];
+        }
+
+        var pointsFixed = new Dictionary<byte, byte>();
+        bool fix = false;
+
+        int count = 0;
+        foreach (var pair in points.OrderBy(x => x.Key))
+        {
+            if (count == 0 && pair.Key >= 40)
+            {
+                fix = true;
+                pointsFixed.Add(30, 0);
+            }
+
+            if (count != 3 || !fix)
+                pointsFixed.Add(pair.Key, pair.Value);
+            count++;
+        }
+
+        count = 0;
+        foreach (var pair in pointsFixed.OrderBy(x => x.Key))
+        {
+            curve[count] = pair.Key;
+            curve[count + 8] = pair.Value;
+            count++;
+        }
+
+        return curve;
+
+    }
+
+    public bool IsXGConnected()
+    {
+        //return true;
+        return DeviceGet(GPUXGConnected) == 1;
+    }
+
+    public bool IsAllAmdPPT()
+    {
+        return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
+    }
+
+
+    public void ScanRange()
+    {
+        int value;
+        string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+        string logFile = appPath + "\\scan.txt";
+        for (uint i = 0x00000000; i <= 0x00160000; i++)
+        {
+            value = DeviceGet(i);
+            if (value >= 0)
+                using (StreamWriter w = File.AppendText(logFile))
+                {
+                    w.WriteLine(i.ToString("X8") + ": " + value.ToString("X4") + " (" + value + ")");
+                    w.Close();
+                }
+        }
+
+    }
+
     public void TUFKeyboardBrightness(int brightness)
     {
         int param = 0x80 | (brightness & 0x7F);
@@ -281,16 +542,17 @@ public class ASUSWmi
     public void TUFKeyboardRGB(int mode, Color color, int speed)
     {
 
-        byte[] setting = new byte[12];
-        setting[0] = (byte)0xB4;
+        byte[] setting = new byte[6];
+        
+        setting[0] = (byte)0xb4;
         setting[1] = (byte)mode;
         setting[2] = color.R;
         setting[3] = color.G;
         setting[4] = color.B;
         setting[5] = (byte)speed;
 
-        DeviceSet(TUF_KB, setting, "TUF RGB");
-        //Debug.WriteLine(BitConverter.ToString(setting));
+        int result = DeviceSet(TUF_KB, setting, "TUF RGB");
+        if (result != 1) DeviceSet(TUF_KB2, setting, "TUF RGB");
 
     }
 
@@ -321,7 +583,8 @@ public class ASUSWmi
             watcher.Scope = new ManagementScope("root\\wmi");
             watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
             watcher.Start();
-        } catch
+        }
+        catch
         {
             Logger.WriteLine("Can't connect to ASUS WMI events");
         }

app/AsusMouseSettings.cs

@@ -0,0 +1,899 @@
+using GHelper.Peripherals.Mouse;
+using GHelper.UI;
+
+namespace GHelper
+{
+    public partial class AsusMouseSettings : RForm
+    {
+        private static Dictionary<LightingMode, string> lightingModeNames = new Dictionary<LightingMode, string>()
+        {
+            { LightingMode.Static,Properties.Strings.AuraStatic},
+            { LightingMode.Breathing, Properties.Strings.AuraBreathe},
+            { LightingMode.ColorCycle, Properties.Strings.AuraColorCycle},
+            { LightingMode.Rainbow, Properties.Strings.AuraRainbow},
+            { LightingMode.React, Properties.Strings.AuraReact},
+            { LightingMode.Comet, Properties.Strings.AuraComet},
+            { LightingMode.BatteryState, Properties.Strings.AuraBatteryState},
+            { LightingMode.Off, Properties.Strings.MatrixOff},
+        };
+        private List<LightingMode> supportedLightingModes = new List<LightingMode>();
+
+        private readonly AsusMouse mouse;
+        private readonly RButton[] dpiButtons;
+        private LightingZone visibleZone = LightingZone.All;
+
+        private bool updateMouseDPI = true;
+
+        public AsusMouseSettings(AsusMouse mouse)
+        {
+            this.mouse = mouse;
+            InitializeComponent();
+
+            dpiButtons = new RButton[] { buttonDPI1, buttonDPI2, buttonDPI3, buttonDPI4 };
+
+
+            labelPollingRate.Text = Properties.Strings.PollingRate;
+            labelLighting.Text = Properties.Strings.Lighting;
+            labelLightingMode.Text = Properties.Strings.AuraLightingMode;
+            labelEnergy.Text = Properties.Strings.EnergySettings;
+            labelPerformance.Text = Properties.Strings.MousePerformance;
+            checkBoxRandomColor.Text = Properties.Strings.AuraRandomColor;
+            labelLowBatteryWarning.Text = Properties.Strings.MouseLowBatteryWarning;
+            labelAutoPowerOff.Text = Properties.Strings.MouseAutoPowerOff;
+            buttonSync.Text = Properties.Strings.MouseSynchronize;
+            checkBoxAngleSnapping.Text = Properties.Strings.MouseAngleSnapping;
+            labelLiftOffDistance.Text = Properties.Strings.MouseLiftOffDistance;
+            labelChargingState.Text = "(" + Properties.Strings.Charging + ")";
+            labelProfile.Text = Properties.Strings.Profile;
+            labelButtonDebounce.Text = Properties.Strings.MouseButtonResponse;
+            labelAcceleration.Text = Properties.Strings.Acceleration;
+            labelDeceleration.Text = Properties.Strings.Deceleration;
+
+            buttonLightingZoneLogo.Text = Properties.Strings.AuraZoneLogo;
+            buttonLightingZoneScroll.Text = Properties.Strings.AuraZoneScroll;
+            buttonLightingZoneUnderglow.Text = Properties.Strings.AuraZoneUnderglow;
+            buttonLightingZoneAll.Text = Properties.Strings.AuraZoneAll;
+            buttonLightingZoneDock.Text = Properties.Strings.AuraZoneDock;
+
+            InitTheme();
+
+            this.Text = mouse.GetDisplayName();
+
+            Shown += AsusMouseSettings_Shown;
+            FormClosing += AsusMouseSettings_FormClosing;
+
+            comboProfile.DropDownClosed += ComboProfile_DropDownClosed;
+
+            sliderDPI.ValueChanged += SliderDPI_ValueChanged;
+            numericUpDownCurrentDPI.ValueChanged += NumericUpDownCurrentDPI_ValueChanged;
+            sliderDPI.MouseUp += SliderDPI_MouseUp;
+            sliderDPI.MouseDown += SliderDPI_MouseDown;
+            buttonDPIColor.Click += ButtonDPIColor_Click;
+            buttonDPI1.Click += ButtonDPI_Click;
+            buttonDPI2.Click += ButtonDPI_Click;
+            buttonDPI3.Click += ButtonDPI_Click;
+            buttonDPI4.Click += ButtonDPI_Click;
+
+            comboBoxPollingRate.DropDownClosed += ComboBoxPollingRate_DropDownClosed;
+            checkBoxAngleSnapping.CheckedChanged += CheckAngleSnapping_CheckedChanged;
+            sliderAngleAdjustment.ValueChanged += SliderAngleAdjustment_ValueChanged;
+            sliderAngleAdjustment.MouseUp += SliderAngleAdjustment_MouseUp;
+            comboBoxLiftOffDistance.DropDownClosed += ComboBoxLiftOffDistance_DropDownClosed;
+            sliderButtonDebounce.ValueChanged += SliderButtonDebounce_ValueChanged;
+            sliderButtonDebounce.MouseUp += SliderButtonDebounce_MouseUp;
+
+            sliderAcceleration.MouseUp += SliderAcceleration_MouseUp;
+            sliderAcceleration.ValueChanged += SliderAcceleration_ValueChanged;
+
+            sliderDeceleration.MouseUp += SliderDeceleration_MouseUp;
+            sliderDeceleration.ValueChanged += SliderDeceleration_ValueChanged;
+
+            buttonLightingColor.Click += ButtonLightingColor_Click;
+            comboBoxLightingMode.DropDownClosed += ComboBoxLightingMode_DropDownClosed;
+            sliderBrightness.MouseUp += SliderBrightness_MouseUp;
+            comboBoxAnimationSpeed.DropDownClosed += ComboBoxAnimationSpeed_DropDownClosed;
+            comboBoxAnimationDirection.DropDownClosed += ComboBoxAnimationDirection_DropDownClosed;
+            checkBoxRandomColor.CheckedChanged += CheckBoxRandomColor_CheckedChanged;
+
+            sliderLowBatteryWarning.ValueChanged += SliderLowBatteryWarning_ValueChanged;
+            sliderLowBatteryWarning.MouseUp += SliderLowBatteryWarning_MouseUp;
+            comboBoxAutoPowerOff.DropDownClosed += ComboBoxAutoPowerOff_DropDownClosed;
+
+
+            buttonLightingZoneAll.Click += ButtonLightingZoneAll_Click;
+            buttonLightingZoneDock.Click += ButtonLightingZoneDock_Click;
+            buttonLightingZoneLogo.Click += ButtonLightingZoneLogo_Click;
+            buttonLightingZoneUnderglow.Click += ButtonLightingZoneUnderglow_Click;
+            buttonLightingZoneScroll.Click += ButtonLightingZoneScroll_Click;
+
+            InitMouseCapabilities();
+            Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Initialized capabilities. Synchronizing mouse data");
+            RefreshMouseData();
+        }
+
+        private void SliderAcceleration_MouseUp(object? sender, MouseEventArgs e)
+        {
+            mouse.SetAcceleration(sliderAcceleration.Value);
+        }
+
+        private void SliderAcceleration_ValueChanged(object? sender, EventArgs e)
+        {
+            labelAccelerationValue.Text = sliderAcceleration.Value.ToString();
+        }
+
+        private void SliderDeceleration_MouseUp(object? sender, MouseEventArgs e)
+        {
+            mouse.SetDeceleration(sliderDeceleration.Value);
+        }
+
+        private void SliderDeceleration_ValueChanged(object? sender, EventArgs e)
+        {
+            labelDecelerationValue.Text = sliderDeceleration.Value.ToString();
+        }
+
+        private void SliderButtonDebounce_MouseUp(object? sender, MouseEventArgs e)
+        {
+            DebounceTime dbt = (DebounceTime)sliderButtonDebounce.Value;
+            mouse.SetDebounce(dbt);
+        }
+
+        private void SliderButtonDebounce_ValueChanged(object? sender, EventArgs e)
+        {
+            DebounceTime dbt = (DebounceTime)sliderButtonDebounce.Value;
+            int time = mouse.DebounceTimeInMS(dbt);
+
+            labelButtonDebounceValue.Text = time + "ms";
+        }
+
+        private void SwitchLightingZone(LightingZone zone)
+        {
+            if (!mouse.HasRGB())
+            {
+                return;
+            }
+            visibleZone = zone;
+            InitLightingModes();
+            VisusalizeLightingSettings();
+        }
+
+        private void ButtonLightingZoneScroll_Click(object? sender, EventArgs e)
+        {
+            SwitchLightingZone(LightingZone.Scrollwheel);
+        }
+
+        private void ButtonLightingZoneUnderglow_Click(object? sender, EventArgs e)
+        {
+            SwitchLightingZone(LightingZone.Underglow);
+        }
+
+        private void ButtonLightingZoneLogo_Click(object? sender, EventArgs e)
+        {
+            SwitchLightingZone(LightingZone.Logo);
+        }
+
+        private void ButtonLightingZoneDock_Click(object? sender, EventArgs e)
+        {
+            SwitchLightingZone(LightingZone.Dock);
+        }
+
+        private void ButtonLightingZoneAll_Click(object? sender, EventArgs e)
+        {
+            SwitchLightingZone(LightingZone.All);
+        }
+
+        private void AsusMouseSettings_FormClosing(object? sender, FormClosingEventArgs e)
+        {
+            mouse.BatteryUpdated -= Mouse_BatteryUpdated;
+            mouse.Disconnect -= Mouse_Disconnect;
+            mouse.MouseReadyChanged -= Mouse_MouseReadyChanged;
+        }
+
+        private void Mouse_MouseReadyChanged(object? sender, EventArgs e)
+        {
+            if (Disposing || IsDisposed)
+            {
+                return;
+            }
+            if (!mouse.IsDeviceReady)
+            {
+                this.Invoke(delegate
+                {
+                    Close();
+                });
+            }
+        }
+
+        private void Mouse_BatteryUpdated(object? sender, EventArgs e)
+        {
+            if (Disposing || IsDisposed)
+            {
+                return;
+            }
+            this.Invoke(delegate
+            {
+                VisualizeBatteryState();
+            });
+
+        }
+
+        private void ComboProfile_DropDownClosed(object? sender, EventArgs e)
+        {
+            if (mouse.Profile == comboProfile.SelectedIndex)
+            {
+                return;
+            }
+
+            mouse.SetProfile(comboProfile.SelectedIndex);
+            RefreshMouseData();
+        }
+
+        private void ComboBoxPollingRate_DropDownClosed(object? sender, EventArgs e)
+        {
+            mouse.SetPollingRate(mouse.SupportedPollingrates()[comboBoxPollingRate.SelectedIndex]);
+        }
+
+        private void ButtonDPIColor_Click(object? sender, EventArgs e)
+        {
+            ColorDialog colorDlg = new ColorDialog
+            {
+                AllowFullOpen = true,
+                Color = pictureDPIColor.BackColor
+            };
+
+            if (colorDlg.ShowDialog() == DialogResult.OK)
+            {
+                AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
+                dpi.Color = colorDlg.Color;
+
+                mouse.SetDPIForProfile(dpi, mouse.DpiProfile);
+
+                VisualizeDPIButtons();
+                VisualizeCurrentDPIProfile();
+            }
+        }
+
+        private void ButtonDPI_Click(object? sender, EventArgs e)
+        {
+            int index = -1;
+
+            for (int i = 0; i < dpiButtons.Length; ++i)
+            {
+                if (sender == dpiButtons[i])
+                {
+                    index = i;
+                    break;
+                }
+            }
+
+            if (index == -1)
+            {
+                //huh?
+                return;
+            }
+
+            mouse.SetDPIProfile(index + 1);
+            VisualizeDPIButtons();
+            VisualizeCurrentDPIProfile();
+        }
+
+        private void UpdateLightingSettings(LightingSetting settings, LightingZone zone)
+        {
+            mouse.SetLightingSetting(settings, visibleZone);
+            VisusalizeLightingSettings();
+        }
+
+        private void CheckBoxRandomColor_CheckedChanged(object? sender, EventArgs e)
+        {
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+            ls.RandomColor = checkBoxRandomColor.Checked;
+
+            UpdateLightingSettings(ls, visibleZone);
+        }
+
+        private void ComboBoxAnimationDirection_DropDownClosed(object? sender, EventArgs e)
+        {
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+            ls.AnimationDirection = (AnimationDirection)comboBoxAnimationDirection.SelectedIndex;
+
+            UpdateLightingSettings(ls, visibleZone);
+        }
+
+        private void ComboBoxAnimationSpeed_DropDownClosed(object? sender, EventArgs e)
+        {
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+            // 0 => 0x9
+            // 1 => 0x7
+            // 2 => 0x5
+            ls.AnimationSpeed = (AnimationSpeed)(0x9 - (comboBoxAnimationSpeed.SelectedIndex * 0x2));
+            UpdateLightingSettings(ls, visibleZone);
+        }
+
+        private void SliderBrightness_MouseUp(object? sender, MouseEventArgs e)
+        {
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+            ls.Brightness = sliderBrightness.Value;
+
+            UpdateLightingSettings(ls, visibleZone);
+        }
+
+        private void ComboBoxLightingMode_DropDownClosed(object? sender, EventArgs e)
+        {
+            if (!mouse.HasRGB())
+            {
+                return;
+            }
+
+            LightingMode lm = supportedLightingModes[comboBoxLightingMode.SelectedIndex];
+
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+            if (ls.LightingMode == lm)
+            {
+                //Nothing to do here.
+                return;
+            }
+
+            ls.LightingMode = lm;
+
+            UpdateLightingSettings(ls, visibleZone);
+        }
+
+        private void ButtonLightingColor_Click(object? sender, EventArgs e)
+        {
+            ColorDialog colorDlg = new ColorDialog
+            {
+                AllowFullOpen = true,
+                Color = pictureBoxLightingColor.BackColor
+            };
+
+            if (colorDlg.ShowDialog() == DialogResult.OK)
+            {
+                LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+                ls.RGBColor = colorDlg.Color;
+
+                UpdateLightingSettings(ls, visibleZone);
+            }
+        }
+
+        private void SliderLowBatteryWarning_ValueChanged(object? sender, EventArgs e)
+        {
+            labelLowBatteryWarningValue.Text = sliderLowBatteryWarning.Value.ToString() + "%";
+        }
+
+        private void SliderLowBatteryWarning_MouseUp(object? sender, MouseEventArgs e)
+        {
+            mouse.SetEnergySettings(sliderLowBatteryWarning.Value, mouse.PowerOffSetting);
+        }
+
+
+        private void ComboBoxAutoPowerOff_DropDownClosed(object? sender, EventArgs e)
+        {
+            object? obj = Enum.GetValues(typeof(PowerOffSetting)).GetValue(comboBoxAutoPowerOff.SelectedIndex);
+            if (obj is null)
+            {
+                return;
+            }
+            PowerOffSetting pos = (PowerOffSetting)obj;
+
+
+            mouse.SetEnergySettings(mouse.LowBatteryWarning, pos);
+        }
+
+        private void SliderAngleAdjustment_ValueChanged(object? sender, EventArgs e)
+        {
+            labelAngleAdjustmentValue.Text = sliderAngleAdjustment.Value.ToString() + "°";
+        }
+
+        private void SliderAngleAdjustment_MouseUp(object? sender, MouseEventArgs e)
+        {
+            mouse.SetAngleAdjustment((short)sliderAngleAdjustment.Value);
+        }
+
+        private void ComboBoxLiftOffDistance_DropDownClosed(object? sender, EventArgs e)
+        {
+            mouse.SetLiftOffDistance((LiftOffDistance)comboBoxLiftOffDistance.SelectedIndex);
+        }
+
+        private void CheckAngleSnapping_CheckedChanged(object? sender, EventArgs e)
+        {
+            mouse.SetAngleSnapping(checkBoxAngleSnapping.Checked);
+            mouse.SetAngleAdjustment((short)sliderAngleAdjustment.Value);
+        }
+
+        private void SliderDPI_ValueChanged(object? sender, EventArgs e)
+        {
+            numericUpDownCurrentDPI.Value = sliderDPI.Value;
+            UpdateMouseDPISettings();
+        }
+
+        private void NumericUpDownCurrentDPI_ValueChanged(object? sender, EventArgs e)
+        {
+            sliderDPI.Value = (int)numericUpDownCurrentDPI.Value;
+        }
+
+        private void SliderDPI_MouseDown(object? sender, MouseEventArgs e)
+        {
+            updateMouseDPI = false;
+        }
+
+        private void SliderDPI_MouseUp(object? sender, MouseEventArgs e)
+        {
+            updateMouseDPI = true;
+            UpdateMouseDPISettings();
+        }
+
+        private void UpdateMouseDPISettings()
+        {
+            if (!updateMouseDPI)
+            {
+                return;
+            }
+            AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
+            dpi.DPI = (uint)sliderDPI.Value;
+
+            mouse.SetDPIForProfile(dpi, mouse.DpiProfile);
+
+            VisualizeDPIButtons();
+            VisualizeCurrentDPIProfile();
+        }
+
+        private void Mouse_Disconnect(object? sender, EventArgs e)
+        {
+            if (Disposing || IsDisposed)
+            {
+                return;
+            }
+            //Mouse disconnected. Bye bye.
+            this.Invoke(delegate
+            {
+                this.Close();
+            });
+
+        }
+
+        private void RefreshMouseData()
+        {
+            mouse.SynchronizeDevice();
+
+            Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Mouse data synchronized");
+            if (!mouse.IsDeviceReady)
+            {
+                Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Mouse is not ready. Closing view.");
+                Mouse_Disconnect(this, EventArgs.Empty);
+                return;
+            }
+
+            if (Disposing || IsDisposed)
+            {
+                return;
+            }
+
+            VisualizeMouseSettings();
+            VisualizeBatteryState();
+        }
+
+        private void InitMouseCapabilities()
+        {
+            for (int i = 0; i < mouse.ProfileCount(); ++i)
+            {
+                String prf = Properties.Strings.Profile + " " + (i + 1);
+                comboProfile.Items.Add(prf);
+            }
+
+            labelMinDPI.Text = mouse.MinDPI().ToString();
+            labelMaxDPI.Text = mouse.MaxDPI().ToString();
+
+            sliderDPI.Max = mouse.MaxDPI();
+            sliderDPI.Min = mouse.MinDPI();
+            sliderDPI.Step = mouse.DPIIncrements();
+
+            numericUpDownCurrentDPI.Minimum = mouse.MinDPI();
+            numericUpDownCurrentDPI.Maximum = mouse.MaxDPI();
+            numericUpDownCurrentDPI.Increment = mouse.DPIIncrements();
+
+            if (!mouse.HasDebounceSetting())
+            {
+                panelDebounce.Visible = false;
+            }
+
+
+            if (!mouse.HasDPIColors())
+            {
+                buttonDPIColor.Visible = false;
+                pictureDPIColor.Visible = false;
+                buttonDPI1.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Red);
+                buttonDPI2.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Purple);
+                buttonDPI3.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Blue);
+                buttonDPI4.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Green);
+
+                buttonDPI1.BorderColor = Color.Red;
+                buttonDPI2.BorderColor = Color.Purple;
+                buttonDPI3.BorderColor = Color.Blue;
+                buttonDPI4.BorderColor = Color.Green;
+            }
+
+            if (mouse.CanSetPollingRate())
+            {
+                foreach (PollingRate pr in mouse.SupportedPollingrates())
+                {
+                    comboBoxPollingRate.Items.Add(mouse.PollingRateDisplayString(pr));
+                }
+
+            }
+            else
+            {
+                panelPollingRate.Visible = false;
+            }
+
+            if (!mouse.HasAngleSnapping())
+            {
+                checkBoxAngleSnapping.Visible = false;
+            }
+
+            if (!mouse.HasAngleTuning())
+            {
+                labelAngleAdjustmentValue.Visible = false;
+                sliderAngleAdjustment.Visible = false;
+                sliderAngleAdjustment.Max = mouse.AngleTuningMax();
+                sliderAngleAdjustment.Min = mouse.AngleTuningMin();
+                sliderAngleAdjustment.Step = mouse.AngleTuningStep();
+            }
+
+            if (!mouse.HasAngleTuning() && !mouse.HasAngleSnapping())
+            {
+                panelAngleSnapping.Visible = false;
+            }
+
+            if (mouse.HasAcceleration())
+            {
+                sliderAcceleration.Max = mouse.MaxAcceleration();
+            }
+            else
+            {
+                panelAcceleration.Visible = false;
+            }
+
+            if (mouse.HasDeceleration())
+            {
+                sliderDeceleration.Max = mouse.MaxDeceleration();
+            }
+            else
+            {
+                panelDeceleration.Visible = false;
+            }
+
+            if (mouse.HasLiftOffSetting())
+            {
+                comboBoxLiftOffDistance.Items.AddRange(new string[] {
+                    Properties.Strings.Low,
+                    Properties.Strings.High,
+                });
+            }
+            else
+            {
+                panelLiftOffDistance.Visible = false;
+            }
+
+            if (mouse.DPIProfileCount() < 4)
+            {
+                for (int i = 3; i > mouse.DPIProfileCount() - 1; --i)
+                {
+                    dpiButtons[i].Visible = false;
+                }
+            }
+
+            if (!mouse.HasBattery())
+            {
+                panelBatteryState.Visible = false;
+            }
+
+            if (mouse.HasAutoPowerOff())
+            {
+                comboBoxAutoPowerOff.Items.AddRange(new string[]{
+                    " 1 "+ Properties.Strings.Minute,
+                    " 2 "+ Properties.Strings.Minutes,
+                    " 3 "+ Properties.Strings.Minutes,
+                    " 5 "+ Properties.Strings.Minutes,
+                    "10 "+ Properties.Strings.Minutes,
+                     Properties.Strings.Never,
+                });
+            }
+
+            if (!mouse.HasLowBatteryWarning())
+            {
+                labelLowBatteryWarning.Visible = false;
+                labelLowBatteryWarningValue.Visible = false;
+                sliderLowBatteryWarning.Visible = false;
+            }
+            else
+            {
+                sliderLowBatteryWarning.Min = 0;
+                sliderLowBatteryWarning.Step = mouse.LowBatteryWarningStep();
+                sliderLowBatteryWarning.Max = mouse.LowBatteryWarningMax();
+            }
+
+            if (!mouse.HasAutoPowerOff() && !mouse.HasLowBatteryWarning())
+            {
+                panelEnergy.Visible = false;
+            }
+
+            if (mouse.HasRGB())
+            {
+                if (mouse.SupportedLightingZones().Length > 1)
+                {
+                    buttonLightingZoneLogo.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Logo);
+                    buttonLightingZoneScroll.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Scrollwheel);
+                    buttonLightingZoneUnderglow.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Underglow);
+                    buttonLightingZoneDock.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Dock);
+                }
+                else
+                {
+                    buttonLightingZoneLogo.Visible = false;
+                    buttonLightingZoneScroll.Visible = false;
+                    buttonLightingZoneUnderglow.Visible = false;
+                    buttonLightingZoneDock.Visible = false;
+                }
+
+                sliderBrightness.Max = mouse.MaxBrightness();
+
+                InitLightingModes();
+
+                comboBoxAnimationDirection.Items.AddRange(new string[] {
+                    Properties.Strings.AuraClockwise,
+                    Properties.Strings.AuraCounterClockwise,
+                });
+
+                comboBoxAnimationSpeed.Items.AddRange(new string[] {
+                    Properties.Strings.AuraSlow,
+                    Properties.Strings.AuraNormal,
+                    Properties.Strings.AuraFast
+                });
+            }
+            else
+            {
+                panelLighting.Visible = false;
+            }
+        }
+
+        private void InitLightingModes()
+        {
+            comboBoxLightingMode.Items.Clear();
+            supportedLightingModes.Clear();
+            foreach (LightingMode lm in Enum.GetValues(typeof(LightingMode)))
+            {
+                if (mouse.IsLightingModeSupported(lm) && mouse.IsLightingModeSupportedForZone(lm, visibleZone))
+                {
+                    comboBoxLightingMode.Items.Add(lightingModeNames.GetValueOrDefault(lm));
+                    supportedLightingModes.Add(lm);
+                }
+            }
+        }
+
+
+        private void VisualizeMouseSettings()
+        {
+            comboProfile.SelectedIndex = mouse.Profile;
+
+            if (mouse.HasRGB())
+            {
+                //If current lighting mode is zoned, pre-select the first zone and not "All".
+                bool zoned = mouse.IsLightingZoned();
+                if (zoned)
+                {
+                    visibleZone = mouse.SupportedLightingZones()[0];
+                    InitLightingModes();
+                }
+            }
+
+
+            VisualizeDPIButtons();
+            VisualizeCurrentDPIProfile();
+            VisusalizeLightingSettings();
+
+            if (mouse.CanSetPollingRate())
+            {
+                int idx = mouse.PollingRateIndex(mouse.PollingRate);
+                if (idx == -1)
+                {
+                    return;
+                }
+                comboBoxPollingRate.SelectedIndex = idx;
+            }
+
+            if (mouse.HasAngleSnapping())
+            {
+                checkBoxAngleSnapping.Checked = mouse.AngleSnapping;
+            }
+
+            if (mouse.HasAngleTuning())
+            {
+                sliderAngleAdjustment.Value = mouse.AngleAdjustmentDegrees;
+            }
+
+            if (mouse.HasAutoPowerOff())
+            {
+                if (mouse.PowerOffSetting == PowerOffSetting.Never)
+                {
+                    comboBoxAutoPowerOff.SelectedIndex = comboBoxAutoPowerOff.Items.Count - 1;
+                }
+                else
+                {
+                    comboBoxAutoPowerOff.SelectedIndex = (int)mouse.PowerOffSetting;
+                }
+            }
+
+            if (mouse.HasLowBatteryWarning())
+            {
+                sliderLowBatteryWarning.Value = mouse.LowBatteryWarning;
+            }
+
+            if (mouse.HasLiftOffSetting())
+            {
+                comboBoxLiftOffDistance.SelectedIndex = (int)mouse.LiftOffDistance;
+            }
+
+            if (mouse.HasDebounceSetting())
+            {
+                sliderButtonDebounce.Value = (int)mouse.Debounce;
+            }
+
+            if (mouse.HasAcceleration())
+            {
+                sliderAcceleration.Value = mouse.Acceleration;
+            }
+
+            if (mouse.HasDeceleration())
+            {
+                sliderDeceleration.Value = mouse.Deceleration;
+            }
+        }
+
+        private void VisualizeBatteryState()
+        {
+            if (!mouse.HasBattery())
+            {
+                return;
+            }
+
+            labelBatteryState.Text = mouse.Battery + "%";
+            labelChargingState.Visible = mouse.Charging;
+
+            if (mouse.Charging)
+            {
+                pictureBoxBatteryState.BackgroundImage = ControlHelper.TintImage(Properties.Resources.icons8_ladende_batterie_48, foreMain);
+            }
+            else
+            {
+                pictureBoxBatteryState.BackgroundImage = ControlHelper.TintImage(Properties.Resources.icons8_batterie_voll_geladen_48, foreMain);
+            }
+        }
+
+        public void VisusalizeLightingZones()
+        {
+            bool zoned = mouse.IsLightingZoned();
+
+            buttonLightingZoneAll.Activated = visibleZone == LightingZone.All;
+            buttonLightingZoneLogo.Activated = visibleZone == LightingZone.Logo;
+            buttonLightingZoneScroll.Activated = visibleZone == LightingZone.Scrollwheel;
+            buttonLightingZoneUnderglow.Activated = visibleZone == LightingZone.Underglow;
+            buttonLightingZoneDock.Activated = visibleZone == LightingZone.Dock;
+
+            buttonLightingZoneAll.Secondary = zoned;
+            buttonLightingZoneLogo.Secondary = !zoned;
+            buttonLightingZoneScroll.Secondary = !zoned;
+            buttonLightingZoneUnderglow.Secondary = !zoned;
+            buttonLightingZoneDock.Secondary = !zoned;
+
+            buttonLightingZoneAll.BackColor = buttonLightingZoneAll.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+            buttonLightingZoneLogo.BackColor = buttonLightingZoneLogo.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+            buttonLightingZoneScroll.BackColor = buttonLightingZoneScroll.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+            buttonLightingZoneUnderglow.BackColor = buttonLightingZoneUnderglow.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+            buttonLightingZoneDock.BackColor = buttonLightingZoneDock.Secondary ? RForm.buttonSecond : RForm.buttonMain;
+        }
+
+        private void VisusalizeLightingSettings()
+        {
+            if (!mouse.HasRGB())
+            {
+                return;
+            }
+
+            VisusalizeLightingZones();
+
+            LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
+
+            if (ls is null)
+            {
+                //Lighting settings not loaded?
+                return;
+            }
+
+            sliderBrightness.Value = ls.Brightness;
+
+            checkBoxRandomColor.Visible = mouse.SupportsRandomColor(ls.LightingMode);
+
+            pictureBoxLightingColor.Visible = mouse.SupportsColorSetting(ls.LightingMode);
+            buttonLightingColor.Visible = mouse.SupportsColorSetting(ls.LightingMode);
+
+            comboBoxAnimationSpeed.Visible = mouse.SupportsAnimationSpeed(ls.LightingMode);
+            labelAnimationSpeed.Visible = mouse.SupportsAnimationSpeed(ls.LightingMode);
+            comboBoxAnimationDirection.Visible = mouse.SupportsAnimationDirection(ls.LightingMode);
+            labelAnimationDirection.Visible = mouse.SupportsAnimationDirection(ls.LightingMode);
+
+            comboBoxLightingMode.SelectedIndex = supportedLightingModes.IndexOf(ls.LightingMode);
+
+            if (mouse.SupportsRandomColor(ls.LightingMode))
+            {
+                checkBoxRandomColor.Checked = ls.RandomColor;
+                buttonLightingColor.Visible = !ls.RandomColor;
+            }
+
+            if (ls.RandomColor && mouse.SupportsRandomColor(ls.LightingMode))
+                pictureBoxLightingColor.BackColor = Color.Transparent;
+            else
+                pictureBoxLightingColor.BackColor = ls.RGBColor;
+
+            //0x09 => 0
+            //0x07 => 1
+            //0x05 => 2
+            comboBoxAnimationSpeed.SelectedIndex = 2 - ((((int)ls.AnimationSpeed) - 5) / 2);
+            comboBoxAnimationDirection.SelectedIndex = (int)ls.AnimationDirection;
+        }
+
+
+        private void VisualizeDPIButtons()
+        {
+            for (int i = 0; i < mouse.DPIProfileCount() && i < 4; ++i)
+            {
+                AsusMouseDPI dpi = mouse.DpiSettings[i];
+                if (dpi is null)
+                {
+                    continue;
+                }
+                if (mouse.HasDPIColors())
+                {
+                    dpiButtons[i].Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, dpi.Color);
+                    dpiButtons[i].BorderColor = dpi.Color;
+                }
+                dpiButtons[i].Activated = (mouse.DpiProfile - 1) == i;
+                dpiButtons[i].Text = "DPI " + (i + 1) + "\n" + dpi.DPI;
+            }
+        }
+
+
+        private void VisualizeCurrentDPIProfile()
+        {
+            AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
+            if (dpi is null)
+            {
+                return;
+            }
+            sliderDPI.Value = (int)dpi.DPI;
+            pictureDPIColor.BackColor = dpi.Color;
+        }
+
+        private void AsusMouseSettings_Shown(object? sender, EventArgs e)
+        {
+
+            if (Height > Program.settingsForm.Height)
+            {
+                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+            }
+            else
+            {
+                Top = Program.settingsForm.Top;
+            }
+
+            Left = Program.settingsForm.Left - Width - 5;
+
+
+            mouse.Disconnect += Mouse_Disconnect;
+            mouse.BatteryUpdated += Mouse_BatteryUpdated;
+            mouse.MouseReadyChanged += Mouse_MouseReadyChanged;
+        }
+
+        private void ButtonSync_Click(object sender, EventArgs e)
+        {
+            RefreshMouseData();
+        }
+    }
+}

app/AsusMouseSettings.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <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>

app/AsusUSB.cs

@@ -0,0 +1,690 @@
+using GHelper.Gpu;
+using GHelper.Helpers;
+using HidLibrary;
+using NAudio.Gui;
+using System.Diagnostics;
+using System.Drawing;
+using System.Text;
+
+namespace GHelper
+{
+
+
+    public class AuraPower
+    {
+        public bool BootLogo;
+        public bool BootKeyb;
+        public bool AwakeLogo;
+        public bool AwakeKeyb;
+        public bool SleepLogo;
+        public bool SleepKeyb;
+        public bool ShutdownLogo;
+        public bool ShutdownKeyb;
+
+        public bool BootBar;
+        public bool AwakeBar;
+        public bool SleepBar;
+        public bool ShutdownBar;
+
+        public bool BootLid;
+        public bool AwakeLid;
+        public bool SleepLid;
+        public bool ShutdownLid;
+
+        public bool BootRear;
+        public bool AwakeRear;
+        public bool SleepRear;
+        public bool ShutdownRear;
+    }
+
+
+    public static class AsusUSB
+    {
+        public const int HEATMAP = 20;
+        public const int GPUMODE = 21;
+
+        public const int ASUS_ID = 0x0b05;
+
+        public const byte INPUT_HID_ID = 0x5a;
+        public const byte AURA_HID_ID = 0x5d;
+
+        public static readonly byte[] LED_INIT1 = new byte[] { AURA_HID_ID, 0xb9 };
+        public static readonly byte[] LED_INIT2 = Encoding.ASCII.GetBytes("]ASUS Tech.Inc.");
+        public static readonly byte[] LED_INIT3 = new byte[] { AURA_HID_ID, 0x05, 0x20, 0x31, 0, 0x1a };
+        public static readonly byte[] LED_INIT4 = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
+        public static readonly byte[] LED_INIT5 = new byte[] { 0x5e, 0x05, 0x20, 0x31, 0, 0x1a };
+
+        static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
+        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
+
+        static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6, 0x1abe };
+
+        private static int mode = 0;
+        private static int speed = 1;
+        public static Color Color1 = Color.White;
+        public static Color Color2 = Color.Black;
+
+        static bool isTuf = AppConfig.IsTUF() || AppConfig.IsVivobook();
+        static bool isStrix = AppConfig.IsStrix();
+
+        static public bool isSingleColor = false;
+
+        static bool isOldHeatmap = AppConfig.Is("old_heatmap");
+
+
+        static System.Timers.Timer timer = new System.Timers.Timer(2000);
+        static HidDevice? auraDevice = null;
+
+
+        static byte[] AuraPowerMessage(AuraPower flags)
+        {
+            byte keyb = 0, bar = 0, lid = 0, rear = 0;
+
+            if (flags.BootLogo) keyb |= 1 << 0;
+            if (flags.BootKeyb) keyb |= 1 << 1;
+            if (flags.AwakeLogo) keyb |= 1 << 2;
+            if (flags.AwakeKeyb) keyb |= 1 << 3;
+            if (flags.SleepLogo) keyb |= 1 << 4;
+            if (flags.SleepKeyb) keyb |= 1 << 5;
+            if (flags.ShutdownLogo) keyb |= 1 << 6;
+            if (flags.ShutdownKeyb) keyb |= 1 << 7;
+
+            if (flags.BootBar) bar |= 1 << 1;
+            if (flags.AwakeBar) bar |= 1 << 2;
+            if (flags.SleepBar) bar |= 1 << 3;
+            if (flags.ShutdownBar) bar |= 1 << 4;
+
+            if (flags.BootLid) lid |= 1 << 0;
+            if (flags.AwakeLid) lid |= 1 << 1;
+            if (flags.SleepLid) lid |= 1 << 2;
+            if (flags.ShutdownLid) lid |= 1 << 3;
+
+            if (flags.BootLid) lid |= 1 << 4;
+            if (flags.AwakeLid) lid |= 1 << 5;
+            if (flags.SleepLid) lid |= 1 << 6;
+            if (flags.ShutdownLid) lid |= 1 << 7;
+
+            if (flags.BootRear) rear |= 1 << 0;
+            if (flags.AwakeRear) rear |= 1 << 1;
+            if (flags.SleepRear) rear |= 1 << 2;
+            if (flags.ShutdownRear) rear |= 1 << 3;
+
+            if (flags.BootRear) rear |= 1 << 4;
+            if (flags.AwakeRear) rear |= 1 << 5;
+            if (flags.SleepRear) rear |= 1 << 6;
+            if (flags.ShutdownRear) rear |= 1 << 7;
+
+            return new byte[] { 0x5d, 0xbd, 0x01, keyb, bar, lid, rear, 0xFF };
+        }
+
+        static AsusUSB()
+        {
+            timer.Elapsed += Timer_Elapsed;
+
+            isSingleColor = AppConfig.ContainsModel("GA401") || AppConfig.ContainsModel("X13"); // Mono Color
+
+            var device = GetDevice(AURA_HID_ID);
+            if (device is not null && (device.Attributes.Version == 22 || device.Attributes.Version == 23) && (AppConfig.ContainsModel("GA402X") || AppConfig.ContainsModel("GA402N"))) isSingleColor = true;
+        }
+
+        private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            SetHeatmap();
+        }
+
+        static void SetHeatmap(bool init = false)
+        {
+            float cpuTemp = (float)HardwareControl.GetCPUTemp();
+            int freeze = 20, cold = 40, warm = 65, hot = 90;
+            Color color;
+
+            //Debug.WriteLine(cpuTemp);
+
+            if (cpuTemp < cold) color = ColorUtilities.GetWeightedAverage(Color.Blue, Color.Green, ((float)cpuTemp - freeze) / (cold - freeze));
+            else if (cpuTemp < warm) color = ColorUtilities.GetWeightedAverage(Color.Green, Color.Yellow, ((float)cpuTemp - cold) / (warm - cold));
+            else if (cpuTemp < hot) color = ColorUtilities.GetWeightedAverage(Color.Yellow, Color.Red, ((float)cpuTemp - warm) / (hot - warm));
+            else color = Color.Red;
+
+            ApplyColor(color, init);
+        }
+
+        public static Dictionary<int, string> GetSpeeds()
+        {
+            return new Dictionary<int, string>
+            {
+                { 0, Properties.Strings.AuraSlow },
+                { 1, Properties.Strings.AuraNormal },
+                { 2, Properties.Strings.AuraFast }
+            };
+        }
+
+        static Dictionary<int, string> _modesSingleColor = new Dictionary<int, string>
+        {
+            { 0, Properties.Strings.AuraStatic },
+            { 1, Properties.Strings.AuraBreathe },
+            { 10, Properties.Strings.AuraStrobe },
+        };
+
+        static Dictionary<int, string> _modes = new Dictionary<int, string>
+        {
+            { 0, Properties.Strings.AuraStatic },
+            { 1, Properties.Strings.AuraBreathe },
+            { 2, Properties.Strings.AuraColorCycle },
+            { 3, Properties.Strings.AuraRainbow },
+            { 10, Properties.Strings.AuraStrobe },
+            { HEATMAP, "Heatmap"},
+            { GPUMODE, "GPU Mode" }
+        };
+
+        static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
+        {
+            { 0, Properties.Strings.AuraStatic },
+            { 1, Properties.Strings.AuraBreathe },
+            { 2, Properties.Strings.AuraColorCycle },
+            { 3, Properties.Strings.AuraRainbow },
+            { 4, "Star" },
+            { 5, "Rain" },
+            { 6, "Highlight" },
+            { 7, "Laser" },
+            { 8, "Ripple" },
+            { 10, Properties.Strings.AuraStrobe},
+            { 11, "Comet" },
+            { 12, "Flash" },
+            { HEATMAP, "Heatmap"}
+        };
+
+
+        public static Dictionary<int, string> GetModes()
+        {
+            if (isTuf)
+            {
+                _modes.Remove(3);
+            }
+
+            if (isSingleColor)
+            {
+                return _modesSingleColor;
+            }
+
+            if (AppConfig.IsAdvantageEdition())
+            {
+                return _modes;
+            }
+
+            if (AppConfig.IsStrix())
+            {
+                return _modesStrix;
+            }
+
+            return _modes;
+        }
+
+
+        public static int Mode
+        {
+            get { return mode; }
+            set
+            {
+                if (GetModes().ContainsKey(value))
+                    mode = value;
+                else
+                    mode = 0;
+            }
+        }
+
+
+        public static bool HasSecondColor()
+        {
+            return (mode == 1 && !isTuf);
+        }
+
+        public static int Speed
+        {
+            get { return speed; }
+            set
+            {
+                if (GetSpeeds().ContainsKey(value))
+                    speed = value;
+                else
+                    speed = 1;
+            }
+
+        }
+
+        public static void SetColor(int colorCode)
+        {
+            Color1 = Color.FromArgb(colorCode);
+        }
+
+        public static void SetColor2(int colorCode)
+        {
+            Color2 = Color.FromArgb(colorCode);
+        }
+
+
+
+        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minFeatures = 1)
+        {
+            HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
+            foreach (HidDevice device in HidDeviceList)
+                if (device.IsConnected && device.Capabilities.FeatureReportByteLength >= minFeatures)
+                    yield return device;
+        }
+
+        public static HidDevice? GetDevice(byte reportID = INPUT_HID_ID)
+        {
+            HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
+            HidDevice input = null;
+
+            foreach (HidDevice device in HidDeviceList)
+                if (device.ReadFeatureData(out byte[] data, reportID))
+                {
+                    input = device;
+                    //Logger.WriteLine("HID Device("+ reportID + ")" +  + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.DevicePath);
+                }
+
+            return input;
+        }
+
+        public static bool TouchpadToggle()
+        {
+            HidDevice? input = GetDevice();
+            if (input != null) return input.WriteFeatureData(new byte[] { INPUT_HID_ID, 0xf4, 0x6b });
+            return false;
+        }
+
+
+        public static byte[] AuraMessage(int mode, Color color, Color color2, int speed, bool mono = false)
+        {
+
+            byte[] msg = new byte[17];
+            msg[0] = AURA_HID_ID;
+            msg[1] = 0xb3;
+            msg[2] = 0x00; // Zone 
+            msg[3] = (byte)mode; // Aura Mode
+            msg[4] = color.R; // R
+            msg[5] = mono ? (byte)0 : color.G; // G
+            msg[6] = mono ? (byte)0 : color.B; // B
+            msg[7] = (byte)speed; // aura.speed as u8;
+            msg[8] = 0; // aura.direction as u8;
+            msg[9] = (mode == 1) ? (byte)1 : (byte)0;
+            msg[10] = color2.R; // R
+            msg[11] = mono ? (byte)0 : color2.G; // G
+            msg[12] = mono ? (byte)0 : color2.B; // B
+            return msg;
+        }
+
+        public static void Init()
+        {
+            Task.Run(async () =>
+            {
+                var devices = GetHidDevices(deviceIds);
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+                    device.WriteFeatureData(LED_INIT1);
+                    device.WriteFeatureData(LED_INIT2);
+                    device.WriteFeatureData(LED_INIT3);
+                    device.WriteFeatureData(LED_INIT4);
+                    device.WriteFeatureData(LED_INIT5);
+                    device.CloseDevice();
+                }
+            });
+        }
+
+
+        public static void ApplyBrightness(int brightness, string log = "Backlight", bool delay = false)
+        {
+
+
+            Task.Run(async () =>
+            {
+
+                if (delay) await Task.Delay(TimeSpan.FromSeconds(1));
+
+                if (isTuf) Program.acpi.TUFKeyboardBrightness(brightness);
+
+                byte[] msg = { AURA_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+                byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+
+                var devices = GetHidDevices(deviceIds);
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+
+                    if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                    {
+                        device.WriteFeatureData(msg);
+                        Logger.WriteLine(log + ":" + BitConverter.ToString(msg));
+                    }
+
+                    if (AppConfig.ContainsModel("GA503") && device.ReadFeatureData(out byte[] dataBackkup, INPUT_HID_ID))
+                    {
+                        device.WriteFeatureData(msgBackup);
+                        Logger.WriteLine(log + ":" + BitConverter.ToString(msgBackup));
+                    }
+
+                    device.CloseDevice();
+                }
+
+                // Backup payload for old models
+                /*
+                if (AppConfig.ContainsModel("GA503RW"))
+                {
+                    byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
+
+                    var devicesBackup = GetHidDevices(deviceIds);
+                    foreach (HidDevice device in devicesBackup)
+                    {
+                        device.OpenDevice();
+                        device.WriteFeatureData(msgBackup);
+                        device.CloseDevice();
+                    }
+                }
+                */
+
+            });
+
+
+        }
+
+
+        public static void ApplyAuraPower()
+        {
+
+            AuraPower flags = new();
+
+            // Keyboard
+            flags.AwakeKeyb = AppConfig.IsNotFalse("keyboard_awake");
+            flags.BootKeyb = AppConfig.IsNotFalse("keyboard_boot");
+            flags.SleepKeyb = AppConfig.IsNotFalse("keyboard_sleep");
+            flags.ShutdownKeyb = AppConfig.IsNotFalse("keyboard_shutdown");
+
+            // Logo
+            flags.AwakeLogo = AppConfig.IsNotFalse("keyboard_awake_logo");
+            flags.BootLogo = AppConfig.IsNotFalse("keyboard_boot_logo");
+            flags.SleepLogo = AppConfig.IsNotFalse("keyboard_sleep_logo");
+            flags.ShutdownLogo = AppConfig.IsNotFalse("keyboard_shutdown_logo");
+
+            // Lightbar
+            flags.AwakeBar = AppConfig.IsNotFalse("keyboard_awake_bar");
+            flags.BootBar = AppConfig.IsNotFalse("keyboard_boot_bar");
+            flags.SleepBar = AppConfig.IsNotFalse("keyboard_sleep_bar");
+            flags.ShutdownBar = AppConfig.IsNotFalse("keyboard_shutdown_bar");
+
+            // Lid
+            flags.AwakeLid = AppConfig.IsNotFalse("keyboard_awake_lid");
+            flags.BootLid = AppConfig.IsNotFalse("keyboard_boot_lid");
+            flags.SleepLid = AppConfig.IsNotFalse("keyboard_sleep_lid");
+            flags.ShutdownLid = AppConfig.IsNotFalse("keyboard_shutdown_lid");
+
+            // Rear Bar
+            flags.AwakeRear = AppConfig.IsNotFalse("keyboard_awake_lid");
+            flags.BootRear = AppConfig.IsNotFalse("keyboard_boot_lid");
+            flags.SleepRear = AppConfig.IsNotFalse("keyboard_sleep_lid");
+            flags.ShutdownRear = AppConfig.IsNotFalse("keyboard_shutdown_lid");
+
+            var devices = GetHidDevices(deviceIds);
+            byte[] msg = AuraPowerMessage(flags);
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    device.WriteFeatureData(msg);
+                    Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                }
+                device.CloseDevice();
+            }
+
+            if (isTuf)
+                Program.acpi.TUFKeyboardPower(
+                    flags.AwakeKeyb,
+                    flags.BootKeyb,
+                    flags.SleepKeyb,
+                    flags.ShutdownKeyb);
+
+        }
+
+
+        static void GetAuraDevice()
+        {
+            var devices = GetHidDevices(deviceIds);
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    Logger.WriteLine("Aura Device:" + device.DevicePath);
+                    auraDevice = device;
+                    return;
+                }
+                else
+                {
+                    device.CloseDevice();
+                }
+            }
+        }
+
+        public static void ApplyColor(Color color, bool init = false)
+        {
+
+            if (isTuf)
+            {
+                Program.acpi.TUFKeyboardRGB(0, color, 0);
+                return;
+            }
+
+            if (auraDevice is null || !auraDevice.IsConnected) GetAuraDevice();
+            if (auraDevice is null || !auraDevice.IsConnected) return;
+
+            if (isStrix && !isOldHeatmap)
+            {
+                byte[] msg = new byte[0x40];
+
+                byte start = 9;
+                byte maxLeds = 0x93;
+
+                msg[0] = AURA_HID_ID;
+                msg[1] = 0xbc;
+                msg[2] = 0;
+                msg[3] = 1;
+                msg[4] = 1;
+                msg[5] = 1;
+                msg[6] = 0;
+                msg[7] = 0x10;
+
+                for (byte i = 0; i < 0x12; i++)
+                {
+                    msg[start + i * 3] = color.R; // R
+                    msg[start + 1 + i * 3] = color.G; // G
+                    msg[start + 2 + i * 3] = color.B; // B
+                }
+
+
+                if (init)
+                {
+                    auraDevice.Write(LED_INIT1);
+                    auraDevice.Write(LED_INIT2);
+                    auraDevice.Write(LED_INIT3);
+                    auraDevice.Write(LED_INIT4);
+                    auraDevice.Write(LED_INIT5);
+                    auraDevice.Write(new byte[] { AURA_HID_ID, 0xbc });
+                }
+
+                for (byte b = 0; b < maxLeds; b += 0x10)
+                {
+                    msg[6] = b;
+                    auraDevice.Write(msg);
+                }
+
+                msg[6] = maxLeds;
+                auraDevice.Write(msg);
+
+                msg[4] = 4;
+                msg[5] = 0;
+                msg[6] = 0;
+                msg[7] = 0;
+                auraDevice.Write(msg);
+            }
+
+            else
+            {
+                Debug.WriteLine(color.ToString());
+                auraDevice.Write(AuraMessage(0, color, color, 0));
+                auraDevice.Write(MESSAGE_SET);
+            }
+
+        }
+
+
+        public static void ApplyGPUColor()
+        {
+            if (AppConfig.Get("aura_mode") != GPUMODE) return;
+
+            Logger.WriteLine(GPUModeControl.gpuMode.ToString());
+
+            switch (GPUModeControl.gpuMode)
+            {
+                case AsusACPI.GPUModeUltimate:
+                    ApplyColor(Color.Red, true);
+                    break;
+                case AsusACPI.GPUModeEco:
+                    ApplyColor(Color.Green, true);
+                    break;
+                default:
+                    ApplyColor(Color.Yellow, true);
+                    break;
+            }
+        }
+
+
+        public static void ApplyAura()
+        {
+
+            Mode = AppConfig.Get("aura_mode");
+            Speed = AppConfig.Get("aura_speed");
+            SetColor(AppConfig.Get("aura_color"));
+            SetColor2(AppConfig.Get("aura_color2"));
+
+            timer.Enabled = false;
+
+            if (Mode == HEATMAP)
+            {
+                SetHeatmap(true);
+                timer.Enabled = true;
+                return;
+            } 
+
+            if (Mode == GPUMODE)
+            {
+                ApplyGPUColor();
+                return;
+            }
+
+            int _speed;
+            switch (Speed)
+            {
+                case 1:
+                    _speed = 0xeb;
+                    break;
+                case 2:
+                    _speed = 0xf5;
+                    break;
+                default:
+                    _speed = 0xe1;
+                    break;
+            }
+
+            byte[] msg;
+            var devices = GetHidDevices(deviceIds);
+
+            foreach (HidDevice device in devices)
+            {
+                device.OpenDevice();
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    msg = AuraMessage(Mode, Color1, Color2, _speed, isSingleColor);
+                    device.WriteFeatureData(msg);
+                    device.WriteFeatureData(MESSAGE_APPLY);
+                    device.WriteFeatureData(MESSAGE_SET);
+                    Logger.WriteLine("USB-KB " + device.Attributes.Version + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+                }
+                device.CloseDevice();
+            }
+
+            if (isTuf)
+                Program.acpi.TUFKeyboardRGB(Mode, Color1, _speed);
+
+        }
+
+
+        // Reference : thanks to https://github.com/RomanYazvinsky/ for initial discovery of XGM payloads
+        public static int SetXGM(byte[] msg)
+        {
+
+            //Logger.WriteLine("XGM Payload :" + BitConverter.ToString(msg));
+
+            var payload = new byte[300];
+            Array.Copy(msg, payload, msg.Length);
+
+            foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }, 300))
+            {
+                device.OpenDevice();
+                Logger.WriteLine("XGM " + device.Attributes.ProductHexId + "|" + device.Capabilities.FeatureReportByteLength + ":" + BitConverter.ToString(msg));
+                device.WriteFeatureData(payload);
+                device.CloseDevice();
+                //return 1;
+            }
+
+            return 0;
+        }
+
+        public static void InitXGM()
+        {
+            byte[] ASUS_INIT = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
+
+            SetXGM(ASUS_INIT);
+
+            /*
+            SetXGM(new byte[] { 0x5e, 0xd0, 0x02 });
+            SetXGM(new byte[] { 0x5e, 0xd0, 0x03 });
+            SetXGM(ASUS_INIT);
+            SetXGM(new byte[] { 0x5e, 0xd1, 0x02 }); // reset fan
+            SetXGM(ASUS_INIT);
+            SetXGM(new byte[] { 0x5e, 0xce, 0x03 }); 
+            SetXGM(new byte[] { 0x5e, 0xd0, 0x04 });
+            SetXGM(new byte[] { 0x5e, 0xd0, 0x01 });
+            */
+        }
+
+        public static void ApplyXGMLight(bool status)
+        {
+            SetXGM(new byte[] { 0x5e, 0xc5, status ? (byte)0x50 : (byte)0 });
+        }
+
+
+        public static int ResetXGM()
+        {
+            return SetXGM(new byte[] { 0x5e, 0xd1, 0x02 });
+        }
+
+        public static int SetXGMFan(byte[] curve)
+        {
+
+            if (AsusACPI.IsInvalidCurve(curve)) return -1;
+
+            //InitXGM();
+
+            byte[] msg = new byte[19];
+            Array.Copy(new byte[] { 0x5e, 0xd1, 0x01 }, msg, 3);
+            Array.Copy(curve, 0, msg, 3, curve.Length);
+
+            return SetXGM(msg);
+        }
+
+
+    }
+
+}

app/Aura.cs

@@ -1,300 +0,0 @@
-using HidLibrary;
-using System.Diagnostics;
-using static Starlight.AnimeMatrix.BuiltInAnimation;
-
-namespace GHelper
-{
-
-    [Flags]
-    public enum AuraDev19b6 : uint
-    {
-        BootLogo = 1,
-        BootKeyb = 1 << 1,
-        AwakeLogo = 1 << 2,
-        AwakeKeyb = 1 << 3,
-        SleepLogo = 1 << 4,
-        SleepKeyb = 1 << 5,
-        ShutdownLogo = 1 << 6,
-        ShutdownKeyb = 1 << 7,
-        BootBar = 1u << (7 + 2),
-        AwakeBar = 1u << (7 + 3),
-        SleepBar = 1u << (7 + 4),
-        ShutdownBar = 1u << (7 + 5),
-        BootLid = 1u << (15 + 1),
-        AwakeLid = 1u << (15 + 2),
-        SleepLid = 1u << (15 + 3),
-        ShutdownLid = 1u << (15 + 4)
-    }
-
-    public static class AuraDev19b6Extensions
-    {
-        public static byte[] ToBytes(this AuraDev19b6[] controls)
-        {
-            uint a = 0;
-            foreach (var n in controls)
-            {
-                a |= (uint)n;
-            }
-            return new byte[] { 0x5d, 0xbd, 0x01, (byte)(a & 0xff), (byte)((a & 0xff00) >> 8), (byte)((a & 0xff0000) >> 16) };
-        }
-
-        public static ushort BitOr(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self | rhs);
-        }
-
-        public static ushort BitAnd(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self & rhs);
-        }
-    }
-
-    public static class Aura
-    {
-
-        static byte[] MESSAGE_SET = { 0x5d, 0xb5, 0, 0, 0 };
-        static byte[] MESSAGE_APPLY = { 0x5d, 0xb4 };
-
-        static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0 };
-
-        private static int mode = 0;
-        private static int speed = 1;
-        public static Color Color1 = Color.White;
-        public static Color Color2 = Color.Black;
-
-
-        public static Dictionary<int, string> GetSpeeds()
-        {
-            return new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraSlow },
-                { 1, Properties.Strings.AuraNormal },
-                { 2, Properties.Strings.AuraFast }
-            };
-        }
-
-        static Dictionary<int, string> _modes = new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraStatic },
-                { 1, Properties.Strings.AuraBreathe },
-                { 2, Properties.Strings.AuraColorCycle },
-                { 3, Properties.Strings.AuraRainbow },
-                { 10, Properties.Strings.AuraStrobe },
-            };
-
-        static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
-            {
-                { 0, Properties.Strings.AuraStatic },
-                { 1, Properties.Strings.AuraBreathe },
-                { 2, Properties.Strings.AuraColorCycle },
-                { 3, Properties.Strings.AuraRainbow },
-                { 4, "Star" },
-                { 5, "Rain" },
-                { 6, "Highlight" },
-                { 7, "Laser" },
-                { 8, "Ripple" },
-                { 10, Properties.Strings.AuraStrobe},
-                { 11, "Comet" },
-                { 12, "Flash" },
-            };
-
-
-        public static Dictionary<int, string> GetModes()
-        {
-            if (Program.config.ContainsModel("TUF"))
-            {
-                _modes.Remove(3);
-            }
-
-            if (Program.config.ContainsModel("401"))
-            {
-                _modes.Remove(2);
-                _modes.Remove(3);
-            }
-
-            if (Program.config.ContainsModel("Strix") || Program.config.ContainsModel("Scar"))
-            {
-                return _modesStrix;
-            }
-
-            return _modes;
-        }
-
-
-        public static int Mode
-        {
-            get { return mode; }
-            set
-            {
-                if (GetModes().ContainsKey(value))
-                    mode = value;
-                else
-                    mode = 0;
-            }
-        }
-
-        public static bool HasSecondColor()
-        {
-            return (mode == 1 && !Program.config.ContainsModel("TUF"));
-        }
-
-        public static int Speed
-        {
-            get { return speed; }
-            set
-            {
-                if (GetSpeeds().ContainsKey(value))
-                    speed = value;
-                else
-                    speed = 1;
-            }
-
-        }
-
-        public static void SetColor(int colorCode)
-        {
-            Color1 = Color.FromArgb(colorCode);
-        }
-
-        public static void SetColor2(int colorCode)
-        {
-            Color2 = Color.FromArgb(colorCode);
-        }
-
-        public static byte[] AuraMessage(int mode, Color color, Color color2, int speed)
-        {
-
-            byte[] msg = new byte[17];
-            msg[0] = 0x5d;
-            msg[1] = 0xb3;
-            msg[2] = 0x00; // Zone 
-            msg[3] = (byte)mode; // Aura Mode
-            msg[4] = (byte)(color.R); // R
-            msg[5] = (byte)(color.G); // G
-            msg[6] = (byte)(color.B); // B
-            msg[7] = (byte)speed; // aura.speed as u8;
-            msg[8] = 0; // aura.direction as u8;
-            msg[10] = (byte)(color2.R); // R
-            msg[11] = (byte)(color2.G); // G
-            msg[12] = (byte)(color2.B); // B
-            return msg;
-        }
-
-
-        public static void ApplyBrightness(int brightness)
-        {
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
-
-            byte[] msg = { 0x5d, 0xba, 0xc5, 0xc4, (byte)brightness };
-
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.CloseDevice();
-                }
-
-            Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
-
-            if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardBrightness(brightness);
-        }
-
-
-        public static void ApplyAuraPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
-        {
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, 0x19b6).ToArray();
-
-            List<AuraDev19b6> flags = new List<AuraDev19b6>();
-
-            if (awake)
-            {
-                flags.Add(AuraDev19b6.AwakeKeyb);
-                flags.Add(AuraDev19b6.AwakeBar);
-                flags.Add(AuraDev19b6.AwakeLid);
-                flags.Add(AuraDev19b6.AwakeLogo);
-            }
-
-            if (boot)
-            {
-                flags.Add(AuraDev19b6.BootKeyb);
-                flags.Add(AuraDev19b6.BootBar);
-                flags.Add(AuraDev19b6.BootLid);
-                flags.Add(AuraDev19b6.BootLogo);
-            }
-
-            if (sleep)
-            {
-                flags.Add(AuraDev19b6.SleepKeyb);
-                flags.Add(AuraDev19b6.SleepBar);
-                flags.Add(AuraDev19b6.SleepLid);
-                flags.Add(AuraDev19b6.SleepLogo);
-            }
-
-            if (shutdown)
-            {
-                flags.Add(AuraDev19b6.ShutdownKeyb);
-                flags.Add(AuraDev19b6.ShutdownBar);
-                flags.Add(AuraDev19b6.ShutdownLid);
-                flags.Add(AuraDev19b6.ShutdownLogo);
-            }
-
-            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
-
-            Debug.WriteLine(BitConverter.ToString(msg));
-
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.CloseDevice();
-                }
-
-            Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
-
-            if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardPower(awake, boot, sleep, shutdown);
-
-        }
-
-        public static void ApplyAura()
-        {
-
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
-
-            int _speed;
-
-            switch (Speed)
-            {
-                case 1:
-                    _speed = 0xeb;
-                    break;
-                case 2:
-                    _speed = 0xf5;
-                    break;
-                default:
-                    _speed = 0xe1;
-                    break;
-            }
-
-
-            byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected && device.Description.Contains("HID"))
-                {
-                    device.OpenDevice();
-                    device.Write(msg);
-                    device.Write(MESSAGE_SET);
-                    device.Write(MESSAGE_APPLY);
-                    device.CloseDevice();
-                }
-
-            if (Program.config.ContainsModel("TUF"))
-                Program.wmi.TUFKeyboardRGB(Mode, Color1, _speed);
-
-        }
-    }
-
-}

app/AutoUpdate/AutoUpdateControl.cs

@@ -0,0 +1,133 @@
+using System.Diagnostics;
+using System.Net;
+using System.Reflection;
+using System.Text.Json;
+
+namespace GHelper.AutoUpdate
+{
+    public class AutoUpdateControl
+    {
+
+        SettingsForm settings;
+
+        public string versionUrl = "http://github.com/seerge/g-helper/releases";
+        static long lastUpdate;
+
+        public AutoUpdateControl(SettingsForm settingsForm)
+        {
+            settings = settingsForm;
+            var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+            settings.SetVersionLabel(Properties.Strings.VersionLabel + $": {appVersion.Major}.{appVersion.Minor}.{appVersion.Build}");
+        }
+
+        public void CheckForUpdates()
+        {
+            // Run update once per 12 hours
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeSeconds() - lastUpdate) < 43200) return;
+            lastUpdate = DateTimeOffset.Now.ToUnixTimeSeconds();
+
+            Task.Run(async () =>
+            {
+                await Task.Delay(TimeSpan.FromSeconds(1));
+                CheckForUpdatesAsync();
+            });
+        }
+
+        public void LoadReleases()
+        {
+            Process.Start(new ProcessStartInfo(versionUrl) { UseShellExecute = true });
+        }
+
+        async void CheckForUpdatesAsync()
+        {
+
+            if (AppConfig.Is("skip_updates")) return;
+
+            try
+            {
+
+                using (var httpClient = new HttpClient())
+                {
+                    httpClient.DefaultRequestHeaders.Add("User-Agent", "C# App");
+                    var json = await httpClient.GetStringAsync("https://api.github.com/repos/seerge/g-helper/releases/latest");
+                    var config = JsonSerializer.Deserialize<JsonElement>(json);
+                    var tag = config.GetProperty("tag_name").ToString().Replace("v", "");
+                    var assets = config.GetProperty("assets");
+
+                    string url = null;
+
+                    for (int i = 0; i < assets.GetArrayLength(); i++)
+                    {
+                        if (assets[i].GetProperty("browser_download_url").ToString().Contains(".zip"))
+                            url = assets[i].GetProperty("browser_download_url").ToString();
+                    }
+
+                    if (url is null)
+                        url = assets[0].GetProperty("browser_download_url").ToString();
+
+                    var gitVersion = new Version(tag);
+                    var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+                    //appVersion = new Version("0.50.0.0"); 
+
+                    if (gitVersion.CompareTo(appVersion) > 0)
+                    {
+                        versionUrl = url;
+                        settings.SetVersionLabel(Properties.Strings.DownloadUpdate + ": " + tag, true);
+
+                        if (AppConfig.GetString("skip_version") != tag)
+                        {
+                            DialogResult dialogResult = MessageBox.Show(Properties.Strings.DownloadUpdate + ": G-Helper " + tag + "?", "Update", MessageBoxButtons.YesNo);
+                            if (dialogResult == DialogResult.Yes)
+                                AutoUpdate(url);
+                            else
+                                AppConfig.Set("skip_version", tag);
+                        }
+
+                    }
+                    else
+                    {
+                        Logger.WriteLine($"Latest version {appVersion}");
+                    }
+
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine("Failed to check for updates:" + ex.Message);
+            }
+
+        }
+
+
+        async void AutoUpdate(string requestUri)
+        {
+
+            Uri uri = new Uri(requestUri);
+            string zipName = Path.GetFileName(uri.LocalPath);
+
+            string exeLocation = Application.ExecutablePath;
+            string exeDir = Path.GetDirectoryName(exeLocation);
+            string zipLocation = exeDir + "\\" + zipName;
+
+            using (WebClient client = new WebClient())
+            {
+                client.DownloadFile(uri, zipLocation);
+
+                Logger.WriteLine(requestUri);
+                Logger.WriteLine(zipLocation);
+                Logger.WriteLine(exeLocation);
+
+                var cmd = new Process();
+                cmd.StartInfo.UseShellExecute = false;
+                cmd.StartInfo.CreateNoWindow = true;
+                cmd.StartInfo.FileName = "powershell";
+                cmd.StartInfo.Arguments = $"Start-Sleep -Seconds 1; Expand-Archive {zipLocation} -DestinationPath {exeDir} -Force; Remove-Item {zipLocation} -Force; {exeLocation}";
+                cmd.Start();
+
+                Application.Exit();
+            }
+
+        }
+
+    }
+}

app/Battery/BatteryControl.cs

@@ -0,0 +1,20 @@
+namespace GHelper.Battery
+{
+    internal class BatteryControl
+    {
+
+        public static void SetBatteryChargeLimit(int limit = -1)
+        {
+
+            if (limit < 0) limit = AppConfig.Get("charge_limit");
+            if (limit < 40 || limit > 100) return;
+
+            Program.acpi.DeviceSet(AsusACPI.BatteryLimit, limit, "BatteryLimit");
+            Program.settingsForm.VisualiseBattery(limit);
+
+            AppConfig.Set("charge_limit", limit);
+
+        }
+
+    }
+}

app/Display/ScreenBrightness.cs

@@ -0,0 +1,47 @@
+namespace GHelper.Display
+{
+    using System;
+    using System.Diagnostics;
+    using System.Management;
+
+    public static class ScreenBrightness
+    {
+        public static int Get()
+        {
+            using var mclass = new ManagementClass("WmiMonitorBrightness")
+            {
+                Scope = new ManagementScope(@"\\.\root\wmi")
+            };
+            using var instances = mclass.GetInstances();
+            foreach (ManagementObject instance in instances)
+            {
+                return (byte)instance.GetPropertyValue("CurrentBrightness");
+            }
+            return 0;
+        }
+
+        public static void Set(int brightness)
+        {
+            using var mclass = new ManagementClass("WmiMonitorBrightnessMethods")
+            {
+                Scope = new ManagementScope(@"\\.\root\wmi")
+            };
+            using var instances = mclass.GetInstances();
+            var args = new object[] { 1, brightness };
+            foreach (ManagementObject instance in instances)
+            {
+                instance.InvokeMethod("WmiSetBrightness", args);
+            }
+        }
+
+        public static int Adjust(int delta)
+        {
+            int brightness = Get();
+            Debug.WriteLine(brightness);
+            brightness = Math.Min(100, Math.Max(0, brightness + delta));
+            Set(brightness);
+            return brightness;
+        }
+
+    }
+}

app/Display/ScreenControl.cs

@@ -0,0 +1,103 @@
+using System.Diagnostics;
+
+namespace GHelper.Display
+{
+    public class ScreenControl
+    {
+
+        public const int MAX_REFRESH = 1000;
+
+        public void AutoScreen(bool force = false)
+        {
+            if (force || AppConfig.Is("screen_auto"))
+            {
+                if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
+                    SetScreen(MAX_REFRESH, 1);
+                else
+                    SetScreen(60, 0);
+            }
+            else
+            {
+                SetScreen(overdrive: AppConfig.Get("overdrive"));
+            }
+        }
+
+        public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
+        {
+            var laptopScreen = ScreenNative.FindLaptopScreen(true);
+
+            if (laptopScreen is null) return;
+
+            if (ScreenNative.GetRefreshRate(laptopScreen) < 0) return;
+
+            if (frequency >= MAX_REFRESH)
+            {
+                frequency = ScreenNative.GetMaxRefreshRate(laptopScreen);
+            }
+
+            if (frequency > 0)
+            {
+                ScreenNative.SetRefreshRate(laptopScreen, frequency);
+            }
+
+            if (overdrive >= 0)
+            {
+                if (AppConfig.Get("no_overdrive") == 1) overdrive = 0;
+                Program.acpi.DeviceSet(AsusACPI.ScreenOverdrive, overdrive, "ScreenOverdrive");
+
+            }
+
+            if (miniled >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.ScreenMiniled, miniled, "Miniled");
+                Debug.WriteLine("Miniled " + miniled);
+            }
+
+            InitScreen();
+        }
+
+
+        public void ToogleMiniled()
+        {
+            int miniled = (AppConfig.Get("miniled") == 1) ? 0 : 1;
+            AppConfig.Set("miniled", miniled);
+            SetScreen(-1, -1, miniled);
+        }
+
+        public void InitScreen()
+        {
+            var laptopScreen = ScreenNative.FindLaptopScreen();
+
+            int frequency = ScreenNative.GetRefreshRate(laptopScreen);
+            int maxFrequency = ScreenNative.GetMaxRefreshRate(laptopScreen);
+
+            bool screenAuto = AppConfig.Is("screen_auto");
+            bool overdriveSetting = !AppConfig.Is("no_overdrive");
+
+            int overdrive = Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
+            int miniled = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled);
+
+            if (miniled >= 0)
+                AppConfig.Set("miniled", miniled);
+
+            bool screenEnabled = (frequency >= 0);
+
+            AppConfig.Set("frequency", frequency);
+            AppConfig.Set("overdrive", overdrive);
+
+            Program.settingsForm.Invoke(delegate
+            {
+                Program.settingsForm.VisualiseScreen(
+                    screenEnabled: screenEnabled,
+                    screenAuto: screenAuto,
+                    frequency: frequency,
+                    maxFrequency: maxFrequency,
+                    overdrive: overdrive,
+                    overdriveSetting: overdriveSetting,
+                    miniled: miniled
+                );
+            });
+
+        }
+    }
+}

app/Display/ScreenInterrogatory.cs

@@ -0,0 +1,375 @@
+using GHelper.Helpers;
+using NvAPIWrapper.Display;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace GHelper.Display
+{
+    public static class ScreenInterrogatory
+    {
+        public const int ERROR_SUCCESS = 0;
+
+        #region enums
+
+        public enum QUERY_DEVICE_CONFIG_FLAGS : uint
+        {
+            QDC_ALL_PATHS = 0x00000001,
+            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
+            QDC_DATABASE_CURRENT = 0x00000004
+        }
+
+        public enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY : uint
+        {
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = 0xFFFFFFFF,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_SCANLINE_ORDERING : uint
+        {
+            DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
+            DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST = DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
+            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
+            DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_ROTATION : uint
+        {
+            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
+            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
+            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
+            DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
+            DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_SCALING : uint
+        {
+            DISPLAYCONFIG_SCALING_IDENTITY = 1,
+            DISPLAYCONFIG_SCALING_CENTERED = 2,
+            DISPLAYCONFIG_SCALING_STRETCHED = 3,
+            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
+            DISPLAYCONFIG_SCALING_CUSTOM = 5,
+            DISPLAYCONFIG_SCALING_PREFERRED = 128,
+            DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_PIXELFORMAT : uint
+        {
+            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
+            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
+            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
+            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
+            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
+            DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff
+        }
+
+        public enum DISPLAYCONFIG_MODE_INFO_TYPE : uint
+        {
+            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
+            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
+            DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        public enum DISPLAYCONFIG_DEVICE_INFO_TYPE : uint
+        {
+            DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
+            DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
+            DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
+            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
+            DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
+        }
+
+        #endregion
+
+        #region structs
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct LUID
+        {
+            public uint LowPart;
+            public int HighPart;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_SOURCE_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public uint statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_TARGET_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            private DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            private DISPLAYCONFIG_ROTATION rotation;
+            private DISPLAYCONFIG_SCALING scaling;
+            private DISPLAYCONFIG_RATIONAL refreshRate;
+            private DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+            public bool targetAvailable;
+            public uint statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_RATIONAL
+        {
+            public uint Numerator;
+            public uint Denominator;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_PATH_INFO
+        {
+            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
+            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
+            public uint flags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_2DREGION
+        {
+            public uint cx;
+            public uint cy;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
+        {
+            public ulong pixelRate;
+            public DISPLAYCONFIG_RATIONAL hSyncFreq;
+            public DISPLAYCONFIG_RATIONAL vSyncFreq;
+            public DISPLAYCONFIG_2DREGION activeSize;
+            public DISPLAYCONFIG_2DREGION totalSize;
+            public uint videoStandard;
+            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_TARGET_MODE
+        {
+            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct POINTL
+        {
+            private int x;
+            private int y;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_SOURCE_MODE
+        {
+            public uint width;
+            public uint height;
+            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
+            public POINTL position;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public struct DISPLAYCONFIG_MODE_INFO_UNION
+        {
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_TARGET_MODE targetMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_MODE_INFO
+        {
+            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
+            public uint id;
+            public LUID adapterId;
+            public DISPLAYCONFIG_MODE_INFO_UNION modeInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
+        {
+            public uint value;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DISPLAYCONFIG_DEVICE_INFO_HEADER
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
+            public uint size;
+            public LUID adapterId;
+            public uint id;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            public DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
+            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            public ushort edidManufactureId;
+            public ushort edidProductCodeId;
+            public uint connectorInstance;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
+            public string monitorFriendlyDeviceName;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            public string monitorDevicePath;
+        }
+
+        #endregion
+
+        #region DLL-Imports
+
+        [DllImport("user32.dll")]
+        public static extern int GetDisplayConfigBufferSizes(
+            QUERY_DEVICE_CONFIG_FLAGS flags, out uint numPathArrayElements, out uint numModeInfoArrayElements);
+
+        [DllImport("user32.dll")]
+        public static extern int QueryDisplayConfig(
+            QUERY_DEVICE_CONFIG_FLAGS flags,
+            ref uint numPathArrayElements, [Out] DISPLAYCONFIG_PATH_INFO[] PathInfoArray,
+            ref uint numModeInfoArrayElements, [Out] DISPLAYCONFIG_MODE_INFO[] ModeInfoArray,
+            nint currentTopologyId
+            );
+
+        [DllImport("user32.dll")]
+        public static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName);
+
+        #endregion
+
+
+        [Flags]
+        public enum DisplayDeviceStates : int
+        {
+            ATTACHED_TO_DESKTOP = 0x01,
+            PRIMARY_DEVICE = 0x04,
+            MIRRORING_DRIVER = 0x08,
+            VGA_COMPATIBLE = 0x10,
+            REMOVABLE = 0x20,
+            DISCONNECTED = 0x2000000,
+            REMOTE = 0x4000000,
+            MODESPRUNED = 0x8000000
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct DISPLAY_DEVICE
+        {
+            public int cb;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+            public string DeviceName;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            public string DeviceString;
+
+            public DisplayDeviceStates StateFlags;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            public string DeviceID;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            public string DeviceKey;
+        }
+
+
+        [DllImport(nameof(User32), CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern bool EnumDisplayDevices(
+            string? lpDevice,
+            uint iDevNum,
+            ref DISPLAY_DEVICE lpDisplayDevice,
+            uint dwFlags);
+
+
+        private static DISPLAYCONFIG_TARGET_DEVICE_NAME DeviceName(LUID adapterId, uint targetId)
+        {
+            var deviceName = new DISPLAYCONFIG_TARGET_DEVICE_NAME
+            {
+                header =
+                {
+                    size = (uint)Marshal.SizeOf(typeof (DISPLAYCONFIG_TARGET_DEVICE_NAME)),
+                    adapterId = adapterId,
+                    id = targetId,
+                    type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
+                }
+            };
+            var error = DisplayConfigGetDeviceInfo(ref deviceName);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            return deviceName;
+        }
+
+        public static IEnumerable<DISPLAYCONFIG_TARGET_DEVICE_NAME> GetAllDevices()
+        {
+            uint pathCount, modeCount;
+            var error = GetDisplayConfigBufferSizes(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS, out pathCount, out modeCount);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            var displayPaths = new DISPLAYCONFIG_PATH_INFO[pathCount];
+            var displayModes = new DISPLAYCONFIG_MODE_INFO[modeCount];
+            error = QueryDisplayConfig(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS,
+                ref pathCount, displayPaths, ref modeCount, displayModes, nint.Zero);
+            if (error != ERROR_SUCCESS)
+                throw new Win32Exception(error);
+
+            for (var i = 0; i < modeCount; i++)
+                if (displayModes[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE.DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
+                    yield return DeviceName(displayModes[i].adapterId, displayModes[i].id);
+        }
+
+
+        public static IEnumerable<DISPLAY_DEVICE> GetDisplayDevices()
+        {
+
+            var displayAdapter = new DISPLAY_DEVICE();
+            displayAdapter.cb = Marshal.SizeOf<DISPLAY_DEVICE>();
+
+            var displayAdapterNumber = default(uint);
+            while (EnumDisplayDevices(null, displayAdapterNumber, ref displayAdapter, 1))
+            {
+                var displayMonitor = new DISPLAY_DEVICE();
+                displayMonitor.cb = Marshal.SizeOf<DISPLAY_DEVICE>();
+
+                var displayMonitorNumber = default(uint);
+                while (EnumDisplayDevices(displayAdapter.DeviceName, displayMonitorNumber, ref displayMonitor, 1))
+                {
+                    var isAttached = (displayMonitor.StateFlags & DisplayDeviceStates.ATTACHED_TO_DESKTOP) == DisplayDeviceStates.ATTACHED_TO_DESKTOP;
+                    var isMirroring = (displayMonitor.StateFlags & DisplayDeviceStates.MIRRORING_DRIVER) == DisplayDeviceStates.MIRRORING_DRIVER;
+                    if (isAttached && !isMirroring) yield return displayMonitor;
+                    displayMonitorNumber++;
+                    
+                }
+
+                displayAdapterNumber++;
+            }
+        }
+
+
+    }
+
+}

app/Display/ScreenNative.cs

@@ -0,0 +1,286 @@
+using Microsoft.VisualBasic.Logging;
+using System.Collections;
+using System.Diagnostics.Metrics;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using static GHelper.Display.ScreenInterrogatory;
+
+namespace GHelper.Display
+{
+
+    class DeviceComparer : IComparer
+    {
+        public int Compare(object x, object y)
+        {
+            uint displayX = ((DISPLAYCONFIG_TARGET_DEVICE_NAME)x).connectorInstance;
+            uint displayY = ((DISPLAYCONFIG_TARGET_DEVICE_NAME)y).connectorInstance;
+
+            if (displayX > displayY)
+                return 1;
+            if (displayX < displayY)
+                return -1;
+            else
+                return 0;
+        }
+    }
+
+    class ScreenComparer : IComparer
+    {
+        public int Compare(object x, object y)
+        {
+            int displayX = Int32.Parse(((Screen)x).DeviceName.Replace(@"\\.\DISPLAY", ""));
+            int displayY = Int32.Parse(((Screen)y).DeviceName.Replace(@"\\.\DISPLAY", ""));
+            return (new CaseInsensitiveComparer()).Compare(displayX, displayY);
+        }
+    }
+    internal class ScreenNative
+    {
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+        public struct DEVMODE
+        {
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+            public string dmDeviceName;
+
+            public short dmSpecVersion;
+            public short dmDriverVersion;
+            public short dmSize;
+            public short dmDriverExtra;
+            public int dmFields;
+            public int dmPositionX;
+            public int dmPositionY;
+            public int dmDisplayOrientation;
+            public int dmDisplayFixedOutput;
+            public short dmColor;
+            public short dmDuplex;
+            public short dmYResolution;
+            public short dmTTOption;
+            public short dmCollate;
+
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+            public string dmFormName;
+
+            public short dmLogPixels;
+            public short dmBitsPerPel;
+            public int dmPelsWidth;
+            public int dmPelsHeight;
+            public int dmDisplayFlags;
+            public int dmDisplayFrequency;
+            public int dmICMMethod;
+            public int dmICMIntent;
+            public int dmMediaType;
+            public int dmDitherType;
+            public int dmReserved1;
+            public int dmReserved2;
+            public int dmPanningWidth;
+            public int dmPanningHeight;
+        };
+
+        [Flags()]
+        public enum DisplaySettingsFlags : int
+        {
+            CDS_UPDATEREGISTRY = 1,
+            CDS_TEST = 2,
+            CDS_FULLSCREEN = 4,
+            CDS_GLOBAL = 8,
+            CDS_SET_PRIMARY = 0x10,
+            CDS_RESET = 0x40000000,
+            CDS_NORESET = 0x10000000
+        }
+
+        // PInvoke declaration for EnumDisplaySettings Win32 API
+        [DllImport("user32.dll")]
+        public static extern int EnumDisplaySettingsEx(
+             string lpszDeviceName,
+             int iModeNum,
+             ref DEVMODE lpDevMode);
+
+        // PInvoke declaration for ChangeDisplaySettings Win32 API
+        [DllImport("user32.dll")]
+        public static extern int ChangeDisplaySettingsEx(
+                string lpszDeviceName, ref DEVMODE lpDevMode, IntPtr hwnd,
+                DisplaySettingsFlags dwflags, IntPtr lParam);
+
+        public static DEVMODE CreateDevmode()
+        {
+            DEVMODE dm = new DEVMODE();
+            dm.dmDeviceName = new String(new char[32]);
+            dm.dmFormName = new String(new char[32]);
+            dm.dmSize = (short)Marshal.SizeOf(dm);
+            return dm;
+        }
+
+        public enum COLORPROFILETYPE
+        {
+            CPT_ICC,
+            CPT_DMP,
+            CPT_CAMP,
+            CPT_GMMP
+        }
+        public enum COLORPROFILESUBTYPE
+        {
+            CPST_PERCEPTUAL,
+            CPST_RELATIVE_COLORIMETRIC,
+            CPST_SATURATION,
+            CPST_ABSOLUTE_COLORIMETRIC,
+            CPST_NONE,
+            CPST_RGB_WORKING_SPACE,
+            CPST_CUSTOM_WORKING_SPACE,
+            CPST_STANDARD_DISPLAY_COLOR_MODE,
+            CPST_EXTENDED_DISPLAY_COLOR_MODE
+        }
+        public enum WCS_PROFILE_MANAGEMENT_SCOPE
+        {
+            WCS_PROFILE_MANAGEMENT_SCOPE_SYSTEM_WIDE,
+            WCS_PROFILE_MANAGEMENT_SCOPE_CURRENT_USER
+        }
+
+        [DllImport("mscms.dll", CharSet = CharSet.Unicode)]
+        public static extern bool WcsSetDefaultColorProfile(
+            WCS_PROFILE_MANAGEMENT_SCOPE scope,
+            string pDeviceName,
+            COLORPROFILETYPE cptColorProfileType,
+            COLORPROFILESUBTYPE cpstColorProfileSubType,
+            uint dwProfileID,
+            string pProfileName
+        );
+
+
+        public const int ENUM_CURRENT_SETTINGS = -1;
+        public const string defaultDevice = @"\\.\DISPLAY1";
+
+
+        private static string? FindInternalName(bool log = false)
+        {
+            try
+            {
+                var devices = GetAllDevices().ToArray();
+                string internalName = AppConfig.GetString("internal_display");
+
+                foreach (var device in devices)
+                {
+                    if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
+                        device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
+                        device.monitorFriendlyDeviceName == internalName)
+                    {
+                        if (log) Logger.WriteLine(device.monitorDevicePath + " " + device.outputTechnology);
+                        AppConfig.Set("internal_display", device.monitorFriendlyDeviceName);
+                        var names = device.monitorDevicePath.Split("#");
+                        return names[1];
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+
+            return null;
+        }
+
+        static string ExtractDisplay(string input)
+        {
+            int index = input.IndexOf('\\', 4); // Start searching from index 4 to skip ""
+
+            if (index != -1)
+            {
+                string extracted = input.Substring(0, index);
+                return extracted;
+            }
+
+            return input;
+        }
+
+        public static string? FindLaptopScreen(bool log = false)
+        {
+            string? laptopScreen = null;
+            string? internalName = FindInternalName(log);
+
+            if (internalName == null)
+            {
+                Logger.WriteLine("Internal screen off");
+                return null;
+            }
+
+            try
+            {
+                var displays = GetDisplayDevices().ToArray();
+                foreach (var display in displays)
+                {
+                    if (log) Logger.WriteLine(display.DeviceID + " " + display.DeviceName);
+                    if (display.DeviceID.Contains(internalName))
+                    {
+                        laptopScreen = ExtractDisplay(display.DeviceName);
+                        break;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+
+            if (laptopScreen is null)
+            {
+                Logger.WriteLine("Default internal screen");
+                laptopScreen = Screen.PrimaryScreen.DeviceName;
+            }
+
+            return laptopScreen;
+        }
+
+
+        public static int GetMaxRefreshRate(string? laptopScreen)
+        {
+
+            if (laptopScreen is null) return -1;
+
+            DEVMODE dm = CreateDevmode();
+            int frequency = -1;
+
+            int i = 0;
+            while (0 != EnumDisplaySettingsEx(laptopScreen, i, ref dm))
+            {
+                if (dm.dmDisplayFrequency > frequency) frequency = dm.dmDisplayFrequency;
+                i++;
+            }
+
+            if (frequency > 0) AppConfig.Set("screen_max", frequency);
+            else frequency = AppConfig.Get("screen_max");
+
+            return frequency;
+
+        }
+
+        public static int GetRefreshRate(string? laptopScreen)
+        {
+
+            if (laptopScreen is null) return -1;
+
+            DEVMODE dm = CreateDevmode();
+            int frequency = -1;
+
+            if (0 != EnumDisplaySettingsEx(laptopScreen, ENUM_CURRENT_SETTINGS, ref dm))
+            {
+                frequency = dm.dmDisplayFrequency;
+            }
+
+            return frequency;
+        }
+
+        public static int SetRefreshRate(string laptopScreen, int frequency = 120)
+        {
+            DEVMODE dm = CreateDevmode();
+
+            if (0 != EnumDisplaySettingsEx(laptopScreen, ENUM_CURRENT_SETTINGS, ref dm))
+            {
+                dm.dmDisplayFrequency = frequency;
+                int iRet = ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
+                Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
+                return iRet;
+            }
+
+            return 0;
+
+        }
+    }
+}

app/Extra.cs

@@ -1,4 +1,9 @@
-using CustomControls;
+using GHelper.Display;
+using GHelper.Gpu.AMD;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.Mode;
+using GHelper.UI;
 using System.Diagnostics;
 
 namespace GHelper
@@ -6,9 +11,14 @@ namespace GHelper
     public partial class Extra : RForm
     {
 
+        ScreenControl screenControl = new ScreenControl();
+        ClamshellModeControl clamshellControl = new ClamshellModeControl();
+
+        const string EMPTY = "--------------";
+
         Dictionary<string, string> customActions = new Dictionary<string, string>
         {
-          {"","--------------" },
+          {"", EMPTY},
           {"mute", Properties.Strings.VolumeMute},
           {"screenshot", Properties.Strings.PrintScreen},
           {"play", Properties.Strings.PlayPause},
@@ -16,18 +26,47 @@ namespace GHelper
           {"performance", Properties.Strings.PerformanceMode},
           {"screen", Properties.Strings.ToggleScreen},
           {"miniled", Properties.Strings.ToggleMiniled},
+          {"fnlock", Properties.Strings.ToggleFnLock},
+          {"brightness_down", Properties.Strings.BrightnessDown},
+          {"brightness_up", Properties.Strings.BrightnessUp},
           {"custom", Properties.Strings.Custom}
         };
 
         private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
         {
-            if (name == "m4")
-                customActions[""] = Properties.Strings.OpenGHelper;
 
-            if (name == "fnf4")
+            switch (name)
             {
-                customActions[""] = Properties.Strings.ToggleAura;
-                customActions.Remove("aura");
+                case "m1":
+                    customActions[""] = Properties.Strings.VolumeDown;
+                    break;
+                case "m2":
+                    customActions[""] = Properties.Strings.VolumeUp;
+                    break;
+                case "m3":
+                    customActions[""] = Properties.Strings.MuteMic;
+                    break;
+                case "m4":
+                    customActions[""] = Properties.Strings.OpenGHelper;
+                    break;
+                case "fnf4":
+                    customActions[""] = Properties.Strings.ToggleAura;
+                    customActions.Remove("aura");
+                    break;
+                case "fnc":
+                    customActions[""] = Properties.Strings.ToggleFnLock;
+                    customActions.Remove("fnlock");
+                    break;
+                case "fne":
+                    customActions[""] = "Calculator";
+                    customActions["ghelper"] = Properties.Strings.OpenGHelper;
+                    break;
+                case "paddle":
+                    customActions[""] = EMPTY;
+                    break;
+                case "cc":
+                    customActions[""] = EMPTY;
+                    break;
             }
 
             combo.DropDownStyle = ComboBoxStyle.DropDownList;
@@ -35,7 +74,7 @@ namespace GHelper
             combo.DisplayMember = "Value";
             combo.ValueMember = "Key";
 
-            string action = Program.config.getConfigString(name);
+            string action = AppConfig.GetString(name);
 
             combo.SelectedValue = (action is not null) ? action : "";
             if (combo.SelectedValue is null) combo.SelectedValue = "";
@@ -43,13 +82,17 @@ namespace GHelper
             combo.SelectedValueChanged += delegate
             {
                 if (combo.SelectedValue is not null)
-                    Program.config.setConfig(name, combo.SelectedValue.ToString());
+                    AppConfig.Set(name, combo.SelectedValue.ToString());
+
+                if (name == "m1" || name == "m2")
+                    Program.inputDispatcher.RegisterKeys();
+
             };
 
-            txbox.Text = Program.config.getConfigString(name + "_custom");
+            txbox.Text = AppConfig.GetString(name + "_custom");
             txbox.TextChanged += delegate
             {
-                Program.config.setConfig(name + "_custom", txbox.Text);
+                AppConfig.Set(name + "_custom", txbox.Text);
             };
         }
 
@@ -57,79 +100,411 @@ namespace GHelper
         {
             InitializeComponent();
 
-            groupBindings.Text = Properties.Strings.KeyBindings;
-            groupLight.Text = Properties.Strings.KeyboardBacklight;
-            groupOther.Text = Properties.Strings.Other;
+            labelBindings.Text = Properties.Strings.KeyBindings;
+            labelBacklightTitle.Text = Properties.Strings.LaptopBacklight;
+            labelSettings.Text = Properties.Strings.Other;
 
             checkAwake.Text = Properties.Strings.Awake;
             checkSleep.Text = Properties.Strings.Sleep;
             checkBoot.Text = Properties.Strings.Boot;
             checkShutdown.Text = Properties.Strings.Shutdown;
+            checkBootSound.Text = Properties.Strings.BootSound;
 
             labelSpeed.Text = Properties.Strings.AnimationSpeed;
-            labelBrightness.Text = Properties.Strings.Brightness;
+            //labelBrightness.Text = Properties.Strings.Brightness;
+
+            labelBacklightTimeout.Text = Properties.Strings.BacklightTimeout;
+            //labelBacklightTimeoutPlugged.Text = Properties.Strings.BacklightTimeoutPlugged;
 
-            checkKeyboardAuto.Text = Properties.Strings.KeyboardAuto;
             checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
             checkTopmost.Text = Properties.Strings.WindowTop;
             checkUSBC.Text = Properties.Strings.OptimizedUSBC;
+            checkAutoToggleClamshellMode.Text = Properties.Strings.ToggleClamshellMode;
+
+            labelBacklightKeyboard.Text = Properties.Strings.Keyboard;
+            labelBacklightBar.Text = Properties.Strings.Lightbar;
+            labelBacklightLid.Text = Properties.Strings.Lid;
+            labelBacklightLogo.Text = Properties.Strings.Logo;
+
+            checkGpuApps.Text = Properties.Strings.KillGpuApps;
+            labelHibernateAfter.Text = Properties.Strings.HibernateAfter;
 
             Text = Properties.Strings.ExtraSettings;
 
+            if (AppConfig.IsDUO())
+            {
+                customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
+                customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
+            }
+
+            if (AppConfig.NoMKeys())
+            {
+                labelM1.Text = "FN+F2";
+                labelM2.Text = "FN+F3";
+                labelM3.Text = "FN+F4";
+                labelM4.Visible = comboM4.Visible = textM4.Visible = false;
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (AppConfig.NoAura())
+            {
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (!AppConfig.IsTUF())
+            {
+                labelFNE.Visible = comboFNE.Visible = textFNE.Visible = false;
+            }
+
+            if (Program.acpi.DeviceGet(AsusACPI.GPUEco) < 0)
+            {
+                checkGpuApps.Visible = false;
+                checkUSBC.Visible = false;
+            }
+
+            // Change text and hide irrelevant options on the ROG Ally,
+            // which is a bit of a special case piece of hardware.
+            if (AppConfig.IsAlly())
+            {
+                labelM1.Visible = comboM1.Visible = textM1.Visible = false;
+                labelM2.Visible = comboM2.Visible = textM2.Visible = false;
+
+                // Re-label M3 and M4 and FNF4 to match the front labels.
+                labelM3.Text = "Ctrl Center";
+                labelM4.Text = "ROG";
+                labelFNF4.Text = "Back Paddles";
+
+                // Hide all of the FN options, as the Ally has no special keyboard FN key.
+                labelFNC.Visible = false;
+                comboFNC.Visible = false;
+                textFNC.Visible = false;
+
+                SetKeyCombo(comboM3, textM3, "cc");
+                SetKeyCombo(comboM4, textM4, "m4");
+                SetKeyCombo(comboFNF4, textFNF4, "paddle");
+
+            }
+            else
+            {
+                SetKeyCombo(comboM1, textM1, "m1");
+                SetKeyCombo(comboM2, textM2, "m2");
+
+                SetKeyCombo(comboM3, textM3, "m3");
+                SetKeyCombo(comboM4, textM4, "m4");
+                SetKeyCombo(comboFNF4, textFNF4, "fnf4");
+
+                SetKeyCombo(comboFNC, textFNC, "fnc");
+                SetKeyCombo(comboFNE, textFNE, "fne");
+            }
+
+            if (AppConfig.IsStrix())
+            {
+                labelM4.Text = "M5/ROG";
+            }
+
+
             InitTheme();
-
-            SetKeyCombo(comboM3, textM3, "m3");
-            SetKeyCombo(comboM4, textM4, "m4");
-            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
-
             Shown += Keyboard_Shown;
 
             comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboKeyboardSpeed.DataSource = new BindingSource(Aura.GetSpeeds(), null);
+            comboKeyboardSpeed.DataSource = new BindingSource(AsusUSB.GetSpeeds(), null);
             comboKeyboardSpeed.DisplayMember = "Value";
             comboKeyboardSpeed.ValueMember = "Key";
-            comboKeyboardSpeed.SelectedValue = Aura.Speed;
+            comboKeyboardSpeed.SelectedValue = AsusUSB.Speed;
             comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
 
-            checkAwake.Checked = !(Program.config.getConfig("keyboard_awake") == 0);
-            checkBoot.Checked = !(Program.config.getConfig("keyboard_boot") == 0);
-            checkSleep.Checked = !(Program.config.getConfig("keyboard_sleep") == 0);
-            checkShutdown.Checked = !(Program.config.getConfig("keyboard_shutdown") == 0);
+            // Keyboard
+            checkAwake.Checked = AppConfig.IsNotFalse("keyboard_awake");
+            checkBoot.Checked = AppConfig.IsNotFalse("keyboard_boot");
+            checkSleep.Checked = AppConfig.IsNotFalse("keyboard_sleep");
+            checkShutdown.Checked = AppConfig.IsNotFalse("keyboard_shutdown");
+
+            // Lightbar
+            checkAwakeBar.Checked = AppConfig.IsNotFalse("keyboard_awake_bar");
+            checkBootBar.Checked = AppConfig.IsNotFalse("keyboard_boot_bar");
+            checkSleepBar.Checked = AppConfig.IsNotFalse("keyboard_sleep_bar");
+            checkShutdownBar.Checked = AppConfig.IsNotFalse("keyboard_shutdown_bar");
+
+            // Lid
+            checkAwakeLid.Checked = AppConfig.IsNotFalse("keyboard_awake_lid");
+            checkBootLid.Checked = AppConfig.IsNotFalse("keyboard_boot_lid");
+            checkSleepLid.Checked = AppConfig.IsNotFalse("keyboard_sleep_lid");
+            checkShutdownLid.Checked = AppConfig.IsNotFalse("keyboard_shutdown_lid");
+
+            // Logo
+            checkAwakeLogo.Checked = AppConfig.IsNotFalse("keyboard_awake_logo");
+            checkBootLogo.Checked = AppConfig.IsNotFalse("keyboard_boot_logo");
+            checkSleepLogo.Checked = AppConfig.IsNotFalse("keyboard_sleep_logo");
+            checkShutdownLogo.Checked = AppConfig.IsNotFalse("keyboard_shutdown_logo");
 
             checkAwake.CheckedChanged += CheckPower_CheckedChanged;
             checkBoot.CheckedChanged += CheckPower_CheckedChanged;
             checkSleep.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdown.CheckedChanged += CheckPower_CheckedChanged;
 
-            checkTopmost.Checked = (Program.config.getConfig("topmost") == 1);
+            checkAwakeBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownBar.CheckedChanged += CheckPower_CheckedChanged;
+
+            checkAwakeLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownLid.CheckedChanged += CheckPower_CheckedChanged;
+
+            checkAwakeLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkBootLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkSleepLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkShutdownLogo.CheckedChanged += CheckPower_CheckedChanged;
+
+            if (!AppConfig.IsStrix())
+            {
+                labelBacklightBar.Visible = false;
+                checkAwakeBar.Visible = false;
+                checkBootBar.Visible = false;
+                checkSleepBar.Visible = false;
+                checkShutdownBar.Visible = false;
+
+                if (!AppConfig.IsZ13())
+                {
+                    labelBacklightLid.Visible = false;
+                    checkAwakeLid.Visible = false;
+                    checkBootLid.Visible = false;
+                    checkSleepLid.Visible = false;
+                    checkShutdownLid.Visible = false;
+
+                    labelBacklightLogo.Visible = false;
+                    checkAwakeLogo.Visible = false;
+                    checkBootLogo.Visible = false;
+                    checkSleepLogo.Visible = false;
+                    checkShutdownLogo.Visible = false;
+
+                    labelBacklightKeyboard.Visible = false;
+                }
+            }
+
+            //checkAutoToggleClamshellMode.Visible = clamshellControl.IsExternalDisplayConnected();
+            checkAutoToggleClamshellMode.Checked = AppConfig.Is("toggle_clamshell_mode");
+            checkAutoToggleClamshellMode.CheckedChanged += checkAutoToggleClamshellMode_CheckedChanged;
+
+            checkTopmost.Checked = AppConfig.Is("topmost");
             checkTopmost.CheckedChanged += CheckTopmost_CheckedChanged; ;
 
-            checkKeyboardAuto.Checked = (Program.config.getConfig("keyboard_auto") == 1);
-            checkKeyboardAuto.CheckedChanged += CheckKeyboardAuto_CheckedChanged;
-
-            checkNoOverdrive.Checked = (Program.config.getConfig("no_overdrive") == 1);
+            checkNoOverdrive.Checked = AppConfig.Is("no_overdrive");
             checkNoOverdrive.CheckedChanged += CheckNoOverdrive_CheckedChanged;
 
-            checkUSBC.Checked = (Program.config.getConfig("optimized_usbc") == 1);
+            checkUSBC.Checked = AppConfig.Is("optimized_usbc");
             checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
 
-            int kb_brightness = Program.config.getConfig("keyboard_brightness");
-            trackBrightness.Value = (kb_brightness >= 0 && kb_brightness <= 3) ? kb_brightness : 3;
+            sliderBrightness.Value = InputDispatcher.GetBacklight();
+            sliderBrightness.ValueChanged += SliderBrightness_ValueChanged;
+
+            panelXMG.Visible = (Program.acpi.DeviceGet(AsusACPI.GPUXGConnected) == 1);
+            checkXMG.Checked = !(AppConfig.Get("xmg_light") == 0);
+            checkXMG.CheckedChanged += CheckXMG_CheckedChanged;
+
+            numericBacklightTime.Value = AppConfig.Get("keyboard_timeout", 60);
+            numericBacklightPluggedTime.Value = AppConfig.Get("keyboard_ac_timeout", 0);
+
+            numericBacklightTime.ValueChanged += NumericBacklightTime_ValueChanged;
+            numericBacklightPluggedTime.ValueChanged += NumericBacklightTime_ValueChanged;
+
+            checkGpuApps.Checked = AppConfig.Is("kill_gpu_apps");
+            checkGpuApps.CheckedChanged += CheckGpuApps_CheckedChanged;
+
+            checkBootSound.Checked = (Program.acpi.DeviceGet(AsusACPI.BootSound) == 1);
+            checkBootSound.CheckedChanged += CheckBootSound_CheckedChanged;
 
             pictureHelp.Click += PictureHelp_Click;
-            trackBrightness.Scroll += TrackBrightness_Scroll;
+            buttonServices.Click += ButtonServices_Click;
 
+            pictureLog.Click += PictureLog_Click;
+
+            checkGPUFix.Visible = AppConfig.IsGPUFixNeeded();
+            checkGPUFix.Checked = AppConfig.IsGPUFix();
+            checkGPUFix.CheckedChanged += CheckGPUFix_CheckedChanged;
+
+            toolTip.SetToolTip(checkAutoToggleClamshellMode, "Disable sleep on lid close when plugged in and external monitor is connected");
+
+            InitVariBright();
+            InitServices();
+            InitHibernate();
+        }
+
+        private void CheckBootSound_CheckedChanged(object? sender, EventArgs e)
+        {
+            Program.acpi.DeviceSet(AsusACPI.BootSound, (checkBootSound.Checked ? 1 : 0), "BootSound");
+        }
+
+        private void CheckGPUFix_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("gpu_fix", (checkGPUFix.Checked ? 1 : 0));
+        }
+
+        private void InitHibernate()
+        {
+            try
+            {
+                int hibernate = PowerNative.GetHibernateAfter();
+                if (hibernate < 0 || hibernate > numericHibernateAfter.Maximum) hibernate = 0;
+                numericHibernateAfter.Value = hibernate;
+                numericHibernateAfter.ValueChanged += NumericHibernateAfter_ValueChanged;
+
+            }
+            catch (Exception ex)
+            {
+                panelPower.Visible = false;
+                Logger.WriteLine(ex.ToString());
+            }
+
+        }
+
+        private void NumericHibernateAfter_ValueChanged(object? sender, EventArgs e)
+        {
+            PowerNative.SetHibernateAfter((int)numericHibernateAfter.Value);
+        }
+
+        private void PictureLog_Click(object? sender, EventArgs e)
+        {
+            new Process
+            {
+                StartInfo = new ProcessStartInfo(Logger.logFile)
+                {
+                    UseShellExecute = true
+                }
+            }.Start();
+        }
+
+        private void SliderBrightness_ValueChanged(object? sender, EventArgs e)
+        {
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            if (onBattery)
+                AppConfig.Set("keyboard_brightness_ac", sliderBrightness.Value);
+            else
+                AppConfig.Set("keyboard_brightness", sliderBrightness.Value);
+
+            AsusUSB.ApplyBrightness(sliderBrightness.Value, "Slider");
+        }
+
+        private void InitServices()
+        {
+
+            int servicesCount = OptimizationService.GetRunningCount();
+
+            if (servicesCount > 0)
+            {
+                buttonServices.Text = Properties.Strings.Stop;
+                labelServices.ForeColor = colorTurbo;
+            }
+            else
+            {
+                buttonServices.Text = Properties.Strings.Start;
+                labelServices.ForeColor = colorStandard;
+            }
+
+            labelServices.Text = Properties.Strings.AsusServicesRunning + ":  " + servicesCount;
+            buttonServices.Enabled = true;
+
+        }
+
+        public void ServiesToggle()
+        {
+            buttonServices.Enabled = false;
+
+            if (OptimizationService.GetRunningCount() > 0)
+            {
+                labelServices.Text = Properties.Strings.StoppingServices + " ...";
+                Task.Run(() =>
+                {
+                    OptimizationService.StopAsusServices();
+                    BeginInvoke(delegate
+                    {
+                        InitServices();
+                    });
+                    Program.inputDispatcher.Init();
+                });
+            }
+            else
+            {
+                labelServices.Text = Properties.Strings.StartingServices + " ...";
+                Task.Run(() =>
+                {
+                    OptimizationService.StartAsusServices();
+                    BeginInvoke(delegate
+                    {
+                        InitServices();
+                    });
+                });
+            }
+        }
+
+        private void ButtonServices_Click(object? sender, EventArgs e)
+        {
+            if (ProcessHelper.IsUserAdministrator())
+                ServiesToggle();
+            else
+                ProcessHelper.RunAsAdmin("services");
+        }
+
+        private void InitVariBright()
+        {
+            try
+            {
+
+                using (var amdControl = new AmdGpuControl())
+                {
+                    int variBrightSupported = 0, VariBrightEnabled;
+                    if (amdControl.GetVariBright(out variBrightSupported, out VariBrightEnabled))
+                    {
+                        Logger.WriteLine("Varibright: " + variBrightSupported + "," + VariBrightEnabled);
+                        checkVariBright.Checked = (VariBrightEnabled == 3);
+                    }
+
+                    checkVariBright.Visible = (variBrightSupported > 0);
+                    checkVariBright.CheckedChanged += CheckVariBright_CheckedChanged;
+                }
+
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.ToString());
+                checkVariBright.Visible = false;
+            }
+
+
+        }
+
+        private void CheckVariBright_CheckedChanged(object? sender, EventArgs e)
+        {
+            using (var amdControl = new AmdGpuControl())
+            {
+                amdControl.SetVariBright(checkVariBright.Checked ? 1 : 0);
+                ProcessHelper.KillByName("RadeonSoftware");
+            }
+        }
+
+        private void CheckGpuApps_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("kill_gpu_apps", (checkGpuApps.Checked ? 1 : 0));
+        }
+
+        private void NumericBacklightTime_ValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("keyboard_timeout", (int)numericBacklightTime.Value);
+            AppConfig.Set("keyboard_ac_timeout", (int)numericBacklightPluggedTime.Value);
+            Program.inputDispatcher.InitBacklightTimer();
+        }
+
+        private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("xmg_light", (checkXMG.Checked ? 1 : 0));
+            AsusUSB.ApplyXGMLight(checkXMG.Checked);
         }
 
         private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
         {
-            Program.config.setConfig("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
-        }
-
-        private void TrackBrightness_Scroll(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("keyboard_brightness", trackBrightness.Value);
-            Aura.ApplyBrightness(trackBrightness.Value);
+            AppConfig.Set("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
         }
 
         private void PictureHelp_Click(object? sender, EventArgs e)
@@ -139,42 +514,78 @@ namespace GHelper
 
         private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
         {
-            Program.config.setConfig("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
-            Program.settingsForm.AutoScreen(true);
+            AppConfig.Set("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
+            screenControl.AutoScreen(true);
         }
 
-        private void CheckKeyboardAuto_CheckedChanged(object? sender, EventArgs e)
-        {
-            Program.config.setConfig("keyboard_auto", (checkKeyboardAuto.Checked ? 1 : 0));
-        }
 
         private void CheckTopmost_CheckedChanged(object? sender, EventArgs e)
         {
-            Program.config.setConfig("topmost", (checkTopmost.Checked ? 1 : 0));
+            AppConfig.Set("topmost", (checkTopmost.Checked ? 1 : 0));
             Program.settingsForm.TopMost = checkTopmost.Checked;
         }
 
         private void CheckPower_CheckedChanged(object? sender, EventArgs e)
         {
-            Program.config.setConfig("keyboard_awake", (checkAwake.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_boot", (checkBoot.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_sleep", (checkSleep.Checked ? 1 : 0));
-            Program.config.setConfig("keyboard_shutdown", (checkShutdown.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_awake", (checkAwake.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot", (checkBoot.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep", (checkSleep.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown", (checkShutdown.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_bar", (checkAwakeBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_bar", (checkBootBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_bar", (checkSleepBar.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_bar", (checkShutdownBar.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_lid", (checkAwakeLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_lid", (checkBootLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_lid", (checkSleepLid.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_lid", (checkShutdownLid.Checked ? 1 : 0));
+
+            AppConfig.Set("keyboard_awake_logo", (checkAwakeLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_boot_logo", (checkBootLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
+            AppConfig.Set("keyboard_shutdown_logo", (checkShutdownLogo.Checked ? 1 : 0));
+
+            AsusUSB.ApplyAuraPower();
 
-            Aura.ApplyAuraPower(checkAwake.Checked, checkBoot.Checked, checkSleep.Checked, checkShutdown.Checked);
         }
 
         private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
         {
-            Program.config.setConfig("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
-            Program.settingsForm.SetAura();
+            AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
+            AsusUSB.ApplyAura();
         }
 
 
         private void Keyboard_Shown(object? sender, EventArgs e)
         {
-            Top = Program.settingsForm.Top;
+            if (Height > Program.settingsForm.Height)
+            {
+                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+            }
+            else
+            {
+                Top = Program.settingsForm.Top;
+            }
+
             Left = Program.settingsForm.Left - Width - 5;
         }
+
+
+        private void checkAutoToggleClamshellMode_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("toggle_clamshell_mode", checkAutoToggleClamshellMode.Checked ? 1 : 0);
+
+            if (checkAutoToggleClamshellMode.Checked)
+            {
+                clamshellControl.ToggleLidAction();
+            }
+            else
+            {
+                ClamshellModeControl.DisableClamshellMode();
+            }
+
+        }
     }
 }

app/Extra.resx

@@ -1,4 +1,64 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <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">
@@ -57,4 +117,7 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
 </root>

app/Fan/FanSensorControl.cs

@@ -0,0 +1,185 @@
+using GHelper.Mode;
+
+namespace GHelper.Fan
+{
+    public class FanSensorControl
+    {
+        public const int DEFAULT_FAN_MIN = 18;
+        public const int DEFAULT_FAN_MAX = 58;
+
+        public const int XGM_FAN_MAX = 72;
+
+        public const int INADEQUATE_MAX = 90;
+
+        const int FAN_COUNT = 3;
+
+        Fans fansForm;
+        ModeControl modeControl = Program.modeControl;
+
+        static int[] measuredMax;
+        static int sameCount = 0;
+
+        static System.Timers.Timer timer = default!;
+
+        static int[] _fanMax = InitFanMax();
+        static bool _fanRpm = AppConfig.IsNotFalse("fan_rpm");
+
+        public FanSensorControl(Fans fansForm)
+        {
+            this.fansForm = fansForm;
+            timer = new System.Timers.Timer(1000);
+            timer.Elapsed += Timer_Elapsed;
+        }
+
+        static int[] InitFanMax()
+        {
+            int[] defaultMax = GetDefaultMax();
+
+            return new int[3] {
+                AppConfig.Get("fan_max_" + (int)AsusFan.CPU, defaultMax[(int)AsusFan.CPU]),
+                AppConfig.Get("fan_max_" + (int)AsusFan.GPU, defaultMax[(int)AsusFan.GPU]),
+                AppConfig.Get("fan_max_" + (int)AsusFan.Mid, defaultMax[(int)AsusFan.Mid])
+            };
+        }
+
+
+        static int[] GetDefaultMax()
+        {
+            if (AppConfig.ContainsModel("GA401I")) return new int[3] { 78, 76, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("GA401")) return new int[3] { 71, 73, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("GA402")) return new int[3] { 55, 56, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("G513R")) return new int[3] { 58, 60, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("G513Q")) return new int[3] { 69, 69, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("GA503")) return new int[3] { 64, 64, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("GU603")) return new int[3] { 62, 64, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("FA507R")) return new int[3] { 63, 57, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("FA507X")) return new int[3] { 63, 68, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("GX650")) return new int[3] { 62, 62, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("G732")) return new int[3] { 61, 60, DEFAULT_FAN_MAX };
+            if (AppConfig.ContainsModel("G713")) return new int[3] { 56, 60, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("Z301")) return new int[3] { 72, 64, DEFAULT_FAN_MAX };
+
+            if (AppConfig.ContainsModel("GV601")) return new int[3] { 78, 59, 85 };
+
+            return new int[3] { DEFAULT_FAN_MAX, DEFAULT_FAN_MAX, DEFAULT_FAN_MAX };
+        }
+
+        public static int GetFanMax(AsusFan device)
+        {
+            if (device == AsusFan.XGM) return XGM_FAN_MAX;
+
+            if (_fanMax[(int)device] < 0 || _fanMax[(int)device] > INADEQUATE_MAX)
+                SetFanMax(device, DEFAULT_FAN_MAX);
+
+            return _fanMax[(int)device];
+        }
+
+        public static void SetFanMax(AsusFan device, int value)
+        {
+            _fanMax[(int)device] = value;
+            AppConfig.Set("fan_max_" + (int)device, value);
+        }
+
+        public static bool fanRpm
+        {
+            get
+            {
+                return _fanRpm;
+            }
+            set
+            {
+                AppConfig.Set("fan_rpm", value ? 1 : 0);
+                _fanRpm = value;
+            }
+        }
+
+        public static string FormatFan(AsusFan device, int value)
+        {
+            if (value < 0) return null;
+
+            if (value > GetFanMax(device) && value <= INADEQUATE_MAX) SetFanMax(device, value);
+
+            if (fanRpm)
+                return Properties.Strings.FanSpeed + ": " + (value * 100).ToString() + "RPM";
+            else
+                return Properties.Strings.FanSpeed + ": " + Math.Min(Math.Round((float)value / GetFanMax(device) * 100), 100).ToString() + "%"; // relatively to max RPM
+        }
+
+        public void StartCalibration()
+        {
+
+            measuredMax = new int[] { 0, 0, 0 };
+            timer.Enabled = true;
+
+            for (int i = 0; i < FAN_COUNT; i++)
+                AppConfig.Remove("fan_max_" + i);
+
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, AsusACPI.PerformanceTurbo, "ModeCalibration");
+
+            for (int i = 0; i < FAN_COUNT; i++)
+                Program.acpi.SetFanCurve((AsusFan)i, new byte[] { 20, 30, 40, 50, 60, 70, 80, 90, 100, 100, 100, 100, 100, 100, 100, 100 });
+
+        }
+
+        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            int fan;
+            bool same = true;
+
+            for (int i = 0; i < FAN_COUNT; i++)
+            {
+                fan = Program.acpi.GetFan((AsusFan)i);
+                if (fan > measuredMax[i])
+                {
+                    measuredMax[i] = fan;
+                    same = false;
+                }
+            }
+
+            if (same) sameCount++;
+            else sameCount = 0;
+
+            string label = "Measuring Max Speed - CPU: " + measuredMax[(int)AsusFan.CPU] * 100 + ", GPU: " + measuredMax[(int)AsusFan.GPU] * 100;
+            if (measuredMax[(int)AsusFan.Mid] > 10) label = label + ", Mid: " + measuredMax[(int)AsusFan.Mid] * 100;
+            label = label + " (" + sameCount + "s)";
+
+            fansForm.LabelFansResult(label);
+
+            if (sameCount >= 15)
+            {
+                for (int i = 0; i < FAN_COUNT; i++)
+                {
+                    if (measuredMax[i] > 30 && measuredMax[i] < INADEQUATE_MAX) SetFanMax((AsusFan)i, measuredMax[i]);
+                }
+
+                sameCount = 0;
+                FinishCalibration();
+            }
+
+        }
+
+        private void FinishCalibration()
+        {
+
+            timer.Enabled = false;
+            modeControl.SetPerformanceMode();
+
+            string label = "Measured - CPU: " + AppConfig.Get("fan_max_" + (int)AsusFan.CPU) * 100;
+
+            if (AppConfig.Get("fan_max_" + (int)AsusFan.GPU) > 0)
+                label = label + ", GPU: " + AppConfig.Get("fan_max_" + (int)AsusFan.GPU) * 100;
+
+            if (AppConfig.Get("fan_max_" + (int)AsusFan.Mid) > 0)
+                label = label + ", Mid: " + AppConfig.Get("fan_max_" + (int)AsusFan.Mid) * 100;
+
+            fansForm.LabelFansResult(label);
+            fansForm.InitAxis();
+        }
+    }
+}

app/Fans.resx

@@ -1,4 +1,64 @@
-<root>
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
   <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">
@@ -57,4 +117,7 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="labelRisky.Text" xml:space="preserve">
+    <value>Undervolting is experimental and risky feature. If applied values are too low for your hardware, it can become unstable or shut down. Try small negative values first, click Apply and test what works for you.</value>
+  </data>
 </root>

app/GHelper.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows8.0</TargetFramework>
+    <TargetFramework>net7.0-windows</TargetFramework>
     <Nullable>enable</Nullable>
     <UseWindowsForms>True</UseWindowsForms>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -11,12 +11,11 @@
     <StartupObject>GHelper.Program</StartupObject>
     <ApplicationIcon>favicon.ico</ApplicationIcon>
     <Platforms>AnyCPU;x64</Platforms>
-    <SupportedOSPlatformVersion>8.0</SupportedOSPlatformVersion>
     <AssemblyName>GHelper</AssemblyName>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.58</AssemblyVersion>
+    <AssemblyVersion>0.123</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -59,8 +58,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="FftSharp" Version="2.0.0" />
     <PackageReference Include="hidlibrary" Version="3.3.40" />
     <PackageReference Include="HidSharpCore" Version="1.2.1.1" />
+    <PackageReference Include="NAudio" Version="2.1.0" />
+    <PackageReference Include="NvAPIWrapper.Net" Version="0.8.1.101" />
     <PackageReference Include="System.Management" Version="7.0.1" />
     <PackageReference Include="TaskScheduler" Version="2.10.1" />
     <PackageReference Include="WinForms.DataVisualization" Version="1.8.0" />
@@ -131,6 +133,12 @@
       <Generator>SettingsSingleFileGenerator</Generator>
       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
     </None>
+    <None Update="WinRing0x64.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="WinRing0x64.sys">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
 </Project>

app/Gpu/AMD/AmdAdl2.cs

@@ -1,18 +1,47 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
 
-namespace AmdAdl2;
+namespace GHelper.Gpu.AMD;
 
 #region Export Struct
 
+[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+public struct ADLSGApplicationInfo
+{
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strFileName;
+
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strFilePath;
+
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+    public string strVersion;
+
+    public long timeStamp;
+    public uint iProfileExists;
+    public uint iGPUAffinity;
+    public ADLBdf GPUBdf;
+}
+
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLSingleSensorData {
+public struct ADLBdf
+{
+    public int iBus;
+    public int iDevice;
+    public int iFunction;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ADLSingleSensorData
+{
     public int Supported;
     public int Value;
 }
 
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLPMLogDataOutput {
+public struct ADLPMLogDataOutput
+{
     int Size;
 
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_PMLOG_MAX_SENSORS)]
@@ -30,7 +59,8 @@ public struct ADLGcnInfo
 }
 
 [Flags]
-public enum ADLAsicFamilyType {
+public enum ADLAsicFamilyType
+{
     Undefined = 0,
     Discrete = 1 << 0,
     Integrated = 1 << 1,
@@ -42,7 +72,8 @@ public enum ADLAsicFamilyType {
     Embedded = 1 << 7,
 }
 
-public enum ADLSensorType {
+public enum ADLSensorType
+{
     SENSOR_MAXTYPES = 0,
     PMLOG_CLK_GFXCLK = 1, // Current graphic clock value in MHz
     PMLOG_CLK_MEMCLK = 2, // Current memory clock value in MHz
@@ -122,13 +153,15 @@ public enum ADLSensorType {
 
 //Throttle Status
 [Flags]
-public enum ADL_THROTTLE_NOTIFICATION {
+public enum ADL_THROTTLE_NOTIFICATION
+{
     ADL_PMLOG_THROTTLE_POWER = 1 << 0,
     ADL_PMLOG_THROTTLE_THERMAL = 1 << 1,
     ADL_PMLOG_THROTTLE_CURRENT = 1 << 2,
 };
 
-public enum ADL_PMLOG_SENSORS {
+public enum ADL_PMLOG_SENSORS
+{
     ADL_SENSOR_MAXTYPES = 0,
     ADL_PMLOG_CLK_GFXCLK = 1,
     ADL_PMLOG_CLK_MEMCLK = 2,
@@ -210,7 +243,8 @@ public enum ADL_PMLOG_SENSORS {
 
 /// <summary> ADLAdapterInfo Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLAdapterInfo {
+public struct ADLAdapterInfo
+{
     /// <summary>The size of the structure</summary>
     int Size;
 
@@ -265,7 +299,8 @@ public struct ADLAdapterInfo {
 
 /// <summary> ADLAdapterInfo Array</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLAdapterInfoArray {
+public struct ADLAdapterInfoArray
+{
     /// <summary> ADLAdapterInfo Array </summary>
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_MAX_ADAPTERS)]
     public ADLAdapterInfo[] ADLAdapterInfo;
@@ -277,7 +312,8 @@ public struct ADLAdapterInfoArray {
 
 /// <summary> ADLDisplayID Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLDisplayID {
+public struct ADLDisplayID
+{
     /// <summary> Display Logical Index </summary>
     public int DisplayLogicalIndex;
 
@@ -293,7 +329,8 @@ public struct ADLDisplayID {
 
 /// <summary> ADLDisplayInfo Structure</summary>
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLDisplayInfo {
+public struct ADLDisplayInfo
+{
     /// <summary> Display Index </summary>
     public ADLDisplayID DisplayID;
 
@@ -328,7 +365,8 @@ public struct ADLDisplayInfo {
 
 #endregion Export Struct
 
-public class Adl2 {
+public class Adl2
+{
     public const string Atiadlxx_FileName = "atiadlxx.dll";
 
     #region Internal Constant
@@ -371,24 +409,30 @@ public class Adl2 {
     // ///// <summary> ADL Create Function to create ADL Data</summary>
     /// <param name="enumConnectedAdapters">If it is 1, then ADL will only return the physical exist adapters </param>
     ///// <returns> retrun ADL Error Code</returns>
-    public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out IntPtr adlContextHandle) {
+    public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out nint adlContextHandle)
+    {
         return NativeMethods.ADL2_Main_Control_Create(ADL_Main_Memory_Alloc_Impl_Reference, enumConnectedAdapters, out adlContextHandle);
     }
 
-    public static void FreeMemory(IntPtr buffer) {
+    public static void FreeMemory(nint buffer)
+    {
         Memory_Free_Impl(buffer);
     }
 
     private static bool? isDllLoaded;
 
-    public static bool Load() {
+    public static bool Load()
+    {
         if (isDllLoaded != null)
             return isDllLoaded.Value;
 
-        try {
+        try
+        {
             Marshal.PrelinkAll(typeof(Adl2));
             isDllLoaded = true;
-        } catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException) {
+        }
+        catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException)
+        {
             Debug.WriteLine(e);
             isDllLoaded = false;
         }
@@ -396,53 +440,57 @@ public class Adl2 {
         return isDllLoaded.Value;
     }
 
-    private static NativeMethods.ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
+    private static ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
 
     /// <summary> Build in memory allocation function</summary>
     /// <param name="size">input size</param>
     /// <returns>return the memory buffer</returns>
-    private static IntPtr Memory_Alloc_Impl(int size) {
+    private static nint Memory_Alloc_Impl(int size)
+    {
         return Marshal.AllocCoTaskMem(size);
     }
 
     /// <summary> Build in memory free function</summary>
     /// <param name="buffer">input buffer</param>
-    private static void Memory_Free_Impl(IntPtr buffer) {
-        if (IntPtr.Zero != buffer) {
+    private static void Memory_Free_Impl(nint buffer)
+    {
+        if (nint.Zero != buffer)
+        {
             Marshal.FreeCoTaskMem(buffer);
         }
     }
 
-    public static class NativeMethods {
+    public static class NativeMethods
+    {
         /// <summary> ADL Memory allocation function allows ADL to callback for memory allocation</summary>
         /// <param name="size">input size</param>
         /// <returns> retrun ADL Error Code</returns>
-        public delegate IntPtr ADL_Main_Memory_Alloc(int size);
+        public delegate nint ADL_Main_Memory_Alloc(int size);
 
         // ///// <summary> ADL Create Function to create ADL Data</summary>
         /// <param name="callback">Call back functin pointer which is ised to allocate memeory </param>
         /// <param name="enumConnectedAdapters">If it is 1, then ADL will only retuen the physical exist adapters </param>
         ///// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out IntPtr adlContextHandle);
+        public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out nint adlContextHandle);
 
         /// <summary> ADL Destroy Function to free up ADL Data</summary>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Main_Control_Destroy(IntPtr adlContextHandle);
+        public static extern int ADL2_Main_Control_Destroy(nint adlContextHandle);
 
         /// <summary> ADL Function to get the number of adapters</summary>
         /// <param name="numAdapters">return number of adapters</param>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_NumberOfAdapters_Get(IntPtr adlContextHandle, out int numAdapters);
+        public static extern int ADL2_Adapter_NumberOfAdapters_Get(nint adlContextHandle, out int numAdapters);
 
         /// <summary> ADL Function to get the GPU adapter information</summary>
         /// <param name="info">return GPU adapter information</param>
         /// <param name="inputSize">the size of the GPU adapter struct</param>
         /// <returns> retrun ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_AdapterInfo_Get(IntPtr adlContextHandle, IntPtr info, int inputSize);
+        public static extern int ADL2_Adapter_AdapterInfo_Get(nint adlContextHandle, nint info, int inputSize);
 
         /// <summary> Function to determine if the adapter is active or not.</summary>
         /// <remarks>The function is used to check if the adapter associated with iAdapterIndex is active</remarks>  
@@ -450,7 +498,7 @@ public class Adl2 {
         /// <param name="status"> Status of the adapter. True: Active; False: Dsiabled</param>
         /// <returns>Non zero is successfull</returns> 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_Active_Get(IntPtr adlContextHandle, int adapterIndex, out int status);
+        public static extern int ADL2_Adapter_Active_Get(nint adlContextHandle, int adapterIndex, out int status);
 
         /// <summary>Get display information based on adapter index</summary>
         /// <param name="adapterIndex">Adapter Index</param>
@@ -460,16 +508,16 @@ public class Adl2 {
         /// <returns>return ADL Error Code</returns>
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Display_DisplayInfo_Get(
-            IntPtr adlContextHandle,
+            nint adlContextHandle,
             int adapterIndex,
             out int numDisplays,
-            out IntPtr displayInfoArray,
+            out nint displayInfoArray,
             int forceDetect
         );
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Overdrive_Caps(
-            IntPtr adlContextHandle,
+            nint adlContextHandle,
             int adapterIndex,
             out int supported,
             out int enabled,
@@ -477,9 +525,75 @@ public class Adl2 {
         );
 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_New_QueryPMLogData_Get(IntPtr adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
+        public static extern int ADL2_New_QueryPMLogData_Get(nint adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
 
         [DllImport(Atiadlxx_FileName)]
-        public static extern int ADL2_Adapter_ASICFamilyType_Get(IntPtr adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
+        public static extern int ADL2_Adapter_ASICFamilyType_Get(nint adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_SwitchableGraphics_Applications_Get(
+            nint context,
+            int iListType,
+            out int lpNumApps,
+            out nint lppAppList);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_VariBright_Caps(
+            nint context,
+            int iAdapterIndex,
+            out int iSupported,
+            out int iEnabled,
+            out int iVersion);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_VariBrightEnable_Set(
+            nint context,
+            int iAdapterIndex,
+            int iEnabled);
+
+        // Clocks
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLODNPerformanceLevel
+        {
+            public int iClock;
+            public int iVddc;
+            public int iEnabled;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLODNPerformanceLevels
+        {
+            public int iSize;
+            public int iMode;
+            public int iNumberOfPerformanceLevels;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
+            public ADLODNPerformanceLevel[] aLevels;
+        }
+
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_SystemClocks_Get(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_SystemClocks_Set(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_MemoryClocks_Get(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_OverdriveN_MemoryClocks_Set(
+            nint context,
+            int adapterIndex,
+            ref ADLODNPerformanceLevels performanceLevels);
     }
 }

app/Gpu/AMD/AmdGpuControl.cs

@@ -0,0 +1,234 @@
+using GHelper.Helpers;
+using System.Runtime.InteropServices;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
+
+namespace GHelper.Gpu.AMD;
+
+// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
+public class AmdGpuControl : IGpuControl
+{
+    private bool _isReady;
+    private nint _adlContextHandle;
+    private readonly ADLAdapterInfo _internalDiscreteAdapter;
+
+    public bool IsNvidia => false;
+
+    public string FullName => _internalDiscreteAdapter!.AdapterName;
+
+    private ADLAdapterInfo? FindByType(ADLAsicFamilyType type = ADLAsicFamilyType.Discrete)
+    {
+        ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
+        if (numberOfAdapters <= 0)
+            return null;
+
+        ADLAdapterInfoArray osAdapterInfoData = new();
+        int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
+        nint AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
+        Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
+        if (ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
+            return null;
+
+        osAdapterInfoData = (ADLAdapterInfoArray)Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
+
+        const int amdVendorId = 1002;
+
+        // Determine which GPU is internal discrete AMD GPU
+        ADLAdapterInfo internalDiscreteAdapter =
+            osAdapterInfoData.ADLAdapterInfo
+                .FirstOrDefault(adapter =>
+                {
+                    if (adapter.Exist == 0 || adapter.Present == 0)
+                        return false;
+
+                    if (adapter.VendorID != amdVendorId)
+                        return false;
+
+                    if (ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
+                        return false;
+
+                    asicFamilyType = (ADLAsicFamilyType)((int)asicFamilyType & asicFamilyTypeValids);
+
+                    return (asicFamilyType & type) != 0;
+                });
+
+        if (internalDiscreteAdapter.Exist == 0)
+            return null;
+
+        return internalDiscreteAdapter;
+
+    }
+
+    public AmdGpuControl()
+    {
+        if (!Adl2.Load())
+            return;
+
+        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
+            return;
+
+        ADLAdapterInfo? internalDiscreteAdapter = FindByType(ADLAsicFamilyType.Discrete);
+
+        if (internalDiscreteAdapter is not null)
+        {
+            _internalDiscreteAdapter = (ADLAdapterInfo)internalDiscreteAdapter;
+            _isReady = true;
+        }
+
+    }
+
+    public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
+
+    public int? GetCurrentTemperature()
+    {
+        if (!IsValid)
+            return null;
+
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
+            return null;
+
+        ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_TEMPERATURE_EDGE];
+        if (temperatureSensor.Supported == 0)
+            return null;
+
+        return temperatureSensor.Value;
+    }
+
+
+    public int? GetGpuUse()
+    {
+        if (!IsValid) return null;
+
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
+            return null;
+
+        ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_INFO_ACTIVITY_GFX];
+        if (gpuUsage.Supported == 0)
+            return null;
+
+        return gpuUsage.Value;
+
+    }
+
+
+    public bool SetVariBright(int enabled)
+    {
+        if (_adlContextHandle == nint.Zero) return false;
+
+        ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
+        if (iGPU is null) return false;
+
+        return ADL2_Adapter_VariBrightEnable_Set(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, enabled) == Adl2.ADL_SUCCESS;
+
+    }
+
+    public bool GetVariBright(out int supported, out int enabled)
+    {
+        supported = enabled = -1;
+
+        if (_adlContextHandle == nint.Zero) return false;
+
+        ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
+        if (iGPU is null) return false;
+
+        if (ADL2_Adapter_VariBright_Caps(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, out int supportedOut, out int enabledOut, out int version) != Adl2.ADL_SUCCESS)
+            return false;
+
+        supported = supportedOut;
+        enabled = enabledOut;
+
+        return true;
+    }
+
+    public ADLODNPerformanceLevels? GetGPUClocks()
+    {
+        if (!IsValid) return null;
+
+        ADLODNPerformanceLevels performanceLevels = new();
+        ADL2_OverdriveN_SystemClocks_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, ref performanceLevels);
+
+        return performanceLevels;
+    }
+
+    public void KillGPUApps()
+    {
+
+        if (!IsValid) return;
+
+        nint appInfoPtr = nint.Zero;
+        int appCount = 0;
+
+        try
+        {
+            // Get switchable graphics applications information
+            var result = ADL2_SwitchableGraphics_Applications_Get(_adlContextHandle, 2, out appCount, out appInfoPtr);
+            if (result != 0)
+            {
+                throw new Exception("Failed to get switchable graphics applications. Error code: " + result);
+            }
+
+            // Convert the application data pointers to an array of structs
+            var appInfoArray = new ADLSGApplicationInfo[appCount];
+            nint currentPtr = appInfoPtr;
+
+            for (int i = 0; i < appCount; i++)
+            {
+                appInfoArray[i] = Marshal.PtrToStructure<ADLSGApplicationInfo>(currentPtr);
+                currentPtr = nint.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
+            }
+
+            var appNames = new List<string>();
+
+            for (int i = 0; i < appCount; i++)
+            {
+                if (appInfoArray[i].iGPUAffinity == 1)
+                {
+                    Logger.WriteLine(appInfoArray[i].strFileName + ":" + appInfoArray[i].iGPUAffinity + "(" + appInfoArray[i].timeStamp + ")");
+                    appNames.Add(Path.GetFileNameWithoutExtension(appInfoArray[i].strFileName));
+                }
+            }
+
+            List<string> immune = new() { "svchost", "system", "ntoskrnl", "csrss", "winlogon", "wininit", "smss" };
+
+            foreach (string kill in appNames)
+                if (!immune.Contains(kill.ToLower()))
+                    ProcessHelper.KillByName(kill);
+
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.Message);
+        }
+        finally
+        {
+            // Clean up resources
+            if (appInfoPtr != nint.Zero)
+            {
+                Marshal.FreeCoTaskMem(appInfoPtr);
+            }
+
+        }
+    }
+
+
+    private void ReleaseUnmanagedResources()
+    {
+        if (_adlContextHandle != nint.Zero)
+        {
+            ADL2_Main_Control_Destroy(_adlContextHandle);
+            _adlContextHandle = nint.Zero;
+            _isReady = false;
+        }
+    }
+
+    public void Dispose()
+    {
+        ReleaseUnmanagedResources();
+        GC.SuppressFinalize(this);
+    }
+
+    ~AmdGpuControl()
+    {
+        ReleaseUnmanagedResources();
+    }
+}

app/Gpu/AmdGpuControl.cs

@@ -1,113 +0,0 @@
-using System.Runtime.InteropServices;
-using AmdAdl2;
-
-namespace GHelper.Gpu;
-
-// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
-public class AmdGpuControl : IGpuControl {
-    private bool _isReady;
-    private IntPtr _adlContextHandle;
-    private readonly ADLAdapterInfo _internalDiscreteAdapter;
-
-    public bool IsNvidia => false;
-
-
-    public AmdGpuControl() {
-        if (!Adl2.Load())
-            return;
-
-        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
-            return;
-
-        Adl2.NativeMethods.ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
-        if (numberOfAdapters <= 0)
-            return;
-
-        ADLAdapterInfoArray osAdapterInfoData = new();
-        int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
-        IntPtr AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
-        Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
-        if (Adl2.NativeMethods.ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
-            return;
-
-        osAdapterInfoData = (ADLAdapterInfoArray) Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
-
-        const int amdVendorId = 1002;
-        
-        // Determine which GPU is internal discrete AMD GPU
-        ADLAdapterInfo internalDiscreteAdapter = 
-            osAdapterInfoData.ADLAdapterInfo
-                .FirstOrDefault(adapter => {
-                    if (adapter.Exist == 0 || adapter.Present == 0)
-                        return false;
-                    
-                    if (adapter.VendorID != amdVendorId)
-                        return false;
-
-                    if (Adl2.NativeMethods.ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
-                        return false;
-
-                    asicFamilyType = (ADLAsicFamilyType) ((int) asicFamilyType & asicFamilyTypeValids);
-                    
-                    // FIXME: is this correct for G14 2022?
-                    return (asicFamilyType & ADLAsicFamilyType.Discrete) != 0; 
-                });
-        
-        if (internalDiscreteAdapter.Exist == 0)
-            return;
-
-        _internalDiscreteAdapter = internalDiscreteAdapter;
-        _isReady = true;
-    }
-
-    public bool IsValid => _isReady && _adlContextHandle != IntPtr.Zero;
-
-    public int? GetCurrentTemperature() {
-        if (!IsValid)
-            return null;
-        
-        if (Adl2.NativeMethods.ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
-            return null;
-        
-        ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int) ADLSensorType.PMLOG_TEMPERATURE_EDGE];
-        if (temperatureSensor.Supported == 0)
-            return null;
-
-        return temperatureSensor.Value;
-    }
-
-
-    public int? GetGpuUse()
-    {
-        if (!IsValid)
-            return null;
-
-        if (Adl2.NativeMethods.ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
-            return null;
-
-        ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_INFO_ACTIVITY_GFX];
-        if (gpuUsage.Supported == 0)
-            return null;
-
-        return gpuUsage.Value;
-
-    }
-
-
-    private void ReleaseUnmanagedResources() {
-        if (_adlContextHandle != IntPtr.Zero) {
-            Adl2.NativeMethods.ADL2_Main_Control_Destroy(_adlContextHandle);
-            _adlContextHandle = IntPtr.Zero;
-            _isReady = false;
-        }
-    }
-
-    public void Dispose() {
-        ReleaseUnmanagedResources();
-        GC.SuppressFinalize(this);
-    }
-
-    ~AmdGpuControl() {
-        ReleaseUnmanagedResources();
-    }
-}

app/Gpu/GPUModeControl.cs

@@ -0,0 +1,354 @@
+using GHelper.Display;
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using System.Diagnostics;
+
+namespace GHelper.Gpu
+{
+    public class GPUModeControl
+    {
+        SettingsForm settings;
+        ScreenControl screenControl = new ScreenControl();
+
+        public static int gpuMode;
+        public static bool? gpuExists = null;
+
+
+        public GPUModeControl(SettingsForm settingsForm)
+        {
+            settings = settingsForm;
+        }
+
+        public void InitGPUMode()
+        {
+            int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+            int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
+
+            Logger.WriteLine("Eco flag : " + eco);
+            Logger.WriteLine("Mux flag : " + mux);
+
+            if (mux == 0)
+            {
+                gpuMode = AsusACPI.GPUModeUltimate;
+            }
+            else
+            {
+                if (eco == 1)
+                    gpuMode = AsusACPI.GPUModeEco;
+                else
+                    gpuMode = AsusACPI.GPUModeStandard;
+
+                // Ultimate mode not supported
+                if (mux != 1) settings.HideUltimateMode();
+
+                // GPU mode not supported
+                if (eco < 0 && mux < 0)
+                {
+                    if (gpuExists is null) gpuExists = Program.acpi.GetFan(AsusFan.GPU) >= 0;
+                    settings.HideGPUModes((bool)gpuExists);
+                }
+            }
+
+            AppConfig.Set("gpu_mode", gpuMode);
+            settings.VisualiseGPUMode(gpuMode);
+
+            AsusUSB.ApplyGPUColor();
+
+        }
+
+
+
+        public void SetGPUMode(int GPUMode, int auto = 0)
+        {
+
+            int CurrentGPU = AppConfig.Get("gpu_mode");
+            AppConfig.Set("gpu_auto", auto);
+
+            if (CurrentGPU == GPUMode)
+            {
+                settings.VisualiseGPUMode();
+                return;
+            }
+
+            var restart = false;
+            var changed = false;
+
+            if (CurrentGPU == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+            }
+            else if (GPUMode == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    if (AppConfig.NoAutoUltimate())
+                    {
+                        Program.acpi.SetGPUEco(0);
+                        Thread.Sleep(100);
+                    }
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+
+            }
+            else if (GPUMode == AsusACPI.GPUModeEco)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(1, true);
+                changed = true;
+            }
+            else if (GPUMode == AsusACPI.GPUModeStandard)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(0);
+                changed = true;
+            }
+
+            if (changed)
+            {
+                AppConfig.Set("gpu_mode", GPUMode);
+            }
+
+            if (restart)
+            {
+                settings.VisualiseGPUMode();
+                Process.Start("shutdown", "/r /t 1");
+            }
+
+        }
+
+
+
+        public void SetGPUEco(int eco, bool hardWay = false)
+        {
+
+            settings.LockGPUModes();
+
+            Task.Run(async () =>
+            {
+
+                int status = 1;
+
+                if (eco == 1)
+                {
+                    /*
+                    if (NvidiaSmi.GetDisplayActiveStatus())
+                    {
+                        DialogResult dialogResult = MessageBox.Show(Properties.Strings.EnableOptimusText, Properties.Strings.EnableOptimusTitle, MessageBoxButtons.YesNo);
+                        if (dialogResult == DialogResult.No)
+                        {
+                            InitGPUMode();
+                            return;
+                        }
+                    }
+                    */
+
+                    HardwareControl.KillGPUApps();
+                }
+
+                Logger.WriteLine($"Running eco command {eco}");
+
+                status = Program.acpi.SetGPUEco(eco);
+
+                if (status == 0 && eco == 1 && hardWay) RestartGPU();
+
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                    screenControl.AutoScreen();
+                });
+
+                if (eco == 0)
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    HardwareControl.RecreateGpuControl();
+                    Program.modeControl.SetGPUClocks(false);
+                }
+
+            });
+
+
+        }
+
+        public static bool IsPlugged()
+        {
+            if (SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online) return false;
+            if (!AppConfig.Is("optimized_usbc")) return true;
+
+            int chargerMode = Program.acpi.DeviceGet(AsusACPI.ChargerMode);
+            Logger.WriteLine("ChargerStatus: " + chargerMode);
+
+            if (chargerMode < 0) return true;
+            return (chargerMode & AsusACPI.ChargerBarrel) > 0;
+
+        }
+
+        public bool AutoGPUMode(bool optimized = false)
+        {
+
+            bool GpuAuto = AppConfig.Is("gpu_auto");
+            bool ForceGPU = AppConfig.IsForceSetGPUMode();
+
+            int GpuMode = AppConfig.Get("gpu_mode");
+
+            if (!GpuAuto && !ForceGPU) return false;
+
+            int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+            int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
+
+            if (mux == 0)
+            {
+                if (optimized) SetGPUMode(AsusACPI.GPUModeStandard, 1);
+                return false;
+            }
+            else
+            {
+
+                if (eco == 1)
+                    if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
+                    {
+                        SetGPUEco(0);
+                        return true;
+                    }
+                if (eco == 0)
+                    if ((GpuAuto && !IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeEco))
+                    {
+
+                        if (HardwareControl.IsUsedGPU())
+                        {
+                            DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertDGPU, Properties.Strings.AlertDGPUTitle, MessageBoxButtons.YesNo);
+                            if (dialogResult == DialogResult.No) return false;
+                        }
+
+                        SetGPUEco(1);
+                        return true;
+                    }
+            }
+
+            return false;
+
+        }
+
+
+        public void RestartGPU(bool confirm = true)
+        {
+            if (HardwareControl.GpuControl is null) return;
+            if (!HardwareControl.GpuControl!.IsNvidia) return;
+
+            if (confirm)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.RestartGPU, Properties.Strings.EcoMode, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.No) return;
+            }
+
+            ProcessHelper.RunAsAdmin("gpurestart");
+
+            if (!ProcessHelper.IsUserAdministrator()) return;
+
+            Logger.WriteLine("Trying to restart dGPU");
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes("Restarting GPU ...");
+
+                var nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+                bool status = nvControl.RestartGPU();
+
+                settings.Invoke(delegate
+                {
+                    //labelTipGPU.Text = status ? "GPU Restarted, you can try Eco mode again" : "Failed to restart GPU"; TODO
+                    InitGPUMode();
+                });
+            });
+
+        }
+
+
+        public void InitXGM()
+        {
+            if (Program.acpi.IsXGConnected())
+            {
+                //Program.acpi.DeviceSet(AsusACPI.GPUXGInit, 1, "XG Init");
+                AsusUSB.InitXGM();
+            }
+
+        }
+
+        public void ToggleXGM()
+        {
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes();
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
+                {
+                    AsusUSB.ResetXGM();
+                    HardwareControl.KillGPUApps();
+
+                    DialogResult dialogResult = MessageBox.Show("Did you close all applications running on XG Mobile?", "Disabling XG Mobile", MessageBoxButtons.YesNo);
+                    if (dialogResult == DialogResult.Yes)
+                    {
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 0, "GPU XGM");
+                        await Task.Delay(TimeSpan.FromSeconds(15));
+                    }
+                }
+                else
+                {
+
+                    if (AppConfig.Is("xgm_special"))
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 0x101, "GPU XGM");
+                    else
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
+
+                    InitXGM();
+
+                    AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
+
+                    await Task.Delay(TimeSpan.FromSeconds(15));
+
+                    if (AppConfig.IsMode("auto_apply"))
+                        AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+
+                    HardwareControl.RecreateGpuControl();
+
+                }
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                });
+            });
+        }
+
+        public void KillGPUApps()
+        {
+            if (HardwareControl.GpuControl is not null)
+            {
+                HardwareControl.GpuControl.KillGPUApps();
+            }
+        }
+
+        // Manually forcing standard mode on shutdown/hibernate for some exotic cases
+        // https://github.com/seerge/g-helper/pull/855 
+        public void StandardModeFix()
+        {
+            if (!AppConfig.IsGPUFix()) return; // No config entry
+            if (Program.acpi.DeviceGet(AsusACPI.GPUMux) == 0) return; // Ultimate mode
+
+            Logger.WriteLine("Forcing Standard Mode on shutdown / hibernation");
+            Program.acpi.SetGPUEco(0);
+        }
+
+    }
+}

app/Gpu/IGpuControl.cs

@@ -1,8 +1,11 @@
 namespace GHelper.Gpu;
 
-public interface IGpuControl : IDisposable {
+public  interface IGpuControl : IDisposable {
     bool IsNvidia { get; }
     bool IsValid { get; }
+    public string FullName { get; }
     int? GetCurrentTemperature();
     int? GetGpuUse();
+    void KillGPUApps();
+
 }

app/Gpu/NVidia/NvidiaGpuControl.cs

@@ -0,0 +1,241 @@
+using GHelper.Helpers;
+using NvAPIWrapper.GPU;
+using NvAPIWrapper.Native;
+using NvAPIWrapper.Native.GPU;
+using NvAPIWrapper.Native.GPU.Structures;
+using NvAPIWrapper.Native.Interfaces.GPU;
+using System.Diagnostics;
+using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
+
+namespace GHelper.Gpu.NVidia;
+
+public class NvidiaGpuControl : IGpuControl
+{
+
+    public static int MaxCoreOffset => AppConfig.Get("max_gpu_core", 250);
+    public static int MaxMemoryOffset => AppConfig.Get("max_gpu_memory", 250);
+
+    public const int MinCoreOffset = -250;
+    public const int MinMemoryOffset = -250;
+
+    public const int MinClockLimit = 1000;
+    public const int MaxClockLimit = 3000;
+
+    private static PhysicalGPU? _internalGpu;
+
+    public NvidiaGpuControl()
+    {
+        _internalGpu = GetInternalDiscreteGpu();
+    }
+
+    public bool IsValid => _internalGpu != null;
+
+    public bool IsNvidia => IsValid;
+
+    public string FullName => _internalGpu!.FullName;
+
+    public int? GetCurrentTemperature()
+    {
+        if (!IsValid) return null;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+        IThermalSensor? gpuSensor =
+            GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
+            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
+
+        return gpuSensor?.CurrentTemperature;
+    }
+
+    public void Dispose()
+    {
+    }
+
+    public void KillGPUApps()
+    {
+
+        if (!IsValid) return;
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        try
+        {
+            Process[] processes = internalGpu.GetActiveApplications();
+            foreach (Process process in processes)
+                try
+                {
+                    Logger.WriteLine("Kill:" + process.ProcessName);
+                    ProcessHelper.KillByProcess(process);
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.Message);
+        }
+
+        //GeneralApi.RestartDisplayDriver();
+    }
+
+
+    public bool GetClocks(out int core, out int memory)
+    {
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        //Logger.WriteLine(internalGpu.FullName);
+        //Logger.WriteLine(internalGpu.ArchitectInformation.ToString());
+
+        try
+        {
+            IPerformanceStates20Info states = GPUApi.GetPerformanceStates20(internalGpu.Handle);
+            core = states.Clocks[PerformanceStateId.P0_3DPerformance][0].FrequencyDeltaInkHz.DeltaValue / 1000;
+            memory = states.Clocks[PerformanceStateId.P0_3DPerformance][1].FrequencyDeltaInkHz.DeltaValue / 1000;
+            Logger.WriteLine($"GET GPU CLOCKS: {core}, {memory}");
+
+            foreach (var delta in states.Voltages[PerformanceStateId.P0_3DPerformance])
+            {
+                Logger.WriteLine("GPU VOLT:" + delta.IsEditable + " - " + delta.ValueDeltaInMicroVolt.DeltaValue);
+            }
+
+            return true;
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("GET GPU CLOCKS:" + ex.Message);
+            core = memory = 0;
+            return false;
+        }
+
+    }
+
+
+    private bool RunPowershellCommand(string script)
+    {
+        try
+        {
+            ProcessHelper.RunCMD("powershell", script);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine(ex.ToString());
+            return false;
+        }
+
+    }
+
+    public int GetMaxGPUCLock()
+    {
+        PhysicalGPU internalGpu = _internalGpu!;
+        try
+        {
+            PrivateClockBoostLockV2 data = GPUApi.GetClockBoostLock(internalGpu.Handle);
+            int limit = (int)data.ClockBoostLocks[0].VoltageInMicroV / 1000;
+            Logger.WriteLine("GET CLOCK LIMIT: " + limit);
+            return limit;
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("GET CLOCK LIMIT: " + ex.Message);
+            return -1;
+
+        }
+    }
+
+
+    public int SetMaxGPUClock(int clock)
+    {
+
+        if (clock < MinClockLimit || clock >= MaxClockLimit) clock = 0;
+
+        int _clockLimit = GetMaxGPUCLock();
+
+        if (_clockLimit != clock)
+        {
+            if (clock > 0) RunPowershellCommand($"nvidia-smi -lgc 0,{clock}");
+            else RunPowershellCommand($"nvidia-smi -rgc");
+            return 1;
+        }
+        else
+        {
+            return 0;
+        }
+
+
+    }
+
+    public bool RestartGPU()
+    {
+        return RunPowershellCommand(@"$device = Get-PnpDevice | Where-Object { $_.FriendlyName -imatch 'NVIDIA' -and $_.Class -eq 'Display' }; Disable-PnpDevice $device.InstanceId -Confirm:$false; Start-Sleep -Seconds 5; Enable-PnpDevice $device.InstanceId -Confirm:$false");
+    }
+
+
+    public int SetClocks(int core, int memory)
+    {
+
+        if (core < MinCoreOffset || core > MaxCoreOffset) return 0;
+        if (memory < MinMemoryOffset || memory > MaxMemoryOffset) return 0;
+
+        if (GetClocks(out int currentCore, out int currentMemory))
+        {
+            if (Math.Abs(core - currentCore) < 5 && Math.Abs(memory - currentMemory) < 5) return 0;
+        }
+
+        PhysicalGPU internalGpu = _internalGpu!;
+
+        var coreClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Graphics, new PerformanceStates20ParameterDelta(core * 1000));
+        var memoryClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Memory, new PerformanceStates20ParameterDelta(memory * 1000));
+        //var voltageEntry = new PerformanceStates20BaseVoltageEntryV1(PerformanceVoltageDomain.Core, new PerformanceStates20ParameterDelta(voltage));
+
+        PerformanceStates20ClockEntryV1[] clocks = { coreClock, memoryClock };
+        PerformanceStates20BaseVoltageEntryV1[] voltages = { };
+
+        PerformanceState20[] performanceStates = { new PerformanceState20(PerformanceStateId.P0_3DPerformance, clocks, voltages) };
+
+        var overclock = new PerformanceStates20InfoV1(performanceStates, 2, 0);
+
+        try
+        {
+            Logger.WriteLine($"SET GPU CLOCKS: {core}, {memory}");
+            GPUApi.SetPerformanceStates20(internalGpu.Handle, overclock);
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("SET GPU CLOCKS: " + ex.Message);
+            return -1;
+        }
+
+        return 1;
+    }
+
+    private static PhysicalGPU? GetInternalDiscreteGpu()
+    {
+        try
+        {
+            return PhysicalGPU
+                .GetPhysicalGPUs()
+                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.Message);
+            return null;
+        }
+    }
+
+
+    public int? GetGpuUse()
+    {
+        if (!IsValid)
+            return null;
+
+        PhysicalGPU internalGpu = _internalGpu!;
+        IUtilizationDomainInfo? gpuUsage = GPUApi.GetUsages(internalGpu.Handle).GPU;
+
+        return (int?)gpuUsage?.Percentage;
+
+    }
+
+}

app/Gpu/NVidia/NvidiaSmi.cs

@@ -0,0 +1,65 @@
+using Ryzen;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+
+public static class NvidiaSmi
+{
+    public static bool GetDisplayActiveStatus()
+    {
+        // Non AMD devices doesn't seem to be affected
+        if (!RyzenControl.IsAMD()) return false;
+
+        string commandOutput = RunNvidiaSmiCommand();
+
+        Logger.WriteLine(commandOutput);
+
+        if (commandOutput.Length == 0) return false;
+        if (!commandOutput.Contains("RTX 40")) return false;
+
+        // Extract the "Display Active" status using regular expressions
+        string displayActivePattern = @"Display Active\s+:\s+(\w+)";
+
+        Match match = Regex.Match(commandOutput, displayActivePattern, RegexOptions.IgnoreCase);
+
+        if (match.Success)
+        {
+            string status = match.Groups[1].Value.ToLower().Trim(' ');
+            return status == "enabled";
+        }
+
+        return false; // Return false if the "Display Active" status is not found
+    }
+
+    private static string RunNvidiaSmiCommand(string arguments = "-i 0 -q")
+    {
+        ProcessStartInfo startInfo = new ProcessStartInfo
+        {
+            FileName = "nvidia-smi",
+            Arguments = arguments,
+            RedirectStandardOutput = true,
+            UseShellExecute = false,
+            CreateNoWindow = true
+        };
+
+        Process process = new Process
+        {
+            StartInfo = startInfo
+        };
+
+        try
+        {
+            process.Start();
+            string output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit();
+            return output;
+        }
+        catch (Exception ex)
+        {
+            //return File.ReadAllText(@"smi.txt");
+            Debug.WriteLine(ex.Message);
+        }
+
+        return "";
+
+    }
+}

app/Gpu/NvidiaGpuControl.cs

@@ -1,132 +0,0 @@
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-using NvAPIWrapper.Native.Interfaces.GPU;
-using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
-
-namespace GHelper.Gpu;
-
-public class NvidiaGpuControl : IGpuControl
-{
-
-    public const int MaxCoreOffset = 250;
-    public const int MaxMemoryOffset = 250;
-
-    public const int MinCoreOffset = -250;
-    public const int MinMemoryOffset = -250;
-
-    private readonly PhysicalGPU? _internalGpu;
-
-    public NvidiaGpuControl()
-    {
-        _internalGpu = GetInternalDiscreteGpu();
-    }
-
-    public bool IsValid => _internalGpu != null;
-
-    public bool IsNvidia => IsValid;
-
-    public int? GetCurrentTemperature()
-    {
-        if (!IsValid)
-            return null;
-
-        PhysicalGPU internalGpu = _internalGpu!;
-        IThermalSensor? gpuSensor =
-            GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
-            .FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
-
-        return gpuSensor?.CurrentTemperature;
-    }
-
-    public void Dispose()
-    {
-    }
-
-
-
-    public void GetClocks(out int core, out int memory)
-    {
-        PhysicalGPU internalGpu = _internalGpu!;
-        Logger.WriteLine(internalGpu.FullName);
-        Logger.WriteLine(internalGpu.ArchitectInformation.ToString());
-
-        IPerformanceStates20Info states = GPUApi.GetPerformanceStates20(internalGpu.Handle);
-
-        Logger.WriteLine("IPerformanceStates20Info type : " + states.GetType());
-
-        core = states.Clocks[PerformanceStateId.P0_3DPerformance][0].FrequencyDeltaInkHz.DeltaValue / 1000;
-        memory = states.Clocks[PerformanceStateId.P0_3DPerformance][1].FrequencyDeltaInkHz.DeltaValue / 1000;
-    }
-
-    public int SetClocksFromConfig()
-    {
-        int core = Program.config.getConfig("gpu_core");
-        int memory = Program.config.getConfig("gpu_memory");
-        int status = SetClocks(core, memory);
-        return status;
-    }
-
-    public int SetClocks(int core, int memory)
-    {
-
-        if (core < MinCoreOffset || core > MaxCoreOffset) return 0;
-        if (memory < MinMemoryOffset || memory > MaxMemoryOffset) return 0;
-
-        PhysicalGPU internalGpu = _internalGpu!;
-
-        var coreClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Graphics, new PerformanceStates20ParameterDelta(core * 1000));
-        var memoryClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Memory, new PerformanceStates20ParameterDelta(memory * 1000));
-
-        PerformanceStates20ClockEntryV1[] clocks = { coreClock , memoryClock};
-        PerformanceStates20BaseVoltageEntryV1[] voltages = { };
-
-        PerformanceState20[] performanceStates = { new PerformanceState20(PerformanceStateId.P0_3DPerformance, clocks, voltages) };
-
-        var overclock = new PerformanceStates20InfoV1(performanceStates, 2, 0);
-
-        try
-        {
-            GPUApi.SetPerformanceStates20(internalGpu.Handle, overclock);
-        }
-        catch (Exception ex)
-        {
-            Logger.WriteLine(ex.ToString());
-            return -1;
-        }
-
-
-
-        return 1;
-    }
-
-    private static PhysicalGPU? GetInternalDiscreteGpu()
-    {
-        try
-        {
-            return PhysicalGPU
-                .GetPhysicalGPUs()
-                .FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
-        }
-        catch (Exception ex)
-        {
-            Logger.WriteLine(ex.ToString());
-            return null;
-        }
-    }
-
-
-    public int? GetGpuUse()
-    {
-        if (!IsValid)
-            return null;
-
-        PhysicalGPU internalGpu = _internalGpu!;
-        IUtilizationDomainInfo? gpuUsage = GPUApi.GetUsages(internalGpu.Handle).GPU;
-
-        return (int?)gpuUsage?.Percentage;
-
-    }
-
-}

app/HardwareControl.cs

@@ -0,0 +1,299 @@
+using GHelper;
+using GHelper.Fan;
+using GHelper.Gpu;
+using GHelper.Gpu.NVidia;
+using GHelper.Gpu.AMD;
+
+using GHelper.Helpers;
+using System.Diagnostics;
+using System.Management;
+
+public static class HardwareControl
+{
+
+    public static IGpuControl? GpuControl;
+
+    public static float? cpuTemp = -1;
+    public static decimal? batteryRate = 0;
+    public static decimal batteryHealth = -1;
+    public static decimal batteryCapacity = -1;
+
+    public static decimal? designCapacity;
+    public static decimal? fullCapacity;
+    public static decimal? chargeCapacity;
+
+
+    public static int? gpuTemp = null;
+
+    public static string? cpuFan;
+    public static string? gpuFan;
+    public static string? midFan;
+
+    public static int? gpuUse;
+
+    static long lastUpdate;
+
+    private static int GetGpuUse()
+    {
+        try
+        {
+            int? gpuUse = GpuControl?.GetGpuUse();
+            Logger.WriteLine("GPU usage: " + GpuControl?.FullName + " " + gpuUse + "%");
+            if (gpuUse is not null) return (int)gpuUse;
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.ToString());
+        }
+
+        return 0;
+    }
+
+
+    public static void GetBatteryStatus()
+    {
+
+        batteryRate = 0;
+        chargeCapacity = 0;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStatus");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+
+                chargeCapacity = Convert.ToDecimal(obj["RemainingCapacity"]);
+
+                decimal chargeRate = Convert.ToDecimal(obj["ChargeRate"]);
+                decimal dischargeRate = Convert.ToDecimal(obj["DischargeRate"]);
+                
+                if (chargeRate > 0)
+                    batteryRate = chargeRate / 1000;
+                else
+                    batteryRate = -dischargeRate / 1000;
+
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Discharge Reading: " + ex.Message);
+        }
+
+    }
+    public static void ReadFullChargeCapacity()
+    {
+        if (fullCapacity > 0) return;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryFullChargedCapacity");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+                fullCapacity = Convert.ToDecimal(obj["FullChargedCapacity"]);
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Full Charge Reading: " + ex.Message);
+        }
+
+    }
+
+    public static void ReadDesignCapacity()
+    {
+        if (designCapacity > 0) return;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStaticData");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+                designCapacity = Convert.ToDecimal(obj["DesignedCapacity"]);
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Design Capacity Reading: " + ex.Message);
+        }
+    }
+
+    public static void RefreshBatteryHealth()
+    {
+        batteryHealth = GetBatteryHealth() * 100;
+    }
+
+
+    public static decimal GetBatteryHealth()
+    {
+        if (designCapacity is null)
+        {
+            ReadDesignCapacity();
+        }
+        ReadFullChargeCapacity();
+
+        if (designCapacity is null || fullCapacity is null || designCapacity == 0 || fullCapacity == 0)
+        {
+            return -1;
+        }
+
+        decimal health = (decimal)fullCapacity / (decimal)designCapacity;
+        Logger.WriteLine("Design Capacity: " + designCapacity + "mWh, Full Charge Capacity: " + fullCapacity + "mWh, Health: " + health + "%");
+
+        return health;
+    }
+
+    public static float? GetCPUTemp() {
+
+        var last = DateTimeOffset.Now.ToUnixTimeSeconds();
+        if (Math.Abs(last - lastUpdate) < 2) return cpuTemp;
+        lastUpdate = last;
+
+        cpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_CPU);
+
+        if (cpuTemp < 0) try
+            {
+                using (var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true))
+                {
+                    cpuTemp = ct.NextValue() - 273;
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
+            }
+
+
+        return cpuTemp;
+    }
+
+
+    public static void ReadSensors()
+    {
+        batteryRate = 0;
+        gpuTemp = -1;
+        gpuUse = -1;
+
+        cpuFan = FanSensorControl.FormatFan(AsusFan.CPU, Program.acpi.GetFan(AsusFan.CPU));
+        gpuFan = FanSensorControl.FormatFan(AsusFan.GPU, Program.acpi.GetFan(AsusFan.GPU));
+        midFan = FanSensorControl.FormatFan(AsusFan.Mid, Program.acpi.GetFan(AsusFan.Mid));
+
+        cpuTemp = GetCPUTemp();
+
+        try
+        {
+            gpuTemp = GpuControl?.GetCurrentTemperature();
+
+        }
+        catch (Exception ex)
+        {
+            gpuTemp = -1;
+            Debug.WriteLine("Failed reading GPU temp :" + ex.Message);
+        }
+
+        if (gpuTemp is null || gpuTemp < 0)
+            gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
+
+        ReadFullChargeCapacity();
+        GetBatteryStatus();
+
+        if (fullCapacity > 0 && chargeCapacity > 0)
+        {
+            batteryCapacity = Math.Min(100, ((decimal)chargeCapacity / (decimal)fullCapacity) * 100);
+        }
+
+
+    }
+
+    public static bool IsUsedGPU(int threshold = 10)
+    {
+        if (GetGpuUse() > threshold)
+        {
+            Thread.Sleep(1000);
+            return (GetGpuUse() > threshold);
+        }
+        return false;
+    }
+
+
+    public static NvidiaGpuControl? GetNvidiaGpuControl()
+    {
+        if ((bool)GpuControl?.IsNvidia)
+            return (NvidiaGpuControl)GpuControl;
+        else
+            return null;
+    }
+
+    public static void RecreateGpuControlWithDelay(int delay = 5)
+    {
+        // Re-enabling the discrete GPU takes a bit of time,
+        // so a simple workaround is to refresh again after that happens
+        Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromSeconds(delay));
+            RecreateGpuControl();
+        });
+    }
+
+    public static void RecreateGpuControl()
+    {
+        try
+        {
+            GpuControl?.Dispose();
+
+            IGpuControl _gpuControl = new NvidiaGpuControl();
+            
+            if (_gpuControl.IsValid)
+            {
+                GpuControl = _gpuControl;
+                Logger.WriteLine(GpuControl.FullName);
+                return;
+            }
+
+            _gpuControl.Dispose();
+
+            _gpuControl = new AmdGpuControl();
+            if (_gpuControl.IsValid)
+            {
+                GpuControl = _gpuControl;
+                if (GpuControl.FullName.Contains("6850M")) AppConfig.Set("xgm_special", 1);
+                Logger.WriteLine(GpuControl.FullName);
+                return;
+            }
+            _gpuControl.Dispose();
+
+            Logger.WriteLine("dGPU not found");
+            GpuControl = null;
+
+
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine("Can't connect to GPU " + ex.ToString());
+        }
+    }
+
+
+    public static void KillGPUApps()
+    {
+
+        List<string> tokill = new() { "EADesktop", "RadeonSoftware", "epicgameslauncher", "ASUSSmartDisplayControl" };
+        foreach (string kill in tokill) ProcessHelper.KillByName(kill);
+
+        if (AppConfig.Is("kill_gpu_apps") && GpuControl is not null)
+        {
+            GpuControl.KillGPUApps();
+        }
+    }
+}

app/HardwareMonitor.cs

@@ -1,176 +0,0 @@
-using GHelper;
-using GHelper.Gpu;
-using System.Diagnostics;
-
-public static class HardwareMonitor
-{
-    public static IGpuControl? GpuControl;
-
-    public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -1;
-    public static int? gpuTemp = null;
-
-    public static string? cpuFan;
-    public static string? gpuFan;
-    public static string? midFan;
-
-    public static int? gpuUse;
-
-    public static int GetFanMax()
-    {
-        int max = 58;
-        if (Program.config.ContainsModel("401")) max = 72;
-        else if (Program.config.ContainsModel("503")) max = 68;
-        return Math.Max(max, Program.config.getConfig("fan_max"));
-    }
-
-    public static void SetFanMax(int fan)
-    {
-        Program.config.setConfig("fan_max", fan);
-    }
-    private static string FormatFan(int fan)
-    {
-        // fix for old models 
-        if (fan < 0)
-        {
-            fan += 65536;
-            if (fan <= 0 || fan > 100) return null; //nothing reasonable
-        }
-
-        int fanMax = GetFanMax();
-        if (fan > fanMax) SetFanMax(fan);
-
-        if (Program.config.getConfig("fan_rpm") == 1)
-            return " Fan: " + (fan * 100).ToString() + "RPM";
-        else
-            return " Fan: " + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
-    }
-
-    private static int GetGpuUse()
-    {
-        try
-        {
-            int? gpuUse = GpuControl?.GetGpuUse();
-            if (gpuUse is not null) return (int)gpuUse;
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine(ex.ToString());
-        }
-
-        return 0;
-    }
-
-
-    public static void ReadSensors()
-    {
-        batteryDischarge = -1;
-        gpuTemp = -1;
-        gpuUse = -1;
-
-        cpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan));
-        gpuFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan));
-        midFan = FormatFan(Program.wmi.DeviceGet(ASUSWmi.Mid_Fan));
-
-        cpuTemp = Program.wmi.DeviceGet(ASUSWmi.Temp_CPU);
-
-        if (cpuTemp < 0) try
-            {
-                using (var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true))
-                {
-                    cpuTemp = ct.NextValue() - 273;
-                }
-            }
-            catch
-            {
-                Debug.WriteLine("Failed reading CPU temp");
-            }
-
-        try
-        {
-            gpuTemp = GpuControl?.GetCurrentTemperature();
-
-        }
-        catch (Exception ex)
-        {
-            gpuTemp = -1;
-            Debug.WriteLine("Failed reading GPU temp");
-            Debug.WriteLine(ex.ToString());
-        }
-
-        if (gpuTemp is null || gpuTemp < 0)
-            gpuTemp = Program.wmi.DeviceGet(ASUSWmi.Temp_GPU);
-
-        try
-        {
-            using (var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true))
-            {
-                batteryDischarge = cb.NextValue() / 1000;
-            }
-        }
-        catch
-        {
-            Debug.WriteLine("Failed reading Battery discharge");
-        }
-    }
-
-    public static bool IsUsedGPU(int threshold = 20)
-    {
-        if (GetGpuUse() > threshold)
-        {
-            Thread.Sleep(1000);
-            return (GetGpuUse() > threshold);
-        }
-        return false;
-    }
-
-    public static void RecreateGpuControlWithDelay(int delay = 5)
-    {
-
-        // Re-enabling the discrete GPU takes a bit of time,
-        // so a simple workaround is to refresh again after that happens
-        Task.Run(async () =>
-        {
-            await Task.Delay(TimeSpan.FromSeconds(delay));
-            RecreateGpuControl();
-        });
-
-
-
-    }
-
-    public static void RecreateGpuControl()
-    {
-        try
-        {
-            GpuControl?.Dispose();
-
-            // Detect valid GPU temperature provider.
-            // We start with NVIDIA because there's always at least an integrated AMD GPU
-            IGpuControl _gpuControl = new NvidiaGpuControl();
-            if (_gpuControl.IsValid)
-            {
-                GpuControl = _gpuControl;
-                return;
-            }
-
-            _gpuControl.Dispose();
-
-            /*
-            _gpuControl = new AmdGpuControl();
-            if (_gpuControl.IsValid)
-            {
-                GpuControl = _gpuControl;
-                return;
-            }
-            _gpuControl.Dispose();
-            */
-
-            GpuControl = null;
-        }
-        catch (Exception ex)
-        {
-            Debug.WriteLine(ex.ToString());
-        }
-    }
-}

app/Helpers/Audio.cs

@@ -0,0 +1,29 @@
+using NAudio.CoreAudioApi;
+
+namespace GHelper.Helpers
+{
+    internal class Audio
+    {
+        public static bool ToggleMute()
+        {
+            using (var enumerator = new MMDeviceEnumerator())
+            {
+                var commDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
+                var consoleDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
+                var mmDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Multimedia);
+
+                bool status = !commDevice.AudioEndpointVolume.Mute;
+                
+                commDevice.AudioEndpointVolume.Mute = status;
+                consoleDevice.AudioEndpointVolume.Mute = status;
+                mmDevice.AudioEndpointVolume.Mute = status;
+
+                Logger.WriteLine(commDevice.ToString() + ":" + status);
+                Logger.WriteLine(consoleDevice.ToString() + ":" + status);
+                Logger.WriteLine(mmDevice.ToString() + ":" + status);
+
+                return status;
+            }
+        }
+    }
+}

app/Helpers/ClamshellModeControl.cs

@@ -0,0 +1,138 @@
+using GHelper.Display;
+using GHelper.Mode;
+using Microsoft.Win32;
+
+namespace GHelper.Helpers
+{
+    internal class ClamshellModeControl
+    {
+
+        public ClamshellModeControl()
+        {
+            //Save current setting if hibernate or shutdown to prevent reverting the user set option.
+            CheckAndSaveLidAction();
+        }
+
+        public bool IsExternalDisplayConnected()
+        {
+            var devices = ScreenInterrogatory.GetAllDevices().ToArray();
+
+            string internalName = AppConfig.GetString("internal_display");
+
+            foreach (var device in devices)
+            {
+                if (device.outputTechnology != ScreenInterrogatory.DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL &&
+                    device.outputTechnology != ScreenInterrogatory.DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED
+                    && device.monitorFriendlyDeviceName != internalName)
+                {
+                    Logger.WriteLine("Found external screen: " + device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString());
+
+                    //Already found one, we do not have to check whether there are more
+                    return true;
+                }
+
+            }
+
+            return false;
+        }
+
+        public bool IsClamshellEnabled()
+        {
+            return AppConfig.Is("toggle_clamshell_mode");
+        }
+
+        public bool IsChargerConnected()
+        {
+            return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
+        }
+
+        public bool IsClamshellReady()
+        {
+            return IsExternalDisplayConnected() && IsChargerConnected();
+        }
+
+        public void ToggleLidAction()
+        {
+            if (!IsClamshellEnabled())
+            {
+                return;
+            }
+
+            if (IsClamshellReady())
+            {
+                EnableClamshellMode();
+            }
+            else
+            {
+                DisableClamshellMode();
+            }
+        }
+        public static void DisableClamshellMode()
+        {
+            PowerNative.SetLidAction(GetDefaultLidAction(), true);
+            Logger.WriteLine("Disengaging Clamshell Mode");
+        }
+
+        public static void EnableClamshellMode()
+        {
+            PowerNative.SetLidAction(0, true);
+            Logger.WriteLine("Engaging Clamshell Mode");
+        }
+
+        public void UnregisterDisplayEvents()
+        {
+            SystemEvents.DisplaySettingsChanged -= SystemEvents_DisplaySettingsChanged;
+        }
+
+        public void RegisterDisplayEvents()
+        {
+            SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
+        }
+
+        private void SystemEvents_DisplaySettingsChanged(object? sender, EventArgs e)
+        {
+            Logger.WriteLine("Display configuration changed.");
+
+            if (IsClamshellEnabled())
+                ToggleLidAction();
+        }
+
+        private static int CheckAndSaveLidAction()
+        {
+            if (AppConfig.Get("clamshell_default_lid_action", -1) != -1)
+            {
+                //Seting was alredy set. Do not touch it
+                return AppConfig.Get("clamshell_default_lid_action", -1);
+            }
+
+            int val = PowerNative.GetLidAction(true);
+            //If it is 0 then it is likely already set by clamshell mdoe
+            //If 0 was set by the user, then why do they even use clamshell mode?
+            //We only care about hibernate or shutdown setting here
+            if (val == 2 || val == 3)
+            {
+                AppConfig.Set("clamshell_default_lid_action", val);
+                return val;
+            }
+
+            return 1;
+        }
+
+        //Power users can change that setting.
+        //0 = Do nothing
+        //1 = Sleep (default)
+        //2 = Hibernate
+        //3 = Shutdown
+        private static int GetDefaultLidAction()
+        {
+            int val = AppConfig.Get("clamshell_default_lid_action", 1);
+
+            if (val < 0 || val > 3)
+            {
+                val = 1;
+            }
+
+            return val;
+        }
+    }
+}

app/Helpers/ColorUtilities.cs

@@ -0,0 +1,21 @@
+namespace GHelper.Helpers
+{
+    public class ColorUtilities
+    {
+        // Method to get the weighted average between two colors
+        public static Color GetWeightedAverage(Color color1, Color color2, float weight)
+        {
+
+            int red = (int)Math.Round(color1.R * (1 - weight) + color2.R * weight);
+            int green = (int)Math.Round(color1.G * (1 - weight) + color2.G * weight);
+            int blue = (int)Math.Round(color1.B * (1 - weight) + color2.B * weight);
+
+            red = Math.Min(255, Math.Max(0, red));
+            green = Math.Min(255, Math.Max(0, green));
+            blue = Math.Min(255, Math.Max(0, blue));
+
+            return Color.FromArgb(red, green, blue);
+        }
+    }
+
+}

app/Helpers/Logger.cs

@@ -2,8 +2,8 @@
 
 public static class Logger
 {
-    static string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
-    static string logFile = appPath + "\\log.txt";
+    public static string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
+    public static string logFile = appPath + "\\log.txt";
 
     public static void WriteLine(string logMessage)
     {
@@ -30,7 +30,7 @@ public static class Logger
         try
         {
             var file = File.ReadAllLines(logFile);
-            int skip = Math.Max(0, file.Count() - 500);
+            int skip = Math.Max(0, file.Count() - 1000);
             File.WriteAllLines(logFile, file.Skip(skip).ToArray());
         }
         catch { }

app/Helpers/OSDBase.cs

@@ -1,10 +1,10 @@
 using System.Drawing.Imaging;
 using System.Runtime.InteropServices;
 
-namespace OSD
+namespace GHelper.Helpers
 {
 
-    class OSDNativeForm : NativeWindow, IDisposable
+    public class OSDNativeForm : NativeWindow, IDisposable
     {
 
         private bool _disposed = false;
@@ -19,11 +19,11 @@ namespace OSD
 
         protected internal void Invalidate()
         {
-            this.UpdateLayeredWindow();
+            UpdateLayeredWindow();
         }
         private void UpdateLayeredWindow()
         {
-            Bitmap bitmap1 = new Bitmap(this.Size.Width, this.Size.Height, PixelFormat.Format32bppArgb);
+            Bitmap bitmap1 = new Bitmap(Size.Width, Size.Height, PixelFormat.Format32bppArgb);
             using (Graphics graphics1 = Graphics.FromImage(bitmap1))
             {
                 Rectangle rectangle1;
@@ -31,27 +31,27 @@ namespace OSD
                 POINT point1;
                 POINT point2;
                 BLENDFUNCTION blendfunction1;
-                rectangle1 = new Rectangle(0, 0, this.Size.Width, this.Size.Height);
+                rectangle1 = new Rectangle(0, 0, Size.Width, Size.Height);
                 PerformPaint(new PaintEventArgs(graphics1, rectangle1));
-                IntPtr ptr1 = User32.GetDC(IntPtr.Zero);
-                IntPtr ptr2 = Gdi32.CreateCompatibleDC(ptr1);
-                IntPtr ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
-                IntPtr ptr4 = Gdi32.SelectObject(ptr2, ptr3);
-                size1.cx = this.Size.Width;
-                size1.cy = this.Size.Height;
-                point1.x = this.Location.X;
-                point1.x = this.Location.X;
-                point1.y = this.Location.Y;
+                nint ptr1 = User32.GetDC(nint.Zero);
+                nint ptr2 = Gdi32.CreateCompatibleDC(ptr1);
+                nint ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
+                nint ptr4 = Gdi32.SelectObject(ptr2, ptr3);
+                size1.cx = Size.Width;
+                size1.cy = Size.Height;
+                point1.x = Location.X;
+                point1.x = Location.X;
+                point1.y = Location.Y;
                 point2.x = 0;
                 point2.y = 0;
                 blendfunction1 = new BLENDFUNCTION();
                 blendfunction1.BlendOp = 0;
                 blendfunction1.BlendFlags = 0;
-                blendfunction1.SourceConstantAlpha = this._alpha;
+                blendfunction1.SourceConstantAlpha = _alpha;
                 blendfunction1.AlphaFormat = 1;
-                User32.UpdateLayeredWindow(base.Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
+                User32.UpdateLayeredWindow(Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
                 Gdi32.SelectObject(ptr2, ptr4);
-                User32.ReleaseDC(IntPtr.Zero, ptr1);
+                User32.ReleaseDC(nint.Zero, ptr1);
                 Gdi32.DeleteObject(ptr3);
                 Gdi32.DeleteDC(ptr2);
             }
@@ -59,25 +59,25 @@ namespace OSD
 
         public virtual void Show()
         {
-            if (base.Handle == IntPtr.Zero) //if handle don't equal to zero - window was created and just hided
-                this.CreateWindowOnly();
-            User32.ShowWindow(base.Handle, User32.SW_SHOWNOACTIVATE);
+            if (Handle == nint.Zero) //if handle don't equal to zero - window was created and just hided
+                CreateWindowOnly();
+            User32.ShowWindow(Handle, User32.SW_SHOWNOACTIVATE);
         }
 
 
         public virtual void Hide()
         {
-            if (base.Handle == IntPtr.Zero)
+            if (Handle == nint.Zero)
                 return;
-            User32.ShowWindow(base.Handle, User32.SW_HIDE);
-            this.DestroyHandle();
+            User32.ShowWindow(Handle, User32.SW_HIDE);
+            DestroyHandle();
         }
 
 
         public virtual void Close()
         {
-            this.Hide();
-            this.Dispose();
+            Hide();
+            Dispose();
         }
 
         private void CreateWindowOnly()
@@ -85,55 +85,55 @@ namespace OSD
 
             CreateParams params1 = new CreateParams();
             params1.Caption = "FloatingNativeWindow";
-            int nX = this._location.X;
-            int nY = this._location.Y;
-            Screen screen1 = Screen.FromHandle(base.Handle);
-            if ((nX + this._size.Width) > screen1.Bounds.Width)
+            int nX = _location.X;
+            int nY = _location.Y;
+            Screen screen1 = Screen.FromHandle(Handle);
+            if (nX + _size.Width > screen1.Bounds.Width)
             {
-                nX = screen1.Bounds.Width - this._size.Width;
+                nX = screen1.Bounds.Width - _size.Width;
             }
-            if ((nY + this._size.Height) > screen1.Bounds.Height)
+            if (nY + _size.Height > screen1.Bounds.Height)
             {
-                nY = screen1.Bounds.Height - this._size.Height;
+                nY = screen1.Bounds.Height - _size.Height;
             }
-            this._location = new Point(nX, nY);
-            Size size1 = this._size;
-            Point point1 = this._location;
+            _location = new Point(nX, nY);
+            Size size1 = _size;
+            Point point1 = _location;
             params1.X = nX;
             params1.Y = nY;
             params1.Height = size1.Height;
             params1.Width = size1.Width;
-            params1.Parent = IntPtr.Zero;
+            params1.Parent = nint.Zero;
             uint ui = User32.WS_POPUP;
             params1.Style = (int)ui;
             params1.ExStyle = User32.WS_EX_TOPMOST | User32.WS_EX_TOOLWINDOW | User32.WS_EX_LAYERED | User32.WS_EX_NOACTIVATE | User32.WS_EX_TRANSPARENT;
-            this.CreateHandle(params1);
-            this.UpdateLayeredWindow();
+            CreateHandle(params1);
+            UpdateLayeredWindow();
         }
 
 
 
         protected virtual void SetBoundsCore(int x, int y, int width, int height)
         {
-            if (((this.X != x) || (this.Y != y)) || ((this.Width != width) || (this.Height != height)))
+            if (X != x || Y != y || Width != width || Height != height)
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
                     int num1 = 20;
-                    if ((this.X == x) && (this.Y == y))
+                    if (X == x && Y == y)
                     {
                         num1 |= 2;
                     }
-                    if ((this.Width == width) && (this.Height == height))
+                    if (Width == width && Height == height)
                     {
                         num1 |= 1;
                     }
-                    User32.SetWindowPos(base.Handle, IntPtr.Zero, x, y, width, height, (uint)num1);
+                    User32.SetWindowPos(Handle, nint.Zero, x, y, width, height, (uint)num1);
                 }
                 else
                 {
-                    this.Location = new Point(x, y);
-                    this.Size = new Size(width, height);
+                    Location = new Point(x, y);
+                    Size = new Size(width, height);
                 }
             }
         }
@@ -147,20 +147,20 @@ namespace OSD
         /// </summary>
         public virtual Point Location
         {
-            get { return this._location; }
+            get { return _location; }
             set
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
-                    this.SetBoundsCore(value.X, value.Y, this._size.Width, this._size.Height);
+                    SetBoundsCore(value.X, value.Y, _size.Width, _size.Height);
                     RECT rect = new RECT();
-                    User32.GetWindowRect(base.Handle, ref rect);
-                    this._location = new Point(rect.left, rect.top);
-                    this.UpdateLayeredWindow();
+                    User32.GetWindowRect(Handle, ref rect);
+                    _location = new Point(rect.left, rect.top);
+                    UpdateLayeredWindow();
                 }
                 else
                 {
-                    this._location = value;
+                    _location = value;
                 }
             }
         }
@@ -169,20 +169,20 @@ namespace OSD
         /// </summary>
         public virtual Size Size
         {
-            get { return this._size; }
+            get { return _size; }
             set
             {
-                if (base.Handle != IntPtr.Zero)
+                if (Handle != nint.Zero)
                 {
-                    this.SetBoundsCore(this._location.X, this._location.Y, value.Width, value.Height);
+                    SetBoundsCore(_location.X, _location.Y, value.Width, value.Height);
                     RECT rect = new RECT();
-                    User32.GetWindowRect(base.Handle, ref rect);
-                    this._size = new Size(rect.right - rect.left, rect.bottom - rect.top);
-                    this.UpdateLayeredWindow();
+                    User32.GetWindowRect(Handle, ref rect);
+                    _size = new Size(rect.right - rect.left, rect.bottom - rect.top);
+                    UpdateLayeredWindow();
                 }
                 else
                 {
-                    this._size = value;
+                    _size = value;
                 }
             }
         }
@@ -191,10 +191,10 @@ namespace OSD
         /// </summary>
 		public int Height
         {
-            get { return this._size.Height; }
+            get { return _size.Height; }
             set
             {
-                this._size = new Size(this._size.Width, value);
+                _size = new Size(_size.Width, value);
             }
         }
         /// <summary>
@@ -202,10 +202,10 @@ namespace OSD
         /// </summary>
         public int Width
         {
-            get { return this._size.Width; }
+            get { return _size.Width; }
             set
             {
-                this._size = new Size(value, this._size.Height);
+                _size = new Size(value, _size.Height);
             }
         }
         /// <summary>
@@ -213,10 +213,10 @@ namespace OSD
         /// </summary>
 		public int X
         {
-            get { return this._location.X; }
+            get { return _location.X; }
             set
             {
-                this.Location = new Point(value, this.Location.Y);
+                Location = new Point(value, Location.Y);
             }
         }
         /// <summary>
@@ -224,10 +224,10 @@ namespace OSD
         /// </summary>
         public int Y
         {
-            get { return this._location.Y; }
+            get { return _location.Y; }
             set
             {
-                this.Location = new Point(this.Location.X, value);
+                Location = new Point(Location.X, value);
             }
         }
         /// <summary>
@@ -237,7 +237,7 @@ namespace OSD
         {
             get
             {
-                return new Rectangle(new Point(0, 0), this._size);
+                return new Rectangle(new Point(0, 0), _size);
             }
         }
         /// <summary>
@@ -245,12 +245,12 @@ namespace OSD
         /// </summary>
 		public byte Alpha
         {
-            get { return this._alpha; }
+            get { return _alpha; }
             set
             {
-                if (this._alpha == value) return;
-                this._alpha = value;
-                this.UpdateLayeredWindow();
+                if (_alpha == value) return;
+                _alpha = value;
+                UpdateLayeredWindow();
             }
         }
         #endregion
@@ -258,15 +258,15 @@ namespace OSD
         #region IDisposable Members
         public void Dispose()
         {
-            this.Dispose(true);
+            Dispose(true);
             GC.SuppressFinalize(this);
         }
         private void Dispose(bool disposing)
         {
-            if (!this._disposed)
+            if (!_disposed)
             {
-                this.DestroyHandle();
-                this._disposed = true;
+                DestroyHandle();
+                _disposed = true;
             }
         }
         #endregion
@@ -299,16 +299,16 @@ namespace OSD
     {
         public uint cbSize;
         public uint dwFlags;
-        public IntPtr hWnd;
+        public nint hWnd;
         public uint dwHoverTime;
     }
     [StructLayout(LayoutKind.Sequential)]
     internal struct MSG
     {
-        public IntPtr hwnd;
+        public nint hwnd;
         public int message;
-        public IntPtr wParam;
-        public IntPtr lParam;
+        public nint wParam;
+        public nint lParam;
         public int time;
         public int pt_x;
         public int pt_y;
@@ -345,69 +345,69 @@ namespace OSD
         {
         }
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool AnimateWindow(IntPtr hWnd, uint dwTime, uint dwFlags);
+        internal static extern bool AnimateWindow(nint hWnd, uint dwTime, uint dwFlags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT pt);
+        internal static extern bool ClientToScreen(nint 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);
+        internal static extern bool DrawFocusRect(nint hWnd, ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetDC(IntPtr hWnd);
+        internal static extern nint GetDC(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetFocus();
+        internal static extern nint GetFocus();
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern ushort GetKeyState(int virtKey);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool GetMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetParent(IntPtr hWnd);
+        internal static extern nint GetParent(nint hWnd);
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
-        public static extern bool GetClientRect(IntPtr hWnd, [In, Out] ref RECT rect);
+        public static extern bool GetClientRect(nint hWnd, [In, Out] ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+        internal static extern int GetWindowLong(nint hWnd, int nIndex);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr GetWindow(IntPtr hWnd, int cmd);
+        internal static extern nint GetWindow(nint hWnd, int cmd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
+        internal static extern bool GetWindowRect(nint hWnd, ref RECT rect);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool HideCaret(IntPtr hWnd);
+        internal static extern bool HideCaret(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool InvalidateRect(IntPtr hWnd, ref RECT rect, bool erase);
+        internal static extern bool InvalidateRect(nint hWnd, ref RECT rect, bool erase);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr LoadCursor(IntPtr hInstance, uint cursor);
+        internal static extern nint LoadCursor(nint hInstance, uint cursor);
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
-        public static extern int MapWindowPoints(IntPtr hWndFrom, IntPtr hWndTo, [In, Out] ref RECT rect, int cPoints);
+        public static extern int MapWindowPoints(nint hWndFrom, nint hWndTo, [In, Out] ref RECT rect, int cPoints);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint);
+        internal static extern bool MoveWindow(nint hWnd, int x, int y, int width, int height, bool repaint);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool PeekMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax, uint wFlag);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool PostMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        internal static extern bool PostMessage(nint hWnd, int Msg, uint wParam, uint lParam);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool ReleaseCapture();
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
+        internal static extern int ReleaseDC(nint hWnd, nint hDC);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ScreenToClient(IntPtr hWnd, ref POINT pt);
+        internal static extern bool ScreenToClient(nint hWnd, ref POINT pt);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern uint SendMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
+        internal static extern uint SendMessage(nint hWnd, int Msg, uint wParam, uint lParam);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SetCursor(IntPtr hCursor);
+        internal static extern nint SetCursor(nint hCursor);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SetFocus(IntPtr hWnd);
+        internal static extern nint SetFocus(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int newLong);
+        internal static extern int SetWindowLong(nint hWnd, int nIndex, int newLong);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SetWindowPos(IntPtr hWnd, IntPtr hWndAfter, int X, int Y, int Width, int Height, uint flags);
+        internal static extern int SetWindowPos(nint hWnd, nint hWndAfter, int X, int Y, int Width, int Height, uint flags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw);
+        internal static extern bool SetWindowRgn(nint hWnd, nint hRgn, bool redraw);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool ShowCaret(IntPtr hWnd);
+        internal static extern bool ShowCaret(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool SetCapture(IntPtr hWnd);
+        internal static extern bool SetCapture(nint hWnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern int ShowWindow(IntPtr hWnd, short cmdShow);
+        internal static extern int ShowWindow(nint hWnd, short cmdShow);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool SystemParametersInfo(uint uiAction, uint uiParam, ref int bRetValue, uint fWinINI);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
@@ -415,9 +415,9 @@ namespace OSD
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool TranslateMessage(ref MSG msg);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref POINT pptDst, ref SIZE psize, IntPtr hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
+        internal static extern bool UpdateLayeredWindow(nint hwnd, nint hdcDst, ref POINT pptDst, ref SIZE psize, nint hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool UpdateWindow(IntPtr hwnd);
+        internal static extern bool UpdateWindow(nint hwnd);
         [DllImport("User32.dll", CharSet = CharSet.Auto)]
         internal static extern bool WaitMessage();
         [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
@@ -431,25 +431,25 @@ namespace OSD
         {
         }
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);
+        internal static extern int CombineRgn(nint dest, nint src1, nint src2, int flags);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateBrushIndirect(ref LOGBRUSH brush);
+        internal static extern nint CreateBrushIndirect(ref LOGBRUSH brush);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateCompatibleDC(IntPtr hDC);
+        internal static extern nint CreateCompatibleDC(nint hDC);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr CreateRectRgnIndirect(ref RECT rect);
+        internal static extern nint CreateRectRgnIndirect(ref RECT rect);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool DeleteDC(IntPtr hDC);
+        internal static extern bool DeleteDC(nint hDC);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr DeleteObject(IntPtr hObject);
+        internal static extern nint DeleteObject(nint hObject);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int GetClipBox(IntPtr hDC, ref RECT rectBox);
+        internal static extern int GetClipBox(nint hDC, ref RECT rectBox);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern bool PatBlt(IntPtr hDC, int x, int y, int width, int height, uint flags);
+        internal static extern bool PatBlt(nint hDC, int x, int y, int width, int height, uint flags);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
+        internal static extern int SelectClipRgn(nint hDC, nint hRgn);
         [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
-        internal static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
+        internal static extern nint SelectObject(nint hDC, nint hObject);
     }
     [StructLayout(LayoutKind.Sequential)]
     public struct LOGBRUSH

app/Helpers/OptimizationService.cs

@@ -0,0 +1,112 @@
+using Microsoft.Win32;
+using System.Diagnostics;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace GHelper.Helpers
+{
+    public static class OptimizationService
+    {
+
+        static List<string> services = new() {
+                "ArmouryCrateControlInterface",
+                "ASUSOptimization",
+                "AsusAppService",
+                "ASUSLinkNear",
+                "ASUSLinkRemote",
+                "ASUSSoftwareManager",
+                "ASUSSwitch",
+                "ASUSSystemAnalysis",
+                "ASUSSystemDiagnosis",
+                "AsusCertService"
+        };
+
+        public static void SetChargeLimit(int newValue)
+        {
+            // Set the path to the .ini file
+            string path = @"C:\ProgramData\ASUS\ASUS System Control Interface\ASUSOptimization\Customization.ini";
+
+
+            // Make a backup copy of the INI file
+            string backupPath = path + ".bak";
+            File.Copy(path, backupPath, true);
+
+            string fileContents = File.ReadAllText(path, Encoding.Unicode);
+
+            // Find the section [BatteryHealthCharging]
+            string sectionPattern = @"\[BatteryHealthCharging\]\s*(version=\d+)?\s+value=(\d+)";
+            Match sectionMatch = Regex.Match(fileContents, sectionPattern);
+            if (sectionMatch.Success)
+            {
+                // Replace the value with the new value
+                string oldValueString = sectionMatch.Groups[2].Value;
+                int oldValue = int.Parse(oldValueString);
+                string newSection = sectionMatch.Value.Replace($"value={oldValue}", $"value={newValue}");
+
+                // Replace the section in the file contents
+                fileContents = fileContents.Replace(sectionMatch.Value, newSection);
+
+                File.WriteAllText(path, fileContents, Encoding.Unicode);
+            }
+        }
+
+        public static bool IsRunning()
+        {
+            return Process.GetProcessesByName("AsusOptimization").Count() > 0;
+        }
+
+        public static bool IsOSDRunning()
+        {
+            return Process.GetProcessesByName("AsusOSD").Count() > 0;
+        }
+
+
+        public static int GetRunningCount()
+        {
+            int count = 0;
+            foreach (string service in services)
+            {
+                if (Process.GetProcessesByName(service).Count() > 0) count++;
+            }
+            return count;
+        }
+
+
+        public static void SetBacklightOffDelay(int value = 60)
+        {
+            try
+            {
+                RegistryKey myKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\ASUS\ASUS System Control Interface\AsusOptimization\ASUS Keyboard Hotkeys", true);
+                if (myKey != null)
+                {
+                    myKey.SetValue("TurnOffKeybdLight", value, RegistryValueKind.DWord);
+                    myKey.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
+        }
+
+
+
+        public static void StopAsusServices()
+        {
+            foreach (string service in services)
+            {
+                ProcessHelper.StopDisableService(service);
+            }
+        }
+
+        public static void StartAsusServices()
+        {
+            foreach (string service in services)
+            {
+                ProcessHelper.StartEnableService(service);
+            }
+        }
+
+    }
+
+}

app/Helpers/ProcessHelper.cs

@@ -0,0 +1,146 @@
+using System.Diagnostics;
+using System.Security.Principal;
+
+namespace GHelper.Helpers
+{
+    public static class ProcessHelper
+    {
+        private static long lastAdmin;
+
+        public static void CheckAlreadyRunning()
+        {
+            Process currentProcess = Process.GetCurrentProcess();
+            Process[] processes = Process.GetProcessesByName(currentProcess.ProcessName);
+
+            if (processes.Length > 1)
+            {
+                foreach (Process process in processes)
+                    if (process.Id != currentProcess.Id)
+                        try
+                        {
+                            process.Kill();
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.WriteLine(ex.ToString());
+                            MessageBox.Show(Properties.Strings.AppAlreadyRunningText, Properties.Strings.AppAlreadyRunning, MessageBoxButtons.OK);
+                            Application.Exit();
+                            return;
+                        }
+            }
+        }
+
+        public static bool IsUserAdministrator()
+        {
+            WindowsIdentity identity = WindowsIdentity.GetCurrent();
+            WindowsPrincipal principal = new WindowsPrincipal(identity);
+            return principal.IsInRole(WindowsBuiltInRole.Administrator);
+        }
+
+        public static void RunAsAdmin(string? param = null)
+        {
+
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAdmin) < 2000) return;
+            lastAdmin = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
+            // Check if the current user is an administrator
+            if (!IsUserAdministrator())
+            {
+                ProcessStartInfo startInfo = new ProcessStartInfo();
+                startInfo.UseShellExecute = true;
+                startInfo.WorkingDirectory = Environment.CurrentDirectory;
+                startInfo.FileName = Application.ExecutablePath;
+                startInfo.Arguments = param;
+                startInfo.Verb = "runas";
+                try
+                {
+                    Process.Start(startInfo);
+                    Application.Exit();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+            }
+        }
+
+
+        public static void KillByName(string name)
+        {
+            foreach (var process in Process.GetProcessesByName(name))
+            {
+                try
+                {
+                    process.Kill();
+                    Logger.WriteLine($"Stopped: {process.ProcessName}");
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
+                }
+            }
+        }
+
+        public static void KillByProcess(Process process)
+        {
+            try
+            {
+                process.Kill();
+                Logger.WriteLine($"Stopped: {process.ProcessName}");
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
+            }
+        }
+
+        public static void StopDisableService(string serviceName)
+        {
+            try
+            {
+                string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType Disabled";
+                Logger.WriteLine(script);
+                RunCMD("powershell", script);
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        public static void StartEnableService(string serviceName)
+        {
+            try
+            {
+                string script = $"Set-Service -Name \"{serviceName}\" -Status running -StartupType Automatic";
+                Logger.WriteLine(script);
+                RunCMD("powershell", script);
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        public static void RunCMD(string name, string args)
+        {
+            var cmd = new Process();
+            cmd.StartInfo.UseShellExecute = false;
+            cmd.StartInfo.CreateNoWindow = true;
+            cmd.StartInfo.RedirectStandardOutput = true;
+            cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+            cmd.StartInfo.FileName = name;
+            cmd.StartInfo.Arguments = args;
+            cmd.Start();
+
+            string result = cmd.StandardOutput.ReadToEnd().Replace(Environment.NewLine, " ").Trim(' ');
+
+            Logger.WriteLine(args);
+            Logger.WriteLine(result);
+            
+            cmd.WaitForExit();
+        }
+
+
+    }
+}

app/Helpers/Startup.cs

@@ -1,4 +1,4 @@
-using GHelper;
+using GHelper.Helpers;
 using Microsoft.Win32.TaskScheduler;
 using System.Diagnostics;
 using System.Security.Principal;
@@ -14,6 +14,15 @@ public class Startup
         return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
     }
 
+    public static void ReScheduleAdmin()
+    {
+        if (ProcessHelper.IsUserAdministrator() && IsScheduled())
+        {
+            UnSchedule();
+            Schedule();
+        }
+    }
+
     public static void Schedule()
     {
 
@@ -25,11 +34,12 @@ public class Startup
 
         using (TaskDefinition td = TaskService.Instance.NewTask())
         {
+
             td.RegistrationInfo.Description = "G-Helper Auto Start";
-            td.Triggers.Add(new LogonTrigger { UserId = userId });
+            td.Triggers.Add(new LogonTrigger { UserId = userId, Delay = TimeSpan.FromSeconds(1) });
             td.Actions.Add(strExeFilePath);
 
-            if (Program.IsUserAdministrator()) 
+            if (ProcessHelper.IsUserAdministrator()) 
                 td.Principal.RunLevel = TaskRunLevel.Highest;
 
             td.Settings.StopIfGoingOnBatteries = false;
@@ -45,10 +55,10 @@ public class Startup
             }
             catch (Exception e)
             {
-                if (Program.IsUserAdministrator())
+                if (ProcessHelper.IsUserAdministrator())
                     MessageBox.Show("Can't create a start up task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
-                else 
-                    Program.RunAsAdmin();
+                else
+                    ProcessHelper.RunAsAdmin();
             }
         }
 
@@ -64,10 +74,10 @@ public class Startup
             }
             catch (Exception e)
             {
-                if (Program.IsUserAdministrator())
+                if (ProcessHelper.IsUserAdministrator())
                     MessageBox.Show("Can't remove task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
                 else
-                    Program.RunAsAdmin();
+                    ProcessHelper.RunAsAdmin();
             }
         }
     }

app/Helpers/ToastForm.cs

@@ -0,0 +1,166 @@
+using System.Drawing.Drawing2D;
+
+namespace GHelper.Helpers
+{
+
+    static class Drawing
+    {
+
+        public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
+        {
+            int diameter = radius * 2;
+            Size size = new Size(diameter, diameter);
+            Rectangle arc = new Rectangle(bounds.Location, size);
+            GraphicsPath path = new GraphicsPath();
+
+            if (radius == 0)
+            {
+                path.AddRectangle(bounds);
+                return path;
+            }
+
+            path.AddArc(arc, 180, 90);
+            arc.X = bounds.Right - diameter;
+            path.AddArc(arc, 270, 90);
+            arc.Y = bounds.Bottom - diameter;
+            path.AddArc(arc, 0, 90);
+            arc.X = bounds.Left;
+            path.AddArc(arc, 90, 90);
+            path.CloseFigure();
+            return path;
+        }
+
+        public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
+        {
+            using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
+            {
+                graphics.FillPath(brush, path);
+            }
+        }
+    }
+
+    public enum ToastIcon
+    {
+        BrightnessUp,
+        BrightnessDown,
+        BacklightUp,
+        BacklightDown,
+        Touchpad,
+        Microphone,
+        MicrophoneMute,
+        FnLock,
+        Battery,
+        Charger
+    }
+
+    public class ToastForm : OSDNativeForm
+    {
+
+        protected static string toastText = "Balanced";
+        protected static ToastIcon? toastIcon = null;
+
+        protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
+
+        public ToastForm()
+        {
+            timer.Tick += timer_Tick;
+            timer.Enabled = false;
+            timer.Interval = 2000;
+        }
+
+        protected override void PerformPaint(PaintEventArgs e)
+        {
+            Brush brush = new SolidBrush(Color.FromArgb(150, Color.Black));
+            e.Graphics.FillRoundedRectangle(brush, Bound, 10);
+
+            StringFormat format = new StringFormat();
+            format.LineAlignment = StringAlignment.Center;
+            format.Alignment = StringAlignment.Center;
+
+            Bitmap? icon = null;
+
+            switch (toastIcon)
+            {
+                case ToastIcon.BrightnessUp:
+                    icon = Properties.Resources.brightness_up;
+                    break;
+                case ToastIcon.BrightnessDown:
+                    icon = Properties.Resources.brightness_down;
+                    break;
+                case ToastIcon.BacklightUp:
+                    icon = Properties.Resources.backlight_up;
+                    break;
+                case ToastIcon.BacklightDown:
+                    icon = Properties.Resources.backlight_down;
+                    break;
+                case ToastIcon.Microphone:
+                    icon = Properties.Resources.icons8_microphone_96;
+                    break;
+                case ToastIcon.MicrophoneMute:
+                    icon = Properties.Resources.icons8_mute_unmute_96;
+                    break;
+                case ToastIcon.Touchpad:
+                    icon = Properties.Resources.icons8_touchpad_96;
+                    break;
+                case ToastIcon.FnLock:
+                    icon = Properties.Resources.icons8_function;
+                    break;
+                case ToastIcon.Battery:
+                    icon = Properties.Resources.icons8_charged_battery_96;
+                    break;
+                case ToastIcon.Charger:
+                    icon = Properties.Resources.icons8_charging_battery_96;
+                    break;
+
+            }
+
+            int shiftX = 0;
+
+            if (icon is not null)
+            {
+                e.Graphics.DrawImage(icon, 18, 18, 64, 64);
+                shiftX = 40;
+            }
+
+            e.Graphics.DrawString(toastText,
+                new Font("Segoe UI", 36f, FontStyle.Bold, GraphicsUnit.Pixel),
+                new SolidBrush(Color.White),
+                new PointF(Bound.Width / 2 + shiftX, Bound.Height / 2),
+            format);
+
+        }
+
+        public void RunToast(string text, ToastIcon? icon = null)
+        {
+
+            if (AppConfig.Is("disable_osd")) return;
+
+            Program.settingsForm.Invoke(delegate
+            {
+                //Hide();
+                timer.Stop();
+
+                toastText = text;
+                toastIcon = icon;
+
+                Screen screen1 = Screen.FromHandle(Handle);
+
+                Width = Math.Max(300, 100 + toastText.Length * 22);
+                Height = 100;
+                X = (screen1.Bounds.Width - Width) / 2;
+                Y = screen1.Bounds.Height - 300 - Height;
+
+                Show();
+                timer.Start();
+            });
+
+        }
+
+        private void timer_Tick(object? sender, EventArgs e)
+        {
+            //Debug.WriteLine("Toast end");
+            Hide();
+            timer.Stop();
+        }
+    }
+}

app/Input/InputDispatcher.cs

@@ -0,0 +1,707 @@
+using GHelper.Display;
+using GHelper.Helpers;
+using GHelper.Mode;
+using Microsoft.Win32;
+using System.Diagnostics;
+using System.Management;
+
+namespace GHelper.Input
+{
+
+    public class InputDispatcher
+    {
+        System.Timers.Timer timer = new System.Timers.Timer(1000);
+        public static bool backlightActivity = true;
+
+        public static Keys keyProfile = Keys.F5;
+        public static Keys keyApp = Keys.F12;
+
+        static ModeControl modeControl = Program.modeControl;
+        static ScreenControl screenControl = new ScreenControl();
+
+        static bool isTUF = AppConfig.IsTUF();
+
+        KeyboardListener listener;
+        KeyboardHook hook = new KeyboardHook();
+
+        public InputDispatcher()
+        {
+
+            byte[] result = Program.acpi.DeviceInit();
+            Debug.WriteLine($"Init: {BitConverter.ToString(result)}");
+
+            Program.acpi.SubscribeToEvents(WatcherEventArrived);
+            //Task.Run(Program.acpi.RunListener);
+
+            hook.KeyPressed += new EventHandler<KeyPressedEventArgs>(KeyPressed);
+
+            RegisterKeys();
+
+            timer.Elapsed += Timer_Elapsed;
+
+        }
+
+        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (GetBacklight() == 0) return;
+
+            TimeSpan iddle = NativeMethods.GetIdleTime();
+            int kb_timeout;
+
+            if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
+                kb_timeout = AppConfig.Get("keyboard_ac_timeout", 0);
+            else
+                kb_timeout = AppConfig.Get("keyboard_timeout", 60);
+
+            if (kb_timeout == 0) return;
+
+            if (backlightActivity && iddle.TotalSeconds > kb_timeout)
+            {
+                backlightActivity = false;
+                AsusUSB.ApplyBrightness(0, "Timeout");
+            }
+
+            if (!backlightActivity && iddle.TotalSeconds < kb_timeout)
+            {
+                backlightActivity = true;
+                SetBacklightAuto();
+            }
+
+            //Debug.WriteLine(iddle.TotalSeconds);
+        }
+
+        public void Init()
+        {
+            if (listener is not null) listener.Dispose();
+
+            Program.acpi.DeviceInit();
+
+            if (!OptimizationService.IsRunning())
+                listener = new KeyboardListener(HandleEvent);
+            else
+                Logger.WriteLine("Optimization service is running");
+
+            InitBacklightTimer();
+        }
+
+        public void InitBacklightTimer()
+        {
+            timer.Enabled = AppConfig.Get("keyboard_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online ||
+                            AppConfig.Get("keyboard_ac_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
+        }
+
+
+
+        public void RegisterKeys()
+        {
+            hook.UnregisterAll();
+
+            // CTRL + SHIFT + F5 to cycle profiles
+            if (AppConfig.Get("keybind_profile") != -1) keyProfile = (Keys)AppConfig.Get("keybind_profile");
+            if (AppConfig.Get("keybind_app") != -1) keyApp = (Keys)AppConfig.Get("keybind_app");
+
+            string actionM1 = AppConfig.GetString("m1");
+            string actionM2 = AppConfig.GetString("m2");
+
+            if (keyProfile != Keys.None)
+            {
+                hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyProfile);
+                hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control | ModifierKeys.Alt, keyProfile);
+            }
+
+            if (keyApp != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyApp);
+
+            if (!AppConfig.Is("skip_hotkeys"))
+            {
+                hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeDown);
+                hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeUp);
+                hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeDown);
+                hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeUp);
+                hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, Keys.F20);
+            }
+
+            if (!AppConfig.IsZ13() && !AppConfig.IsAlly())
+            {
+                if (actionM1 is not null && actionM1.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeDown);
+                if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
+            }
+
+            // FN-Lock group
+
+            if (AppConfig.Is("fn_lock") && !AppConfig.ContainsModel("VivoBook"))
+                for (Keys i = Keys.F1; i <= Keys.F11; i++) hook.RegisterHotKey(ModifierKeys.None, i);
+
+            // Arrow-lock group
+            if (AppConfig.Is("arrow_lock") && AppConfig.IsDUO())
+            {
+                hook.RegisterHotKey(ModifierKeys.None, Keys.Left);
+                hook.RegisterHotKey(ModifierKeys.None, Keys.Right);
+                hook.RegisterHotKey(ModifierKeys.None, Keys.Up);
+                hook.RegisterHotKey(ModifierKeys.None, Keys.Down);
+            }
+
+        }
+
+        static void CustomKey(string configKey = "m3")
+        {
+            string command = AppConfig.GetString(configKey + "_custom");
+            int intKey;
+
+            try
+            {
+                intKey = Convert.ToInt32(command, 16);
+            }
+            catch
+            {
+                intKey = -1;
+            }
+
+
+            if (intKey > 0)
+                KeyboardHook.KeyPress((Keys)intKey);
+            else
+                LaunchProcess(command);
+
+        }
+
+
+        static void SetBrightness(int delta)
+        {
+            int brightness = -1;
+            
+            if (isTUF) brightness = ScreenBrightness.Get();
+            if (AppConfig.SwappedBrightness()) delta = -delta;
+
+            Program.acpi.DeviceSet(AsusACPI.UniversalControl, delta > 0 ? AsusACPI.Brightness_Up : AsusACPI.Brightness_Down, "Brightness");
+
+            if (isTUF)
+            {
+                if (AppConfig.SwappedBrightness()) return;
+                if (delta < 0 && brightness <= 0) return;
+                if (delta > 0 && brightness >= 100) return;
+
+                Thread.Sleep(100);
+                if (brightness == ScreenBrightness.Get())
+                    Program.toast.RunToast(ScreenBrightness.Adjust(delta) + "%", (delta < 0 ) ? ToastIcon.BrightnessDown : ToastIcon.BrightnessUp);
+            }
+
+        }
+
+        public void KeyPressed(object sender, KeyPressedEventArgs e)
+        {
+
+            if (e.Modifier == ModifierKeys.None)
+            {
+                Logger.WriteLine(e.Key.ToString());
+
+                if (AppConfig.NoMKeys())
+                {
+                    switch (e.Key)
+                    {
+                        case Keys.F2:
+                            KeyboardHook.KeyPress(Keys.VolumeDown);
+                            return;
+                        case Keys.F3:
+                            KeyboardHook.KeyPress(Keys.VolumeUp);
+                            return;
+                        case Keys.F4:
+                            KeyProcess("m3");
+                            return;
+                    }
+                }
+
+                if (AppConfig.IsZ13() || AppConfig.IsDUO())
+                {
+                    switch (e.Key)
+                    {
+                        case Keys.F11:
+                            HandleEvent(199);
+                            return;
+                    }
+                }
+
+                if (AppConfig.NoAura())
+                {
+                    switch (e.Key)
+                    {
+                        case Keys.F2:
+                            KeyboardHook.KeyPress(Keys.MediaPreviousTrack);
+                            return;
+                        case Keys.F3:
+                            KeyboardHook.KeyPress(Keys.MediaPlayPause);
+                            return;
+                        case Keys.F4:
+                            KeyboardHook.KeyPress(Keys.MediaNextTrack);
+                            return;
+                    }
+                }
+
+
+                switch (e.Key)
+                {
+                    case Keys.F1:
+                        KeyboardHook.KeyPress(Keys.VolumeMute);
+                        break;
+                    case Keys.F2:
+                        SetBacklight(-1, true);
+                        break;
+                    case Keys.F3:
+                        SetBacklight(1, true);
+                        break;
+                    case Keys.F4:
+                        KeyProcess("fnf4");
+                        break;
+                    case Keys.F5:
+                        KeyProcess("fnf5");
+                        break;
+                    case Keys.F6:
+                        KeyboardHook.KeyPress(Keys.Snapshot);
+                        break;
+                    case Keys.F7:
+                        SetBrightness(-10);
+                        break;
+                    case Keys.F8:
+                        SetBrightness(+10);
+                        break;
+                    case Keys.F9:
+                        KeyboardHook.KeyWinPress(Keys.P);
+                        break;
+                    case Keys.F10:
+                        HandleOptimizationEvent(107);
+                        break;
+                    case Keys.F11:
+                        HandleOptimizationEvent(108);
+                        break;
+                    case Keys.F12:
+                        KeyboardHook.KeyWinPress(Keys.A);
+                        break;
+                    case Keys.VolumeDown:
+                        KeyProcess("m1");
+                        break;
+                    case Keys.VolumeUp:
+                        KeyProcess("m2");
+                        break;
+                    case Keys.Left:
+                        KeyboardHook.KeyPress(Keys.Home);
+                        break;
+                    case Keys.Right:
+                        KeyboardHook.KeyPress(Keys.End);
+                        break;
+                    case Keys.Up:
+                        KeyboardHook.KeyPress(Keys.PageUp);
+                        break;
+                    case Keys.Down:
+                        KeyboardHook.KeyPress(Keys.PageDown);
+                        break;
+                    default:
+                        break;
+                }
+
+            }
+
+            if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift))
+            {
+                if (e.Key == keyProfile) modeControl.CyclePerformanceMode();
+                if (e.Key == keyApp) Program.SettingsToggle();
+                if (e.Key == Keys.F20) KeyProcess("m3");
+            }
+
+            if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift | ModifierKeys.Alt))
+            {
+                if (e.Key == keyProfile) modeControl.CyclePerformanceMode(true);
+            }
+
+            if (e.Modifier == (ModifierKeys.Control))
+            {
+                switch (e.Key)
+                {
+                    case Keys.VolumeDown:
+                        // Screen brightness down on CTRL+VolDown
+                        SetBrightness(-10);
+                        break;
+                    case Keys.VolumeUp:
+                        // Screen brightness up on CTRL+VolUp
+                        SetBrightness(+10);
+                        break;
+                }
+            }
+
+            if (e.Modifier == (ModifierKeys.Shift))
+            {
+                switch (e.Key)
+                {
+                    case Keys.VolumeDown:
+                        // Keyboard backlight down on SHIFT+VolDown
+                        SetBacklight(-1);
+                        break;
+                    case Keys.VolumeUp:
+                        // Keyboard backlight up on SHIFT+VolUp
+                        SetBacklight(1);
+                        break;
+                }
+            }
+        }
+
+
+        public static void KeyProcess(string name = "m3")
+        {
+            string action = AppConfig.GetString(name);
+
+            if (action is null || action.Length <= 1)
+            {
+                if (name == "m4")
+                    action = "ghelper";
+                if (name == "fnf4")
+                    action = "aura";
+                if (name == "fnf5")
+                    action = "performance";
+                if (name == "m3" && !OptimizationService.IsRunning())
+                    action = "micmute";
+                if (name == "fnc")
+                    action = "fnlock";
+                if (name == "fne")
+                    action = "calculator";
+            }
+
+            switch (action)
+            {
+                case "mute":
+                    KeyboardHook.KeyPress(Keys.VolumeMute);
+                    break;
+                case "play":
+                    KeyboardHook.KeyPress(Keys.MediaPlayPause);
+                    break;
+                case "screenshot":
+                    KeyboardHook.KeyPress(Keys.Snapshot);
+                    break;
+                case "screen":
+                    Logger.WriteLine("Screen off toggle");
+                    NativeMethods.TurnOffScreen();
+                    break;
+                case "miniled":
+                    screenControl.ToogleMiniled();
+                    break;
+                case "aura":
+                    Program.settingsForm.BeginInvoke(Program.settingsForm.CycleAuraMode);
+                    break;
+                case "performance":
+                    modeControl.CyclePerformanceMode(Control.ModifierKeys == Keys.Shift);
+                    break;
+                case "ghelper":
+                    Program.settingsForm.BeginInvoke(delegate
+                    {
+                        Program.SettingsToggle();
+                    });
+                    break;
+                case "fnlock":
+                    ToggleFnLock();
+                    break;
+                case "micmute":
+                    bool muteStatus = Audio.ToggleMute();
+                    Program.toast.RunToast(muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
+                    if (AppConfig.IsVivobook()) Program.acpi.DeviceSet(AsusACPI.MICMUTE_LED, muteStatus ? 1 : 0, "MicmuteLed");
+                    break;
+                case "brightness_up":
+                    SetBrightness(+10);
+                    break;
+                case "brightness_down":
+                    SetBrightness(-10);
+                    break;
+                case "screenpad_up":
+                    SetScreenpad(10);
+                    break;
+                case "screenpad_down":
+                    SetScreenpad(-10);
+                    break;
+                case "custom":
+                    CustomKey(name);
+                    break;
+                case "calculator":
+                    LaunchProcess("calc");
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        static bool GetTouchpadState()
+        {
+            using (var key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\PrecisionTouchPad\Status", false))
+            {
+                Logger.WriteLine("Touchpad status:" + key?.GetValue("Enabled")?.ToString());
+                return key?.GetValue("Enabled")?.ToString() == "1";
+            }
+        }
+
+        public static void ToggleArrowLock()
+        {
+            int arLock = AppConfig.Is("arrow_lock") ? 0 : 1;
+            AppConfig.Set("arrow_lock", arLock);
+
+            Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
+            Program.toast.RunToast("Arrow-Lock " + (arLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
+        }
+
+        public static void ToggleFnLock()
+        {
+            int fnLock = AppConfig.Is("fn_lock") ? 0 : 1;
+            AppConfig.Set("fn_lock", fnLock);
+
+            if (AppConfig.ContainsModel("VivoBook"))
+                Program.acpi.DeviceSet(AsusACPI.FnLock, fnLock == 1 ? 0 : 1, "FnLock");
+            else
+                Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
+
+            Program.settingsForm.BeginInvoke(Program.settingsForm.VisualiseFnLock);
+
+            Program.toast.RunToast("Fn-Lock " + (fnLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
+        }
+
+        public static void TabletMode()
+        {
+            if (AppConfig.Is("disable_tablet")) return;
+
+            bool touchpadState = GetTouchpadState();
+            bool tabletState = Program.acpi.DeviceGet(AsusACPI.TabletState) > 0;
+
+            Logger.WriteLine("Tablet: " + tabletState + " Touchpad: " + touchpadState);
+
+            if (tabletState && touchpadState || !tabletState && !touchpadState) AsusUSB.TouchpadToggle();
+
+        }
+
+        static void HandleEvent(int EventID)
+        {
+            // The ROG Ally uses different M-key codes.
+            // We'll special-case the translation of those.
+            if (AppConfig.IsAlly())
+            {
+                switch(EventID)
+                {
+
+                    // This is both the M1 and M2 keys.
+                    // There's a way to differentiate, apparently, but it isn't over USB or any other obvious protocol.
+                    case 165:
+                        KeyProcess("paddle");
+                        return;
+                    // The Command Center ("play-looking") button below the select key.
+                    case 166:
+                        KeyProcess("cc");
+                        return;
+                    // The M4/ROG key.
+                    case 56:
+                        KeyProcess("m4");
+                        return;
+
+                }
+            }
+            // All other devices seem to use the same HID key-codes,
+            // so we can process them all the same.
+            else
+            {
+                switch (EventID)
+                {
+                    case 124:    // M3
+                        KeyProcess("m3");
+                        return;
+                    case 56:    // M4 / Rog button
+                        KeyProcess("m4");
+                        return;
+                    case 55:    // Arconym
+                        KeyProcess("m6");
+                        return;
+                    case 181:    // FN + Numpad Enter
+                        KeyProcess("fne");
+                        return;
+                    case 174:   // FN+F5
+                        modeControl.CyclePerformanceMode(Control.ModifierKeys == Keys.Shift);
+                        return;
+                    case 179:   // FN+F4
+                    case 178:   // FN+F4
+                        KeyProcess("fnf4");
+                        return;
+                    case 158:   // Fn + C
+                        KeyProcess("fnc");
+                        return;
+                    case 78:    // Fn + ESC
+                        ToggleFnLock();
+                        return;
+                    case 75:    // Fn + ESC
+                        ToggleArrowLock();
+                        return;
+                    case 189: // Tablet mode
+                        TabletMode();
+                        return;
+                    case 197: // FN+F2
+                        SetBacklight(-1);
+                        return;
+                    case 196: // FN+F3
+                        SetBacklight(1);
+                        return;
+                    case 199: // ON Z13 - FN+F11 - cycles backlight
+                        SetBacklight(4);
+                        return;
+                    case 53:    // FN+F6 on GA-502DU model
+                        NativeMethods.TurnOffScreen();
+                        return;
+                }
+            }
+
+            if (!OptimizationService.IsRunning())
+                HandleOptimizationEvent(EventID);
+
+        }
+
+        // Asus Optimization service Events 
+        static void HandleOptimizationEvent(int EventID)
+        {
+            switch (EventID)
+            {
+                case 16: // FN+F7
+                    //ScreenBrightness.Adjust(-10);
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
+                    break;
+                case 32: // FN+F8
+                    //ScreenBrightness.Adjust(+10);
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
+                    break;
+                case 107: // FN+F10
+                    AsusUSB.TouchpadToggle();
+                    Thread.Sleep(200);
+                    Program.toast.RunToast(GetTouchpadState() ? "On" : "Off", ToastIcon.Touchpad);
+                    break;
+                case 108: // FN+F11
+                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
+                    break;
+                case 106: // Screenpad button on DUO
+                    SetScreenpad(100);
+                    break;
+
+
+            }
+        }
+
+
+        public static int GetBacklight()
+        {
+            int backlight_power = AppConfig.Get("keyboard_brightness", 1);
+            int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            int backlight;
+
+            //backlight = onBattery ? Math.Min(backlight_battery, backlight_power) : Math.Max(backlight_battery, backlight_power);
+            backlight = onBattery ? backlight_battery : backlight_power;
+
+            return Math.Max(Math.Min(3, backlight), 0);
+        }
+
+        public static void SetBacklightAuto(bool init = false)
+        {
+            if (init) AsusUSB.Init();
+            AsusUSB.ApplyBrightness(GetBacklight(), "Auto", init);
+        }
+
+        public static void SetBacklight(int delta, bool force = false)
+        {
+            int backlight_power = AppConfig.Get("keyboard_brightness", 1);
+            int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            int backlight = onBattery ? backlight_battery : backlight_power;
+
+            if (delta >= 4)
+                backlight = ++backlight % 4;
+            else
+                backlight = Math.Max(Math.Min(3, backlight + delta), 0);
+
+            if (onBattery)
+                AppConfig.Set("keyboard_brightness_ac", backlight);
+            else
+                AppConfig.Set("keyboard_brightness", backlight);
+
+            if (force || !OptimizationService.IsRunning())
+            {
+                AsusUSB.ApplyBrightness(backlight, "HotKey");
+            }
+
+            if (!OptimizationService.IsOSDRunning())
+            {
+                string[] backlightNames = new string[] { "Off", "Low", "Mid", "Max" };
+                Program.toast.RunToast(backlightNames[backlight], delta > 0 ? ToastIcon.BacklightUp : ToastIcon.BacklightDown);
+            }
+
+        }
+
+        public static void SetScreenpad(int delta)
+        {
+            int brightness = AppConfig.Get("screenpad", 100);
+
+            if (delta == 100)
+            {
+                if (brightness < 0) brightness = 100;
+                else if (brightness >= 100) brightness = 0;
+                else brightness = -10;
+
+            } else
+            {
+                brightness = Math.Max(Math.Min(100, brightness + delta), -10);
+            }
+
+            AppConfig.Set("screenpad", brightness);
+
+            if (brightness >= 0) Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, 1, "ScreenpadOn");
+
+            Program.acpi.DeviceSet(AsusACPI.ScreenPadBrightness, Math.Max(brightness * 255 / 100, 0 ), "Screenpad");
+
+            if (brightness < 0)  Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, 0, "ScreenpadOff");
+
+            string toast;
+
+            if (brightness < 0) toast = "Off";
+            else if (brightness == 0) toast = "Hidden";
+            else toast = brightness.ToString() + "%";
+
+            Program.toast.RunToast($"Screen Pad {toast}", delta > 0 ? ToastIcon.BrightnessUp : ToastIcon.BrightnessDown);
+
+        }
+
+
+        static void LaunchProcess(string command = "")
+        {
+
+            try
+            {
+
+                //string executable = command.Split(' ')[0];
+                //string arguments = command.Substring(executable.Length).Trim();
+                ProcessStartInfo startInfo = new ProcessStartInfo("cmd", "/C " + command);
+
+                startInfo.RedirectStandardOutput = true;
+                startInfo.RedirectStandardError = true;
+                startInfo.UseShellExecute = false;
+                startInfo.CreateNoWindow = true;
+
+                startInfo.WorkingDirectory = Environment.CurrentDirectory;
+                //startInfo.Arguments = arguments;
+                Process proc = Process.Start(startInfo);
+            }
+            catch
+            {
+                Logger.WriteLine("Failed to run  " + command);
+            }
+
+
+        }
+
+
+
+        static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
+        {
+            if (e.NewEvent is null) return;
+            int EventID = int.Parse(e.NewEvent["EventID"].ToString());
+            Logger.WriteLine("WMI event " + EventID);
+            HandleEvent(EventID);
+        }
+    }
+}

app/Input/KeyboardHook.cs

@@ -0,0 +1,173 @@
+using System.Runtime.InteropServices;
+
+public sealed class KeyboardHook : IDisposable
+{
+    // Registers a hot key with Windows.
+    [DllImport("user32.dll")]
+    private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
+    // Unregisters the hot key with Windows.
+    [DllImport("user32.dll")]
+    private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+
+    [DllImport("user32.dll")]
+    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
+
+    public const int KEYEVENTF_EXTENDEDKEY = 1;
+    public const int KEYEVENTF_KEYUP = 2;
+    private const byte VK_LWIN = 0x5B;
+
+    public static void KeyPress(Keys key)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+    }
+
+    public static void KeyWinPress(Keys key)
+    {
+        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
+
+
+    /// <summary>
+    /// Represents the window that is used internally to get the messages.
+    /// </summary>
+    private class Window : NativeWindow, IDisposable
+    {
+        private static int WM_HOTKEY = 0x0312;
+        public static Keys? fakeKey;
+
+        public Window()
+        {
+            // create the handle for the window.
+            this.CreateHandle(new CreateParams());
+        }
+
+        /// <summary>
+        /// Overridden to get the notifications.
+        /// </summary>
+        /// <param name="m"></param>
+        protected override void WndProc(ref Message m)
+        {
+            base.WndProc(ref m);
+
+            // check if we got a hot key pressed.
+            if (m.Msg == WM_HOTKEY)
+            {
+                // get the keys.
+                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
+                ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);
+
+                // invoke the event to notify the parent.
+                if (KeyPressed != null)
+                    KeyPressed(this, new KeyPressedEventArgs(modifier, key));
+            }
+        }
+
+        public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            this.DestroyHandle();
+        }
+
+        #endregion
+    }
+
+    private Window _window = new Window();
+    private int _currentId;
+
+    public KeyboardHook()
+    {
+        // register the event of the inner native window.
+        _window.KeyPressed += delegate (object sender, KeyPressedEventArgs args)
+        {
+            if (KeyPressed != null)
+                KeyPressed(this, args);
+        };
+    }
+
+    /// <summary>
+    /// Registers a hot key in the system.
+    /// </summary>
+    /// <param name="modifier">The modifiers that are associated with the hot key.</param>
+    /// <param name="key">The key itself that is associated with the hot key.</param>
+    public void RegisterHotKey(ModifierKeys modifier, Keys key)
+    {
+        // increment the counter.
+        _currentId = _currentId + 1;
+
+        // register the hot key.
+        if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
+            Logger.WriteLine("Couldn’t register " + key);
+    }
+
+    /// <summary>
+    /// A hot key has been pressed.
+    /// </summary>
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    #region IDisposable Members
+
+    public void UnregisterAll()
+    {
+        // unregister all the registered hot keys.
+        for (int i = _currentId; i > 0; i--)
+        {
+            UnregisterHotKey(_window.Handle, i);
+        }
+    }
+
+    public void Dispose()
+    {
+        UnregisterAll();
+        // dispose the inner native window.
+        _window.Dispose();
+    }
+
+    #endregion
+}
+
+/// <summary>
+/// Event Args for the event that is fired after the hot key has been pressed.
+/// </summary>
+public class KeyPressedEventArgs : EventArgs
+{
+    private ModifierKeys _modifier;
+    private Keys _key;
+
+    internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
+    {
+        _modifier = modifier;
+        _key = key;
+    }
+
+    public ModifierKeys Modifier
+    {
+        get { return _modifier; }
+    }
+
+    public Keys Key
+    {
+        get { return _key; }
+    }
+}
+
+/// <summary>
+/// The enumeration of possible modifiers.
+/// </summary>
+[Flags]
+public enum ModifierKeys : uint
+{
+    None = 0,
+    Alt = 1,
+    Control = 2,
+    Shift = 4,
+    Win = 8
+}

app/Input/KeyboardListener.cs

@@ -0,0 +1,69 @@
+using HidLibrary;
+
+namespace GHelper.Input
+{
+    public class KeyboardListener
+    {
+
+        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+
+        public KeyboardListener(Action<int> KeyHandler)
+        {
+            HidDevice? input = AsusUSB.GetDevice();
+            
+            // Fallback
+            if (input == null)
+            {
+                AsusUSB.Init();
+                Thread.Sleep(1000);
+                input = AsusUSB.GetDevice();
+            }
+
+            if (input == null)
+            {
+                Logger.WriteLine($"Input device not found");
+                return;
+            }
+
+            Logger.WriteLine($"Input: {input.DevicePath}");
+
+            var task = Task.Run(() =>
+            {
+                try
+                {
+                    while (!cancellationTokenSource.Token.IsCancellationRequested)
+                    {
+
+                        // Emergency break
+                        if (input == null || !input.IsConnected)
+                        {
+                            Logger.WriteLine("Listener terminated");
+                            break;
+                        }
+
+                        var data = input.Read().Data;
+                        if (data.Length > 1 && data[0] == AsusUSB.INPUT_HID_ID && data[1] > 0 && data[1] != 236)
+                        {
+                            Logger.WriteLine($"Key: {data[1]}");
+                            KeyHandler(data[1]);
+                        }
+                    }
+
+                    Logger.WriteLine("Listener stopped");
+
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+            });
+
+
+        }
+
+        public void Dispose()
+        {
+            cancellationTokenSource?.Cancel();
+        }
+    }
+}

app/Matrix.Designer.cs

@@ -0,0 +1,258 @@
+namespace GHelper
+{
+    partial class Matrix
+    {
+        /// <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()
+        {
+            pictureMatrix = new PictureBox();
+            trackZoom = new TrackBar();
+            buttonPicture = new UI.RButton();
+            panelPicture = new Panel();
+            panelMain = new Panel();
+            panelButtons = new Panel();
+            buttonReset = new UI.RButton();
+            panelScaling = new Panel();
+            comboScaling = new UI.RComboBox();
+            labelScaling = new Label();
+            panelZoom = new Panel();
+            labelZoom = new Label();
+            labelZoomTitle = new Label();
+            ((System.ComponentModel.ISupportInitialize)pictureMatrix).BeginInit();
+            ((System.ComponentModel.ISupportInitialize)trackZoom).BeginInit();
+            panelPicture.SuspendLayout();
+            panelMain.SuspendLayout();
+            panelButtons.SuspendLayout();
+            panelScaling.SuspendLayout();
+            panelZoom.SuspendLayout();
+            SuspendLayout();
+            // 
+            // pictureMatrix
+            // 
+            pictureMatrix.BackColor = Color.Black;
+            pictureMatrix.Cursor = Cursors.SizeAll;
+            pictureMatrix.Location = new Point(731, 27);
+            pictureMatrix.Name = "pictureMatrix";
+            pictureMatrix.Size = new Size(81, 73);
+            pictureMatrix.TabIndex = 0;
+            pictureMatrix.TabStop = false;
+            // 
+            // trackZoom
+            // 
+            trackZoom.LargeChange = 50;
+            trackZoom.Location = new Point(16, 52);
+            trackZoom.Maximum = 200;
+            trackZoom.Minimum = 10;
+            trackZoom.Name = "trackZoom";
+            trackZoom.Size = new Size(782, 90);
+            trackZoom.SmallChange = 10;
+            trackZoom.TabIndex = 2;
+            trackZoom.TickFrequency = 20;
+            trackZoom.TickStyle = TickStyle.TopLeft;
+            trackZoom.Value = 100;
+            // 
+            // buttonPicture
+            // 
+            buttonPicture.Activated = false;
+            buttonPicture.BackColor = SystemColors.ControlLight;
+            buttonPicture.BorderColor = Color.Transparent;
+            buttonPicture.BorderRadius = 5;
+            buttonPicture.FlatAppearance.BorderSize = 0;
+            buttonPicture.FlatStyle = FlatStyle.Flat;
+            buttonPicture.Image = Properties.Resources.icons8_matrix_32;
+            buttonPicture.Location = new Point(16, 19);
+            buttonPicture.Name = "buttonPicture";
+            buttonPicture.Secondary = true;
+            buttonPicture.Size = new Size(258, 56);
+            buttonPicture.TabIndex = 3;
+            buttonPicture.Text = "Picture / Gif";
+            buttonPicture.TextAlign = ContentAlignment.MiddleRight;
+            buttonPicture.TextImageRelation = TextImageRelation.ImageBeforeText;
+            buttonPicture.UseVisualStyleBackColor = false;
+            // 
+            // panelPicture
+            // 
+            panelPicture.BackColor = Color.Black;
+            panelPicture.Controls.Add(pictureMatrix);
+            panelPicture.Dock = DockStyle.Top;
+            panelPicture.Location = new Point(0, 0);
+            panelPicture.Name = "panelPicture";
+            panelPicture.Size = new Size(834, 419);
+            panelPicture.TabIndex = 4;
+            // 
+            // panelMain
+            // 
+            panelMain.Controls.Add(panelButtons);
+            panelMain.Controls.Add(panelScaling);
+            panelMain.Controls.Add(panelZoom);
+            panelMain.Controls.Add(panelPicture);
+            panelMain.Dock = DockStyle.Top;
+            panelMain.Location = new Point(20, 20);
+            panelMain.Name = "panelMain";
+            panelMain.Size = new Size(834, 924);
+            panelMain.TabIndex = 5;
+            // 
+            // panelButtons
+            // 
+            panelButtons.Controls.Add(buttonReset);
+            panelButtons.Controls.Add(buttonPicture);
+            panelButtons.Dock = DockStyle.Top;
+            panelButtons.Location = new Point(0, 642);
+            panelButtons.Name = "panelButtons";
+            panelButtons.Size = new Size(834, 94);
+            panelButtons.TabIndex = 6;
+            // 
+            // buttonReset
+            // 
+            buttonReset.Activated = false;
+            buttonReset.BackColor = SystemColors.ControlLight;
+            buttonReset.BorderColor = Color.Transparent;
+            buttonReset.BorderRadius = 5;
+            buttonReset.FlatAppearance.BorderSize = 0;
+            buttonReset.FlatStyle = FlatStyle.Flat;
+            buttonReset.Image = Properties.Resources.icons8_refresh_32;
+            buttonReset.Location = new Point(290, 19);
+            buttonReset.Name = "buttonReset";
+            buttonReset.Secondary = true;
+            buttonReset.Size = new Size(258, 56);
+            buttonReset.TabIndex = 4;
+            buttonReset.Text = "Reset";
+            buttonReset.TextAlign = ContentAlignment.MiddleRight;
+            buttonReset.TextImageRelation = TextImageRelation.ImageBeforeText;
+            buttonReset.UseVisualStyleBackColor = false;
+            // 
+            // panelScaling
+            // 
+            panelScaling.Controls.Add(comboScaling);
+            panelScaling.Controls.Add(labelScaling);
+            panelScaling.Dock = DockStyle.Top;
+            panelScaling.Location = new Point(0, 564);
+            panelScaling.Name = "panelScaling";
+            panelScaling.Size = new Size(834, 78);
+            panelScaling.TabIndex = 7;
+            // 
+            // comboScaling
+            // 
+            comboScaling.BorderColor = Color.White;
+            comboScaling.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboScaling.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            comboScaling.FormattingEnabled = true;
+            comboScaling.ItemHeight = 32;
+            comboScaling.Items.AddRange(new object[] { "Default", "Low", "High", "Bilinear", "Bicubic", "NearestNeighbor", "HighQualityBilinear", "HighQualityBicubic" });
+            comboScaling.Location = new Point(229, 17);
+            comboScaling.Margin = new Padding(4, 11, 4, 8);
+            comboScaling.Name = "comboScaling";
+            comboScaling.Size = new Size(322, 40);
+            comboScaling.TabIndex = 17;
+            // 
+            // labelScaling
+            // 
+            labelScaling.AutoSize = true;
+            labelScaling.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelScaling.Location = new Point(16, 20);
+            labelScaling.Name = "labelScaling";
+            labelScaling.Size = new Size(185, 32);
+            labelScaling.TabIndex = 4;
+            labelScaling.Text = "Scaling Quality";
+            // 
+            // panelZoom
+            // 
+            panelZoom.AutoSize = true;
+            panelZoom.Controls.Add(labelZoom);
+            panelZoom.Controls.Add(labelZoomTitle);
+            panelZoom.Controls.Add(trackZoom);
+            panelZoom.Dock = DockStyle.Top;
+            panelZoom.Location = new Point(0, 419);
+            panelZoom.Name = "panelZoom";
+            panelZoom.Size = new Size(834, 145);
+            panelZoom.TabIndex = 5;
+            // 
+            // labelZoom
+            // 
+            labelZoom.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelZoom.AutoSize = true;
+            labelZoom.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            labelZoom.Location = new Point(731, 17);
+            labelZoom.Name = "labelZoom";
+            labelZoom.Size = new Size(77, 32);
+            labelZoom.TabIndex = 4;
+            labelZoom.Text = "Zoom";
+            // 
+            // labelZoomTitle
+            // 
+            labelZoomTitle.AutoSize = true;
+            labelZoomTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelZoomTitle.Location = new Point(16, 17);
+            labelZoomTitle.Name = "labelZoomTitle";
+            labelZoomTitle.Size = new Size(81, 32);
+            labelZoomTitle.TabIndex = 3;
+            labelZoomTitle.Text = "Zoom";
+            // 
+            // Matrix
+            // 
+            AutoScaleDimensions = new SizeF(192F, 192F);
+            AutoScaleMode = AutoScaleMode.Dpi;
+            AutoSize = true;
+            ClientSize = new Size(874, 978);
+            Controls.Add(panelMain);
+            MaximizeBox = false;
+            MinimizeBox = false;
+            MinimumSize = new Size(900, 0);
+            Name = "Matrix";
+            Padding = new Padding(20);
+            ShowIcon = false;
+            ShowInTaskbar = false;
+            Text = "Matrix";
+            ((System.ComponentModel.ISupportInitialize)pictureMatrix).EndInit();
+            ((System.ComponentModel.ISupportInitialize)trackZoom).EndInit();
+            panelPicture.ResumeLayout(false);
+            panelMain.ResumeLayout(false);
+            panelMain.PerformLayout();
+            panelButtons.ResumeLayout(false);
+            panelScaling.ResumeLayout(false);
+            panelScaling.PerformLayout();
+            panelZoom.ResumeLayout(false);
+            panelZoom.PerformLayout();
+            ResumeLayout(false);
+        }
+
+        #endregion
+
+        private PictureBox pictureMatrix;
+        private TrackBar trackZoom;
+        private UI.RButton buttonPicture;
+        private Panel panelPicture;
+        private Panel panelMain;
+        private Panel panelZoom;
+        private Label labelZoom;
+        private Label labelZoomTitle;
+        private Panel panelButtons;
+        private UI.RButton buttonReset;
+        private Panel panelScaling;
+        private Label labelScaling;
+        private UI.RComboBox comboScaling;
+    }
+}

app/Matrix.cs

@@ -0,0 +1,211 @@
+using GHelper.AnimeMatrix;
+using GHelper.UI;
+
+namespace GHelper
+{
+    public partial class Matrix : RForm
+    {
+
+        public AniMatrixControl matrixControl = Program.settingsForm.matrixControl;
+
+        private bool Dragging;
+        private int xPos;
+        private int yPos;
+
+        private int baseX;
+        private int baseY;
+
+        private float uiScale;
+
+        Image picture;
+        MemoryStream ms = new MemoryStream();
+
+        public Matrix()
+        {
+            InitializeComponent();
+            InitTheme(true);
+
+            Shown += Matrix_Shown;
+            FormClosing += Matrix_FormClosed;
+
+            buttonPicture.Click += ButtonPicture_Click;
+            buttonReset.Click += ButtonReset_Click;
+
+            pictureMatrix.MouseUp += PictureMatrix_MouseUp;
+            pictureMatrix.MouseMove += PictureMatrix_MouseMove;
+            pictureMatrix.MouseDown += PictureMatrix_MouseDown;
+
+            trackZoom.MouseUp += TrackZoom_MouseUp;
+            trackZoom.ValueChanged += TrackZoom_Changed;
+
+            trackZoom.Value = Math.Min(trackZoom.Maximum, AppConfig.Get("matrix_zoom", 100));
+            VisualiseZoom();
+
+            comboScaling.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboScaling.SelectedIndex = AppConfig.Get("matrix_quality", 0);
+            comboScaling.SelectedValueChanged += ComboScaling_SelectedValueChanged;
+
+            uiScale = panelPicture.Width / matrixControl.device.MaxColumns / 3;
+            panelPicture.Height = (int)(matrixControl.device.MaxRows * uiScale);
+
+        }
+
+        private void ComboScaling_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_quality", comboScaling.SelectedIndex);
+            SetMatrixPicture(false);
+        }
+
+        private void Matrix_FormClosed(object? sender, FormClosingEventArgs e)
+        {
+            if (picture is not null) picture.Dispose();
+            if (ms is not null) ms.Dispose();
+
+            pictureMatrix.Dispose();
+
+            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
+        }
+
+        private void VisualiseZoom()
+        {
+            labelZoom.Text = trackZoom.Value + "%";
+        }
+
+        private void ButtonReset_Click(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_zoom", 100);
+            AppConfig.Set("matrix_x", 0);
+            AppConfig.Set("matrix_y", 0);
+
+            trackZoom.Value = 100;
+
+            SetMatrixPicture();
+
+        }
+
+        private void TrackZoom_MouseUp(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_zoom", trackZoom.Value);
+            SetMatrixPicture();
+        }
+
+        private void TrackZoom_Changed(object? sender, EventArgs e)
+        {
+            VisualiseZoom();
+        }
+
+
+        private void PictureMatrix_MouseDown(object? sender, MouseEventArgs e)
+        {
+            if (e.Button == MouseButtons.Left)
+            {
+                Dragging = true;
+                xPos = e.X;
+                yPos = e.Y;
+            }
+        }
+
+        private void PictureMatrix_MouseMove(object? sender, MouseEventArgs e)
+        {
+            Control c = sender as Control;
+            if (Dragging && c != null)
+            {
+                c.Top = e.Y + c.Top - yPos;
+                c.Left = e.X + c.Left - xPos;
+            }
+        }
+
+        private void PictureMatrix_MouseUp(object? sender, MouseEventArgs e)
+        {
+
+            Dragging = false;
+
+            Control c = sender as Control;
+
+            int matrixX = (int)((baseX - c.Left) / uiScale);
+            int matrixY = (int)((baseY - c.Top) / uiScale);
+
+            AppConfig.Set("matrix_x", matrixX);
+            AppConfig.Set("matrix_y", matrixY);
+
+            SetMatrixPicture(false);
+        }
+
+        private void Matrix_Shown(object? sender, EventArgs e)
+        {
+            FormPosition();
+            SetMatrixPicture();
+        }
+
+        private void SetMatrixPicture(bool visualise = true)
+        {
+            matrixControl.SetMatrixPicture(AppConfig.GetString("matrix_picture"), visualise);
+        }
+
+        private void ButtonPicture_Click(object? sender, EventArgs e)
+        {
+            matrixControl.OpenMatrixPicture();
+
+        }
+        public void FormPosition()
+        {
+            if (Height > Program.settingsForm.Height)
+            {
+                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+            }
+            else
+            {
+                Height = Program.settingsForm.Height;
+                Top = Program.settingsForm.Top;
+            }
+
+            Left = Program.settingsForm.Left - Width - 5;
+        }
+
+        public void VisualiseMatrix(string fileName)
+        {
+
+            if (picture is not null) picture.Dispose();
+
+            using (var fs = new FileStream(fileName, FileMode.Open))
+            {
+
+                ms.SetLength(0);
+                fs.CopyTo(ms);
+                ms.Position = 0;
+                fs.Close();
+
+                picture = Image.FromStream(ms);
+
+                int width = picture.Width;
+                int height = picture.Height;
+
+                int matrixX = AppConfig.Get("matrix_x", 0);
+                int matrixY = AppConfig.Get("matrix_y", 0);
+                int matrixZoom = AppConfig.Get("matrix_zoom", 100);
+
+
+                float scale = Math.Min((float)panelPicture.Width / (float)width, (float)panelPicture.Height / (float)height) * matrixZoom / 100;
+
+                pictureMatrix.Width = (int)(width * scale);
+                pictureMatrix.Height = (int)(height * scale);
+
+                baseX = panelPicture.Width - pictureMatrix.Width;
+                baseY = 0;
+
+                pictureMatrix.Left = baseX - (int)(matrixX * uiScale);
+                pictureMatrix.Top = baseY - (int)(matrixY * uiScale);
+
+                pictureMatrix.SizeMode = PictureBoxSizeMode.Zoom;
+                pictureMatrix.Image = picture;
+
+
+            }
+
+
+
+
+        }
+
+    }
+}

app/Matrix.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <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>

app/Mode/ModeControl.cs

@@ -0,0 +1,435 @@
+using GHelper.Battery;
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using Ryzen;
+
+namespace GHelper.Mode
+{
+    public class ModeControl
+    {
+
+        static SettingsForm settings = Program.settingsForm;
+
+        private static bool customFans = false;
+        private static int customPower = 0;
+
+        private int _cpuUV = 0;
+        private int _igpuUV = 0;
+
+        static System.Timers.Timer reapplyTimer = default!;
+
+        public ModeControl()
+        {
+            reapplyTimer = new System.Timers.Timer(AppConfig.GetMode("reapply_time", 30) * 1000);
+            reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
+            reapplyTimer.Enabled = false;
+        }
+
+        private void ReapplyTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            SetCPUTemp(AppConfig.GetMode("cpu_temp"), false);
+        }
+
+        public void AutoPerformance(bool powerChanged = false)
+        {
+            var Plugged = SystemInformation.PowerStatus.PowerLineStatus;
+
+            int mode = AppConfig.Get("performance_" + (int)Plugged);
+
+            if (mode != -1)
+                SetPerformanceMode(mode, powerChanged);
+            else
+                SetPerformanceMode(Modes.GetCurrent());
+        }
+
+
+        public void ResetPerformanceMode()
+        {
+            ResetRyzen();
+
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
+
+            // Default power mode
+            AppConfig.RemoveMode("powermode");
+            PowerNative.SetPowerMode(Modes.GetCurrentBase());
+        }
+
+        public void SetPerformanceMode(int mode = -1, bool notify = false)
+        {
+
+            int oldMode = Modes.GetCurrent();
+            if (mode < 0) mode = oldMode;
+
+            if (!Modes.Exists(mode)) mode = 0;
+
+            customFans = false;
+            customPower = 0;
+
+            settings.ShowMode(mode);
+            SetModeLabel();
+
+            Modes.SetCurrent(mode);
+
+            int status = Program.acpi.DeviceSet(AsusACPI.PerformanceMode, AppConfig.IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
+            
+            // Vivobook fallback
+            if (status != 1)
+            {
+                int vivoMode = Modes.GetBase(mode);
+                if (vivoMode == 1) vivoMode = 2;
+                else if (vivoMode == 2) vivoMode = 1;
+                Program.acpi.DeviceSet(AsusACPI.VivoBookMode, vivoMode, "VivoMode");
+            }
+
+            if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
+
+            if (notify)
+                Program.toast.RunToast(Modes.GetCurrentName(), SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online ? ToastIcon.Charger : ToastIcon.Battery);
+
+            SetGPUClocks();
+            AutoFans();
+            AutoPower(1000);
+
+            // Power plan from config or defaulting to balanced
+            if (AppConfig.GetModeString("scheme") is not null)
+                PowerNative.SetPowerPlan(AppConfig.GetModeString("scheme"));
+            else
+                PowerNative.SetBalancedPowerPlan();
+
+            // Windows power mode
+            if (AppConfig.GetModeString("powermode") is not null)
+                PowerNative.SetPowerMode(AppConfig.GetModeString("powermode"));
+            else
+                PowerNative.SetPowerMode(Modes.GetBase(mode));
+
+            // CPU Boost setting override
+            if (AppConfig.GetMode("auto_boost") != -1)
+                PowerNative.SetCPUBoost(AppConfig.GetMode("auto_boost"));
+
+            //BatteryControl.SetBatteryChargeLimit();
+
+            /*
+            if (NativeMethods.PowerGetEffectiveOverlayScheme(out Guid activeScheme) == 0)
+            {
+                Debug.WriteLine("Effective :" + activeScheme);
+            }
+            */
+
+            settings.FansInit();
+        }
+
+
+        public void CyclePerformanceMode(bool back = false)
+        {
+            SetPerformanceMode(Modes.GetNext(back), true);
+        }
+
+        public void AutoFans(bool force = false)
+        {
+            customFans = false;
+
+            if (AppConfig.IsMode("auto_apply") || force)
+            {
+
+                bool xgmFan = false;
+                if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected())
+                {
+                    //AsusUSB.InitXGM();
+                    AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                    xgmFan = true;
+                }
+
+                int cpuResult = Program.acpi.SetFanCurve(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
+                int gpuResult = Program.acpi.SetFanCurve(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
+
+                if (AppConfig.Is("mid_fan"))
+                    Program.acpi.SetFanCurve(AsusFan.Mid, AppConfig.GetFanConfig(AsusFan.Mid));
+
+
+                // something went wrong, resetting to default profile
+                if (cpuResult != 1 || gpuResult != 1)
+                {
+                    cpuResult = Program.acpi.SetFanRange(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
+                    gpuResult = Program.acpi.SetFanRange(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
+
+                    if (cpuResult != 1 || gpuResult != 1)
+                    {
+                        int mode = Modes.GetCurrentBase();
+                        Logger.WriteLine("ASUS BIOS rejected fan curve, resetting mode to " + mode);
+                        Program.acpi.DeviceSet(AsusACPI.PerformanceMode, mode, "Reset Mode");
+                        settings.LabelFansResult("ASUS BIOS rejected fan curve");
+                    }
+                }
+                else
+                {
+                    settings.LabelFansResult("");
+                    customFans = true;
+                }
+
+                // force set PPTs for missbehaving bios on FX507/517 series
+                if ((AppConfig.IsPowerRequired() || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
+                {
+                    Task.Run(async () =>
+                    {
+                        await Task.Delay(TimeSpan.FromSeconds(1));
+                        Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, 80, "PowerLimit Fix A0");
+                        Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, 80, "PowerLimit Fix A3");
+                    });
+                }
+
+            }
+
+            SetModeLabel();
+
+        }
+
+        public void AutoPower(int delay = 0)
+        {
+
+            customPower = 0;
+
+            bool applyPower = AppConfig.IsMode("auto_apply_power");
+            bool applyFans = AppConfig.IsMode("auto_apply");
+            //bool applyGPU = true;
+
+            if (applyPower && !applyFans)
+            {
+                // force fan curve for misbehaving bios PPTs on some models
+                if (AppConfig.IsFanRequired())
+                {
+                    delay = 500;
+                    AutoFans(true);
+                }
+
+                // Fix for models that don't support PPT settings in all modes, setting a "manual" mode for them
+                if (AppConfig.IsManualModeRequired())
+                {
+                    AutoFans(true);
+                }
+            }
+
+            if (delay > 0)
+            {
+                var timer = new System.Timers.Timer(delay);
+                timer.Elapsed += delegate
+                {
+                    timer.Stop();
+                    timer.Dispose();
+
+                    if (applyPower) SetPower();
+                    Thread.Sleep(500);
+                    SetGPUPower();
+                    AutoRyzen();
+                };
+                timer.Start();
+            }
+            else
+            {
+                if (applyPower) SetPower(true);
+                SetGPUPower();
+                AutoRyzen();
+            }
+
+        }
+
+        public void SetModeLabel()
+        {
+            settings.SetModeLabel(Properties.Strings.PerformanceMode + ": " + Modes.GetCurrentName() + (customFans ? "+" : "") + ((customPower > 0) ? " " + customPower + "W" : ""));
+        }
+
+        public void SetPower(bool launchAsAdmin = false)
+        {
+
+            int limit_total = AppConfig.GetMode("limit_total");
+            int limit_cpu = AppConfig.GetMode("limit_cpu");
+            int limit_fast = AppConfig.GetMode("limit_fast");
+
+            if (limit_total > AsusACPI.MaxTotal) return;
+            if (limit_total < AsusACPI.MinTotal) return;
+
+            if (limit_cpu > AsusACPI.MaxCPU) return;
+            if (limit_cpu < AsusACPI.MinCPU) return;
+
+            if (limit_fast > AsusACPI.MaxTotal) return;
+            if (limit_fast < AsusACPI.MinTotal) return;
+
+            // SPL + SPPT togeher in one slider
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, limit_total, "PowerLimit A0");
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, limit_total, "PowerLimit A3");
+                customPower = limit_total;
+            }
+            else if (RyzenControl.IsAMD())
+            {
+
+                if (ProcessHelper.IsUserAdministrator())
+                {
+                    var stapmResult = SendCommand.set_stapm_limit((uint)limit_total * 1000);
+                    Logger.WriteLine($"STAPM: {limit_total} {stapmResult}");
+
+                    var stapmResult2 = SendCommand.set_stapm2_limit((uint)limit_total * 1000);
+                    Logger.WriteLine($"STAPM2: {limit_total} {stapmResult2}");
+
+                    var slowResult = SendCommand.set_slow_limit((uint)limit_total * 1000);
+                    Logger.WriteLine($"SLOW: {limit_total} {slowResult}");
+
+                    var fastResult = SendCommand.set_fast_limit((uint)limit_total * 1000);
+                    Logger.WriteLine($"FAST: {limit_total} {fastResult}");
+
+                    customPower = limit_total;
+                }
+                else if (launchAsAdmin)
+                {
+                    ProcessHelper.RunAsAdmin("cpu");
+                    return;
+                }
+            }
+
+            if (Program.acpi.IsAllAmdPPT()) // CPU limit all amd models
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_CPUB0, limit_cpu, "PowerLimit B0");
+                customPower = limit_cpu;
+            }
+            else if (Program.acpi.DeviceGet(AsusACPI.PPT_APUC1) >= 0) // FPPT boost for non all-amd models
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUC1, limit_fast, "PowerLimit C1");
+                customPower = limit_fast;
+            }
+
+
+            SetModeLabel();
+
+        }
+
+        public void SetGPUClocks(bool launchAsAdmin = true)
+        {
+            Task.Run(() =>
+            {
+
+                int core = AppConfig.GetMode("gpu_core");
+                int memory = AppConfig.GetMode("gpu_memory");
+                int clock_limit = AppConfig.GetMode("gpu_clock_limit");
+
+                if (core == -1 && memory == -1) return;
+
+                //if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) return;
+                if (HardwareControl.GpuControl is null) return;
+                if (!HardwareControl.GpuControl!.IsNvidia) return;
+
+                using NvidiaGpuControl nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+                try
+                {
+                    int statusLimit = nvControl.SetMaxGPUClock(clock_limit);
+                    int statusClocks = nvControl.SetClocks(core, memory);
+                    if ((statusLimit != 0 || statusClocks != 0) && launchAsAdmin) ProcessHelper.RunAsAdmin("gpu");
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+
+                settings.GPUInit();
+            });
+        }
+
+        public void SetGPUPower()
+        {
+
+            int gpu_boost = AppConfig.GetMode("gpu_boost");
+            int gpu_temp = AppConfig.GetMode("gpu_temp");
+
+
+            if (gpu_boost < AsusACPI.MinGPUBoost || gpu_boost > AsusACPI.MaxGPUBoost) return;
+            if (gpu_temp < AsusACPI.MinGPUTemp || gpu_temp > AsusACPI.MaxGPUTemp) return;
+
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.PPT_GPUC0, gpu_boost, "PowerLimit C0");
+
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC2) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.PPT_GPUC2, gpu_temp, "PowerLimit C2");
+
+        }
+
+        public void SetCPUTemp(int? cpuTemp, bool log = true)
+        {
+            if (cpuTemp >= RyzenControl.MinTemp && cpuTemp < RyzenControl.MaxTemp)
+            {
+                var resultCPU = SendCommand.set_tctl_temp((uint)cpuTemp);
+                if (log) Logger.WriteLine($"CPU Temp: {cpuTemp} {resultCPU}");
+
+                var restultAPU = SendCommand.set_apu_skin_temp_limit((uint)cpuTemp);
+                if (log) Logger.WriteLine($"APU Temp: {cpuTemp} {restultAPU}");
+
+                reapplyTimer.Enabled = AppConfig.IsMode("auto_uv");
+
+            }
+            else
+            {
+                reapplyTimer.Enabled = false;
+            }
+        }
+
+        public void SetUV(int cpuUV)
+        {
+            if (!RyzenControl.IsSupportedUV()) return;
+
+            if (cpuUV >= RyzenControl.MinCPUUV && cpuUV <= RyzenControl.MaxCPUUV)
+            {
+                var uvResult = SendCommand.set_coall(cpuUV);
+                Logger.WriteLine($"UV: {cpuUV} {uvResult}");
+                if (uvResult == Smu.Status.OK) _cpuUV = cpuUV;
+            }
+        }
+
+        public void SetUViGPU(int igpuUV)
+        {
+            if (!RyzenControl.IsSupportedUViGPU()) return;
+
+            if (igpuUV >= RyzenControl.MinIGPUUV && igpuUV <= RyzenControl.MaxIGPUUV)
+            {
+                var iGPUResult = SendCommand.set_cogfx(igpuUV);
+                Logger.WriteLine($"iGPU UV: {igpuUV} {iGPUResult}");
+                if (iGPUResult == Smu.Status.OK) _igpuUV = igpuUV;
+            }
+        }
+
+
+        public void SetRyzen(bool launchAsAdmin = false)
+        {
+            if (!ProcessHelper.IsUserAdministrator())
+            {
+                if (launchAsAdmin) ProcessHelper.RunAsAdmin("uv");
+                return;
+            }
+
+            try
+            {
+                SetUV(AppConfig.GetMode("cpu_uv", 0));
+                SetUViGPU(AppConfig.GetMode("igpu_uv", 0));
+                SetCPUTemp(AppConfig.GetMode("cpu_temp"));
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine("UV Error: " + ex.ToString());
+            }
+        }
+
+        public void ResetRyzen()
+        {
+            if (_cpuUV != 0) SetUV(0);
+            if (_igpuUV != 0) SetUViGPU(0);
+        }
+
+        public void AutoRyzen()
+        {
+            if (!RyzenControl.IsAMD()) return;
+
+            if (AppConfig.IsMode("auto_uv")) SetRyzen();
+            else ResetRyzen();
+        }
+
+    }
+}

app/Mode/Modes.cs

@@ -0,0 +1,155 @@
+namespace GHelper.Mode
+{
+    internal class Modes
+    {
+
+        const int maxModes = 20;
+
+        public static Dictionary<int, string> GetDictonary()
+        {
+            Dictionary<int, string> modes = new Dictionary<int, string>
+            {
+              {2, Properties.Strings.Silent},
+              {0, Properties.Strings.Balanced},
+              {1, Properties.Strings.Turbo}
+            };
+
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (Exists(i)) modes.Add(i, GetName(i));
+            }
+
+            return modes;
+        }
+
+        public static List<int> GetList()
+        {
+            List<int> modes = new() { 2, 0, 1 };
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (Exists(i)) modes.Add(i);
+            }
+
+            return modes;
+        }
+
+        public static void Remove(int mode)
+        {
+            List<string> cleanup = new() {
+                "mode_base",
+                "mode_name",
+                "limit_total",
+                "limit_fast",
+                "limit_cpu",
+                "limit_total",
+                "fan_profile_cpu",
+                "fan_profile_gpu",
+                "fan_profile_mid",
+                "gpu_boost",
+                "gpu_temp",
+                "gpu_core",
+                "gpu_memory",
+                "auto_boost",
+                "auto_apply",
+                "auto_apply_power",
+                "powermode"
+            };
+
+            foreach (string clean in cleanup)
+            {
+                AppConfig.Remove(clean + "_" + mode);
+            }
+        }
+
+        public static int Add()
+        {
+            for (int i = 3; i < maxModes; i++)
+            {
+                if (!Exists(i))
+                {
+                    int modeBase = GetCurrentBase();
+                    string nameName = "Custom " + (i - 2);
+                    AppConfig.Set("mode_base_" + i, modeBase);
+                    AppConfig.Set("mode_name_" + i, nameName);
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        public static int GetCurrent()
+        {
+            return AppConfig.Get("performance_mode");
+        }
+
+        public static bool IsCurrentCustom()
+        {
+            return GetCurrent() > 2;
+        }
+
+        public static void SetCurrent(int mode)
+        {
+            AppConfig.Set("performance_" + (int)SystemInformation.PowerStatus.PowerLineStatus, mode);
+            AppConfig.Set("performance_mode", mode);
+        }
+
+        public static int GetCurrentBase()
+        {
+            return GetBase(GetCurrent());
+        }
+
+        public static string GetCurrentName()
+        {
+            return GetName(GetCurrent());
+        }
+
+        public static bool Exists(int mode)
+        {
+            return GetBase(mode) >= 0;
+        }
+
+        public static int GetBase(int mode)
+        {
+            if (mode >= 0 && mode <= 2)
+                return mode;
+            else
+                return AppConfig.Get("mode_base_" + mode);
+        }
+
+        public static string GetName(int mode)
+        {
+            switch (mode)
+            {
+                case 0:
+                    return Properties.Strings.Balanced;
+                case 1:
+                    return Properties.Strings.Turbo;
+                case 2:
+                    return Properties.Strings.Silent;
+                default:
+                    return AppConfig.GetString("mode_name_" + mode);
+            }
+        }
+
+
+        public static int GetNext(bool back = false)
+        {
+            var modes = GetList();
+            int index = modes.IndexOf(GetCurrent());
+
+            if (back)
+            {
+                index--;
+                if (index < 0) index = modes.Count - 1;
+                return modes[index];
+            }
+            else
+            {
+                index++;
+                if (index > modes.Count - 1) index = 0;
+                return modes[index];
+            }
+        }
+    }
+}

app/Mode/PowerNative.cs

@@ -0,0 +1,293 @@
+using System.Runtime.InteropServices;
+
+namespace GHelper.Mode
+{
+    internal class PowerNative
+    {
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerWriteDCValueIndex(IntPtr RootPowerKey,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
+            int AcValueIndex);
+
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerWriteACValueIndex(IntPtr RootPowerKey,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
+            int AcValueIndex);
+
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerReadACValueIndex(IntPtr RootPowerKey,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
+            out IntPtr AcValueIndex
+            );
+
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerReadDCValueIndex(IntPtr RootPowerKey,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
+            out IntPtr AcValueIndex
+            );
+
+
+        [DllImport("powrprof.dll")]
+        static extern uint PowerReadACValue(
+            IntPtr RootPowerKey,
+            Guid SchemeGuid,
+            Guid SubGroupOfPowerSettingGuid,
+            Guid PowerSettingGuid,
+            ref int Type,
+            ref IntPtr Buffer,
+            ref uint BufferSize
+            );
+
+
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerSetActiveScheme(IntPtr RootPowerKey,
+            [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid);
+
+        [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
+        static extern UInt32 PowerGetActiveScheme(IntPtr UserPowerKey, out IntPtr ActivePolicyGuid);
+
+        static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
+        static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
+
+        private static Guid GUID_SLEEP_SUBGROUP = new Guid("238c9fa8-0aad-41ed-83f4-97be242c8f20");
+        private static Guid GUID_HIBERNATEIDLE = new Guid("9d7815a6-7ee4-497e-8888-515a05f02364");
+
+        private static Guid GUID_SYSTEM_BUTTON_SUBGROUP = new Guid("4f971e89-eebd-4455-a8de-9e59040e7347");
+        private static Guid GUID_LIDACTION = new Guid("5CA83367-6E45-459F-A27B-476B1D01C936");
+
+        [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
+        public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
+
+        [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetEffectiveOverlayScheme")]
+        public static extern uint PowerGetEffectiveOverlayScheme(out Guid EffectiveOverlayGuid);
+
+        [DllImportAttribute("powrprof.dll", EntryPoint = "PowerSetActiveOverlayScheme")]
+        public static extern uint PowerSetActiveOverlayScheme(Guid OverlaySchemeGuid);
+
+        const string POWER_SILENT = "961cc777-2547-4f9d-8174-7d86181b8a7a";
+        const string POWER_BALANCED = "00000000-0000-0000-0000-000000000000";
+        const string POWER_TURBO = "ded574b5-45a0-4f42-8737-46345c09c238";
+        const string POWER_BETTERPERFORMANCE = "ded574b5-45a0-4f42-8737-46345c09c238";
+
+        static List<string> overlays = new() {
+                POWER_BALANCED,
+                POWER_TURBO,
+                POWER_SILENT,
+                POWER_BETTERPERFORMANCE
+            };
+
+        public static Dictionary<string, string> powerModes = new Dictionary<string, string>
+            {
+                { POWER_SILENT, "Best Power Efficiency" },
+                { POWER_BALANCED, "Balanced" },
+                { POWER_TURBO, "Best Performance" },
+            };
+        static Guid GetActiveScheme()
+        {
+            IntPtr pActiveSchemeGuid;
+            var hr = PowerGetActiveScheme(IntPtr.Zero, out pActiveSchemeGuid);
+            Guid activeSchemeGuid = (Guid)Marshal.PtrToStructure(pActiveSchemeGuid, typeof(Guid));
+            return activeSchemeGuid;
+        }
+
+        public static int GetCPUBoost()
+        {
+            IntPtr AcValueIndex;
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            UInt32 value = PowerReadACValueIndex(IntPtr.Zero,
+                 activeSchemeGuid,
+                 GUID_CPU,
+                 GUID_BOOST, out AcValueIndex);
+
+            return AcValueIndex.ToInt32();
+
+        }
+
+        public static void SetCPUBoost(int boost = 0)
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            if (boost == GetCPUBoost()) return;
+
+            var hrAC = PowerWriteACValueIndex(
+                 IntPtr.Zero,
+                 activeSchemeGuid,
+                 GUID_CPU,
+                 GUID_BOOST,
+                 boost);
+
+            PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+
+            var hrDC = PowerWriteDCValueIndex(
+                 IntPtr.Zero,
+                 activeSchemeGuid,
+                 GUID_CPU,
+                 GUID_BOOST,
+                 boost);
+
+            PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+
+            Logger.WriteLine("Boost " + boost);
+        }
+
+        public static string GetPowerMode()
+        {
+            PowerGetEffectiveOverlayScheme(out Guid activeScheme);
+            return activeScheme.ToString();
+        }
+
+        public static void SetPowerMode(string scheme)
+        {
+
+            if (!overlays.Contains(scheme)) return;
+
+            Guid guidScheme = new Guid(scheme);
+
+            uint status = PowerGetEffectiveOverlayScheme(out Guid activeScheme);
+            if (status != 0 || activeScheme != guidScheme)
+            {
+                status = PowerSetActiveOverlayScheme(guidScheme);
+                Logger.WriteLine("Power Mode " + scheme + ":" + (status == 0 ? "OK" : status));
+            }
+
+        }
+
+        public static void SetBalancedPowerPlan()
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+            string balanced = "381b4222-f694-41f0-9685-ff5bb260df2e";
+
+            if (activeSchemeGuid.ToString() != balanced && !AppConfig.Is("skip_power_plan"))
+            {
+                SetPowerPlan(balanced);
+            }
+        }
+
+        public static void SetPowerPlan(string scheme)
+        {
+            // Skipping power modes
+            if (overlays.Contains(scheme)) return;
+
+            Guid guidScheme = new Guid(scheme);
+            uint status = PowerSetActiveScheme(IntPtr.Zero, guidScheme);
+            Logger.WriteLine("Power Plan " + scheme + ":" + (status == 0 ? "OK" : status));
+        }
+
+        public static string GetDefaultPowerMode(int mode)
+        {
+            switch (mode)
+            {
+                case 1: // turbo
+                    return POWER_TURBO;
+                case 2: //silent
+                    return POWER_SILENT;
+                default: // balanced
+                    return POWER_BALANCED;
+            }
+        }
+
+        public static void SetPowerMode(int mode)
+        {
+            SetPowerMode(GetDefaultPowerMode(mode));
+        }
+
+        public static int GetLidAction(bool ac)
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            IntPtr activeIndex;
+            if (ac)
+                PowerReadACValueIndex(IntPtr.Zero,
+                     activeSchemeGuid,
+                     GUID_SYSTEM_BUTTON_SUBGROUP,
+                     GUID_LIDACTION, out activeIndex);
+
+            else
+                PowerReadDCValueIndex(IntPtr.Zero,
+                    activeSchemeGuid,
+                    GUID_SYSTEM_BUTTON_SUBGROUP,
+                    GUID_LIDACTION, out activeIndex);
+
+
+            return activeIndex.ToInt32();
+        }
+
+
+        public static void SetLidAction(int action, bool acOnly = false)
+        {
+            /**
+             * 1: Do nothing
+             * 2: Seelp
+             * 3: Hibernate
+             * 4: Shutdown
+             */
+
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            var hrAC = PowerWriteACValueIndex(
+                IntPtr.Zero,
+                activeSchemeGuid,
+                GUID_SYSTEM_BUTTON_SUBGROUP,
+                GUID_LIDACTION,
+                action);
+
+            PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+
+            if (!acOnly)
+            {
+                var hrDC = PowerWriteDCValueIndex(
+                  IntPtr.Zero,
+                  activeSchemeGuid,
+                  GUID_SYSTEM_BUTTON_SUBGROUP,
+                  GUID_LIDACTION,
+                  action);
+
+                PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+            }
+
+            Logger.WriteLine("Changed Lid Action to " + action);
+        }
+
+        public static int GetHibernateAfter()
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+            IntPtr seconds;
+            PowerReadDCValueIndex(IntPtr.Zero,
+                    activeSchemeGuid,
+                    GUID_SLEEP_SUBGROUP,
+                    GUID_HIBERNATEIDLE, out seconds);
+
+            Logger.WriteLine("Hibernate after " + seconds);
+            return (seconds.ToInt32() / 60);
+        }
+
+
+        public static void SetHibernateAfter(int minutes)
+        {
+            int seconds = minutes * 60;
+
+            Guid activeSchemeGuid = GetActiveScheme();
+            var hrAC = PowerWriteDCValueIndex(
+                IntPtr.Zero,
+                activeSchemeGuid,
+                GUID_SLEEP_SUBGROUP,
+                GUID_HIBERNATEIDLE,
+                seconds);
+
+            PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+
+            Logger.WriteLine("Setting Hibernate after " + seconds + ": " + (hrAC == 0 ? "OK" : hrAC));
+        }
+
+
+    }
+}

app/NativeMethods.cs

@@ -1,356 +1,27 @@
-using GHelper;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using static Tools.ScreenInterrogatory;
+using System.Runtime.InteropServices;
 
-namespace Tools
-{
-
-    public class KeyHandler
-    {
-
-        public const int NOMOD = 0x0000;
-        public const int ALT = 0x0001;
-        public const int CTRL = 0x0002;
-        public const int SHIFT = 0x0004;
-        public const int WIN = 0x0008;
-
-        public const int WM_HOTKEY_MSG_ID = 0x0312;
-
-
-        [DllImport("user32.dll")]
-        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
-        [DllImport("user32.dll")]
-        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
-
-        private int modifier;
-        private int key;
-        private IntPtr hWnd;
-        private int id;
-        public KeyHandler(int modifier, Keys key, nint handle)
-        {
-            this.modifier = modifier;
-            this.key = (int)key;
-            this.hWnd = handle;
-            id = this.GetHashCode();
-        }
-        public override int GetHashCode()
-        {
-            return modifier ^ key ^ hWnd.ToInt32();
-        }
-        public bool Register()
-        {
-            return RegisterHotKey(hWnd, id, modifier, key);
-        }
-        public bool Unregiser()
-        {
-            return UnregisterHotKey(hWnd, id);
-        }
-    }
-
-    public static class ScreenInterrogatory
-    {
-        public const int ERROR_SUCCESS = 0;
-
-        #region enums
-
-        public enum QUERY_DEVICE_CONFIG_FLAGS : uint
-        {
-            QDC_ALL_PATHS = 0x00000001,
-            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
-            QDC_DATABASE_CURRENT = 0x00000004
-        }
-
-        public enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY : uint
-        {
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = 0xFFFFFFFF,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_SCANLINE_ORDERING : uint
-        {
-            DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
-            DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST = DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
-            DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_ROTATION : uint
-        {
-            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
-            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
-            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
-            DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
-            DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_SCALING : uint
-        {
-            DISPLAYCONFIG_SCALING_IDENTITY = 1,
-            DISPLAYCONFIG_SCALING_CENTERED = 2,
-            DISPLAYCONFIG_SCALING_STRETCHED = 3,
-            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
-            DISPLAYCONFIG_SCALING_CUSTOM = 5,
-            DISPLAYCONFIG_SCALING_PREFERRED = 128,
-            DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_PIXELFORMAT : uint
-        {
-            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
-            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
-            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
-            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
-            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
-            DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff
-        }
-
-        public enum DISPLAYCONFIG_MODE_INFO_TYPE : uint
-        {
-            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
-            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
-            DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_DEVICE_INFO_TYPE : uint
-        {
-            DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
-            DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
-            DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
-            DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        #endregion
-
-        #region structs
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct LUID
-        {
-            public uint LowPart;
-            public int HighPart;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_SOURCE_INFO
-        {
-            public LUID adapterId;
-            public uint id;
-            public uint modeInfoIdx;
-            public uint statusFlags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_TARGET_INFO
-        {
-            public LUID adapterId;
-            public uint id;
-            public uint modeInfoIdx;
-            private DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
-            private DISPLAYCONFIG_ROTATION rotation;
-            private DISPLAYCONFIG_SCALING scaling;
-            private DISPLAYCONFIG_RATIONAL refreshRate;
-            private DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
-            public bool targetAvailable;
-            public uint statusFlags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_RATIONAL
-        {
-            public uint Numerator;
-            public uint Denominator;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_INFO
-        {
-            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
-            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
-            public uint flags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_2DREGION
-        {
-            public uint cx;
-            public uint cy;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
-        {
-            public ulong pixelRate;
-            public DISPLAYCONFIG_RATIONAL hSyncFreq;
-            public DISPLAYCONFIG_RATIONAL vSyncFreq;
-            public DISPLAYCONFIG_2DREGION activeSize;
-            public DISPLAYCONFIG_2DREGION totalSize;
-            public uint videoStandard;
-            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_TARGET_MODE
-        {
-            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct POINTL
-        {
-            private int x;
-            private int y;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_SOURCE_MODE
-        {
-            public uint width;
-            public uint height;
-            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
-            public POINTL position;
-        }
-
-        [StructLayout(LayoutKind.Explicit)]
-        public struct DISPLAYCONFIG_MODE_INFO_UNION
-        {
-            [FieldOffset(0)]
-            public DISPLAYCONFIG_TARGET_MODE targetMode;
-
-            [FieldOffset(0)]
-            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_MODE_INFO
-        {
-            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
-            public uint id;
-            public LUID adapterId;
-            public DISPLAYCONFIG_MODE_INFO_UNION modeInfo;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
-        {
-            public uint value;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_DEVICE_INFO_HEADER
-        {
-            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
-            public uint size;
-            public LUID adapterId;
-            public uint id;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME
-        {
-            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
-            public DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
-            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
-            public ushort edidManufactureId;
-            public ushort edidProductCodeId;
-            public uint connectorInstance;
-
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
-            public string monitorFriendlyDeviceName;
-
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
-            public string monitorDevicePath;
-        }
-
-        #endregion
-
-        #region DLL-Imports
-
-        [DllImport("user32.dll")]
-        public static extern int GetDisplayConfigBufferSizes(
-            QUERY_DEVICE_CONFIG_FLAGS flags, out uint numPathArrayElements, out uint numModeInfoArrayElements);
-
-        [DllImport("user32.dll")]
-        public static extern int QueryDisplayConfig(
-            QUERY_DEVICE_CONFIG_FLAGS flags,
-            ref uint numPathArrayElements, [Out] DISPLAYCONFIG_PATH_INFO[] PathInfoArray,
-            ref uint numModeInfoArrayElements, [Out] DISPLAYCONFIG_MODE_INFO[] ModeInfoArray,
-            IntPtr currentTopologyId
-            );
-
-        [DllImport("user32.dll")]
-        public static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName);
-
-        #endregion
-
-        private static DISPLAYCONFIG_TARGET_DEVICE_NAME DeviceName(LUID adapterId, uint targetId)
-        {
-            var deviceName = new DISPLAYCONFIG_TARGET_DEVICE_NAME
-            {
-                header =
-                {
-                    size = (uint)Marshal.SizeOf(typeof (DISPLAYCONFIG_TARGET_DEVICE_NAME)),
-                    adapterId = adapterId,
-                    id = targetId,
-                    type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
-                }
-            };
-            var error = DisplayConfigGetDeviceInfo(ref deviceName);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            return deviceName;
-        }
-
-        public static IEnumerable<DISPLAYCONFIG_TARGET_DEVICE_NAME> GetAllDevices()
-        {
-            uint pathCount, modeCount;
-            var error = GetDisplayConfigBufferSizes(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS, out pathCount, out modeCount);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            var displayPaths = new DISPLAYCONFIG_PATH_INFO[pathCount];
-            var displayModes = new DISPLAYCONFIG_MODE_INFO[modeCount];
-            error = QueryDisplayConfig(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS,
-                ref pathCount, displayPaths, ref modeCount, displayModes, IntPtr.Zero);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            for (var i = 0; i < modeCount; i++)
-                if (displayModes[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE.DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
-                    yield return DeviceName(displayModes[i].adapterId, displayModes[i].id);
-        }
-
-
-    }
-
-}
 
 public class NativeMethods
 {
 
+    internal struct LASTINPUTINFO
+    {
+        public uint cbSize;
+        public uint dwTime;
+    }
+
+    [DllImport("User32.dll")]
+    private static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
+
+    public static TimeSpan GetIdleTime()
+    {
+        LASTINPUTINFO lastInPut = new LASTINPUTINFO();
+        lastInPut.cbSize = (uint)Marshal.SizeOf(lastInPut);
+        GetLastInputInfo(ref lastInPut);
+        return TimeSpan.FromMilliseconds((uint)Environment.TickCount - lastInPut.dwTime);
+
+    }
+
     private const int WM_SYSCOMMAND = 0x0112;
     private const int SC_MONITORPOWER = 0xF170;
     private const int MONITOR_OFF = 2;
@@ -361,9 +32,9 @@ public class NativeMethods
     [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
     private static extern uint FormatMessage(uint dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, out string lpBuffer, uint nSize, IntPtr Arguments);
 
-    public static void TurnOffScreen(IntPtr handle)
+    public static void TurnOffScreen()
     {
-        IntPtr result = SendMessage(handle, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
+        IntPtr result = SendMessage(-1, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
         if (result == IntPtr.Zero)
         {
             int error = Marshal.GetLastWin32Error();
@@ -435,347 +106,5 @@ public class NativeMethods
     }
 
 
-    public const int KEYEVENTF_EXTENDEDKEY = 1;
-    public const int KEYEVENTF_KEYUP = 2;
 
-    public const int VK_MEDIA_NEXT_TRACK = 0xB0;
-    public const int VK_MEDIA_PLAY_PAUSE = 0xB3;
-    public const int VK_MEDIA_PREV_TRACK = 0xB1;
-    public const int VK_VOLUME_MUTE = 0xAD;
-    public const int VK_SNAPSHOT = 0x2C;
-
-    [DllImport("user32.dll", SetLastError = true)]
-    public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
-
-    public static void KeyPress(int key = VK_MEDIA_PLAY_PAUSE)
-    {
-        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
-    }
-
-
-    [DllImport("user32.dll")]
-    public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
-    public const int SW_RESTORE = 9;
-
-    public static bool SwitchToCurrent()
-    {
-        IntPtr hWnd = IntPtr.Zero;
-        Process process = Process.GetCurrentProcess();
-        Process[] processes = Process.GetProcessesByName(process.ProcessName);
-        foreach (Process _process in processes)
-        {
-            if (_process.Id != process.Id)
-            {
-
-                if (_process.MainWindowHandle != IntPtr.Zero)
-                {
-                    Debug.WriteLine(_process.Id);
-                    Debug.WriteLine(process.Id);
-
-                    hWnd = _process.MainWindowHandle;
-                    ShowWindowAsync(hWnd, SW_RESTORE);
-                }
-
-                return true;
-                break;
-            }
-        }
-
-        return false;
-    }
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerWriteDCValueIndex(IntPtr RootPowerKey,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
-        int AcValueIndex);
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerWriteACValueIndex(IntPtr RootPowerKey,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
-        int AcValueIndex);
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerReadACValueIndex(IntPtr RootPowerKey,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
-        out IntPtr AcValueIndex
-        );
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerReadDCValueIndex(IntPtr RootPowerKey,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
-        out IntPtr AcValueIndex
-        );
-
-
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerSetActiveScheme(IntPtr RootPowerKey,
-        [MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid);
-
-    [DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
-    static extern UInt32 PowerGetActiveScheme(IntPtr UserPowerKey, out IntPtr ActivePolicyGuid);
-
-    static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
-    static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
-
-    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
-    public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
-
-    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetEffectiveOverlayScheme")]
-    public static extern uint PowerGetEffectiveOverlayScheme(out Guid EffectiveOverlayGuid);
-
-    [DllImportAttribute("powrprof.dll", EntryPoint = "PowerSetActiveOverlayScheme")]
-    public static extern uint PowerSetActiveOverlayScheme(Guid OverlaySchemeGuid);
-
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
-    public struct DEVMODE
-    {
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
-        public string dmDeviceName;
-
-        public short dmSpecVersion;
-        public short dmDriverVersion;
-        public short dmSize;
-        public short dmDriverExtra;
-        public int dmFields;
-        public int dmPositionX;
-        public int dmPositionY;
-        public int dmDisplayOrientation;
-        public int dmDisplayFixedOutput;
-        public short dmColor;
-        public short dmDuplex;
-        public short dmYResolution;
-        public short dmTTOption;
-        public short dmCollate;
-
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
-        public string dmFormName;
-
-        public short dmLogPixels;
-        public short dmBitsPerPel;
-        public int dmPelsWidth;
-        public int dmPelsHeight;
-        public int dmDisplayFlags;
-        public int dmDisplayFrequency;
-        public int dmICMMethod;
-        public int dmICMIntent;
-        public int dmMediaType;
-        public int dmDitherType;
-        public int dmReserved1;
-        public int dmReserved2;
-        public int dmPanningWidth;
-        public int dmPanningHeight;
-    };
-
-    [Flags()]
-    public enum DisplaySettingsFlags : int
-    {
-        CDS_UPDATEREGISTRY = 1,
-        CDS_TEST = 2,
-        CDS_FULLSCREEN = 4,
-        CDS_GLOBAL = 8,
-        CDS_SET_PRIMARY = 0x10,
-        CDS_RESET = 0x40000000,
-        CDS_NORESET = 0x10000000
-    }
-
-    // PInvoke declaration for EnumDisplaySettings Win32 API
-    [DllImport("user32.dll")]
-    public static extern int EnumDisplaySettingsEx(
-         string lpszDeviceName,
-         int iModeNum,
-         ref DEVMODE lpDevMode);
-
-    // PInvoke declaration for ChangeDisplaySettings Win32 API
-    [DllImport("user32.dll")]
-    public static extern int ChangeDisplaySettingsEx(
-            string lpszDeviceName, ref DEVMODE lpDevMode, IntPtr hwnd,
-            DisplaySettingsFlags dwflags, IntPtr lParam);
-
-    public static DEVMODE CreateDevmode()
-    {
-        DEVMODE dm = new DEVMODE();
-        dm.dmDeviceName = new String(new char[32]);
-        dm.dmFormName = new String(new char[32]);
-        dm.dmSize = (short)Marshal.SizeOf(dm);
-        return dm;
-    }
-
-    public const int ENUM_CURRENT_SETTINGS = -1;
-    public const string defaultDevice = "\\\\.\\DISPLAY1";
-
-    public static string FindLaptopScreen()
-    {
-        string laptopScreen = null;
-
-        try
-        {
-            var devices = GetAllDevices().ToArray();
-            int count = 0, displayNum = -1;
-
-            foreach (var device in devices)
-            {
-                if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
-                    device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED)
-                {
-                    displayNum = count;
-                }
-                count++;
-                //Logger.WriteLine(device.outputTechnology.ToString());
-                //Logger.WriteLine(device.monitorFriendlyDeviceName);
-            }
-
-            var screens = Screen.AllScreens;
-
-            if (screens.Length != count) return null;
-
-            count = 0;
-            foreach (var screen in screens)
-            {
-                if (count == displayNum)
-                {
-                    laptopScreen = screen.DeviceName;
-                }
-                //Logger.WriteLine(screen.DeviceName);
-                count++;
-            }
-        }
-        catch (Exception ex)
-        {
-            Logger.WriteLine(ex.ToString());
-            Logger.WriteLine("Can't detect internal screen");
-            //laptopScreen = Screen.PrimaryScreen.DeviceName;
-        }
-
-
-        return laptopScreen;
-    }
-
-    public static int GetRefreshRate(bool max = false)
-    {
-        DEVMODE dm = CreateDevmode();
-
-        string laptopScreen = FindLaptopScreen();
-        int frequency = -1;
-
-        if (laptopScreen is null)
-            return -1;
-
-        if (max)
-        {
-            int i = 0;
-            while (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, i, ref dm))
-            {
-                if (dm.dmDisplayFrequency > frequency) frequency = dm.dmDisplayFrequency;
-                i++;
-            }
-        }
-        else
-        {
-            if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
-            {
-                frequency = dm.dmDisplayFrequency;
-            }
-        }
-
-
-        return frequency;
-    }
-
-    public static int SetRefreshRate(int frequency = 120)
-    {
-        DEVMODE dm = CreateDevmode();
-        string laptopScreen = FindLaptopScreen();
-
-        if (laptopScreen is null)
-            return -1;
-
-        if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
-        {
-            dm.dmDisplayFrequency = frequency;
-            int iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
-            Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
-            return iRet;
-        }
-
-        return 0;
-
-    }
-
-    static Guid GetActiveScheme()
-    {
-        IntPtr pActiveSchemeGuid;
-        var hr = PowerGetActiveScheme(IntPtr.Zero, out pActiveSchemeGuid);
-        Guid activeSchemeGuid = (Guid)Marshal.PtrToStructure(pActiveSchemeGuid, typeof(Guid));
-        return activeSchemeGuid;
-    }
-
-    public static int GetCPUBoost()
-    {
-        IntPtr AcValueIndex;
-        Guid activeSchemeGuid = GetActiveScheme();
-
-        UInt32 value = PowerReadACValueIndex(IntPtr.Zero,
-             activeSchemeGuid,
-             GUID_CPU,
-             GUID_BOOST, out AcValueIndex);
-
-        return AcValueIndex.ToInt32();
-
-    }
-
-    public static void SetCPUBoost(int boost = 0)
-    {
-        Guid activeSchemeGuid = GetActiveScheme();
-
-        var hrAC = PowerWriteACValueIndex(
-             IntPtr.Zero,
-             activeSchemeGuid,
-             GUID_CPU,
-             GUID_BOOST,
-             boost);
-
-        PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
-
-        var hrDC = PowerWriteDCValueIndex(
-             IntPtr.Zero,
-             activeSchemeGuid,
-             GUID_CPU,
-             GUID_BOOST,
-             boost);
-
-        PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
-
-        Logger.WriteLine("Boost " + boost);
-    }
-
-    public static void SetPowerScheme(string scheme)
-    {
-        PowerSetActiveScheme(IntPtr.Zero, new Guid(scheme));
-        PowerSetActiveOverlayScheme(new Guid(scheme));
-    }
-
-    public static void SetPowerScheme(int mode)
-    {
-        switch (mode)
-        {
-            case 0: // balanced
-                PowerSetActiveOverlayScheme(new Guid("00000000-0000-0000-0000-000000000000"));
-                break;
-            case 1: // turbo
-                PowerSetActiveOverlayScheme(new Guid("ded574b5-45a0-4f42-8737-46345c09c238"));
-                break;
-            case 2: //silent
-                PowerSetActiveOverlayScheme(new Guid("961cc777-2547-4f9d-8174-7d86181b8a7a"));
-                break;
-        }
-    }
 }

app/NvAPIWrapper/DRS/DriverSettingsProfile.cs

@@ -1,481 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.DRS;
-using NvAPIWrapper.Native.DRS.Structures;
-
-namespace NvAPIWrapper.DRS
-{
-    /// <summary>
-    ///     Represents a NVIDIA driver settings profile
-    /// </summary>
-    public class DriverSettingsProfile
-    {
-        internal DriverSettingsProfile(DRSProfileHandle handle, DriverSettingsSession parentSession)
-        {
-            Handle = handle;
-            Session = parentSession;
-        }
-
-        /// <summary>
-        ///     Gets a list of applications under this profile
-        /// </summary>
-        public IEnumerable<ProfileApplication> Applications
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                return DRSApi.EnumApplications(Session.Handle, Handle)
-                    .Select(application => new ProfileApplication(application, this));
-            }
-        }
-
-        /// <summary>
-        ///     Gets or sets the profile support value for GPU series
-        /// </summary>
-        public DRSGPUSupport GPUSupport
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-
-                return profileInfo.GPUSupport;
-            }
-            set
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-                profileInfo.GPUSupport = value;
-                DRSApi.SetProfileInfo(Session.Handle, Handle, profileInfo);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the profile handle
-        /// </summary>
-        public DRSProfileHandle Handle { get; private set; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this profile is predefined
-        /// </summary>
-        public bool IsPredefined
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-
-                return profileInfo.IsPredefined;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this profile is valid and contains a non-zero handle
-        /// </summary>
-        public bool IsValid
-        {
-            get => !Handle.IsNull;
-        }
-
-        /// <summary>
-        ///     Gets the name of the profile
-        /// </summary>
-        public string Name
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-
-                return profileInfo.Name;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the number of application registered under this profile
-        /// </summary>
-        public int NumberOfApplications
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-
-                return profileInfo.NumberOfApplications;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the number of settings under this profile
-        /// </summary>
-        public int NumberOfSettings
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                var profileInfo = DRSApi.GetProfileInfo(Session.Handle, Handle);
-
-                return profileInfo.NumberOfSettings;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the session that had queried this profile
-        /// </summary>
-        public DriverSettingsSession Session { get; }
-
-        /// <summary>
-        ///     Gets a list of settings under this profile
-        /// </summary>
-        public IEnumerable<ProfileSetting> Settings
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid profile instance."
-                    );
-                }
-
-                return DRSApi.EnumSettings(Session.Handle, Handle).Select(setting => new ProfileSetting(setting));
-            }
-        }
-
-        /// <summary>
-        ///     Creates a new profile
-        /// </summary>
-        /// <param name="session">The session to create this profile in.</param>
-        /// <param name="profileName">The name of the profile.</param>
-        /// <param name="gpuSupport">The supported GPU series for this profile.</param>
-        /// <returns>An instance of <see cref="DriverSettingsProfile" /> representing this newly created profile.</returns>
-        public static DriverSettingsProfile CreateProfile(
-            DriverSettingsSession session,
-            string profileName,
-            DRSGPUSupport? gpuSupport = null)
-        {
-            gpuSupport = gpuSupport ?? new DRSGPUSupport();
-            var profileInfo = new DRSProfileV1(profileName, gpuSupport.Value);
-            var profileHandle = DRSApi.CreateProfile(session.Handle, profileInfo);
-
-            return new DriverSettingsProfile(profileHandle, session);
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (!IsValid)
-            {
-                return "[Invalid]";
-            }
-
-            if (IsPredefined)
-            {
-                return $"{Name} (Predefined)";
-            }
-
-            return Name;
-        }
-
-        /// <summary>
-        ///     Deletes this profile and makes this instance invalid.
-        /// </summary>
-        public void Delete()
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            DRSApi.DeleteProfile(Session.Handle, Handle);
-            Handle = DRSProfileHandle.DefaultHandle;
-        }
-
-        /// <summary>
-        ///     Deletes an application by its name.
-        /// </summary>
-        /// <param name="applicationName">The name of the application to be deleted.</param>
-        public void DeleteApplicationByName(string applicationName)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            DRSApi.DeleteApplication(Session.Handle, Handle, applicationName);
-        }
-
-        /// <summary>
-        ///     Deletes a setting by its identification number
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to be deleted.</param>
-        public void DeleteSetting(uint settingId)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            DRSApi.DeleteProfileSetting(Session.Handle, Handle, settingId);
-        }
-
-        /// <summary>
-        ///     Deletes a setting by its known identification number.
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to be deleted.</param>
-        public void DeleteSetting(KnownSettingId settingId)
-        {
-            DeleteSetting(SettingInfo.GetSettingId(settingId));
-        }
-
-        /// <summary>
-        ///     Finds an application by its name.
-        /// </summary>
-        /// <param name="applicationName">The name of the application to search for.</param>
-        /// <returns>
-        ///     An instance of <see cref="ProfileApplication" /> if an application is found; otherwise <see langword="null" />
-        ///     .
-        /// </returns>
-        public ProfileApplication GetApplicationByName(string applicationName)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            var application = DRSApi.GetApplicationInfo(Session.Handle, Handle, applicationName);
-
-            if (application == null)
-            {
-                return null;
-            }
-
-            return new ProfileApplication(application, this);
-        }
-
-        /// <summary>
-        ///     Searches for a setting using its identification number.
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to search for.</param>
-        /// <returns>An instance of <see cref="ProfileSetting" /> if a setting is found; otherwise <see langword="null" />.</returns>
-        public ProfileSetting GetSetting(uint settingId)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            var setting = DRSApi.GetSetting(Session.Handle, Handle, settingId);
-
-            if (setting == null)
-            {
-                return null;
-            }
-
-            return new ProfileSetting(setting.Value);
-        }
-
-
-        /// <summary>
-        ///     Searches for a setting using its known identification number.
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to search for.</param>
-        /// <returns>An instance of <see cref="ProfileSetting" /> if a setting is found; otherwise <see langword="null" />.</returns>
-        public ProfileSetting GetSetting(KnownSettingId settingId)
-        {
-            return GetSetting(SettingInfo.GetSettingId(settingId));
-        }
-
-        /// <summary>
-        ///     Restores applications and settings of this profile to their default. This also deletes custom profiles resulting in
-        ///     their handles becoming invalid.
-        /// </summary>
-        public void RestoreDefaults()
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            var isPredefined = IsPredefined;
-            DRSApi.RestoreDefaults(Session.Handle, Handle);
-
-            if (!isPredefined)
-            {
-                Handle = DRSProfileHandle.DefaultHandle;
-            }
-        }
-
-        /// <summary>
-        ///     Restores a setting to its default value.
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting.</param>
-        public void RestoreSettingToDefault(uint settingId)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            DRSApi.RestoreDefaults(Session.Handle, Handle, settingId);
-        }
-
-        /// <summary>
-        ///     Restores a setting to its default value.
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting.</param>
-        public void RestoreSettingToDefault(KnownSettingId settingId)
-        {
-            RestoreSettingToDefault(SettingInfo.GetSettingId(settingId));
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to change its value.</param>
-        /// <param name="settingType">The type of the setting value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(KnownSettingId settingId, DRSSettingType settingType, object value)
-        {
-            SetSetting(SettingInfo.GetSettingId(settingId), settingType, value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(KnownSettingId settingId, string value)
-        {
-            SetSetting(SettingInfo.GetSettingId(settingId), value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(KnownSettingId settingId, byte[] value)
-        {
-            SetSetting(SettingInfo.GetSettingId(settingId), value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(KnownSettingId settingId, uint value)
-        {
-            SetSetting(SettingInfo.GetSettingId(settingId), value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to change its value.</param>
-        /// <param name="settingType">The type of the setting value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(uint settingId, DRSSettingType settingType, object value)
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid profile instance."
-                );
-            }
-
-            var setting = new DRSSettingV1(settingId, settingType, value);
-
-            DRSApi.SetSetting(Session.Handle, Handle, setting);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(uint settingId, string value)
-        {
-            SetSetting(settingId, DRSSettingType.UnicodeString, value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(uint settingId, byte[] value)
-        {
-            SetSetting(settingId, DRSSettingType.Binary, value);
-        }
-
-        /// <summary>
-        ///     Sets a new value for a setting or creates a new setting and sets its value
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to change its value.</param>
-        /// <param name="value">The new value for the setting.</param>
-        public void SetSetting(uint settingId, uint value)
-        {
-            SetSetting(settingId, DRSSettingType.Integer, value);
-        }
-    }
-}

app/NvAPIWrapper/DRS/DriverSettingsSession.cs

@@ -1,236 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.DRS.Structures;
-
-namespace NvAPIWrapper.DRS
-{
-    /// <summary>
-    ///     Represents a driver settings session. This is the starting point for using DRS set of functionalities.
-    /// </summary>
-    public class DriverSettingsSession : IDisposable
-    {
-        internal DriverSettingsSession(DRSSessionHandle handle)
-        {
-            Handle = handle;
-        }
-
-        private DriverSettingsSession() : this(DRSApi.CreateSession())
-        {
-        }
-
-        /// <summary>
-        ///     Gets the base settings profile
-        /// </summary>
-        public DriverSettingsProfile BaseProfile
-        {
-            get
-            {
-                var profileHandle = DRSApi.GetBaseProfile(Handle);
-
-                if (profileHandle.IsNull)
-                {
-                    return null;
-                }
-
-                return new DriverSettingsProfile(profileHandle, this);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the global settings profile
-        /// </summary>
-        public DriverSettingsProfile CurrentGlobalProfile
-        {
-            get
-            {
-                var profileHandle = DRSApi.GetCurrentGlobalProfile(Handle);
-
-                if (profileHandle.IsNull)
-                {
-                    return null;
-                }
-
-                return new DriverSettingsProfile(profileHandle, this);
-            }
-            set
-            {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
-                if (string.IsNullOrEmpty(value.Name))
-                {
-                    throw new ArgumentException("Profile name can not be empty.", nameof(value));
-                }
-
-                DRSApi.SetCurrentGlobalProfile(Handle, value.Name);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the session handle
-        /// </summary>
-        public DRSSessionHandle Handle { get; }
-
-        /// <summary>
-        ///     Gets the number of registered profiles
-        /// </summary>
-        public int NumberOfProfiles
-        {
-            get => DRSApi.GetNumberOfProfiles(Handle);
-        }
-
-        /// <summary>
-        ///     Gets the list of all registered profiles
-        /// </summary>
-        public IEnumerable<DriverSettingsProfile> Profiles
-        {
-            get { return DRSApi.EnumProfiles(Handle).Select(handle => new DriverSettingsProfile(handle, this)); }
-        }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            ReleaseUnmanagedResources();
-            GC.SuppressFinalize(this);
-        }
-
-        /// <summary>
-        ///     Creates a new session and load the settings
-        /// </summary>
-        /// <returns>A new instance of <see cref="DriverSettingsSession" /> representing a session.</returns>
-        public static DriverSettingsSession CreateAndLoad()
-        {
-            var session = new DriverSettingsSession();
-            session.Load();
-
-            return session;
-        }
-
-        /// <summary>
-        ///     Creates a new session and load the settings from a file
-        /// </summary>
-        /// <param name="fileName">The full path of file to load settings from.</param>
-        /// <returns>A new instance of <see cref="DriverSettingsSession" /> representing a session.</returns>
-        public static DriverSettingsSession CreateAndLoad(string fileName)
-        {
-            var session = new DriverSettingsSession();
-            session.Load(fileName);
-
-            return session;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{Handle} ({NumberOfProfiles} Profiles)";
-        }
-
-        /// <summary>
-        ///     Finds an application by name. This method is useful when passed a full path of a file as it does return an
-        ///     application almost always describing the NVIDIA driver behavior regarding the passed executable file.
-        /// </summary>
-        /// <param name="applicationName">The name of the application (with extension) or the full path of an executable file.</param>
-        /// <returns>An instance of <see cref="ProfileApplication" /> class.</returns>
-        public ProfileApplication FindApplication(string applicationName)
-        {
-            var application = DRSApi.FindApplicationByName(Handle, applicationName, out var profileHandle);
-
-            if (application == null || !profileHandle.HasValue || profileHandle.Value.IsNull)
-            {
-                return null;
-            }
-
-            var profile = new DriverSettingsProfile(profileHandle.Value, this);
-
-            return new ProfileApplication(application, profile);
-        }
-
-        /// <summary>
-        ///     Finds a profile based on the application named passed. This method is useful when passed a full path of a file as
-        ///     it does return a profile almost always describing the NVIDIA driver behavior regarding the passed executable file.
-        /// </summary>
-        /// <param name="applicationName">The name of the application (with extension) or the full path of an executable file.</param>
-        /// <returns>
-        ///     An instance of <see cref="DriverSettingsProfile" /> class describing the NVIDIA driver behavior regarding the
-        ///     passed executable file.
-        /// </returns>
-        public DriverSettingsProfile FindApplicationProfile(string applicationName)
-        {
-            var application = DRSApi.FindApplicationByName(Handle, applicationName, out var profileHandle);
-
-            if (application == null || !profileHandle.HasValue || profileHandle.Value.IsNull)
-            {
-                return null;
-            }
-
-            return new DriverSettingsProfile(profileHandle.Value, this);
-        }
-
-        /// <summary>
-        ///     Finds a profile based on its name.
-        /// </summary>
-        /// <param name="profileName">The profile name to search for.</param>
-        /// <returns>An instance of <see cref="DriverSettingsProfile" /> class.</returns>
-        public DriverSettingsProfile FindProfileByName(string profileName)
-        {
-            var profileHandle = DRSApi.FindProfileByName(Handle, profileName);
-
-            if (profileHandle.IsNull)
-            {
-                return null;
-            }
-
-            return new DriverSettingsProfile(profileHandle, this);
-        }
-
-        /// <summary>
-        ///     Resets all settings to default.
-        /// </summary>
-        public void RestoreDefaults()
-        {
-            DRSApi.RestoreDefaults(Handle);
-        }
-
-        /// <summary>
-        ///     Saves the current session settings
-        /// </summary>
-        public void Save()
-        {
-            DRSApi.SaveSettings(Handle);
-        }
-
-        /// <summary>
-        ///     Saves the current session settings to a file
-        /// </summary>
-        /// <param name="fileName">The full path of file to save settings to.</param>
-        public void Save(string fileName)
-        {
-            DRSApi.SaveSettings(Handle, fileName);
-        }
-
-        private void Load()
-        {
-            DRSApi.LoadSettings(Handle);
-        }
-
-        private void Load(string fileName)
-        {
-            DRSApi.LoadSettings(Handle, fileName);
-        }
-
-        private void ReleaseUnmanagedResources()
-        {
-            DRSApi.DestroySession(Handle);
-        }
-
-        /// <inheritdoc />
-        ~DriverSettingsSession()
-        {
-            ReleaseUnmanagedResources();
-        }
-    }
-}

app/NvAPIWrapper/DRS/KnownSettingId.cs

@@ -1,555 +0,0 @@
-using System.ComponentModel;
-
-namespace NvAPIWrapper.DRS
-{
-#pragma warning disable 1591
-    public enum KnownSettingId : uint
-    {
-        /// <summary>
-        ///     Antialiasing - Line gamma
-        /// </summary>
-        [Description("Antialiasing - Line gamma")]
-        OpenGLAntiAliasingLineGamma = 0x2089BF6C,
-
-        /// <summary>
-        ///     Deep color for 3D applications
-        /// </summary>
-        [Description("Deep color for 3D applications")]
-        OpenGLDeepColorScanOut = 0x2097C2F6,
-
-        /// <summary>
-        ///     OpenGL default swap interval
-        /// </summary>
-        [Description("OpenGL default swap interval")]
-        OpenGLDefaultSwapInterval = 0x206A6582,
-
-        /// <summary>
-        ///     OpenGL default swap interval fraction
-        /// </summary>
-        [Description("OpenGL default swap interval fraction")]
-        OpenGLDefaultSwapIntervalFractional = 0x206C4581,
-
-        /// <summary>
-        ///     OpenGL default swap interval sign
-        /// </summary>
-        [Description("OpenGL default swap interval sign")]
-        OpenGLDefaultSwapIntervalSign = 0x20655CFA,
-
-        /// <summary>
-        ///     Event Log Severity Threshold
-        /// </summary>
-        [Description("Event Log Severity Threshold")]
-        OpenGLEventLogSeverityThreshold = 0x209DF23E,
-
-        /// <summary>
-        ///     Extension String version
-        /// </summary>
-        [Description("Extension String version")]
-        OpenGLExtensionStringVersion = 0x20FF7493,
-
-        /// <summary>
-        ///     Buffer-flipping mode
-        /// </summary>
-        [Description("Buffer-flipping mode")] OpenGLForceBlit = 0x201F619F,
-
-        /// <summary>
-        ///     Force Stereo shuttering
-        /// </summary>
-        [Description("Force Stereo shuttering")]
-        OpenGLForceStereo = 0x204D9A0C,
-
-        /// <summary>
-        ///     Preferred OpenGL GPU
-        /// </summary>
-        [Description("Preferred OpenGL GPU")] OpenGLImplicitGPUAffinity = 0x20D0F3E6,
-
-        /// <summary>
-        ///     Maximum frames allowed
-        /// </summary>
-        [Description("Maximum frames allowed")]
-        OpenGLMaximumFramesAllowed = 0x208E55E3,
-
-        /// <summary>
-        ///     Exported Overlay pixel types
-        /// </summary>
-        [Description("Exported Overlay pixel types")]
-        OpenGLOverlayPixelType = 0x209AE66F,
-
-        /// <summary>
-        ///     Enable overlay
-        /// </summary>
-        [Description("Enable overlay")] OpenGLOverlaySupport = 0x206C28C4,
-
-        /// <summary>
-        ///     High level control of the rendering quality on OpenGL
-        /// </summary>
-        [Description("High level control of the rendering quality on OpenGL")]
-        OpenGLQualityEnhancements = 0x20797D6C,
-
-        /// <summary>
-        ///     Unified back/depth buffer
-        /// </summary>
-        [Description("Unified back/depth buffer")]
-        OpenGLSingleBackDepthBuffer = 0x20A29055,
-
-        /// <summary>
-        ///     Enable NV_gpu_multicast extension
-        /// </summary>
-        [Description("Enable NV_gpu_multicast extension")]
-        OpenGLSLIMulticast = 0x2092D3BE,
-
-        /// <summary>
-        ///     Threaded optimization
-        /// </summary>
-        [Description("Threaded optimization")] OpenGLThreadControl = 0x20C1221E,
-
-        /// <summary>
-        ///     Event Log Tmon Severity Threshold
-        /// </summary>
-        [Description("Event Log Tmon Severity Threshold")]
-        OpenGLTMONLevel = 0x202888C1,
-
-        /// <summary>
-        ///     Triple buffering
-        /// </summary>
-        [Description("Triple buffering")] OpenGLTripleBuffer = 0x20FDD1F9,
-
-        /// <summary>
-        ///     Antialiasing - Behavior Flags
-        /// </summary>
-        [Description("Antialiasing - Behavior Flags")]
-        AntiAliasingBehaviorFlags = 0x10ECDB82,
-
-        /// <summary>
-        ///     Antialiasing - Transparency Multisampling
-        /// </summary>
-        [Description("Antialiasing - Transparency Multisampling")]
-        AntiAliasingModeAlphaToCoverage = 0x10FC2D9C,
-
-        /// <summary>
-        ///     Antialiasing - Gamma correction
-        /// </summary>
-        [Description("Antialiasing - Gamma correction")]
-        AntiAliasingModeGammaCorrection = 0x107D639D,
-
-        /// <summary>
-        ///     Antialiasing - Setting
-        /// </summary>
-        [Description("Antialiasing - Setting")]
-        AntiAliasingModeMethod = 0x10D773D2,
-
-        /// <summary>
-        ///     Antialiasing - Transparency Supersampling
-        /// </summary>
-        [Description("Antialiasing - Transparency Supersampling")]
-        AntiAliasingModeReplay = 0x10D48A85,
-
-        /// <summary>
-        ///     Antialiasing - Mode
-        /// </summary>
-        [Description("Antialiasing - Mode")] AntiAliasingModeSelector = 0x107EFC5B,
-
-        /// <summary>
-        ///     Antialiasing - SLI AA
-        /// </summary>
-        [Description("Antialiasing - SLI AA")] AntiAliasingModeSelectorSLIAntiAliasing = 0x107AFC5B,
-
-        /// <summary>
-        ///     Anisotropic filtering setting
-        /// </summary>
-        [Description("Anisotropic filtering setting")]
-        AnisotropicModeLevel = 0x101E61A9,
-
-        /// <summary>
-        ///     Anisotropic filtering mode
-        /// </summary>
-        [Description("Anisotropic filtering mode")]
-        AnisotropicModeSelector = 0x10D2BB16,
-
-        /// <summary>
-        ///     NVIDIA Predefined Ansel Usage
-        /// </summary>
-        [Description("NVIDIA Predefined Ansel Usage")]
-        AnselAllow = 0x1035DB89,
-
-        /// <summary>
-        ///     Enable Ansel
-        /// </summary>
-        [Description("Enable Ansel")] AnselEnable = 0x1075D972,
-
-        /// <summary>
-        ///     Ansel flags for enabled applications
-        /// </summary>
-        [Description("Ansel flags for enabled applications")]
-        AnselWhiteListed = 0x1085DA8A,
-
-        /// <summary>
-        ///     Application Profile Notification Popup Timeout
-        /// </summary>
-        [Description("Application Profile Notification Popup Timeout")]
-        ApplicationProfileNotificationTimeOut = 0x104554B6,
-
-        /// <summary>
-        ///     Steam Application ID
-        /// </summary>
-        [Description("Steam Application ID")] ApplicationSteamId = 0x107CDDBC,
-
-        /// <summary>
-        ///     Battery Boost
-        /// </summary>
-        [Description("Battery Boost")] BatteryBoost = 0x10115C89,
-
-        /// <summary>
-        ///     Do not display this profile in the Control Panel
-        /// </summary>
-        [Description("Do not display this profile in the Control Panel")]
-        ControlPanelHiddenProfile = 0x106D5CFF,
-
-        /// <summary>
-        ///     List of Universal GPU ids
-        /// </summary>
-        [Description("List of Universal GPU ids")]
-        CUDAExcludedGPUs = 0x10354FF8,
-
-        /// <summary>
-        ///     Maximum GPU Power
-        /// </summary>
-        [Description("Maximum GPU Power")] D3DOpenGLGPUMaximumPower = 0x10D1EF29,
-
-        /// <summary>
-        ///     Export Performance Counters
-        /// </summary>
-        [Description("Export Performance Counters")]
-        ExportPerformanceCounters = 0x108F0841,
-
-        /// <summary>
-        ///     NVIDIA Predefined FXAA Usage
-        /// </summary>
-        [Description("NVIDIA Predefined FXAA Usage")]
-        FXAAAllow = 0x1034CB89,
-
-        /// <summary>
-        ///     Enable FXAA
-        /// </summary>
-        [Description("Enable FXAA")] FXAAEnable = 0x1074C972,
-
-        /// <summary>
-        ///     Enable FXAA Indicator
-        /// </summary>
-        [Description("Enable FXAA Indicator")] FXAAIndicatorEnable = 0x1068FB9C,
-
-        /// <summary>
-        ///     SLI indicator
-        /// </summary>
-        [Description("SLI indicator")] MCSFRShowSplit = 0x10287051,
-
-        /// <summary>
-        ///     NVIDIA Quality upscaling
-        /// </summary>
-        [Description("NVIDIA Quality upscaling")]
-        NvidiaQualityUpScaling = 0x10444444,
-
-        /// <summary>
-        ///     Maximum AA samples allowed for a given application
-        /// </summary>
-        [Description("Maximum AA samples allowed for a given application")]
-        OptimusMaximumAntiAliasing = 0x10F9DC83,
-
-        /// <summary>
-        ///     Display the PhysX indicator
-        /// </summary>
-        [Description("Display the PhysX indicator")]
-        PhysxIndicator = 0x1094F16F,
-
-        /// <summary>
-        ///     Power management mode
-        /// </summary>
-        [Description("Power management mode")] PreferredPerformanceState = 0x1057EB71,
-
-        /// <summary>
-        ///     No override of Anisotropic filtering
-        /// </summary>
-        [Description("No override of Anisotropic filtering")]
-        PreventUiAnisotropicOverride = 0x103BCCB5,
-
-        /// <summary>
-        ///     Frame Rate Limiter
-        /// </summary>
-        [Description("Frame Rate Limiter")] PerformanceStateFrameRateLimiter = 0x10834FEE,
-
-        /// <summary>
-        ///     Frame Rate Limiter 2 Control
-        /// </summary>
-        [Description("Frame Rate Limiter 2 Control")]
-        PerformanceStateFrameRateLimiter2Control = 0x10834FFF,
-
-        /// <summary>
-        ///     Frame Rate Monitor
-        /// </summary>
-        [Description("Frame Rate Monitor")] PerformanceStateFrameRateLimiterGpsControl = 0x10834F01,
-
-        /// <summary>
-        ///     Frame Rate Monitor Control
-        /// </summary>
-        [Description("Frame Rate Monitor Control")]
-        PerformanceStateFrameRateMonitorControl = 0x10834F05,
-
-        /// <summary>
-        ///     Maximum resolution allowed for a given application
-        /// </summary>
-        [Description("Maximum resolution allowed for a given application")]
-        ShimMaxResolution = 0x10F9DC82,
-
-        /// <summary>
-        ///     Optimus flags for enabled applications
-        /// </summary>
-        [Description("Optimus flags for enabled applications")]
-        ShimMCCOMPAT = 0x10F9DC80,
-
-        /// <summary>
-        ///     Enable application for Optimus
-        /// </summary>
-        [Description("Enable application for Optimus")]
-        ShimRenderingMode = 0x10F9DC81,
-
-        /// <summary>
-        ///     Shim Rendering Mode Options per application for Optimus
-        /// </summary>
-        [Description("Shim Rendering Mode Options per application for Optimus")]
-        ShimRenderingOptions = 0x10F9DC84,
-
-        /// <summary>
-        ///     Number of GPUs to use on SLI rendering mode
-        /// </summary>
-        [Description("Number of GPUs to use on SLI rendering mode")]
-        SLIGPUCount = 0x1033DCD1,
-
-        /// <summary>
-        ///     NVIDIA predefined number of GPUs to use on SLI rendering mode
-        /// </summary>
-        [Description("NVIDIA predefined number of GPUs to use on SLI rendering mode")]
-        SLIPredefinedGPUCount = 0x1033DCD2,
-
-        /// <summary>
-        ///     NVIDIA predefined number of GPUs to use on SLI rendering mode on DirectX 10
-        /// </summary>
-        [Description("NVIDIA predefined number of GPUs to use on SLI rendering mode on DirectX 10")]
-        SLIPredefinedGPUCountDX10 = 0x1033DCD3,
-
-        /// <summary>
-        ///     NVIDIA predefined SLI mode
-        /// </summary>
-        [Description("NVIDIA predefined SLI mode")]
-        SLIPredefinedMode = 0x1033CEC1,
-
-        /// <summary>
-        ///     NVIDIA predefined SLI mode on DirectX 10
-        /// </summary>
-        [Description("NVIDIA predefined SLI mode on DirectX 10")]
-        SLIPredefinedModeDX10 = 0x1033CEC2,
-
-        /// <summary>
-        ///     SLI rendering mode
-        /// </summary>
-        [Description("SLI rendering mode")] SLIRenderingMode = 0x1033CED1,
-
-        /// <summary>
-        ///     Virtual Reality pre-rendered frames
-        /// </summary>
-        [Description("Virtual Reality pre-rendered frames")]
-        VRPreRenderLimit = 0x10111133,
-
-        /// <summary>
-        ///     Toggle the VRR global feature
-        /// </summary>
-        [Description("Toggle the VRR global feature")]
-        VRRFeatureIndicator = 0x1094F157,
-
-        /// <summary>
-        ///     Display the VRR Overlay Indicator
-        /// </summary>
-        [Description("Display the VRR Overlay Indicator")]
-        VRROverlayIndicator = 0x1095F16F,
-
-        /// <summary>
-        ///     VRR requested state
-        /// </summary>
-        [Description("VRR requested state")] VRRRequestState = 0x1094F1F7,
-
-        /// <summary>
-        ///     G-SYNC
-        /// </summary>
-        [Description("G-SYNC")] VRRApplicationOverride = 0x10A879CF,
-
-        /// <summary>
-        ///     G-SYNC
-        /// </summary>
-        [Description("G-SYNC")] VRRApplicationOverrideRequestState = 0x10A879AC,
-
-        /// <summary>
-        ///     Enable G-SYNC globally
-        /// </summary>
-        [Description("Enable G-SYNC globally")]
-        VRRMode = 0x1194F158,
-
-        /// <summary>
-        ///     Flag to control smooth AFR behavior
-        /// </summary>
-        [Description("Flag to control smooth AFR behavior")]
-        VSyncSmoothAFR = 0x101AE763,
-
-        /// <summary>
-        ///     Variable refresh Rate
-        /// </summary>
-        [Description("Variable refresh Rate")] VSyncVRRControl = 0x10A879CE,
-
-        /// <summary>
-        ///     Vsync - Behavior Flags
-        /// </summary>
-        [Description("Vsync - Behavior Flags")]
-        VSyncBehaviorFlags = 0x10FDEC23,
-
-        /// <summary>
-        ///     Stereo - Swap eyes
-        /// </summary>
-        [Description("Stereo - Swap eyes")] WKSAPIStereoEyesExchange = 0x11AE435C,
-
-        /// <summary>
-        ///     Stereo - Display mode
-        /// </summary>
-        [Description("Stereo - Display mode")] WKSAPIStereoMode = 0x11E91A61,
-
-        /// <summary>
-        ///     Memory Allocation Policy
-        /// </summary>
-        [Description("Memory Allocation Policy")]
-        WKSMemoryAllocationPolicy = 0x11112233,
-
-        /// <summary>
-        ///     Stereo - Dongle Support
-        /// </summary>
-        [Description("Stereo - Dongle Support")]
-        WKSStereoDongleSupport = 0x112493BD,
-
-        /// <summary>
-        ///     Stereo - Enable
-        /// </summary>
-        [Description("Stereo - Enable")] WKSStereoSupport = 0x11AA9E99,
-
-        /// <summary>
-        ///     Stereo <20> swap mode
-        /// </summary>
-        [Description("Stereo <20> swap mode")] WKSStereoSwapMode = 0x11333333,
-
-        /// <summary>
-        ///     Ambient Occlusion
-        /// </summary>
-        [Description("Ambient Occlusion")] AmbientOcclusionMode = 0x667329,
-
-        /// <summary>
-        ///     NVIDIA Predefined Ambient Occlusion Usage
-        /// </summary>
-        [Description("NVIDIA Predefined Ambient Occlusion Usage")]
-        AmbientOcclusionModeActive = 0x664339,
-
-        /// <summary>
-        ///     Texture filtering - Driver Controlled LOD Bias
-        /// </summary>
-        [Description("Texture filtering - Driver Controlled LOD Bias")]
-        AutoLODBiasAdjust = 0x638E8F,
-
-        /// <summary>
-        ///     Export Performance Counters for DX9 only
-        /// </summary>
-        [Description("Export Performance Counters for DX9 only")]
-        ExportPerformanceCountersDX9Only = 0xB65E72,
-
-        /// <summary>
-        ///     ICafe Settings
-        /// </summary>
-        [Description("ICafe Settings")] ICafeLogoConfig = 0xDB1337,
-
-        /// <summary>
-        ///     Texture filtering - LOD Bias
-        /// </summary>
-        [Description("Texture filtering - LOD Bias")]
-        LODBiasAdjust = 0x738E8F,
-
-        /// <summary>
-        ///     Enable sample interleaving (MFAA)
-        /// </summary>
-        [Description("Enable sample interleaving (MFAA)")]
-        MaxwellBSampleInterleave = 0x98C1AC,
-
-        /// <summary>
-        ///     Maximum pre-rendered frames
-        /// </summary>
-        [Description("Maximum pre-rendered frames")]
-        PreRenderLimit = 0x7BA09E,
-
-        /// <summary>
-        ///     Shader Cache
-        /// </summary>
-        [Description("Shader Cache")] PerformanceStateShaderDiskCache = 0x198FFF,
-
-        /// <summary>
-        ///     Texture filtering - Anisotropic sample optimization
-        /// </summary>
-        [Description("Texture filtering - Anisotropic sample optimization")]
-        PerformanceStateTextureFilteringAnisotropicOptimization = 0xE73211,
-
-        /// <summary>
-        ///     Texture filtering - Anisotropic filter optimization
-        /// </summary>
-        [Description("Texture filtering - Anisotropic filter optimization")]
-        PerformanceStateTextureFilteringBiLinearInAnisotropic = 0x84CD70,
-
-        /// <summary>
-        ///     Texture filtering - Trilinear optimization
-        /// </summary>
-        [Description("Texture filtering - Trilinear optimization")]
-        PerformanceStateTextureFilteringDisableTrilinearSlope = 0x2ECAF2,
-
-        /// <summary>
-        ///     Texture filtering - Negative LOD bias
-        /// </summary>
-        [Description("Texture filtering - Negative LOD bias")]
-        PerformanceStateTextureFilteringNoNegativeLODBias = 0x19BB68,
-
-        /// <summary>
-        ///     Texture filtering - Quality
-        /// </summary>
-        [Description("Texture filtering - Quality")]
-        QualityEnhancements = 0xCE2691,
-
-        /// <summary>
-        ///     Preferred refresh rate
-        /// </summary>
-        [Description("Preferred refresh rate")]
-        RefreshRateOverride = 0x64B541,
-
-        /// <summary>
-        ///     PowerThrottle
-        /// </summary>
-        [Description("PowerThrottle")] SetPowerThrottleForPCIeCompliance = 0xAE785C,
-
-        /// <summary>
-        ///     VAB Default Data
-        /// </summary>
-        [Description("VAB Default Data")] SetVABData = 0xAB8687,
-
-        /// <summary>
-        ///     Vertical Sync
-        /// </summary>
-        [Description("Vertical Sync")] VSyncMode = 0xA879CF,
-
-        /// <summary>
-        ///     Vertical Sync Tear Control
-        /// </summary>
-        [Description("Vertical Sync Tear Control")]
-        VSyncTearControl = 0x5A375C,
-
-        InvalidSetting = 0xFFFFFFFF
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/ProfileApplication.cs

@@ -1,424 +0,0 @@
-using System;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.DRS.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.DRS
-{
-    /// <summary>
-    ///     Represents an application rule registered in a profile
-    /// </summary>
-    public class ProfileApplication
-    {
-        private IDRSApplication _application;
-
-        internal ProfileApplication(IDRSApplication application, DriverSettingsProfile profile)
-        {
-            Profile = profile;
-            _application = application;
-        }
-
-        /// <summary>
-        ///     Gets the application name
-        /// </summary>
-        public string ApplicationName
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                return _application.ApplicationName;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the application command line
-        /// </summary>
-        public string CommandLine
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                if (_application is DRSApplicationV4 applicationV4)
-                {
-                    return applicationV4.ApplicationCommandLine;
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a list of files that are necessary to be present inside the application parent directory
-        /// </summary>
-        public string[] FilesInFolder
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                if (_application is DRSApplicationV2 applicationV2)
-                {
-                    return applicationV2.FilesInFolder;
-                }
-
-                if (_application is DRSApplicationV3 applicationV3)
-                {
-                    return applicationV3.FilesInFolder;
-                }
-
-                if (_application is DRSApplicationV4 applicationV4)
-                {
-                    return applicationV4.FilesInFolder;
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the application friendly name
-        /// </summary>
-        public string FriendlyName
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                return _application.FriendlyName;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application rule needs a specific command line; or <see langword="null" />
-        ///     if this information is not available.
-        /// </summary>
-        public bool? HasCommandLine
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                if (_application is DRSApplicationV3 applicationV3)
-                {
-                    return applicationV3.HasCommandLine;
-                }
-
-                if (_application is DRSApplicationV4 applicationV4)
-                {
-                    return applicationV4.HasCommandLine;
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application is a metro application; or <see langword="null" /> if this
-        ///     information is not available.
-        /// </summary>
-        public bool? IsMetroApplication
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                if (_application is DRSApplicationV3 applicationV3)
-                {
-                    return applicationV3.IsMetroApplication;
-                }
-
-                if (_application is DRSApplicationV4 applicationV4)
-                {
-                    return applicationV4.IsMetroApplication;
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application is predefined by the NVIDIA driver
-        /// </summary>
-        public bool IsPredefined
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                return _application.IsPredefined;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this instance of <see cref="ProfileApplication" /> is a valid instance
-        ///     representing an application in a profile
-        /// </summary>
-        public bool IsValid
-        {
-            get => _application != null && Profile.IsValid;
-        }
-
-        /// <summary>
-        ///     Gets the application launcher name
-        /// </summary>
-        public string LauncherName
-        {
-            get
-            {
-                if (!IsValid)
-                {
-                    throw new InvalidOperationException(
-                        "Can not perform this operation with an invalid application instance."
-                    );
-                }
-
-                return _application.LauncherName;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the parent profile instance
-        /// </summary>
-        public DriverSettingsProfile Profile { get; }
-
-        /// <summary>
-        ///     Creates a new application
-        /// </summary>
-        /// <param name="profile">The profile to create the new application in.</param>
-        /// <param name="applicationName">The application name (with extension).</param>
-        /// <param name="friendlyName">The application friendly name.</param>
-        /// <param name="launcherName">The application launcher name.</param>
-        /// <param name="fileInFolders">An array of files necessary to be present inside the application parent directory.</param>
-        /// <param name="isMetro">A boolean value indicating if this application is a metro application.</param>
-        /// <param name="commandLine">The application command line string.</param>
-        /// <returns>A new instance of <see cref="ProfileApplication" /> representing the newly created application.</returns>
-        // ReSharper disable once TooManyArguments
-        // ReSharper disable once FunctionComplexityOverflow
-        public static ProfileApplication CreateApplication(
-            DriverSettingsProfile profile,
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            var createDelegates = new Func<string, string, string, string[], bool, string, IDRSApplication>[]
-            {
-                CreateApplicationInstanceV4,
-                CreateApplicationInstanceV3,
-                CreateApplicationInstanceV2,
-                CreateApplicationInstanceV1
-            };
-
-            Exception lastException = null;
-            IDRSApplication application = null;
-
-            foreach (var func in createDelegates)
-            {
-                try
-                {
-                    // ReSharper disable once EventExceptionNotDocumented
-                    application = func(
-                        applicationName,
-                        friendlyName,
-                        launcherName,
-                        fileInFolders,
-                        isMetro,
-                        commandLine
-                    );
-
-                    break;
-                }
-                catch (NVIDIANotSupportedException e)
-                {
-                    // ignore
-                    lastException = e;
-                }
-            }
-
-            if (application == null)
-            {
-                // ReSharper disable once ThrowingSystemException
-                throw lastException;
-            }
-
-            application = DRSApi.CreateApplication(profile.Session.Handle, profile.Handle, application);
-
-            return new ProfileApplication(application, profile);
-        }
-
-        // ReSharper disable once TooManyArguments
-        private static IDRSApplication CreateApplicationInstanceV1(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            if (!string.IsNullOrWhiteSpace(commandLine))
-            {
-                throw new NotSupportedException(
-                    "CommandLine is not supported with the current execution environment."
-                );
-            }
-
-            if (fileInFolders?.Length > 0)
-            {
-                throw new NotSupportedException(
-                    "Same folder file presence check is not supported with the current execution environment."
-                );
-            }
-
-            return new DRSApplicationV1(
-                applicationName,
-                friendlyName,
-                launcherName
-            );
-        }
-
-        // ReSharper disable once TooManyArguments
-        private static IDRSApplication CreateApplicationInstanceV2(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            if (!string.IsNullOrWhiteSpace(commandLine))
-            {
-                throw new NotSupportedException(
-                    "CommandLine is not supported with the current execution environment."
-                );
-            }
-
-            return new DRSApplicationV2(
-                applicationName,
-                friendlyName,
-                launcherName,
-                fileInFolders
-            );
-        }
-
-        // ReSharper disable once TooManyArguments
-        private static IDRSApplication CreateApplicationInstanceV3(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            if (!string.IsNullOrWhiteSpace(commandLine))
-            {
-                throw new NotSupportedException(
-                    "CommandLine is not supported with the current execution environment."
-                );
-            }
-
-            return new DRSApplicationV3(
-                applicationName,
-                friendlyName,
-                launcherName,
-                fileInFolders,
-                isMetro
-            );
-        }
-
-        // ReSharper disable once TooManyArguments
-        private static IDRSApplication CreateApplicationInstanceV4(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            return new DRSApplicationV4(
-                applicationName,
-                friendlyName,
-                launcherName,
-                fileInFolders,
-                isMetro,
-                commandLine
-            );
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (!IsValid)
-            {
-                return "[Invalid]";
-            }
-
-            if (IsPredefined)
-            {
-                return $"{ApplicationName} (Predefined)";
-            }
-
-            return ApplicationName;
-        }
-
-        /// <summary>
-        ///     Deletes this application and makes this instance invalid
-        /// </summary>
-        public void Delete()
-        {
-            if (!IsValid)
-            {
-                throw new InvalidOperationException(
-                    "Can not perform this operation with an invalid application instance."
-                );
-            }
-
-            DRSApi.DeleteApplication(Profile.Session.Handle, Profile.Handle, _application);
-            _application = null;
-        }
-    }
-}

app/NvAPIWrapper/DRS/ProfileSetting.cs

@@ -1,126 +0,0 @@
-using System;
-using NvAPIWrapper.Native.DRS;
-using NvAPIWrapper.Native.DRS.Structures;
-
-namespace NvAPIWrapper.DRS
-{
-    /// <summary>
-    ///     Represents a profile setting and its value
-    /// </summary>
-    public class ProfileSetting
-    {
-        private readonly DRSSettingV1 _setting;
-
-        internal ProfileSetting(DRSSettingV1 setting)
-        {
-            _setting = setting;
-        }
-
-        /// <summary>
-        ///     Gets the current value of the setting
-        /// </summary>
-        public object CurrentValue
-        {
-            get
-            {
-                if (IsPredefinedValueValid && IsCurrentValuePredefined)
-                {
-                    return _setting.PredefinedValue;
-                }
-
-                return _setting.CurrentValue;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the current value is the predefined value.
-        /// </summary>
-        public bool IsCurrentValuePredefined
-        {
-            get => _setting.IsCurrentValuePredefined;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this setting had a predefined valid value.
-        /// </summary>
-        public bool IsPredefinedValueValid
-        {
-            get => _setting.IsPredefinedValueValid;
-        }
-
-        /// <summary>
-        ///     Gets the predefined value of this setting.
-        /// </summary>
-        public object PredefinedValue
-        {
-            get
-            {
-                if (!IsPredefinedValueValid)
-                {
-                    throw new InvalidOperationException("Predefined value is not valid.");
-                }
-
-                return _setting.PredefinedValue;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the setting identification number
-        /// </summary>
-        public uint SettingId
-        {
-            get => _setting.Id;
-        }
-
-        /// <summary>
-        ///     Gets additional information regarding this setting including possible valid values
-        /// </summary>
-        public SettingInfo SettingInfo
-        {
-            get => SettingInfo.FromId(SettingId);
-        }
-
-        /// <summary>
-        ///     Gets the profile location of this setting
-        /// </summary>
-        public DRSSettingLocation SettingLocation
-        {
-            get => _setting.SettingLocation;
-        }
-
-        /// <summary>
-        ///     Gets the value type of this setting
-        /// </summary>
-        public DRSSettingType SettingType
-        {
-            get => _setting.SettingType;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            string settingName = null;
-
-            try
-            {
-                settingName = SettingInfo.Name;
-            }
-            catch
-            {
-                // ignore;
-            }
-
-            if (string.IsNullOrWhiteSpace(settingName))
-            {
-                settingName = $"#{SettingId:X}";
-            }
-
-            if (IsCurrentValuePredefined)
-            {
-                return $"{settingName} = {CurrentValue ?? "[NULL]"} (Predefined)";
-            }
-
-            return $"{settingName} = {CurrentValue ?? "[NULL]"}";
-        }
-    }
-}

app/NvAPIWrapper/DRS/SettingInfo.cs

@@ -1,360 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
-using System.Reflection;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.DRS;
-
-namespace NvAPIWrapper.DRS
-{
-    /// <summary>
-    ///     Contains information about a setting
-    /// </summary>
-    public class SettingInfo
-    {
-        private static uint[] _availableSettingIds;
-
-        private SettingInfo(uint settingId)
-        {
-            SettingId = settingId;
-        }
-
-        /// <summary>
-        ///     Gets an array of available possible valid values.
-        /// </summary>
-        public object[] AvailableValues
-        {
-            get
-            {
-                if (!IsAvailable)
-                {
-                    return null;
-                }
-
-                return DRSApi.EnumAvailableSettingValues(SettingId).Values;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the default value of this setting
-        /// </summary>
-        public object DefaultValue
-        {
-            get
-            {
-                if (!IsAvailable)
-                {
-                    return null;
-                }
-
-                var values = DRSApi.EnumAvailableSettingValues(SettingId);
-
-                return values.DefaultValue;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this setting is available on this machine and with the current version of NVIDIA
-        ///     driver
-        /// </summary>
-        public bool IsAvailable
-        {
-            get => GetAvailableSetting().Any(info => info.SettingId == SettingId);
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this setting is know by this library
-        /// </summary>
-        public bool IsKnown
-        {
-            get => IsSettingKnown(SettingId);
-        }
-
-        /// <summary>
-        ///     Gets the description of this setting from the library or <see langword="null" /> if this setting is not known by
-        ///     the library.
-        /// </summary>
-        public string KnownDescription
-        {
-            get
-            {
-                if (!IsKnown || KnownSettingId == null)
-                {
-                    return null;
-                }
-
-                return GetSettingDescription(KnownSettingId.Value);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the known identification number of this setting from the library or <see langword="null" /> if this setting is
-        ///     not known by the library.
-        /// </summary>
-        public KnownSettingId? KnownSettingId
-        {
-            get
-            {
-                if (!IsKnown)
-                {
-                    return null;
-                }
-
-                return GetKnownSettingId(SettingId);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the type of a static class or an enum containing possible known values for this setting from the library or
-        ///     <see langword="null" /> if this setting is not known by the library
-        /// </summary>
-        public Type KnownValueType
-        {
-            get
-            {
-                if (!IsKnown || !IsAvailable)
-                {
-                    return null;
-                }
-
-                var name = KnownSettingId.ToString();
-                var nameSpace = typeof(SettingInfo).Namespace + ".SettingValues";
-
-                if (SettingType == DRSSettingType.Integer)
-                {
-                    return Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(type =>
-                        type.IsEnum &&
-                        type.Namespace?.Equals(nameSpace, StringComparison.InvariantCultureIgnoreCase) == true &&
-                        type.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
-                }
-
-                if (SettingType == DRSSettingType.String || SettingType == DRSSettingType.UnicodeString)
-                {
-                    return Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(type =>
-                        type.IsClass &&
-                        type.Namespace?.Equals(nameSpace, StringComparison.InvariantCultureIgnoreCase) == true &&
-                        type.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the name of the setting from NVIDIA driver or <see langword="null" /> if the setting is not available on this
-        ///     machine.
-        /// </summary>
-        public string Name
-        {
-            get
-            {
-                if (!IsAvailable)
-                {
-                    return null;
-                }
-
-                return DRSApi.GetSettingNameFromId(SettingId);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the setting identification number
-        /// </summary>
-        public uint SettingId { get; }
-
-        /// <summary>
-        ///     Gets the value type of the setting from NVIDIA driver or <see langword="null" /> if the setting is not available on
-        ///     this machine.
-        /// </summary>
-        public DRSSettingType? SettingType
-        {
-            get
-            {
-                if (!IsAvailable)
-                {
-                    return null;
-                }
-
-                var values = DRSApi.EnumAvailableSettingValues(SettingId);
-
-                return values.SettingType;
-            }
-        }
-
-        /// <summary>
-        ///     Gets information regarding a setting from its identification number.
-        /// </summary>
-        /// <param name="settingId">The identification number of the setting to get information about.</param>
-        /// <returns>An instance of <see cref="SettingInfo" /> containing information about the setting.</returns>
-        public static SettingInfo FromId(uint settingId)
-        {
-            return new SettingInfo(settingId);
-        }
-
-        /// <summary>
-        ///     Gets information regarding a setting from its known identification number.
-        /// </summary>
-        /// <param name="settingId">The known identification number of the setting to get information about.</param>
-        /// <returns>An instance of <see cref="SettingInfo" /> containing information about the setting.</returns>
-        public static SettingInfo FromKnownSettingId(KnownSettingId settingId)
-        {
-            return FromId(GetSettingId(settingId));
-        }
-
-        /// <summary>
-        ///     Gets information regarding a setting from its name.
-        /// </summary>
-        /// <param name="settingName">The name of the setting to get information about.</param>
-        /// <returns>An instance of <see cref="SettingInfo" /> containing information about the setting.</returns>
-        public static SettingInfo FromName(string settingName)
-        {
-            var settingId = DRSApi.GetSettingIdFromName(settingName);
-
-            return FromId(settingId);
-        }
-
-        /// <summary>
-        ///     Gets a list of all available setting on this machine
-        /// </summary>
-        /// <returns>Instances of <see cref="SettingInfo" /> each representing a available setting on this machine.</returns>
-        public static SettingInfo[] GetAvailableSetting()
-        {
-            if (_availableSettingIds == null)
-            {
-                _availableSettingIds = DRSApi.EnumAvailableSettingIds();
-            }
-
-            return _availableSettingIds.Select(FromId).ToArray();
-        }
-
-        /// <summary>
-        ///     Gets the known identification number of a setting from its identification number
-        /// </summary>
-        /// <param name="settingId">The setting identification number.</param>
-        /// <returns>The known setting identification number if the setting is known; otherwise <see langword="null" />.</returns>
-        public static KnownSettingId? GetKnownSettingId(uint settingId)
-        {
-            if (!IsSettingKnown(settingId))
-            {
-                return null;
-            }
-
-            return (KnownSettingId) settingId;
-        }
-
-        /// <summary>
-        ///     Gets the known setting description from its identification number
-        /// </summary>
-        /// <param name="knownSettingId">The known setting identification number.</param>
-        /// <returns>The known setting description if available; otherwise <see langword="null" />.</returns>
-        public static string GetSettingDescription(KnownSettingId knownSettingId)
-        {
-            var enumName = Enum.GetName(typeof(KnownSettingId), knownSettingId);
-
-            if (enumName == null)
-            {
-                return null;
-            }
-
-            var enumField = typeof(KnownSettingId).GetField(enumName);
-
-            if (enumField == null)
-            {
-                return null;
-            }
-
-            var descriptionAttribute = enumField
-                .GetCustomAttributes(typeof(DescriptionAttribute), false)
-                .OfType<DescriptionAttribute>()
-                .FirstOrDefault();
-
-            if (string.IsNullOrWhiteSpace(descriptionAttribute?.Description))
-            {
-                return null;
-            }
-
-            return descriptionAttribute.Description;
-        }
-
-        /// <summary>
-        ///     Gets the identification number of a setting from its known identification number
-        /// </summary>
-        /// <param name="knownSettingId">The known setting identification number.</param>
-        /// <returns>The setting identification number.</returns>
-        public static uint GetSettingId(KnownSettingId knownSettingId)
-        {
-            return (uint) knownSettingId;
-        }
-
-        /// <summary>
-        ///     Checks if a setting is known by this library.
-        /// </summary>
-        /// <param name="settingId">The setting identification number.</param>
-        /// <returns>true if setting is known by this library; otherwise false.</returns>
-        public static bool IsSettingKnown(uint settingId)
-        {
-            return Enum.IsDefined(typeof(KnownSettingId), settingId);
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            try
-            {
-                var settingName = Name;
-
-                if (!string.IsNullOrWhiteSpace(settingName))
-                {
-                    return settingName;
-                }
-            }
-            catch
-            {
-                // ignore;
-            }
-
-            return $"#{SettingId:X}";
-        }
-
-        /// <summary>
-        ///     Tries to resolve the name of a known value using its actual value
-        /// </summary>
-        /// <param name="value">The actual value</param>
-        /// <returns>The name of the known value member.</returns>
-        public string ResolveKnownValueName(object value)
-        {
-            if (!IsKnown)
-            {
-                return null;
-            }
-
-            var valueType = KnownValueType;
-
-            if (valueType == null)
-            {
-                return null;
-            }
-
-            if (valueType.IsEnum)
-            {
-                return Enum.GetName(valueType, value);
-            }
-
-            var comparerType = typeof(EqualityComparer<>).MakeGenericType(value.GetType());
-            var comparer = comparerType.GetProperty(nameof(EqualityComparer<object>.Default))?.GetValue(null);
-
-            if (!(comparer is IEqualityComparer equalityComparer))
-            {
-                return null;
-            }
-
-            return valueType.GetFields()
-                .FirstOrDefault(info =>
-                    info.IsStatic &&
-                    equalityComparer.Equals(info.GetValue(null), value)
-                )?.Name;
-        }
-    }
-}

app/NvAPIWrapper/DRS/SettingValues/AmbientOcclusionMode.cs

@@ -1,17 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AmbientOcclusionMode : uint
-    {
-        Off = 0x0,
-
-        Low = 0x1,
-
-        Medium = 0x2,
-
-        High = 0x3,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AmbientOcclusionModeActive.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AmbientOcclusionModeActive : uint
-    {
-        Disabled = 0x0,
-
-        Enabled = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AnisotropicModeLevel.cs

@@ -1,17 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AnisotropicModeLevel : uint
-    {
-        Mask = 0xFFFF,
-
-        NonePoint = 0x0,
-
-        NoneLinear = 0x1,
-
-        Maximum = 0x10,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AnisotropicModeSelector.cs

@@ -1,19 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AnisotropicModeSelector : uint
-    {
-        Mask = 0xF,
-
-        Application = 0x0,
-
-        User = 0x1,
-
-        Condition = 0x2,
-
-        Maximum = 0x2,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AnselAllow.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AnselAllow : uint
-    {
-        Disallowed = 0x0,
-
-        Allowed = 0x1,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AnselEnable.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AnselEnable : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AnselWhiteListed.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AnselWhiteListed : uint
-    {
-        Disallowed = 0x0,
-
-        Allowed = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingBehaviorFlags.cs

@@ -1,43 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingBehaviorFlags : uint
-    {
-        None = 0x0,
-
-        TreatOverrideAsApplicationControlled = 0x1,
-
-        TreatOverrideAsEnhance = 0x2,
-
-        DisableOverride = 0x3,
-
-        TreatEnhanceAsApplicationControlled = 0x4,
-
-        TreatEnhanceAsOverride = 0x8,
-
-        DisableEnhance = 0xC,
-
-        MapVCAAToMultiSampling = 0x10000,
-
-        SLIDisableTransparencySupersampling = 0x20000,
-
-        DisableCplaa = 0x40000,
-
-        SkipRTDIMCheckForEnhance = 0x80000,
-
-        DisableSLIAntiAliasing = 0x100000,
-
-        Default = 0x0,
-
-        AntiAliasingRTBPPDIV4 = 0xF0000000,
-
-        AntiAliasingRTBPPDIV4Shift = 0x1C,
-
-        NonAntiAliasingRTBPPDIV4 = 0xF000000,
-
-        NonAntiAliasingRTBPPDIV4Shift = 0x18,
-
-        Mask = 0xFF1F000F
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeAlphaToCoverage.cs

@@ -1,17 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeAlphaToCoverage : uint
-    {
-        ModeMask = 0x4,
-
-        ModeOff = 0x0,
-
-        ModeOn = 0x4,
-
-        ModeMaximum = 0x4,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeGammaCorrection.cs

@@ -1,23 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeGammaCorrection : uint
-    {
-        Mask = 0x3,
-
-        Off = 0x0,
-
-        OnIfFOS = 0x1,
-
-        OnAlways = 0x2,
-
-        Maximum = 0x2,
-
-        Default = 0x0,
-
-        DefaultTesla = 0x2,
-
-        DefaultFermi = 0x2
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeMethod.cs

@@ -1,109 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeMethod : uint
-    {
-        None = 0x0,
-
-        SuperSample2XHorizontal = 0x1,
-
-        SuperSample2XVertical = 0x2,
-
-        SuperSample15X15 = 0x2,
-
-        Free0X03 = 0x3,
-
-        Free0X04 = 0x4,
-
-        SuperSample4X = 0x5,
-
-        SuperSample4XBias = 0x6,
-
-        SuperSample4XGaussian = 0x7,
-
-        Free0X08 = 0x8,
-
-        Free0X09 = 0x9,
-
-        SuperSample9X = 0xA,
-
-        SuperSample9XBias = 0xB,
-
-        SuperSample16X = 0xC,
-
-        SuperSample16XBias = 0xD,
-
-        MultiSample2XDiagonal = 0xE,
-
-        MultiSample2XQuincunx = 0xF,
-
-        MultiSample4X = 0x10,
-
-        Free0X11 = 0x11,
-
-        MultiSample4XGaussian = 0x12,
-
-        MixedSample4XSkewed4Tap = 0x13,
-
-        Free0X14 = 0x14,
-
-        Free0X15 = 0x15,
-
-        MixedSample6X = 0x16,
-
-        MixedSample6XSkewed6Tap = 0x17,
-
-        MixedSample8X = 0x18,
-
-        MixedSample8XSkewed8Tap = 0x19,
-
-        MixedSample16X = 0x1A,
-
-        MultiSample4XGamma = 0x1B,
-
-        MultiSample16X = 0x1C,
-
-        VCAA32X8V24 = 0x1D,
-
-        CorruptionCheck = 0x1E,
-
-        _6XCT = 0x1F,
-
-        MultiSample2XDiagonalGamma = 0x20,
-
-        SuperSample4XGamma = 0x21,
-
-        MultiSample4XFosgamma = 0x22,
-
-        MultiSample2XDiagonalFosgamma = 0x23,
-
-        SuperSample4XFosgamma = 0x24,
-
-        MultiSample8X = 0x25,
-
-        VCAA8X4V4 = 0x26,
-
-        VCAA16X4V12 = 0x27,
-
-        VCAA16X8V8 = 0x28,
-
-        MixedSample32X = 0x29,
-
-        SuperVCAA64X4V12 = 0x2A,
-
-        SuperVCAA64X8V8 = 0x2B,
-
-        MixedSample64X = 0x2C,
-
-        MixedSample128X = 0x2D,
-
-        Count = 0x2E,
-
-        MethodMask = 0xFFFF,
-
-        MethodMaximum = 0xF1C57815,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeReplay.cs

@@ -1,49 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeReplay : uint
-    {
-        SamplesMask = 0x70,
-
-        SamplesOne = 0x0,
-
-        SamplesTwo = 0x10,
-
-        SamplesFour = 0x20,
-
-        SamplesEight = 0x30,
-
-        SamplesMaximum = 0x30,
-
-        ModeMask = 0xF,
-
-        ModeOff = 0x0,
-
-        ModeAlphaTest = 0x1,
-
-        ModePixelKill = 0x2,
-
-        ModeDynamicBranch = 0x4,
-
-        ModeOptimal = 0x4,
-
-        ModeAll = 0x8,
-
-        ModeMaximum = 0xF,
-
-        Transparency = 0x23,
-
-        DisAllowTraa = 0x100,
-
-        TransparencyDefault = 0x0,
-
-        TransparencyDefaultTesla = 0x0,
-
-        TransparencyDefaultFermi = 0x0,
-
-        Mask = 0x17F,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeSelector.cs

@@ -1,19 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeSelector : uint
-    {
-        Mask = 0x3,
-
-        ApplicationControl = 0x0,
-
-        Override = 0x1,
-
-        Enhance = 0x2,
-
-        Maximum = 0x2,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AntiAliasingModeSelectorSLIAntiAliasing.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AntiAliasingModeSelectorSLIAntiAliasing : uint
-    {
-        Disabled = 0x0,
-
-        Enabled = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/ApplicationProfileNotificationTimeOut.cs

@@ -1,21 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum ApplicationProfileNotificationTimeOut : uint
-    {
-        Disabled = 0x0,
-
-        NineSeconds = 0x9,
-
-        FifteenSeconds = 0xF,
-
-        ThirtySeconds = 0x1E,
-
-        OneMinute = 0x3C,
-
-        TwoMinutes = 0x78,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/AutoLODBiasAdjust.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum AutoLODBiasAdjust : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/BatteryBoost.cs

@@ -1,17 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum BatteryBoost : uint
-    {
-        Minimum = 0x1,
-
-        Maximum = 0xFF,
-
-        Enabled = 0x10000000,
-
-        Disabled = 0x0,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/CUDAExcludedGPUs.cs

@@ -1,10 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public static class CUDAExcludedGPUs
-    {
-        public const string Default = "none";
-        public const string None = "none";
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/ControlPanelHiddenProfile.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum ControlPanelHiddenProfile : uint
-    {
-        Disabled = 0x0,
-
-        Enabled = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/D3DOpenGLGPUMaximumPower.cs

@@ -1,10 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public static class D3DOpenGLGPUMaximumPower
-    {
-        public const string Default = "0";
-        public const string DefaultPower = "0";
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/ExportPerformanceCounters.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum ExportPerformanceCounters : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/ExportPerformanceCountersDX9Only.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum ExportPerformanceCountersDX9Only : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/FXAAAllow.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum FXAAAllow : uint
-    {
-        Disallowed = 0x0,
-
-        Allowed = 0x1,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/FXAAEnable.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum FXAAEnable : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/FXAAIndicatorEnable.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum FXAAIndicatorEnable : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/LODBiasAdjust.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum LODBiasAdjust : uint
-    {
-        Minimum = 0xFFFFFF80,
-
-        Maximum = 0x80,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/MCSFRShowSplit.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum MCSFRShowSplit : uint
-    {
-        Disabled = 0x34534064,
-
-        Enabled = 0x24545582,
-
-        Default = 0x34534064
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/MaxwellBSampleInterleave.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum MaxwellBSampleInterleave : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/NvidiaQualityUpScaling.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum NvidiaQualityUpScaling : uint
-    {
-        Off = 0x0,
-
-        On = 0x1,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/OpenGLAntiAliasingLineGamma.cs

@@ -1,17 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum OpenGLAntiAliasingLineGamma : uint
-    {
-        Disabled = 0x10,
-
-        Enabled = 0x23,
-
-        Minimum = 0x1,
-
-        Maximum = 0x64,
-
-        Default = 0x10
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/OpenGLDeepColorScanOut.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum OpenGLDeepColorScanOut : uint
-    {
-        Disable = 0x0,
-
-        Enable = 0x1,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/OpenGLDefaultSwapInterval.cs

@@ -1,27 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum OpenGLDefaultSwapInterval : uint
-    {
-        Tear = 0x0,
-
-        VSyncOne = 0x1,
-
-        VSync = 0x1,
-
-        ValueMask = 0xFFFF,
-
-        ForceMask = 0xF0000000,
-
-        ForceOff = 0xF0000000,
-
-        ForceOn = 0x10000000,
-
-        ApplicationControlled = 0x0,
-
-        Disable = 0xFFFFFFFF,
-
-        Default = 0x1
-    }
-#pragma warning restore 1591
-}

app/NvAPIWrapper/DRS/SettingValues/OpenGLDefaultSwapIntervalFractional.cs

@@ -1,13 +0,0 @@
-namespace NvAPIWrapper.DRS.SettingValues
-{
-#pragma warning disable 1591
-    public enum OpenGLDefaultSwapIntervalFractional : uint
-    {
-        ZeroScanLines = 0x0,
-
-        OneFullFrameOfScanLines = 0x64,
-
-        Default = 0x0
-    }
-#pragma warning restore 1591
-}