Updates

* Added support for ROG Chakram Core (P511)

* Add support for the TUF M3 Gen II

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,11 +4,8 @@ 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.
-
+Bug reports without clear information or scenario to reproduce and logs from ``%AppData%\GHelper`` will be closed without answer. Please respect the time of the developer. Thanks.
 
 **Describe the bug**
 A clear and concise description of what the bug is.
@@ -34,7 +31,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/release.yml

@@ -3,6 +3,8 @@ name: Release
 on:
   release:
     types: [ published ]
+  workflow_dispatch:
+  
 
 permissions:
   contents: write
@@ -20,9 +22,9 @@ jobs:
     - 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-windows8.0/win-x64/publish/GHelper.exe GHelper.zip
+        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 }} app/bin/x64/Release/net7.0-windows8.0/win-x64/publish/GHelper.exe GHelper.zip
+        gh release upload ${{ github.ref_name }} GHelper.zip

app/AnimeMatrix/AniMatrixControl.cs

@@ -2,42 +2,49 @@
 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 AniMatrix
+    public class AniMatrixControl
     {
+
+        SettingsForm settings;
+
         System.Timers.Timer matrixTimer = default!;
-        AnimeMatrixDevice mat;
+        public AnimeMatrixDevice? device;
 
-        double[] AudioValues;
-        WasapiCapture AudioDevice;
+        double[]? AudioValues;
+        WasapiCapture? AudioDevice;
 
-        public bool IsValid => mat != null;
+        public bool IsValid => device != null;
 
         private long lastPresent;
         private List<double> maxes = new List<double>();
 
-        public AniMatrix()
+        public AniMatrixControl(SettingsForm settingsForm)
         {
+            settings = settingsForm;
+
             try
             {
-                mat = new AnimeMatrixDevice();
-                Task.Run(mat.WakeUp);
+                device = new AnimeMatrixDevice();
+                Task.Run(device.WakeUp);
                 matrixTimer = new System.Timers.Timer(100);
                 matrixTimer.Elapsed += MatrixTimer_Elapsed;
             }
             catch
             {
-                mat = null;
+                device = null;
             }
 
         }
 
-        public void SetMatrix()
+        public void SetMatrix(bool wakeUp = false)
         {
 
             if (!IsValid) return;
@@ -60,17 +67,28 @@ namespace GHelper.AnimeMatrix
             StopMatrixTimer();
             StopMatrixAudio();
 
-            mat.SetProvider();
+            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))
             {
-                mat.SetDisplayState(false);
+                device.SetDisplayState(false);
+                device.SetDisplayState(false); // some devices are dumb
                 Logger.WriteLine("Matrix Off");
             }
             else
             {
-                mat.SetDisplayState(true);
-                mat.SetBrightness((BrightnessMode)brightness);
+                device.SetDisplayState(true);
+                device.SetBrightness((BrightnessMode)brightness);
 
                 switch (running)
                 {
@@ -84,7 +102,7 @@ namespace GHelper.AnimeMatrix
                         SetMatrixAudio();
                         break;
                     default:
-                        mat.SetBuiltInAnimation(true, animation);
+                        device.SetBuiltInAnimation(true, animation);
                         Logger.WriteLine("Matrix builtin " + animation.AsByte);
                         break;
 
@@ -113,10 +131,10 @@ namespace GHelper.AnimeMatrix
             switch (AppConfig.Get("matrix_running"))
             {
                 case 2:
-                    mat.PresentNextFrame();
+                    device.PresentNextFrame();
                     break;
                 case 3:
-                    mat.PresentClock();
+                    device.PresentClock();
                     break;
             }
 
@@ -125,7 +143,7 @@ namespace GHelper.AnimeMatrix
 
         public void SetMatrixClock()
         {
-            mat.SetBuiltInAnimation(false);
+            device.SetBuiltInAnimation(false);
             StartMatrixTimer(1000);
             Logger.WriteLine("Matrix Clock");
         }
@@ -155,7 +173,7 @@ namespace GHelper.AnimeMatrix
         {
             if (!IsValid) return;
 
-            mat.SetBuiltInAnimation(false);
+            device.SetBuiltInAnimation(false);
             StopMatrixTimer();
             StopMatrixAudio();
 
@@ -224,8 +242,8 @@ namespace GHelper.AnimeMatrix
                 for (int x = 0; x < 2 - (y % 2); x++)
                 {
                     //color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
-                    mat.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
-                    mat.SetLedPlanar(x + dx, dy - y, 255);
+                    device.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
+                    device.SetLedPlanar(x + dx, dy - y, 255);
                 }
         }
 
@@ -235,7 +253,7 @@ namespace GHelper.AnimeMatrix
             if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
             lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
-            mat.Clear();
+            device.Clear();
 
             int size = 20;
             double[] bars = new double[size];
@@ -251,28 +269,67 @@ namespace GHelper.AnimeMatrix
             if (maxes.Count > 20) maxes.RemoveAt(0);
             maxAverage = maxes.Average();
 
-            for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i]*20/maxAverage);
+            for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i] * 20 / maxAverage);
 
-            mat.Present();
+            device.Present();
         }
 
 
-        public void SetMatrixPicture(string fileName)
+        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();
 
-            Image image;
-
             try
             {
                 using (var fs = new FileStream(fileName, FileMode.Open))
+                //using (var ms = new MemoryStream())
                 {
-                    var ms = new MemoryStream();
+                    /*
+                    ms.SetLength(0);
                     fs.CopyTo(ms);
                     ms.Position = 0;
-                    image = Image.FromStream(ms);
+                    */
+                    using (Image image = Image.FromStream(fs))
+                    {
+                        ProcessPicture(image);
+                        Logger.WriteLine("Matrix " + fileName);
+                    }
+
+                    fs.Close();
+                    if (visualise) settings.VisualiseMatrix(fileName);
                 }
             }
             catch
@@ -281,30 +338,63 @@ namespace GHelper.AnimeMatrix
                 return;
             }
 
-            mat.SetBuiltInAnimation(false);
-            mat.ClearFrames();
+        }
+
+        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 matrixContrast = AppConfig.Get("matrix_contrast", 100);
+            
+            int matrixSpeed = AppConfig.Get("matrix_speed", 50);
+
+            MatrixRotation rotation = (MatrixRotation)AppConfig.Get("matrix_rotation", 0); 
+
+            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);
-                    mat.GenerateFrame(image);
-                    mat.AddFrame();
+
+                    if (rotation == MatrixRotation.Planar)
+                        device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                    else
+                        device.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                    
+                    device.AddFrame();
                 }
 
-                StartMatrixTimer();
-                Logger.WriteLine("Matrix GIF " + fileName);
+
+                Logger.WriteLine("GIF Delay:" + frameDelay);
+                StartMatrixTimer(Math.Max(matrixSpeed, frameDelay));
+
+                //image.SelectActiveFrame(dimension, 0);
+
             }
             else
             {
-                mat.GenerateFrame(image);
-                mat.Present();
-                Logger.WriteLine("Matrix " + fileName);
+                if (rotation == MatrixRotation.Planar)
+                    device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+                else
+                    device.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast);
+
+                device.Present();
             }
+
         }
 
 

app/AnimeMatrix/AnimeMatrixDevice.cs

@@ -1,9 +1,8 @@
 // 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.Drawing.Text;
-using System.Globalization;
 using System.Management;
 using System.Text;
 
@@ -51,6 +50,12 @@ namespace Starlight.AnimeMatrix
         }
     }
 
+    public enum MatrixRotation
+    {
+        Planar,
+        Diagonal
+    }
+
     internal class AnimeMatrixPacket : Packet
     {
         public AnimeMatrixPacket(byte[] command)
@@ -77,6 +82,7 @@ namespace Starlight.AnimeMatrix
     }
 
 
+
     public class AnimeMatrixDevice : Device
     {
         int UpdatePageLength = 490;
@@ -86,35 +92,36 @@ 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;
-        //Shifts the whole frame to the left or right to align with the diagonal cut
-        public int frameShiftX = 0;
         public int MaxColumns = 34;
+        public int LedStart = 0;
+
+        public int FullRows = 11;
 
         private int frameIndex = 0;
 
         private static AnimeType _model = AnimeType.GA402;
 
+        [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)
+        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;
+
+                FullRows = 5;
+
+                LedStart = 1;
             }
 
             if (model.Contains("GU604"))
@@ -124,14 +131,28 @@ namespace Starlight.AnimeMatrix
                 MaxColumns = 39;
                 MaxRows = 92;
                 LedCount = 1711;
-                frameShiftX = -5;
                 UpdatePageLength = 630;
+
+                FullRows = 9;
             }
 
             _displayBuffer = new byte[LedCount];
 
+            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()
         {
@@ -175,28 +196,7 @@ 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;
-                    }
-                case AnimeType.GU604:
-                    return (int)Math.Ceiling(Math.Max(0, y - 9) / 2F);
-
-                default:
-                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
-            }
-        }
-
-        public static int Width(int y)
+        public int Width()
         {
             switch (_model)
             {
@@ -209,7 +209,30 @@ namespace Starlight.AnimeMatrix
             }
         }
 
-        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)
             {
@@ -226,15 +249,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);
 
@@ -245,10 +291,21 @@ namespace Starlight.AnimeMatrix
         {
             if (!IsRowInRange(y)) return;
 
-            if (x >= FirstX(y) && x < Width(y))
-                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x + dx + frameShiftX, value);
+            if (x >= FirstX(y) && x < Width())
+                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x, value);
         }
 
+        public void SetLedDiagonal(int x, int y, byte color, int deltaX = 0, int deltaY = 0)
+        {
+            x += deltaX;
+            y -= deltaY;
+
+            int plX = (x - y) / 2;
+            int plY = x + y;
+            SetLedPlanar(plX, plY, color);
+        }
+
+
         public void WakeUp()
         {
             Set(Packet<AnimeMatrixPacket>(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")));
@@ -342,57 +399,77 @@ namespace Starlight.AnimeMatrix
         }
 
 
-        public void PresentClock()
+        private void SetBitmapDiagonal(Bitmap bmp, int deltaX = 0, int deltaY = 0, int contrast = 100)
         {
-            int second = DateTime.Now.Second;
-            string time;
-
-            if (CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern.Contains("H"))
-                time = DateTime.Now.ToString("H" + ((second % 2 == 0) ? ":" : " ") + "mm");
-            else
-                time = DateTime.Now.ToString("h" + ((second % 2 == 0) ? ":" : " ") + "mmtt");
-
-            if (_model == AnimeType.GA401)
-                PresentText(time);
-            else
-                PresentTextDiagonal(time);
+            for (int y = 0; y < bmp.Height; y++)
+            {
+                for (int x = 0; x < bmp.Width; x++)
+                {
+                    var pixel = bmp.GetPixel(x, y);
+                    var color = Math.Min((pixel.R + pixel.G + pixel.B) * contrast / 300, 255);
+                    if (color > 20)
+                        SetLedDiagonal(x, y, (byte)color, deltaX + (FullRows / 2) + 1, deltaY - (FullRows / 2) - 1);
+                }
+            }
         }
 
-
-
-        public void PresentText(string text1, string text2 = "")
+        private void SetBitmapLinear(Bitmap bmp, int contrast = 100)
         {
-            using (Bitmap bmp = new Bitmap(MaxColumns * 3, MaxRows))
+            for (int y = 0; y < bmp.Height; y++)
+            {
+                for (int x = 0; x < bmp.Width; x++)
+                    if (x % 2 == y % 2)
+                    {
+                        var pixel = bmp.GetPixel(x, y);
+                        var color = Math.Min((pixel.R + pixel.G + pixel.B) * contrast / 300, 255);
+                        if (color > 20)
+                            SetLedPlanar(x / 2, y, (byte)color);
+                    }
+            }
+        }
+
+        public void Text(string text, float fontSize = 10, int x = 0, int y = 0)
+        {
+
+            int width = MaxRows - FullRows;
+            int height = MaxRows - FullRows;
+            int textHeight, textWidth;
+
+            using (Bitmap bmp = new Bitmap(width, height))
             {
                 using (Graphics g = Graphics.FromImage(bmp))
                 {
                     g.CompositingQuality = CompositingQuality.HighQuality;
                     g.SmoothingMode = SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
 
-                    using (Font font = new Font("Consolas", 21F, FontStyle.Regular, GraphicsUnit.Pixel))
+                    using (Font font = new Font(fonts.Families[0], fontSize, FontStyle.Regular, GraphicsUnit.Pixel))
                     {
-                        SizeF textSize = g.MeasureString(text1, font);
-                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
+                        SizeF textSize = g.MeasureString(text, font);
+                        textHeight = (int)textSize.Height;
+                        textWidth = (int)textSize.Width;
+                        g.DrawString(text, font, Brushes.White, x, height - y);
                     }
-
-                    if (text2.Length > 0)
-                        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);
-                        }
-
                 }
 
-                GenerateFrame(bmp, InterpolationMode.Bicubic);
-                Present();
-            }
+                SetBitmapDiagonal(bmp, (width - textWidth), height);
 
+            }
         }
 
-        public void GenerateFrame(Image image, InterpolationMode interpolation = InterpolationMode.High)
+        public void PresentClock()
         {
+            string second = (DateTime.Now.Second % 2 == 0) ? ":" : "  ";
+            string time = DateTime.Now.ToString("HH" + second + "mm");
 
+            Clear();
+            Text(time, 15, 0, 25);
+            Text(DateTime.Now.ToString("yy'. 'MM'. 'dd"), 11.5F, 0, 14);
+            Present();
+
+        }
+        public void GenerateFrame(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default, int contrast = 100)
+        {
             int width = MaxColumns / 2 * 6;
             int height = MaxRows;
 
@@ -402,99 +479,55 @@ 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)
-                        {
-                            var pixel = bmp.GetPixel(x, y);
-                            var color = (pixel.R + pixel.G + pixel.B) / 3;
-                            if (color < 10) color = 0;
-                            SetLedPlanar(x / 2, y, (byte)color);
-                        }
-                }
+                Clear();
+                SetBitmapLinear(bmp, contrast);
             }
         }
 
-
-        public void SetLedDiagonal(int x, int y, byte color, int delta = 10)
+        public void GenerateFrameDiagonal(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default, int contrast = 100)
         {
-            //x+=delta;
-            y -= delta;
+            int width = MaxRows - FullRows;
+            int height = MaxRows - FullRows*2;
+            float scale;
 
-            int dx = (x - y) / 2;
-            int dy = x + y;
-            SetLedPlanar(dx, dy, color);
-        }
-
-        public void PresentTextDiagonal(string text)
-        {
-
-            Clear();
-
-
-            InstalledFontCollection installedFontCollection = new InstalledFontCollection();
-
-
-            string familyName;
-            string familyList = "";
-            FontFamily[] fontFamilies;
-            // Get the array of FontFamily objects.
-            fontFamilies = installedFontCollection.Families;
-
-            int count = fontFamilies.Length;
-            for (int j = 0; j < count; ++j)
+            using (Bitmap bmp = new Bitmap(width, height))
             {
-                familyName = fontFamilies[j].Name;
-                familyList = familyList + familyName;
-                familyList = familyList + ",  ";
-            }
+                scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height) * zoom / 100;
 
-            int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
-
-            using (Bitmap bmp = new Bitmap(maxX, MaxRows))
-            {
-                using (Graphics g = Graphics.FromImage(bmp))
+                using (var graph = Graphics.FromImage(bmp))
                 {
-                    g.CompositingQuality = CompositingQuality.HighQuality;
-                    g.SmoothingMode = SmoothingMode.AntiAlias;
+                    var scaleWidth = (float)(image.Width * scale);
+                    var scaleHeight = (float)(image.Height * scale);
+
+                    graph.InterpolationMode = quality;
+                    graph.CompositingQuality = CompositingQuality.HighQuality;
+                    graph.SmoothingMode = SmoothingMode.AntiAlias;
+
+                    graph.DrawImage(image, width - scaleWidth, height - scaleHeight, scaleWidth, scaleHeight);
 
-                    using (Font font = new Font("Consolas", 13F, FontStyle.Regular, GraphicsUnit.Pixel))
-                    {
-                        SizeF textSize = g.MeasureString(text, font);
-                        g.DrawString(text, font, Brushes.White, 4, 1);
-                    }
                 }
 
-                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);
-                    }
-                }
+                Clear();
+                SetBitmapDiagonal(bmp, -panX, height + panY, contrast);
             }
-
-            Present();
         }
 
+
         private bool IsRowInRange(int row)
         {
             return (row >= 0 && row < MaxRows);

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,4 +1,4 @@
-using GHelper;
+using GHelper.Mode;
 using System.Diagnostics;
 using System.Management;
 using System.Text.Json;
@@ -7,7 +7,10 @@ public static class AppConfig
 {
 
     private static string configFile;
+
     private static string? _model;
+    private static string? _modelShort;
+    private static string? _bios;
 
     private static Dictionary<string, object> config = new Dictionary<string, object>();
 
@@ -68,9 +71,45 @@ public static class AppConfig
 
         return _model;
     }
+
+    public static (string, string) GetBiosAndModel()
+    {
+        if (_bios is not null && _modelShort is not null) return (_bios, _modelShort);
+
+        using (ManagementObjectSearcher objSearcher = new ManagementObjectSearcher(@"SELECT * FROM Win32_BIOS"))
+        {
+            using (ManagementObjectCollection objCollection = objSearcher.Get())
+            {
+                foreach (ManagementObject obj in objCollection)
+                    if (obj["SMBIOSBIOSVersion"] is not null)
+                    {
+                        string[] results = obj["SMBIOSBIOSVersion"].ToString().Split(".");
+                        if (results.Length > 1)
+                        {
+                            _modelShort = results[0];
+                            _bios = results[1];
+                        }
+                        else
+                        {
+                            _modelShort = obj["SMBIOSBIOSVersion"].ToString();
+                        }
+                    }
+
+                return (_bios, _modelShort);
+            }
+        }
+    }
+
+    public static string GetModelShort()
+    {
+        string model = GetModel();
+        int trim = model.LastIndexOf("_");
+        if (trim > 0) model = model.Substring(0, trim);
+        return model;
+    }
+
     public static bool ContainsModel(string contains)
     {
-
         GetModel();
         return (_model is not null && _model.ToLower().Contains(contains.ToLower()));
     }
@@ -87,8 +126,15 @@ public static class AppConfig
     public static int Get(string name, int empty = -1)
     {
         if (config.ContainsKey(name))
+        {
+            //Debug.WriteLine(name);
             return int.Parse(config[name].ToString());
-        else return empty;
+        }
+        else
+        {
+            //Debug.WriteLine(name + "E");
+            return empty;
+        }
     }
 
     public static bool Is(string name)
@@ -96,6 +142,11 @@ public static class AppConfig
         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))
@@ -133,6 +184,11 @@ public static class AppConfig
         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();
@@ -239,4 +295,173 @@ public static class AppConfig
         Set(name + "_" + Modes.GetCurrent(), value);
     }
 
+    public static bool IsAlly()
+    {
+        return ContainsModel("RC71");
+    }
+
+    public static bool NoMKeys()
+    {
+        return (ContainsModel("Z13") && !IsARCNM()) ||
+               ContainsModel("FX706") ||
+               ContainsModel("FA506") ||
+               ContainsModel("FX506") ||
+               ContainsModel("Duo") ||
+               ContainsModel("FX505");
+    }
+
+    public static bool IsARCNM()
+    {
+        return ContainsModel("GZ301VIC");
+    }
+
+    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("FA506IC") || ContainsModel("FX506LU") || ContainsModel("FX506IC") || ContainsModel("FX506LH");
+    }
+
+
+    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") || ContainsModel("FX517Z") || ContainsModel("FX516P") || ContainsModel("X13") || IsARCNM() || ContainsModel("GA502IU");
+    }
+
+    public static bool IsStrix()
+    {
+        return ContainsModel("Strix") || ContainsModel("Scar");
+    }
+
+    public static bool IsStrixLimitedRGB()
+    {
+        return ContainsModel("G614JV") || ContainsModel("G614JZ") || ContainsModel("G512LI") || ContainsModel("G513R") || ContainsModel("G713PV") || ContainsModel("G513IE") || ContainsModel("G713RC");
+    }
+
+    public static bool IsStrixNumpad()
+    {
+        return ContainsModel("G713R");
+    }
+
+    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 DynamicBoost5()
+    {
+        return ContainsModel("GZ301ZE");
+    }
+
+    public static bool DynamicBoost15()
+    {
+        return ContainsModel("FX507ZC4");
+    }
+
+    public static bool IsAdvantageEdition()
+    {
+        return ContainsModel("13QY");
+    }
+
+    public static bool NoAutoUltimate()
+    {
+        return ContainsModel("G614") || ContainsModel("GU604") || ContainsModel("FX507") || ContainsModel("G513") || ContainsModel("FA617");
+    }
+
+
+    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()
+    {
+        if (!ContainsModel("GU604")) return false; 
+
+        try
+        {
+            var (bios, model) = GetBiosAndModel();
+            return (Int32.Parse(bios) < 312);
+        } catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsFanRequired()
+    {
+        return ContainsModel("GA402X") || ContainsModel("G513") || ContainsModel("G713R") || ContainsModel("G713P");
+    }
+
+    public static bool IsPowerRequired()
+    {
+        return ContainsModel("FX507") || ContainsModel("FX517") || ContainsModel("FX707");
+    }
+
+    public static bool IsGPUFixNeeded()
+    {
+        return ContainsModel("GA402X") || ContainsModel("GV302") || ContainsModel("GV301") || ContainsModel("GZ301") || ContainsModel("FX506") || ContainsModel("FA506") || ContainsModel("GU603") || ContainsModel("GU604") || ContainsModel("G614J") || ContainsModel("GA503") || ContainsModel("FX507");
+    }
+
+    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();
+    }
+
+    public static bool IsHardwareTouchpadToggle()
+    {
+        return ContainsModel("FA507");
+    }
+
+    public static bool IsASUS()
+    {
+        return ContainsModel("ROG") || ContainsModel("TUF") || ContainsModel("Vivobook") || ContainsModel("Zenbook");
+    }
 }

app/AsusACPI.cs

@@ -1,4 +1,6 @@
-using System.Management;
+using GHelper;
+using GHelper.USB;
+using System.Management;
 using System.Runtime.InteropServices;
 
 public enum AsusFan
@@ -34,7 +36,8 @@ public class AsusACPI
     const uint INIT = 0x54494E49;
 
     public const uint UniversalControl = 0x00100021;
-    
+
+    public const int Airplane = 0x88;
     public const int KB_Light_Up = 0xc4;
     public const int KB_Light_Down = 0xc5;
     public const int Brightness_Down = 0x10;
@@ -55,17 +58,24 @@ public class AsusACPI
     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 GPUMuxVivo = 0x00090026;
 
     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;
@@ -85,13 +95,23 @@ public class AsusACPI
     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 APU_MEM = 0x000600C1;
+
     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;
@@ -106,17 +126,17 @@ public class AsusACPI
     public const int GPUModeStandard = 1;
     public const int GPUModeUltimate = 2;
 
-
-    public const int MaxTotal = 150;
     public const int MinTotal = 5;
-    public const int DefaultTotal = 125;
 
-    public const int MaxCPU = 100;
+    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;
-    public const int MaxGPUBoost = 25;
+    public static int MaxGPUBoost = 25;
 
     public const int MinGPUTemp = 75;
     public const int MaxGPUTemp = 87;
@@ -166,6 +186,7 @@ public class AsusACPI
     private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
 
     private IntPtr eventHandle;
+    private bool _connected = false;
 
     // 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()
@@ -192,24 +213,61 @@ public class AsusACPI
         }
     }
 
+    public bool IsConnected()
+    {
+        return _connected;
+    }
 
     public AsusACPI()
     {
-        handle = CreateFile(
-            FILE_NAME,
-            GENERIC_READ | GENERIC_WRITE,
-            FILE_SHARE_READ | FILE_SHARE_WRITE,
-            IntPtr.Zero,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL,
-            IntPtr.Zero
-        );
-
-        if (handle == new IntPtr(-1))
+        try
         {
-            throw new Exception("Can't connect to ACPI");
+            handle = CreateFile(
+                FILE_NAME,
+                GENERIC_READ | GENERIC_WRITE,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                IntPtr.Zero,
+                OPEN_EXISTING,
+                FILE_ATTRIBUTE_NORMAL,
+                IntPtr.Zero
+            );
+
+            //handle = new IntPtr(-1);
+            //throw new Exception("ERROR");
+            _connected = true;
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Can't connect to ACPI: {ex.Message}");
         }
 
+        if (AppConfig.IsAdvantageEdition())
+        {
+            MaxTotal = 250;
+        }
+
+        if (AppConfig.IsX13())
+        {
+            MaxTotal = 75;
+            DefaultTotal = 50;
+        }
+
+        if (AppConfig.IsAlly())
+        {
+            MaxTotal = 50;
+            DefaultTotal = 30;
+        }
+
+        if (AppConfig.DynamicBoost5())
+        {
+            MaxGPUBoost = 5;
+        }
+
+        if (AppConfig.DynamicBoost15())
+        {
+            MaxGPUBoost = 15;
+        }
     }
 
     public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
@@ -237,7 +295,7 @@ public class AsusACPI
     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);
@@ -258,7 +316,7 @@ public class AsusACPI
 
     }
 
-    public int DeviceSet(uint DeviceID, int Status, string logName)
+    public int DeviceSet(uint DeviceID, int Status, string? logName)
     {
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
@@ -267,12 +325,14 @@ public class AsusACPI
         byte[] status = CallMethod(DEVS, args);
         int result = BitConverter.ToInt32(status, 0);
 
-        Logger.WriteLine(logName + " = " + Status + " : " + (result == 1 ? "OK" : result));
+        if (logName is not null)
+            Logger.WriteLine(logName + " = " + Status + " : " + (result == 1 ? "OK" : result));
+
         return result;
     }
 
 
-    public int DeviceSet(uint DeviceID, byte[] Params, string logName)
+    public int DeviceSet(uint DeviceID, byte[] Params, string? logName)
     {
         byte[] args = new byte[4 + Params.Length];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
@@ -281,7 +341,9 @@ public class AsusACPI
         byte[] status = CallMethod(DEVS, args);
         int result = BitConverter.ToInt32(status, 0);
 
-        Logger.WriteLine(logName + " = " + BitConverter.ToString(Params) + " : " + (result == 1 ? "OK" : result));
+        if (logName is not null)
+            Logger.WriteLine(logName + " = " + BitConverter.ToString(Params) + " : " + (result == 1 ? "OK" : result));
+
         return BitConverter.ToInt32(status, 0);
     }
 
@@ -319,6 +381,56 @@ public class AsusACPI
         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)
+    {
+
+        if (curve.Length != 16) return -1;
+        if (curve.All(singleByte => singleByte == 0)) return -1;
+
+        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)
     {
@@ -328,8 +440,14 @@ public class AsusACPI
 
         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)
         {
@@ -386,7 +504,14 @@ public class AsusACPI
         if (curve.Length != 16) throw new Exception("Incorrect curve");
 
         var points = new Dictionary<byte, byte>();
-        for (int i = 0; i < 8; i++) points[curve[i]] = curve[i + 8];
+        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;
@@ -397,7 +522,7 @@ public class AsusACPI
             if (count == 0 && pair.Key >= 40)
             {
                 fix = true;
-                pointsFixed.Add(20, 0);
+                pointsFixed.Add(30, 0);
             }
 
             if (count != 3 || !fix)
@@ -425,9 +550,80 @@ public class AsusACPI
 
     public bool IsAllAmdPPT()
     {
+        //return false; 
         return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
     }
 
+    public void SetAPUMem(int memory = 4)
+    {
+        if (memory < 0 || memory > 8) return;
+
+        int mem = 0;
+
+        switch (memory)
+        {
+            case 0:
+                mem = 0;
+                break;
+            case 1:
+                mem = 258;
+                break;
+            case 2:
+                mem = 259;
+                break;
+            case 3:
+                mem = 260;
+                break;
+            case 4:
+                mem = 261;
+                break;
+            case 5:
+                mem = 263;
+                break;
+            case 6:
+                mem = 264;
+                break;
+            case 7:
+                mem = 265;
+                break;
+            case 8:
+                mem = 262;
+                break;
+        }
+
+        Program.acpi.DeviceSet(APU_MEM, mem, "APU Mem");
+    }
+
+    public int GetAPUMem()
+    {
+        int memory = Program.acpi.DeviceGet(APU_MEM);
+        if (memory < 0) return -1;
+
+        switch (memory)
+        {
+            case 256:
+                return 0;
+            case 258:
+                return 1;
+            case 259:
+                return 2;
+            case 260:
+                return 3;
+            case 261:
+                return 4;
+            case 262:
+                return 8;
+            case 263:
+                return 5;
+            case 264:
+                return 6;
+            case 265:
+                return 7;
+            default:
+                return 4;
+        }
+    }
+
     public void ScanRange()
     {
         int value;
@@ -452,19 +648,20 @@ public class AsusACPI
         DeviceSet(TUF_KB_BRIGHTNESS, param, "TUF Brightness");
     }
 
-    public void TUFKeyboardRGB(int mode, Color color, int speed)
+    public void TUFKeyboardRGB(AuraMode mode, Color color, int speed, string? log = "TUF RGB")
     {
 
-        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, log);
+        if (result != 1) DeviceSet(TUF_KB2, setting, log);
 
     }
 

app/AsusMouseSettings.cs

@@ -0,0 +1,900 @@
+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()
+        {
+            if (mouse.Profile < comboProfile.Items.Count)
+                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

@@ -1,426 +0,0 @@
-using HidLibrary;
-using System.Text;
-
-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 AsusUSB
-    {
-
-        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, 0x08 };
-        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, 0x08 };
-
-        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
-        static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
-
-        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;
-
-
-        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 (AppConfig.ContainsModel("TUF"))
-            {
-                _modes.Remove(3);
-            }
-
-            if (AppConfig.ContainsModel("401"))
-            {
-                _modes.Remove(2);
-                _modes.Remove(3);
-            }
-
-            if (AppConfig.ContainsModel("G513QY"))
-            {
-                return _modes;
-            }
-
-            if (AppConfig.ContainsModel("Strix") || AppConfig.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 && !AppConfig.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);
-        }
-
-
-        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minInput = 18, int minFeatures = 1)
-        {
-            HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
-            foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected
-                    && device.Capabilities.FeatureReportByteLength >= minFeatures
-                    && device.Capabilities.InputReportByteLength >= minInput)
-                    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)
-        {
-
-            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] = (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 Init()
-        {
-            Task.Run(async () =>
-            {
-                var devices = GetHidDevices(deviceIds, 0);
-                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")
-        {
-
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardBrightness(brightness);
-
-
-            Task.Run(async () =>
-            {
-
-                byte[] msg = { AURA_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
-                byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
-
-                var devices = GetHidDevices(deviceIds, 0);
-                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, 0);
-                    foreach (HidDevice device in devicesBackup)
-                    {
-                        device.OpenDevice();
-                        device.WriteFeatureData(msgBackup);
-                        device.CloseDevice();
-                    }
-                }
-                */
-
-            });
-
-
-        }
-
-
-        public static void ApplyAuraPower(List<AuraDev19b6> flags)
-        {
-
-            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
-
-
-            var devices = GetHidDevices(deviceIds);
-            //Logger.WriteLine("USB-KB = " + BitConverter.ToString(msg));
-
-            foreach (HidDevice device in devices)
-            {
-                device.OpenDevice();
-                device.WriteFeatureData(msg);
-                Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
-                device.CloseDevice();
-            }
-
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardPower(
-                    flags.Contains(AuraDev19b6.AwakeKeyb),
-                    flags.Contains(AuraDev19b6.BootKeyb),
-                    flags.Contains(AuraDev19b6.SleepKeyb),
-                    flags.Contains(AuraDev19b6.ShutdownKeyb));
-
-        }
-
-
-        public static void ApplyAura()
-        {
-
-            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);
-
-            var devices = GetHidDevices(deviceIds);
-
-            if (devices.Count() == 0)
-            {
-                Logger.WriteLine("USB-KB : not found");
-                devices = GetHidDevices(deviceIds, 1);
-            }
-
-            foreach (HidDevice device in devices)
-            {
-                device.OpenDevice();
-                device.WriteFeatureData(msg);
-                device.WriteFeatureData(MESSAGE_SET);
-                device.WriteFeatureData(MESSAGE_APPLY);
-                device.CloseDevice();
-                Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
-            }
-
-            if (AppConfig.ContainsModel("TUF"))
-                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 }, 0, 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 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;
-
-            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/AutoUpdate/AutoUpdateControl.cs

@@ -0,0 +1,146 @@
+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 exeName = Path.GetFileName(exeLocation);
+            string zipLocation = exeDir + "\\" + zipName;
+
+            using (WebClient client = new WebClient())
+            {
+                client.DownloadFile(uri, zipLocation);
+
+                Logger.WriteLine(requestUri);
+                Logger.WriteLine(exeDir);
+                Logger.WriteLine(zipName);
+                Logger.WriteLine(exeName);
+
+                string command = $"Start-Sleep -Seconds 1; $ErrorActionPreference = \"Stop\"; Expand-Archive \"{zipName}\" -DestinationPath . -Force; Remove-Item \"{zipName}\" -Force; \".\\{exeName}\"; ";
+                Logger.WriteLine(command);
+
+                try
+                {
+                    var cmd = new Process();
+                    cmd.StartInfo.WorkingDirectory = exeDir;
+                    cmd.StartInfo.UseShellExecute = false;
+                    cmd.StartInfo.CreateNoWindow = true;
+                    cmd.StartInfo.FileName = "powershell";
+                    cmd.StartInfo.Arguments = command;
+                    cmd.Start();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+
+                Application.Exit();
+            }
+
+        }
+
+    }
+}

app/Battery/BatteryControl.cs

@@ -0,0 +1,46 @@
+namespace GHelper.Battery
+{
+    internal class BatteryControl
+    {
+
+        public static void ToggleBatteryLimitFull()
+        {
+            if (AppConfig.Is("charge_full")) SetBatteryChargeLimit();
+            else SetBatteryLimitFull();
+        }
+
+        public static void SetBatteryLimitFull()
+        {
+            AppConfig.Set("charge_full", 1);
+            Program.acpi.DeviceSet(AsusACPI.BatteryLimit, 100, "BatteryLimit");
+            Program.settingsForm.VisualiseBatteryFull();
+        }
+
+        public static void UnSetBatteryLimitFull()
+        {
+            AppConfig.Set("charge_full", 0);
+            Program.settingsForm.VisualiseBatteryFull();
+        }
+
+        public static void AutoBattery(bool init = false)
+        {
+            if (AppConfig.Is("charge_full") && !init) SetBatteryLimitFull();
+            else SetBatteryChargeLimit();
+        }
+
+        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");
+
+            AppConfig.Set("charge_limit", limit);
+            AppConfig.Set("charge_full", 0);
+
+            Program.settingsForm.VisualiseBattery(limit);
+        }
+
+    }
+}

app/Display/ScreenBrightness.cs

@@ -1,4 +1,4 @@
-namespace GHelper
+namespace GHelper.Display
 {
     using System;
     using System.Diagnostics;

app/Display/ScreenCCD.cs

@@ -0,0 +1,388 @@
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace GHelper.Display
+{
+    public class ScreenCCD
+    {
+
+        public static bool GetHDRStatus()
+        {
+            var err = GetDisplayConfigBufferSizes(QDC.QDC_ONLY_ACTIVE_PATHS, out var pathCount, out var modeCount);
+            if (err != 0)
+                throw new Win32Exception(err);
+
+            var paths = new DISPLAYCONFIG_PATH_INFO[pathCount];
+            var modes = new DISPLAYCONFIG_MODE_INFO[modeCount];
+            err = QueryDisplayConfig(QDC.QDC_ONLY_ACTIVE_PATHS, ref pathCount, paths, ref modeCount, modes, IntPtr.Zero);
+            if (err != 0)
+                throw new Win32Exception(err);
+
+            string internalName = AppConfig.GetString("internal_display");
+
+            foreach (var path in paths)
+            {
+                // get display name
+                var info = new DISPLAYCONFIG_TARGET_DEVICE_NAME();
+                info.header.type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME;
+                info.header.size = Marshal.SizeOf<DISPLAYCONFIG_TARGET_DEVICE_NAME>();
+                info.header.adapterId = path.targetInfo.adapterId;
+                info.header.id = path.targetInfo.id;
+                err = DisplayConfigGetDeviceInfo(ref info);
+                if (err != 0)
+                    throw new Win32Exception(err);
+
+                var colorInfo = new DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO();
+                colorInfo.header.type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO;
+                colorInfo.header.size = Marshal.SizeOf<DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO>();
+                colorInfo.header.adapterId = path.targetInfo.adapterId;
+                colorInfo.header.id = path.targetInfo.id;
+                err = DisplayConfigGetDeviceInfo(ref colorInfo);
+                if (err != 0)
+                    throw new Win32Exception(err);
+
+
+                if (info.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
+                    info.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
+                    info.monitorFriendlyDeviceName == internalName)
+                {
+                    Logger.WriteLine(info.monitorFriendlyDeviceName + " HDR: " + colorInfo.advancedColorEnabled);
+                    return colorInfo.advancedColorEnabled;
+                }
+
+            }
+
+            return false;
+
+        }
+
+        private enum DISPLAYCONFIG_DEVICE_INFO_TYPE
+        {
+            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_GET_SUPPORT_VIRTUAL_RESOLUTION = 7,
+            DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION = 8,
+            DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO = 9,
+            DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE = 10,
+            DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL = 11,
+        }
+
+        private enum DISPLAYCONFIG_COLOR_ENCODING
+        {
+            DISPLAYCONFIG_COLOR_ENCODING_RGB = 0,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR444 = 1,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR422 = 2,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR420 = 3,
+            DISPLAYCONFIG_COLOR_ENCODING_INTENSITY = 4,
+        }
+
+        private enum DISPLAYCONFIG_SCALING
+        {
+            DISPLAYCONFIG_SCALING_IDENTITY = 1,
+            DISPLAYCONFIG_SCALING_CENTERED = 2,
+            DISPLAYCONFIG_SCALING_STRETCHED = 3,
+            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
+            DISPLAYCONFIG_SCALING_CUSTOM = 5,
+            DISPLAYCONFIG_SCALING_PREFERRED = 128,
+        }
+
+        private enum DISPLAYCONFIG_ROTATION
+        {
+            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
+            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
+            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
+        }
+
+        private enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY
+        {
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = -1,
+            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_INDIRECT_WIRED = 16,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL = 17,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = unchecked((int)0x80000000),
+        }
+
+        private enum DISPLAYCONFIG_TOPOLOGY_ID
+        {
+            DISPLAYCONFIG_TOPOLOGY_INTERNAL = 0x00000001,
+            DISPLAYCONFIG_TOPOLOGY_CLONE = 0x00000002,
+            DISPLAYCONFIG_TOPOLOGY_EXTEND = 0x00000004,
+            DISPLAYCONFIG_TOPOLOGY_EXTERNAL = 0x00000008,
+        }
+
+        private enum DISPLAYCONFIG_PATH
+        {
+            DISPLAYCONFIG_PATH_ACTIVE = 0x00000001,
+            DISPLAYCONFIG_PATH_PREFERRED_UNSCALED = 0x00000004,
+            DISPLAYCONFIG_PATH_SUPPORT_VIRTUAL_MODE = 0x00000008,
+        }
+
+        private enum DISPLAYCONFIG_SOURCE_FLAGS
+        {
+            DISPLAYCONFIG_SOURCE_IN_USE = 0x00000001,
+        }
+
+        private enum DISPLAYCONFIG_TARGET_FLAGS
+        {
+            DISPLAYCONFIG_TARGET_IN_USE = 0x00000001,
+            DISPLAYCONFIG_TARGET_FORCIBLE = 0x00000002,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_BOOT = 0x00000004,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_PATH = 0x00000008,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_SYSTEM = 0x00000010,
+            DISPLAYCONFIG_TARGET_IS_HMD = 0x00000020,
+        }
+
+        private enum QDC
+        {
+            QDC_ALL_PATHS = 0x00000001,
+            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
+            QDC_DATABASE_CURRENT = 0x00000004,
+            QDC_VIRTUAL_MODE_AWARE = 0x00000010,
+            QDC_INCLUDE_HMD = 0x00000020,
+        }
+
+        private enum DISPLAYCONFIG_SCANLINE_ORDERING
+        {
+            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,
+        }
+
+        private enum DISPLAYCONFIG_PIXELFORMAT
+        {
+            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
+            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
+            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
+            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
+            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
+        }
+
+        private enum DISPLAYCONFIG_MODE_INFO_TYPE
+        {
+            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
+            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
+            DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE = 3,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_DEVICE_INFO_HEADER
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
+            public int size;
+            public LUID adapterId;
+            public uint id;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            public uint value;
+            public DISPLAYCONFIG_COLOR_ENCODING colorEncoding;
+            public int bitsPerColorChannel;
+
+            public bool advancedColorSupported => (value & 0x1) == 0x1;
+            public bool advancedColorEnabled => (value & 0x2) == 0x2;
+            public bool wideColorEnforced => (value & 0x4) == 0x4;
+            public bool advancedColorForceDisabled => (value & 0x8) == 0x8;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct POINTL
+        {
+            public int x;
+            public int y;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct LUID
+        {
+            public uint LowPart;
+            public int HighPart;
+
+            public long Value => ((long)HighPart << 32) | LowPart;
+            public override string ToString() => Value.ToString();
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_SOURCE_MODE
+        {
+            public uint width;
+            public uint height;
+            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
+            public POINTL position;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_RATIONAL
+        {
+            public uint Numerator;
+            public uint Denominator;
+
+            public override string ToString() => Numerator + " / " + Denominator;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_2DREGION
+        {
+            public uint cx;
+            public uint cy;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_DESKTOP_IMAGE_INFO
+        {
+            public POINTL PathSourceSize;
+            public RECT DesktopImageRegion;
+            public RECT DesktopImageClip;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private 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)]
+        private struct DISPLAYCONFIG_TARGET_MODE
+        {
+            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        private struct DISPLAYCONFIG_MODE_INFO_union
+        {
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_TARGET_MODE targetMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_DESKTOP_IMAGE_INFO desktopImageInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_SOURCE_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public DISPLAYCONFIG_SOURCE_FLAGS statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_TARGET_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            public DISPLAYCONFIG_ROTATION rotation;
+            public DISPLAYCONFIG_SCALING scaling;
+            public DISPLAYCONFIG_RATIONAL refreshRate;
+            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+            public bool targetAvailable;
+            public DISPLAYCONFIG_TARGET_FLAGS statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_INFO
+        {
+            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
+            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
+            public DISPLAYCONFIG_PATH flags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_MODE_INFO
+        {
+            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
+            public uint id;
+            public LUID adapterId;
+            public DISPLAYCONFIG_MODE_INFO_union info;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct DISPLAYCONFIG_SOURCE_DEVICE_NAME
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+            public string viewGdiDeviceName;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
+        {
+            public uint value;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private 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 monitorDevicePat;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct RECT
+        {
+            public int left;
+            public int top;
+            public int right;
+            public int bottom;
+        }
+
+        [DllImport("user32")]
+        private static extern int GetDisplayConfigBufferSizes(QDC flags, out int numPathArrayElements, out int numModeInfoArrayElements);
+
+        [DllImport("user32")]
+        private static extern int QueryDisplayConfig(QDC flags, ref int numPathArrayElements, [In, Out] DISPLAYCONFIG_PATH_INFO[] pathArray, ref int numModeInfoArrayElements, [In, Out] DISPLAYCONFIG_MODE_INFO[] modeInfoArray, out DISPLAYCONFIG_TOPOLOGY_ID currentTopologyId);
+
+        [DllImport("user32")]
+        private static extern int QueryDisplayConfig(QDC flags, ref int numPathArrayElements, [In, Out] DISPLAYCONFIG_PATH_INFO[] pathArray, ref int numModeInfoArrayElements, [In, Out] DISPLAYCONFIG_MODE_INFO[] modeInfoArray, IntPtr currentTopologyId);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO requestPacket);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_SOURCE_DEVICE_NAME requestPacket);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME requestPacket);
+    }
+}

app/Display/ScreenControl.cs

@@ -0,0 +1,109 @@
+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 = (Program.acpi.DeviceGet(AsusACPI.ScreenMiniled) == 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);
+
+            bool hdr = false;
+
+            if (miniled >= 0)
+            {
+                AppConfig.Set("miniled", miniled);
+                hdr = ScreenCCD.GetHDRStatus();
+            }
+
+            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,
+                    hdr: hdr
+                );
+            });
+
+        }
+    }
+}

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 System.Collections;
+using System.Runtime.InteropServices;
+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("#");
+                        
+                        if (names.Length > 1) return names[1];
+                        else return "";
+                    }
+                }
+            }
+            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,5 +1,10 @@
-using CustomControls;
-using GHelper.Gpu;
+using GHelper.Display;
+using GHelper.Gpu.AMD;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.Mode;
+using GHelper.UI;
+using GHelper.USB;
 using System.Diagnostics;
 
 namespace GHelper
@@ -7,25 +12,39 @@ namespace GHelper
     public partial class Extra : RForm
     {
 
-        Dictionary<string, string> customActions = new Dictionary<string, string>
-        {
-          {"","--------------" },
-          {"mute", Properties.Strings.VolumeMute},
-          {"screenshot", Properties.Strings.PrintScreen},
-          {"play", Properties.Strings.PlayPause},
-          {"aura", Properties.Strings.ToggleAura},
-          {"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}
-        };
+        ScreenControl screenControl = new ScreenControl();
+        ModeControl modeControl = new ModeControl();
+        ClamshellModeControl clamshellControl = new ClamshellModeControl();
+
+        const string EMPTY = "--------------";
+
 
         private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
         {
 
+            Dictionary<string, string> customActions = new Dictionary<string, string>
+            {
+              {"", EMPTY},
+              {"mute", Properties.Strings.VolumeMute},
+              {"screenshot", Properties.Strings.PrintScreen},
+              {"play", Properties.Strings.PlayPause},
+              {"aura", Properties.Strings.ToggleAura},
+              {"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},
+              {"ghelper", Properties.Strings.OpenGHelper},
+              {"custom", Properties.Strings.Custom}
+            };
+
+            if (AppConfig.IsDUO())
+            {
+                customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
+                customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
+            }
+
             switch (name)
             {
                 case "m1":
@@ -39,6 +58,7 @@ namespace GHelper
                     break;
                 case "m4":
                     customActions[""] = Properties.Strings.OpenGHelper;
+                    customActions.Remove("ghelper");
                     break;
                 case "fnf4":
                     customActions[""] = Properties.Strings.ToggleAura;
@@ -48,6 +68,15 @@ namespace GHelper
                     customActions[""] = Properties.Strings.ToggleFnLock;
                     customActions.Remove("fnlock");
                     break;
+                case "fne":
+                    customActions[""] = "Calculator";
+                    break;
+                case "paddle":
+                    customActions[""] = EMPTY;
+                    break;
+                case "cc":
+                    customActions[""] = EMPTY;
+                    break;
             }
 
             combo.DropDownStyle = ComboBoxStyle.DropDownList;
@@ -81,77 +110,158 @@ namespace GHelper
         {
             InitializeComponent();
 
-            groupBindings.Text = Properties.Strings.KeyBindings;
-            groupLight.Text = " " + Properties.Strings.LaptopBacklight;
-            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;
+            //labelBacklightTimeoutPlugged.Text = Properties.Strings.BacklightTimeoutPlugged;
 
             checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
             checkTopmost.Text = Properties.Strings.WindowTop;
             checkUSBC.Text = Properties.Strings.OptimizedUSBC;
-            checkAutoApplyWindowsPowerMode.Text = Properties.Strings.ApplyWindowsPowerPlan;
-            checkFnLock.Text = Properties.Strings.FnLock;
+            checkAutoToggleClamshellMode.Text = Properties.Strings.ToggleClamshellMode;
 
-            labelBacklight.Text = Properties.Strings.Keyboard;
+            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;
+
+            labelAPUMem.Text = Properties.Strings.APUMemory;
 
             Text = Properties.Strings.ExtraSettings;
 
+            if (AppConfig.IsARCNM())
+            {
+                labelM3.Text = "FN+F6";
+                labelM1.Visible = comboM1.Visible = textM1.Visible = false;
+                labelM2.Visible = comboM2.Visible = textM2.Visible = false;
+                labelM4.Visible = comboM4.Visible = textM4.Visible = false;
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (AppConfig.NoMKeys())
+            {
+                labelM1.Text = "FN+F2";
+                labelM2.Text = "FN+F3";
+                labelM3.Text = "FN+F4";
+                labelM4.Visible = comboM4.Visible = textM4.Visible = AppConfig.IsDUO();
+                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");
+
+
+                int apuMem = Program.acpi.GetAPUMem();
+                if (apuMem >= 0)
+                {
+                    panelAPU.Visible = true;
+                    comboAPU.DropDownStyle = ComboBoxStyle.DropDownList;
+                    comboAPU.SelectedIndex = apuMem;
+                }
+
+                comboAPU.SelectedIndexChanged += ComboAPU_SelectedIndexChanged;
+
+            }
+            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(comboM1, textM1, "m1");
-            SetKeyCombo(comboM2, textM2, "m2");
-            SetKeyCombo(comboM3, textM3, "m3");
-            SetKeyCombo(comboM4, textM4, "m4");
-            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
-            SetKeyCombo(comboFNC, textFNC, "fnc");
-
             Shown += Keyboard_Shown;
 
             comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboKeyboardSpeed.DataSource = new BindingSource(AsusUSB.GetSpeeds(), null);
+            comboKeyboardSpeed.DataSource = new BindingSource(Aura.GetSpeeds(), null);
             comboKeyboardSpeed.DisplayMember = "Value";
             comboKeyboardSpeed.ValueMember = "Key";
-            comboKeyboardSpeed.SelectedValue = AsusUSB.Speed;
+            comboKeyboardSpeed.SelectedValue = Aura.Speed;
             comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
 
             // Keyboard
-            checkAwake.Checked = !(AppConfig.Get("keyboard_awake") == 0);
-            checkBoot.Checked = !(AppConfig.Get("keyboard_boot") == 0);
-            checkSleep.Checked = !(AppConfig.Get("keyboard_sleep") == 0);
-            checkShutdown.Checked = !(AppConfig.Get("keyboard_shutdown") == 0);
+            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.Get("keyboard_awake_bar") == 0);
-            checkBootBar.Checked = !(AppConfig.Get("keyboard_boot_bar") == 0);
-            checkSleepBar.Checked = !(AppConfig.Get("keyboard_sleep_bar") == 0);
-            checkShutdownBar.Checked = !(AppConfig.Get("keyboard_shutdown_bar") == 0);
+            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.Get("keyboard_awake_lid") == 0);
-            checkBootLid.Checked = !(AppConfig.Get("keyboard_boot_lid") == 0);
-            checkSleepLid.Checked = !(AppConfig.Get("keyboard_sleep_lid") == 0);
-            checkShutdownLid.Checked = !(AppConfig.Get("keyboard_shutdown_lid") == 0);
+            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.Get("keyboard_awake_logo") == 0);
-            checkBootLogo.Checked = !(AppConfig.Get("keyboard_boot_logo") == 0);
-            checkSleepLogo.Checked = !(AppConfig.Get("keyboard_sleep_logo") == 0);
-            checkShutdownLogo.Checked = !(AppConfig.Get("keyboard_shutdown_logo") == 0);
+            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;
@@ -173,7 +283,7 @@ namespace GHelper
             checkSleepLogo.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdownLogo.CheckedChanged += CheckPower_CheckedChanged;
 
-            if (!AppConfig.ContainsModel("Strix"))
+            if (!AppConfig.IsStrix())
             {
                 labelBacklightBar.Visible = false;
                 checkAwakeBar.Visible = false;
@@ -181,22 +291,33 @@ namespace GHelper
                 checkSleepBar.Visible = false;
                 checkShutdownBar.Visible = false;
 
-                if (!AppConfig.ContainsModel("Z13"))
-                {
-                    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;
-                }
             }
 
+            if ((!AppConfig.IsStrix() && !AppConfig.IsZ13()) || AppConfig.IsStrixLimitedRGB() || AppConfig.IsARCNM())
+            {
+                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;
+
+            }
+
+            if (!AppConfig.IsStrix() && !AppConfig.IsZ13())
+            {
+                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; ;
 
@@ -206,11 +327,8 @@ namespace GHelper
             checkUSBC.Checked = AppConfig.Is("optimized_usbc");
             checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
 
-            checkAutoApplyWindowsPowerMode.Checked = (AppConfig.Get("auto_apply_power_plan") != 0);
-            checkAutoApplyWindowsPowerMode.CheckedChanged += checkAutoApplyWindowsPowerMode_CheckedChanged;
-
-            trackBrightness.Value = InputDispatcher.GetBacklight();
-            trackBrightness.Scroll += TrackBrightness_Scroll;
+            sliderBrightness.Value = InputDispatcher.GetBacklight();
+            sliderBrightness.ValueChanged += SliderBrightness_ValueChanged;
 
             panelXMG.Visible = (Program.acpi.DeviceGet(AsusACPI.GPUXGConnected) == 1);
             checkXMG.Checked = !(AppConfig.Get("xmg_light") == 0);
@@ -225,24 +343,111 @@ namespace GHelper
             checkGpuApps.Checked = AppConfig.Is("kill_gpu_apps");
             checkGpuApps.CheckedChanged += CheckGpuApps_CheckedChanged;
 
-            checkFnLock.Checked = AppConfig.Is("fn_lock");
-            checkFnLock.CheckedChanged += CheckFnLock_CheckedChanged; ;
+            checkBootSound.Checked = (Program.acpi.DeviceGet(AsusACPI.BootSound) == 1);
+            checkBootSound.CheckedChanged += CheckBootSound_CheckedChanged;
 
             pictureHelp.Click += PictureHelp_Click;
-
             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 ComboAPU_SelectedIndexChanged(object? sender, EventArgs e)
+        {
+            int mem = comboAPU.SelectedIndex;
+            Program.acpi.SetAPUMem(mem);
+
+            DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertAPUMemoryRestart, Properties.Strings.AlertAPUMemoryRestartTitle, MessageBoxButtons.YesNo);
+            if (dialogResult == DialogResult.Yes)
+            {
+                Process.Start("shutdown", "/r /t 1");
+            }
+
+        }
+
+        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);
+
+            Aura.ApplyBrightness(sliderBrightness.Value, "Slider");
+        }
 
         private void InitServices()
         {
-            if (OptimizationService.IsRunning()) buttonServices.Text = Properties.Strings.Stop;
-            else buttonServices.Text = Properties.Strings.Start;
 
-            labelServices.Text = Properties.Strings.AsusServicesRunning + ":  " + OptimizationService.GetRunningCount();
+            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;
 
         }
@@ -251,7 +456,7 @@ namespace GHelper
         {
             buttonServices.Enabled = false;
 
-            if (OptimizationService.IsRunning())
+            if (OptimizationService.GetRunningCount() > 0)
             {
                 labelServices.Text = Properties.Strings.StoppingServices + " ...";
                 Task.Run(() =>
@@ -290,6 +495,7 @@ namespace GHelper
         {
             try
             {
+
                 using (var amdControl = new AmdGpuControl())
                 {
                     int variBrightSupported = 0, VariBrightEnabled;
@@ -322,15 +528,6 @@ namespace GHelper
             }
         }
 
-        private void CheckFnLock_CheckedChanged(object? sender, EventArgs e)
-        {
-            int fnLock = checkFnLock.Checked ? 1 : 0;
-            AppConfig.Set("fn_lock", fnLock);
-            Program.acpi.DeviceSet(AsusACPI.FnLock, (fnLock == 1) ? 0 : 1, "FnLock");
-
-            Program.inputDispatcher.RegisterKeys();
-        }
-
         private void CheckGpuApps_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("kill_gpu_apps", (checkGpuApps.Checked ? 1 : 0));
@@ -346,7 +543,7 @@ namespace GHelper
         private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("xmg_light", (checkXMG.Checked ? 1 : 0));
-            AsusUSB.ApplyXGMLight(checkXMG.Checked);
+            XGM.Light(checkXMG.Checked);
         }
 
         private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
@@ -354,13 +551,6 @@ namespace GHelper
             AppConfig.Set("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
         }
 
-        private void TrackBrightness_Scroll(object? sender, EventArgs e)
-        {
-            AppConfig.Set("keyboard_brightness", trackBrightness.Value);
-            AppConfig.Set("keyboard_brightness_ac", trackBrightness.Value);
-            AsusUSB.ApplyBrightness(trackBrightness.Value, "Slider");
-        }
-
         private void PictureHelp_Click(object? sender, EventArgs e)
         {
             Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper#custom-hotkey-actions") { UseShellExecute = true });
@@ -369,7 +559,7 @@ namespace GHelper
         private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
-            Program.settingsForm.AutoScreen(true);
+            screenControl.AutoScreen(true);
         }
 
 
@@ -401,36 +591,14 @@ namespace GHelper
             AppConfig.Set("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
             AppConfig.Set("keyboard_shutdown_logo", (checkShutdownLogo.Checked ? 1 : 0));
 
-            List<AuraDev19b6> flags = new List<AuraDev19b6>();
-
-            if (checkAwake.Checked) flags.Add(AuraDev19b6.AwakeKeyb);
-            if (checkBoot.Checked) flags.Add(AuraDev19b6.BootKeyb);
-            if (checkSleep.Checked) flags.Add(AuraDev19b6.SleepKeyb);
-            if (checkShutdown.Checked) flags.Add(AuraDev19b6.ShutdownKeyb);
-
-            if (checkAwakeBar.Checked) flags.Add(AuraDev19b6.AwakeBar);
-            if (checkBootBar.Checked) flags.Add(AuraDev19b6.BootBar);
-            if (checkSleepBar.Checked) flags.Add(AuraDev19b6.SleepBar);
-            if (checkShutdownBar.Checked) flags.Add(AuraDev19b6.ShutdownBar);
-
-            if (checkAwakeLid.Checked) flags.Add(AuraDev19b6.AwakeLid);
-            if (checkBootLid.Checked) flags.Add(AuraDev19b6.BootLid);
-            if (checkSleepLid.Checked) flags.Add(AuraDev19b6.SleepLid);
-            if (checkShutdownLid.Checked) flags.Add(AuraDev19b6.ShutdownLid);
-
-            if (checkAwakeLogo.Checked) flags.Add(AuraDev19b6.AwakeLogo);
-            if (checkBootLogo.Checked) flags.Add(AuraDev19b6.BootLogo);
-            if (checkSleepLogo.Checked) flags.Add(AuraDev19b6.SleepLogo);
-            if (checkShutdownLogo.Checked) flags.Add(AuraDev19b6.ShutdownLogo);
-
-            AsusUSB.ApplyAuraPower(flags);
+            Aura.ApplyPower();
 
         }
 
         private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
-            Program.settingsForm.SetAura();
+            Aura.ApplyAura();
         }
 
 
@@ -448,9 +616,25 @@ namespace GHelper
             Left = Program.settingsForm.Left - Width - 5;
         }
 
-        private void checkAutoApplyWindowsPowerMode_CheckedChanged(object? sender, EventArgs e)
+
+        private void checkAutoToggleClamshellMode_CheckedChanged(object? sender, EventArgs e)
         {
-            AppConfig.Set("auto_apply_power_plan", checkAutoApplyWindowsPowerMode.Checked ? 1 : 0);
+            AppConfig.Set("toggle_clamshell_mode", checkAutoToggleClamshellMode.Checked ? 1 : 0);
+
+            if (checkAutoToggleClamshellMode.Checked)
+            {
+                clamshellControl.ToggleLidAction();
+            }
+            else
+            {
+                ClamshellModeControl.DisableClamshellMode();
+            }
+
+        }
+
+        private void panelAPU_Paint(object sender, PaintEventArgs e)
+        {
+
         }
     }
 }

app/Extra.resx

@@ -18,7 +18,7 @@
     <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="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>
@@ -117,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 = 92;
+
+        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.cs

@@ -1,10 +1,10 @@
-using CustomControls;
-using GHelper.Gpu;
+using GHelper.Fan;
+using GHelper.Gpu.NVidia;
+using GHelper.Mode;
+using GHelper.UI;
+using GHelper.USB;
 using Ryzen;
-using System;
 using System.Diagnostics;
-using System.Net.Sockets;
-using System.Windows.Forms;
 using System.Windows.Forms.DataVisualization.Charting;
 
 namespace GHelper
@@ -13,26 +13,30 @@ namespace GHelper
     {
 
         int curIndex = -1;
-        DataPoint curPoint = null;
+        DataPoint? curPoint = null;
 
         Series seriesCPU;
         Series seriesGPU;
         Series seriesMid;
         Series seriesXGM;
 
-        static int MinRPM, MaxRPM;
-
         static bool gpuVisible = true;
+        static bool fanRpm = true;
 
         const int fansMax = 100;
 
         NvidiaGpuControl? nvControl = null;
+        ModeControl modeControl = Program.modeControl;
+
+        FanSensorControl fanSensorControl;
 
         public Fans()
         {
 
             InitializeComponent();
 
+            fanSensorControl = new FanSensorControl(this);
+
             //float dpi = ControlHelper.GetDpiScale(this).Value;
             //comboModes.Size = new Size(comboModes.Width, (int)dpi * 18);
             comboModes.ClientSize = new Size(comboModes.Width, comboModes.Height - 4);
@@ -53,10 +57,14 @@ namespace GHelper
             labelGPUBoostTitle.Text = Properties.Strings.GPUBoost;
             labelGPUTempTitle.Text = Properties.Strings.GPUTempTarget;
 
+            labelRisky.Text = Properties.Strings.UndervoltingRisky;
+            buttonApplyAdvanced.Text = Properties.Strings.Apply;
+            checkApplyUV.Text = Properties.Strings.AutoApply;
+
+            buttonCalibrate.Text = Properties.Strings.Calibrate;
+
             InitTheme(true);
 
-            MinRPM = 18;
-            MaxRPM = HardwareControl.GetFanMax();
             labelTip.Visible = false;
             labelTip.BackColor = Color.Transparent;
 
@@ -72,23 +80,35 @@ namespace GHelper
             seriesMid.Color = colorEco;
             seriesXGM.Color = Color.Orange;
 
-            chartCPU.MouseMove += ChartCPU_MouseMove;
+            chartCPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.CPU);
             chartCPU.MouseUp += ChartCPU_MouseUp;
+            chartCPU.MouseLeave += ChartCPU_MouseLeave;
 
-            chartGPU.MouseMove += ChartCPU_MouseMove;
+            chartGPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.GPU);
             chartGPU.MouseUp += ChartCPU_MouseUp;
+            chartGPU.MouseLeave += ChartCPU_MouseLeave;
 
-            chartMid.MouseMove += ChartCPU_MouseMove;
+            chartMid.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.Mid);
             chartMid.MouseUp += ChartCPU_MouseUp;
+            chartMid.MouseLeave += ChartCPU_MouseLeave;
 
-            chartXGM.MouseMove += ChartCPU_MouseMove;
+            chartXGM.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.XGM);
             chartXGM.MouseUp += ChartCPU_MouseUp;
+            chartXGM.MouseLeave += ChartCPU_MouseLeave;
+
+            chartCPU.MouseClick += ChartCPU_MouseClick;
+            chartGPU.MouseClick += ChartCPU_MouseClick;
+            chartMid.MouseClick += ChartCPU_MouseClick;
+            chartXGM.MouseClick += ChartCPU_MouseClick;
 
             buttonReset.Click += ButtonReset_Click;
 
             trackA0.Maximum = AsusACPI.MaxTotal;
             trackA0.Minimum = AsusACPI.MinTotal;
 
+            trackA3.Maximum = AsusACPI.MaxTotal;
+            trackA3.Minimum = AsusACPI.MinTotal;
+
             trackB0.Maximum = AsusACPI.MaxCPU;
             trackB0.Minimum = AsusACPI.MinCPU;
 
@@ -98,14 +118,19 @@ namespace GHelper
             trackC1.Scroll += TrackPower_Scroll;
             trackB0.Scroll += TrackPower_Scroll;
             trackA0.Scroll += TrackPower_Scroll;
+            trackA3.Scroll += TrackPower_Scroll;
 
             trackC1.MouseUp += TrackPower_MouseUp;
             trackB0.MouseUp += TrackPower_MouseUp;
             trackA0.MouseUp += TrackPower_MouseUp;
+            trackA3.MouseUp += TrackPower_MouseUp;
 
             checkApplyFans.Click += CheckApplyFans_Click;
             checkApplyPower.Click += CheckApplyPower_Click;
 
+            trackGPUClockLimit.Minimum = NvidiaGpuControl.MinClockLimit;
+            trackGPUClockLimit.Maximum = NvidiaGpuControl.MaxClockLimit;
+
             trackGPUCore.Minimum = NvidiaGpuControl.MinCoreOffset;
             trackGPUCore.Maximum = NvidiaGpuControl.MaxCoreOffset;
 
@@ -118,6 +143,7 @@ namespace GHelper
             trackGPUTemp.Minimum = AsusACPI.MinGPUTemp;
             trackGPUTemp.Maximum = AsusACPI.MaxGPUTemp;
 
+            trackGPUClockLimit.Scroll += trackGPUClockLimit_Scroll;
             trackGPUCore.Scroll += trackGPU_Scroll;
             trackGPUMemory.Scroll += trackGPU_Scroll;
 
@@ -129,13 +155,32 @@ namespace GHelper
             trackGPUBoost.MouseUp += TrackGPU_MouseUp;
             trackGPUTemp.MouseUp += TrackGPU_MouseUp;
 
+            trackGPUClockLimit.MouseUp += TrackGPU_MouseUp;
+
             //labelInfo.MaximumSize = new Size(280, 0);
             labelFansResult.Visible = false;
 
+
+            trackUV.Minimum = RyzenControl.MinCPUUV;
+            trackUV.Maximum = RyzenControl.MaxCPUUV;
+
+            trackUViGPU.Minimum = RyzenControl.MinIGPUUV;
+            trackUViGPU.Maximum = RyzenControl.MaxIGPUUV;
+
+            trackTemp.Minimum = RyzenControl.MinTemp;
+            trackTemp.Maximum = RyzenControl.MaxTemp;
+
+            comboPowerMode.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboPowerMode.DataSource = new BindingSource(PowerNative.powerModes, null);
+            comboPowerMode.DisplayMember = "Value";
+            comboPowerMode.ValueMember = "Key";
+
             FillModes();
             InitAll();
 
             comboBoost.SelectedValueChanged += ComboBoost_Changed;
+            comboPowerMode.SelectedValueChanged += ComboPowerMode_Changed;
+
 
             comboModes.SelectionChangeCommitted += ComboModes_SelectedValueChanged;
             comboModes.TextChanged += ComboModes_TextChanged;
@@ -147,14 +192,10 @@ namespace GHelper
             buttonRemove.Click += ButtonRemove_Click;
             buttonRename.Click += ButtonRename_Click;
 
-            trackUV.Minimum = -30;
-            trackUV.Maximum = 0;
-
-            trackUViGPU.Minimum = -20;
-            trackUViGPU.Maximum = 0;
 
             trackUV.Scroll += TrackUV_Scroll;
             trackUViGPU.Scroll += TrackUV_Scroll;
+            trackTemp.Scroll += TrackUV_Scroll;
 
             buttonApplyAdvanced.Click += ButtonApplyAdvanced_Click;
 
@@ -168,13 +209,52 @@ namespace GHelper
 
             checkApplyUV.Click += CheckApplyUV_Click;
 
+            buttonCalibrate.Click += ButtonCalibrate_Click;
+
             ToggleNavigation(0);
 
+            if (Program.acpi.DeviceGet(AsusACPI.DevsCPUFanCurve) < 0) buttonCalibrate.Visible = false;
+
+            FormClosed += Fans_FormClosed;
+
+        }
+
+
+
+        private void ButtonCalibrate_Click(object? sender, EventArgs e)
+        {
+            buttonCalibrate.Enabled = false;
+            fanSensorControl.StartCalibration();
+        }
+
+        private void ChartCPU_MouseClick(object? sender, MouseEventArgs e)
+        {
+            if (sender is null) return;
+            Chart chart = (Chart)sender;
+
+            HitTestResult result = chart.HitTest(e.X, e.Y);
+
+            if ((result.ChartElementType == ChartElementType.AxisLabels || result.ChartElementType == ChartElementType.Axis) && result.Axis == chart.ChartAreas[0].AxisY)
+            {
+                fanRpm = !fanRpm;
+                SetAxis(chartCPU, AsusFan.CPU);
+                SetAxis(chartGPU, AsusFan.GPU);
+                if (chartMid.Visible) SetAxis(chartMid, AsusFan.Mid);
+                if (chartXGM.Visible) SetAxis(chartXGM, AsusFan.XGM);
+            }
+
+        }
+
+        private void Fans_FormClosed(object? sender, FormClosedEventArgs e)
+        {
+            //Because windows charts seem to eat a lot of memory :(
+            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
         }
 
         private void CheckApplyUV_Click(object? sender, EventArgs e)
         {
             AppConfig.SetMode("auto_uv", checkApplyUV.Checked ? 1 : 0);
+            modeControl.AutoRyzen();
         }
 
         public void InitAll()
@@ -182,7 +262,7 @@ namespace GHelper
             InitMode();
             InitFans();
             InitPower();
-            InitBoost();
+            InitPowerPlan();
             InitUV();
             InitGPU();
         }
@@ -237,7 +317,7 @@ namespace GHelper
 
         private void ButtonApplyAdvanced_Click(object? sender, EventArgs e)
         {
-            Program.settingsForm.SetUV(true);
+            modeControl.SetRyzen(true);
             checkApplyUV.Enabled = true;
         }
 
@@ -249,30 +329,57 @@ namespace GHelper
             int cpuUV = Math.Max(trackUV.Minimum, Math.Min(trackUV.Maximum, AppConfig.GetMode("cpu_uv", 0)));
             int igpuUV = Math.Max(trackUViGPU.Minimum, Math.Min(trackUViGPU.Maximum, AppConfig.GetMode("igpu_uv", 0)));
 
+            int temp = AppConfig.GetMode("cpu_temp");
+            if (temp < RyzenControl.MinTemp || temp > RyzenControl.MaxTemp) temp = RyzenControl.MaxTemp;
+
             checkApplyUV.Enabled = checkApplyUV.Checked = AppConfig.IsMode("auto_uv");
 
             trackUV.Value = cpuUV;
-            labelUV.Text = trackUV.Value.ToString();
-
             trackUViGPU.Value = igpuUV;
+            trackTemp.Value = temp;
+
+            VisualiseAdvanced();
+
+            buttonAdvanced.Visible = RyzenControl.IsAMD();
+
+        }
+
+        private void VisualiseAdvanced()
+        {
+            if (!RyzenControl.IsSupportedUV())
+            {
+                panelTitleAdvanced.Visible = false;
+                labelRisky.Visible = false;
+                panelUV.Visible = false;
+                panelUViGPU.Visible = false;
+            }
+
+            if (!RyzenControl.IsSupportedUViGPU())
+            {
+                panelUViGPU.Visible = false;
+            }
+
+            labelUV.Text = trackUV.Value.ToString();
             labelUViGPU.Text = trackUViGPU.Value.ToString();
+            labelTemp.Text = (trackTemp.Value < RyzenControl.MaxTemp) ? trackTemp.Value.ToString() + "°C" : "Default";
+        }
 
-            buttonAdvanced.Visible = Undervolter.IsAMD();
+        private void AdvancedScroll()
+        {
+            AppConfig.SetMode("auto_uv", 0);
+            checkApplyUV.Enabled = checkApplyUV.Checked = false;
 
+            VisualiseAdvanced();
+
+            AppConfig.SetMode("cpu_temp", trackTemp.Value);
+            AppConfig.SetMode("cpu_uv", trackUV.Value);
+            AppConfig.SetMode("igpu_uv", trackUViGPU.Value);
         }
 
 
         private void TrackUV_Scroll(object? sender, EventArgs e)
         {
-            AppConfig.SetMode("auto_uv", 0);
-            checkApplyUV.Enabled = checkApplyUV.Checked = false;
-
-            labelUV.Text = trackUV.Value.ToString();
-            labelUViGPU.Text = trackUViGPU.Value.ToString();
-
-            AppConfig.SetMode("cpu_uv", trackUV.Value);
-            AppConfig.SetMode("igpu_uv", trackUViGPU.Value);
-
+            AdvancedScroll();
         }
 
         private void ComboModes_KeyPress(object? sender, KeyPressEventArgs e)
@@ -312,7 +419,7 @@ namespace GHelper
             Modes.Remove(mode);
             FillModes();
 
-            Program.settingsForm.SetPerformanceMode(AsusACPI.PerformanceBalanced);
+            modeControl.SetPerformanceMode(AsusACPI.PerformanceBalanced);
 
         }
 
@@ -328,7 +435,7 @@ namespace GHelper
         {
             int mode = Modes.Add();
             FillModes();
-            Program.settingsForm.SetPerformanceMode(mode);
+            modeControl.SetPerformanceMode(mode);
         }
 
         public void InitMode()
@@ -347,13 +454,13 @@ namespace GHelper
 
             Debug.WriteLine(selectedMode);
 
-            Program.settingsForm.SetPerformanceMode((int)selectedMode);
+            modeControl.SetPerformanceMode((int)selectedMode);
         }
 
         private void TrackGPU_MouseUp(object? sender, MouseEventArgs e)
         {
-            Program.settingsForm.SetGPUPower();
-            Program.settingsForm.SetGPUClocks(true);
+            modeControl.SetGPUPower();
+            modeControl.SetGPUClocks(true);
         }
 
         public void InitGPU()
@@ -365,7 +472,7 @@ namespace GHelper
                 return;
             }
 
-            if (HardwareControl.GpuControl is null) HardwareControl.RecreateGpuControl();
+            if (HardwareControl.GpuControl is null || !HardwareControl.GpuControl.IsValid) HardwareControl.RecreateGpuControl();
 
             if (HardwareControl.GpuControl is not null && HardwareControl.GpuControl.IsNvidia)
             {
@@ -383,24 +490,29 @@ namespace GHelper
 
                 int gpu_boost = AppConfig.GetMode("gpu_boost");
                 int gpu_temp = AppConfig.GetMode("gpu_temp");
+
                 int core = AppConfig.GetMode("gpu_core");
                 int memory = AppConfig.GetMode("gpu_memory");
+                int clock_limit = AppConfig.GetMode("gpu_clock_limit");
 
                 if (gpu_boost < 0) gpu_boost = AsusACPI.MaxGPUBoost;
                 if (gpu_temp < 0) gpu_temp = AsusACPI.MaxGPUTemp;
 
                 if (core == -1) core = 0;
                 if (memory == -1) memory = 0;
+                if (clock_limit == -1) clock_limit = NvidiaGpuControl.MaxClockLimit;
 
-                //if (readClocks)
-                //{
-                int status = nvControl.GetClocks(out int current_core, out int current_memory);
-                if (status != -1)
+                if (nvControl.GetClocks(out int current_core, out int current_memory))
                 {
                     core = current_core;
                     memory = current_memory;
                 }
 
+                int _clockLimit = nvControl.GetMaxGPUCLock();
+
+                if (_clockLimit == 0) clock_limit = NvidiaGpuControl.MaxClockLimit;
+                else if (_clockLimit > 0) clock_limit = _clockLimit;
+
                 try
                 {
                     labelGPU.Text = nvControl.FullName;
@@ -411,6 +523,7 @@ namespace GHelper
                 }
 
                 //}
+                trackGPUClockLimit.Value = Math.Max(Math.Min(clock_limit, NvidiaGpuControl.MaxClockLimit), NvidiaGpuControl.MinClockLimit);
 
                 trackGPUCore.Value = Math.Max(Math.Min(core, NvidiaGpuControl.MaxCoreOffset), NvidiaGpuControl.MinCoreOffset);
                 trackGPUMemory.Value = Math.Max(Math.Min(memory, NvidiaGpuControl.MaxMemoryOffset), NvidiaGpuControl.MinMemoryOffset);
@@ -436,8 +549,24 @@ namespace GHelper
         {
             labelGPUCore.Text = $"{trackGPUCore.Value} MHz";
             labelGPUMemory.Text = $"{trackGPUMemory.Value} MHz";
+
             labelGPUBoost.Text = $"{trackGPUBoost.Value}W";
             labelGPUTemp.Text = $"{trackGPUTemp.Value}°C";
+
+            if (trackGPUClockLimit.Value >= NvidiaGpuControl.MaxClockLimit)
+                labelGPUClockLimit.Text = "Default";
+            else
+                labelGPUClockLimit.Text = $"{trackGPUClockLimit.Value} MHz";
+        }
+
+        private void trackGPUClockLimit_Scroll(object? sender, EventArgs e)
+        {
+
+            int maxClock = (int)Math.Round((float)trackGPUClockLimit.Value / 50) * 50;
+
+            trackGPUClockLimit.Value = maxClock;
+            AppConfig.SetMode("gpu_clock_limit", maxClock);
+            VisualiseGPUSettings();
         }
 
         private void trackGPU_Scroll(object? sender, EventArgs e)
@@ -449,6 +578,7 @@ namespace GHelper
             AppConfig.SetMode("gpu_core", trackGPUCore.Value);
             AppConfig.SetMode("gpu_memory", trackGPUMemory.Value);
 
+
             VisualiseGPUSettings();
 
         }
@@ -461,31 +591,52 @@ namespace GHelper
             VisualiseGPUSettings();
         }
 
-        static string ChartPercToRPM(int percentage, string unit = "")
+        static string ChartYLabel(int percentage, AsusFan device, string unit = "")
         {
             if (percentage == 0) return "OFF";
 
-            return (200 * Math.Round((float)(MinRPM * 100 + (MaxRPM - MinRPM) * percentage) / 200)).ToString() + unit;
+            int Min = FanSensorControl.DEFAULT_FAN_MIN;
+            int Max = FanSensorControl.GetFanMax(device);
+
+            if (fanRpm)
+                return (200 * Math.Floor((float)(Min * 100 + (Max - Min) * percentage) / 200)).ToString() + unit;
+            else
+                return percentage + "%";
+        }
+
+        void SetAxis(Chart chart, AsusFan device)
+        {
+
+            chart.ChartAreas[0].AxisY.CustomLabels.Clear();
+
+            for (int i = 0; i <= fansMax; i += 10)
+            {
+                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartYLabel(i, device));
+            }
+
+            //chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax -2, fansMax + 2, Properties.Strings.RPM);
+            chart.ChartAreas[0].AxisY.Interval = 10;
         }
 
         void SetChart(Chart chart, AsusFan device)
         {
 
             string title = "";
+            string scale = ", RPM/°C";
 
             switch (device)
             {
                 case AsusFan.CPU:
-                    title = Properties.Strings.FanProfileCPU;
+                    title = Properties.Strings.FanProfileCPU + scale;
                     break;
                 case AsusFan.GPU:
-                    title = Properties.Strings.FanProfileGPU;
+                    title = Properties.Strings.FanProfileGPU + scale;
                     break;
                 case AsusFan.Mid:
-                    title = Properties.Strings.FanProfileMid;
+                    title = Properties.Strings.FanProfileMid + scale;
                     break;
                 case AsusFan.XGM:
-                    title = "XG Mobile";
+                    title = "XG Mobile" + scale;
                     break;
             }
 
@@ -505,12 +656,7 @@ namespace GHelper
             chart.ChartAreas[0].AxisX.LineColor = chartGrid;
             chart.ChartAreas[0].AxisY.LineColor = chartGrid;
 
-            for (int i = 0; i <= fansMax - 10; i += 10)
-                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartPercToRPM(i));
-
-            chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax - 2, fansMax + 2, Properties.Strings.RPM);
-
-            chart.ChartAreas[0].AxisY.Interval = 10;
+            SetAxis(chart, device);
 
             if (chart.Legends.Count > 0)
                 chart.Legends[0].Enabled = false;
@@ -541,22 +687,44 @@ namespace GHelper
 
         private void TrackPower_MouseUp(object? sender, MouseEventArgs e)
         {
-            Program.settingsForm.AutoPower();
+            modeControl.AutoPower();
         }
 
 
-        public void InitBoost()
+        public void InitPowerPlan()
         {
-            int boost = NativeMethods.GetCPUBoost();
+            int boost = PowerNative.GetCPUBoost();
             if (boost >= 0)
                 comboBoost.SelectedIndex = Math.Min(boost, comboBoost.Items.Count - 1);
+
+            string powerMode = PowerNative.GetPowerMode();
+            bool batterySaver = PowerNative.GetBatterySaverStatus();
+
+            comboPowerMode.Enabled = !batterySaver;
+
+            if (batterySaver) 
+                comboPowerMode.SelectedIndex = 0;
+            else
+                comboPowerMode.SelectedValue = powerMode;
+
+        }
+
+        private void ComboPowerMode_Changed(object? sender, EventArgs e)
+        {
+            string powerMode = (string)comboPowerMode.SelectedValue;
+            PowerNative.SetPowerMode(powerMode);
+
+            if (PowerNative.GetDefaultPowerMode(Modes.GetCurrentBase()) != powerMode)
+                AppConfig.SetMode("powermode", powerMode);
+            else
+                AppConfig.RemoveMode("powermode");
         }
 
         private void ComboBoost_Changed(object? sender, EventArgs e)
         {
             if (AppConfig.GetMode("auto_boost") != comboBoost.SelectedIndex)
             {
-                NativeMethods.SetCPUBoost(comboBoost.SelectedIndex);
+                PowerNative.SetCPUBoost(comboBoost.SelectedIndex);
             }
             AppConfig.SetMode("auto_boost", comboBoost.SelectedIndex);
         }
@@ -567,7 +735,7 @@ namespace GHelper
             CheckBox chk = (CheckBox)sender;
 
             AppConfig.SetMode("auto_apply_power", chk.Checked ? 1 : 0);
-            Program.settingsForm.SetPerformanceMode();
+            modeControl.SetPerformanceMode();
 
         }
 
@@ -577,20 +745,38 @@ namespace GHelper
             CheckBox chk = (CheckBox)sender;
 
             AppConfig.SetMode("auto_apply", chk.Checked ? 1 : 0);
-            Program.settingsForm.SetPerformanceMode();
+            modeControl.SetPerformanceMode();
 
         }
 
+        public void InitAxis()
+        {
+            if (this == null || this.Text == "") return;
+
+            Invoke(delegate
+            {
+                buttonCalibrate.Enabled = true;
+                SetAxis(chartCPU, AsusFan.CPU);
+                SetAxis(chartGPU, AsusFan.GPU);
+                if (chartMid.Visible) SetAxis(chartMid, AsusFan.Mid);
+            });
+        }
 
         public void LabelFansResult(string text)
         {
-            labelFansResult.Text = text;
-            labelFansResult.Visible = (text.Length > 0);
+            if (text.Length > 0) Logger.WriteLine(text);
+
+            if (this == null || this.Text == "") return;
+
+            Invoke(delegate
+            {
+                labelFansResult.Text = text;
+                labelFansResult.Visible = (text.Length > 0);
+            });
         }
 
         private void Fans_FormClosing(object? sender, FormClosingEventArgs e)
         {
-
             /*
             if (e.CloseReason == CloseReason.UserClosing)
             {
@@ -603,13 +789,16 @@ namespace GHelper
         public void InitPower(bool changed = false)
         {
 
-            bool modeA0 = Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0;
+            bool modeA0 = (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0 || RyzenControl.IsAMD());
+            bool modeA3 = Program.acpi.DeviceGet(AsusACPI.PPT_APUA3) >= 0;
             bool modeB0 = Program.acpi.IsAllAmdPPT();
             bool modeC1 = Program.acpi.DeviceGet(AsusACPI.PPT_APUC1) >= 0;
 
             panelA0.Visible = modeA0;
             panelB0.Visible = modeB0;
 
+            panelApplyPower.Visible = panelTitleCPU.Visible = modeA0 || modeB0 || modeC1;
+
 
             // All AMD version has B0 but doesn't have C0 (Nvidia GPU) settings
             if (modeB0)
@@ -617,15 +806,31 @@ namespace GHelper
                 labelLeftA0.Text = "Platform (CPU + GPU)";
                 labelLeftB0.Text = "CPU";
                 panelC1.Visible = false;
+                panelA3.Visible = false;
             }
             else
             {
-                labelLeftA0.Text = "CPU Slow (SPL + sPPT)";
-                labelLeftC1.Text = "CPU Fast (fPPT)";
-                panelC1.Visible = modeC1;
+                panelA3.Visible = modeA3;
+
+                if (RyzenControl.IsAMD())
+                {
+                    labelLeftA0.Text = "CPU Sustained (SPL)";
+                    labelLeftA3.Text = "CPU Slow (sPPT)";
+                    labelLeftC1.Text = "CPU Fast (fPPT)";
+                    panelC1.Visible = modeC1;
+                    
+                }
+                else
+                {
+                    labelLeftA0.Text = "CPU Slow (PL1)";
+                    labelLeftA3.Text = "CPU Fast (PL2)";
+                    panelC1.Visible = false;
+                }
+
             }
 
             int limit_total;
+            int limit_slow;
             int limit_cpu;
             int limit_fast;
 
@@ -634,12 +839,14 @@ namespace GHelper
             if (changed)
             {
                 limit_total = trackA0.Value;
+                limit_slow = trackA3.Value;
                 limit_cpu = trackB0.Value;
                 limit_fast = trackC1.Value;
             }
             else
             {
                 limit_total = AppConfig.GetMode("limit_total");
+                limit_slow = AppConfig.GetMode("limit_slow");
                 limit_cpu = AppConfig.GetMode("limit_cpu");
                 limit_fast = AppConfig.GetMode("limit_fast");
             }
@@ -653,21 +860,28 @@ namespace GHelper
             if (limit_cpu < AsusACPI.MinCPU) limit_cpu = AsusACPI.MinCPU;
             if (limit_cpu > limit_total) limit_cpu = limit_total;
 
+            if (limit_slow < 0) limit_slow = limit_total;
+            if (limit_slow > AsusACPI.MaxTotal) limit_slow = AsusACPI.MaxTotal;
+            if (limit_slow < AsusACPI.MinTotal) limit_slow = AsusACPI.MinTotal;
+
             if (limit_fast < 0) limit_fast = AsusACPI.DefaultTotal;
             if (limit_fast > AsusACPI.MaxTotal) limit_fast = AsusACPI.MaxTotal;
             if (limit_fast < AsusACPI.MinTotal) limit_fast = AsusACPI.MinTotal;
 
             trackA0.Value = limit_total;
+            trackA3.Value = limit_slow;
             trackB0.Value = limit_cpu;
             trackC1.Value = limit_fast;
 
             checkApplyPower.Checked = apply;
 
             labelA0.Text = trackA0.Value.ToString() + "W";
+            labelA3.Text = trackA3.Value.ToString() + "W";
             labelB0.Text = trackB0.Value.ToString() + "W";
             labelC1.Text = trackC1.Value.ToString() + "W";
 
             AppConfig.SetMode("limit_total", limit_total);
+            AppConfig.SetMode("limit_slow", limit_slow);
             AppConfig.SetMode("limit_cpu", limit_cpu);
             AppConfig.SetMode("limit_fast", limit_fast);
 
@@ -717,7 +931,7 @@ namespace GHelper
             try
             {
                 if (chartCount > 2)
-                    Size = MinimumSize = new Size(0, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100)));
+                    Size = MinimumSize = new Size(Size.Width, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100)));
             }
             catch (Exception ex)
             {
@@ -807,40 +1021,47 @@ namespace GHelper
             AppConfig.SetMode("auto_apply", 0);
             AppConfig.SetMode("auto_apply_power", 0);
 
-            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
+            trackUV.Value = RyzenControl.MaxCPUUV;
+            trackUViGPU.Value = RyzenControl.MaxIGPUUV;
+            trackTemp.Value = RyzenControl.MaxTemp;
 
-            if (Program.acpi.IsXGConnected())
-                AsusUSB.ResetXGM();
+            AdvancedScroll();
+            AppConfig.SetMode("cpu_temp", -1);
+
+            modeControl.ResetPerformanceMode();
+
+            InitPowerPlan();
+
+            if (Program.acpi.IsXGConnected()) XGM.Reset();
 
-            trackUV.Value = 0;
-            trackUViGPU.Value = 0;
-            AppConfig.SetMode("cpu_uv", 0);
-            AppConfig.SetMode("igpu_uv", 0);
 
             if (gpuVisible)
             {
+                trackGPUClockLimit.Value = NvidiaGpuControl.MaxClockLimit;
                 trackGPUCore.Value = 0;
                 trackGPUMemory.Value = 0;
                 trackGPUBoost.Value = AsusACPI.MaxGPUBoost;
                 trackGPUTemp.Value = AsusACPI.MaxGPUTemp;
 
+                AppConfig.SetMode("gpu_clock_limit", trackGPUClockLimit.Value);
+
                 AppConfig.SetMode("gpu_boost", trackGPUBoost.Value);
                 AppConfig.SetMode("gpu_temp", trackGPUTemp.Value);
+
                 AppConfig.SetMode("gpu_core", trackGPUCore.Value);
                 AppConfig.SetMode("gpu_memory", trackGPUMemory.Value);
 
                 VisualiseGPUSettings();
-                Program.settingsForm.SetGPUClocks(true);
-                Program.settingsForm.SetGPUPower();
+                modeControl.SetGPUClocks(true);
+                modeControl.SetGPUPower();
             }
 
         }
 
-        private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
+        private void Chart_Save()
         {
             curPoint = null;
             curIndex = -1;
-
             labelTip.Visible = false;
 
             SaveProfile(seriesCPU, AsusFan.CPU);
@@ -852,12 +1073,23 @@ namespace GHelper
             if (AppConfig.Is("xgm_fan"))
                 SaveProfile(seriesXGM, AsusFan.XGM);
 
-            Program.settingsForm.AutoFans();
-
-
+            modeControl.AutoFans();
         }
 
-        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e)
+        private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
+        {
+            Chart_Save();
+        }
+
+
+        private void ChartCPU_MouseLeave(object? sender, EventArgs e)
+        {
+            curPoint = null;
+            curIndex = -1;
+            labelTip.Visible = false;
+        }
+
+        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e, AsusFan device)
         {
 
             if (sender is null) return;
@@ -896,7 +1128,7 @@ namespace GHelper
                     if (dy < 0) dy = 0;
                     if (dy > fansMax) dy = fansMax;
 
-                    dymin = (dx - 65) * 1.2;
+                    dymin = (dx - 70) * 1.2;
 
                     if (dy < dymin) dy = dymin;
 
@@ -918,7 +1150,7 @@ namespace GHelper
                         tip = true;
                     }
 
-                    labelTip.Text = Math.Round(curPoint.XValue) + "C, " + ChartPercToRPM((int)curPoint.YValues[0], " " + Properties.Strings.RPM);
+                    labelTip.Text = Math.Floor(curPoint.XValue) + "C, " + ChartYLabel((int)curPoint.YValues[0], device, " " + Properties.Strings.RPM);
                     labelTip.Top = e.Y + ((Control)sender).Top;
                     labelTip.Left = e.X - 50;
 
@@ -949,8 +1181,8 @@ namespace GHelper
         {
 
             // Get the neighboring DataPoints of the hit point
-            DataPoint upperPoint = null;
-            DataPoint lowerPoint = null;
+            DataPoint? upperPoint = null;
+            DataPoint? lowerPoint = null;
 
             if (index > 0)
             {

app/Fans.resx

@@ -18,7 +18,7 @@
     <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="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>

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.87</AssemblyVersion>
+    <AssemblyVersion>0.142</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -60,9 +59,9 @@
 
   <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" />

app/Gpu/AMD/AmdAdl2.cs

@@ -1,8 +1,8 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using static AmdAdl2.Adl2.NativeMethods;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
 
-namespace AmdAdl2;
+namespace GHelper.Gpu.AMD;
 
 #region Export Struct
 
@@ -33,13 +33,15 @@ public struct ADLBdf
 }
 
 [StructLayout(LayoutKind.Sequential)]
-public struct ADLSingleSensorData {
+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)]
@@ -57,7 +59,8 @@ public struct ADLGcnInfo
 }
 
 [Flags]
-public enum ADLAsicFamilyType {
+public enum ADLAsicFamilyType
+{
     Undefined = 0,
     Discrete = 1 << 0,
     Integrated = 1 << 1,
@@ -69,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
@@ -149,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,
@@ -237,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;
 
@@ -292,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;
@@ -304,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;
 
@@ -320,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;
 
@@ -355,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
@@ -398,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;
         }
@@ -423,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>  
@@ -477,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>
@@ -487,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,
@@ -504,21 +525,21 @@ 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(
-            IntPtr context,
+            nint context,
             int iListType,
             out int lpNumApps,
-            out IntPtr lppAppList);
+            out nint lppAppList);
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Adapter_VariBright_Caps(
-            IntPtr context,
+            nint context,
             int iAdapterIndex,
             out int iSupported,
             out int iEnabled,
@@ -526,7 +547,7 @@ public class Adl2 {
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_Adapter_VariBrightEnable_Set(
-            IntPtr context,
+            nint context,
             int iAdapterIndex,
             int iEnabled);
 
@@ -553,25 +574,25 @@ public class Adl2 {
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_OverdriveN_SystemClocks_Get(
-            IntPtr context,
+            nint context,
             int adapterIndex,
             ref ADLODNPerformanceLevels performanceLevels);
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_OverdriveN_SystemClocks_Set(
-            IntPtr context,
+            nint context,
             int adapterIndex,
             ref ADLODNPerformanceLevels performanceLevels);
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_OverdriveN_MemoryClocks_Get(
-            IntPtr context,
+            nint context,
             int adapterIndex,
             ref ADLODNPerformanceLevels performanceLevels);
 
         [DllImport(Atiadlxx_FileName)]
         public static extern int ADL2_OverdriveN_MemoryClocks_Set(
-            IntPtr context,
+            nint context,
             int adapterIndex,
             ref ADLODNPerformanceLevels performanceLevels);
     }

app/Gpu/AMD/AmdGpuControl.cs

@@ -1,14 +1,14 @@
-using AmdAdl2;
+using GHelper.Helpers;
 using System.Runtime.InteropServices;
-using static AmdAdl2.Adl2.NativeMethods;
+using static GHelper.Gpu.AMD.Adl2.NativeMethods;
 
-namespace GHelper.Gpu;
+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 IntPtr _adlContextHandle;
+    private nint _adlContextHandle;
     private readonly ADLAdapterInfo _internalDiscreteAdapter;
 
     public bool IsNvidia => false;
@@ -23,7 +23,7 @@ public class AmdGpuControl : IGpuControl
 
         ADLAdapterInfoArray osAdapterInfoData = new();
         int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
-        IntPtr AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
+        nint AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
         Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
         if (ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
             return null;
@@ -76,7 +76,7 @@ public class AmdGpuControl : IGpuControl
 
     }
 
-    public bool IsValid => _isReady && _adlContextHandle != IntPtr.Zero;
+    public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
 
     public int? GetCurrentTemperature()
     {
@@ -112,7 +112,7 @@ public class AmdGpuControl : IGpuControl
 
     public bool SetVariBright(int enabled)
     {
-        if (_adlContextHandle == IntPtr.Zero) return false;
+        if (_adlContextHandle == nint.Zero) return false;
 
         ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
         if (iGPU is null) return false;
@@ -125,7 +125,7 @@ public class AmdGpuControl : IGpuControl
     {
         supported = enabled = -1;
 
-        if (_adlContextHandle == IntPtr.Zero) return false;
+        if (_adlContextHandle == nint.Zero) return false;
 
         ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
         if (iGPU is null) return false;
@@ -154,7 +154,7 @@ public class AmdGpuControl : IGpuControl
 
         if (!IsValid) return;
 
-        IntPtr appInfoPtr = IntPtr.Zero;
+        nint appInfoPtr = nint.Zero;
         int appCount = 0;
 
         try
@@ -168,12 +168,12 @@ public class AmdGpuControl : IGpuControl
 
             // Convert the application data pointers to an array of structs
             var appInfoArray = new ADLSGApplicationInfo[appCount];
-            IntPtr currentPtr = appInfoPtr;
+            nint currentPtr = appInfoPtr;
 
             for (int i = 0; i < appCount; i++)
             {
                 appInfoArray[i] = Marshal.PtrToStructure<ADLSGApplicationInfo>(currentPtr);
-                currentPtr = IntPtr.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
+                currentPtr = nint.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
             }
 
             var appNames = new List<string>();
@@ -189,7 +189,7 @@ public class AmdGpuControl : IGpuControl
 
             List<string> immune = new() { "svchost", "system", "ntoskrnl", "csrss", "winlogon", "wininit", "smss" };
 
-            foreach (string kill in appNames) 
+            foreach (string kill in appNames)
                 if (!immune.Contains(kill.ToLower()))
                     ProcessHelper.KillByName(kill);
 
@@ -202,7 +202,7 @@ public class AmdGpuControl : IGpuControl
         finally
         {
             // Clean up resources
-            if (appInfoPtr != IntPtr.Zero)
+            if (appInfoPtr != nint.Zero)
             {
                 Marshal.FreeCoTaskMem(appInfoPtr);
             }
@@ -213,10 +213,10 @@ public class AmdGpuControl : IGpuControl
 
     private void ReleaseUnmanagedResources()
     {
-        if (_adlContextHandle != IntPtr.Zero)
+        if (_adlContextHandle != nint.Zero)
         {
             ADL2_Main_Control_Destroy(_adlContextHandle);
-            _adlContextHandle = IntPtr.Zero;
+            _adlContextHandle = nint.Zero;
             _isReady = false;
         }
     }

app/Gpu/GPUModeControl.cs

@@ -0,0 +1,366 @@
+using GHelper.Display;
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using GHelper.USB;
+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);
+
+            if (mux < 0) mux = Program.acpi.DeviceGet(AsusACPI.GPUMuxVivo);
+
+            Logger.WriteLine("Eco flag : " + eco);
+            Logger.WriteLine("Mux flag : " + mux);
+
+            settings.VisualiseGPUButtons(eco >= 0, mux >= 0);
+
+            if (mux == 0)
+            {
+                gpuMode = AsusACPI.GPUModeUltimate;
+            }
+            else
+            {
+                if (eco == 1)
+                    gpuMode = AsusACPI.GPUModeEco;
+                else
+                    gpuMode = AsusACPI.GPUModeStandard;
+
+                // 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);
+
+            Aura.CustomRGB.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;
+
+            int status;
+
+            if (CurrentGPU == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
+                    if (status != 1) Program.acpi.DeviceSet(AsusACPI.GPUMuxVivo, 1, "GPUMuxVivo");
+                    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);
+                    }
+                    status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
+                    if (status != 1) Program.acpi.DeviceSet(AsusACPI.GPUMuxVivo, 0, "GPUMuxVivo");
+                    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(AppConfig.Get("refresh_delay", 500)));
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                    screenControl.AutoScreen();
+                });
+
+                if (eco == 0)
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    HardwareControl.RecreateGpuControl();
+                    Program.modeControl.SetGPUClocks(false);
+                }
+
+                if (AppConfig.Is("mode_reapply"))
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    Program.modeControl.AutoPerformance();
+                }
+
+            });
+
+
+        }
+
+        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");
+                XGM.Init();
+            }
+
+        }
+
+        public void ToggleXGM()
+        {
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes();
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
+                {
+                    XGM.Reset();
+                    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();
+
+                    XGM.Light(AppConfig.Is("xmg_light"));
+
+                    await Task.Delay(TimeSpan.FromSeconds(15));
+
+                    if (AppConfig.IsMode("auto_apply"))
+                        XGM.SetFan(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/NVidia/NvidiaGpuControl.cs

@@ -1,4 +1,5 @@
-using NvAPIWrapper.GPU;
+using GHelper.Helpers;
+using NvAPIWrapper.GPU;
 using NvAPIWrapper.Native;
 using NvAPIWrapper.Native.GPU;
 using NvAPIWrapper.Native.GPU.Structures;
@@ -6,16 +7,19 @@ using NvAPIWrapper.Native.Interfaces.GPU;
 using System.Diagnostics;
 using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
 
-namespace GHelper.Gpu;
+namespace GHelper.Gpu.NVidia;
 
 public class NvidiaGpuControl : IGpuControl
 {
 
-    public const int MaxCoreOffset = 250;
-    public const int MaxMemoryOffset = 250;
+    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 static int MinCoreOffset = AppConfig.Get("min_gpu_core", -250);
+    public static int MinMemoryOffset = AppConfig.Get("min_gpu_memory", -250);
+
+    public const int MinClockLimit = 400;
+    public const int MaxClockLimit = 3000;
 
     private static PhysicalGPU? _internalGpu;
 
@@ -55,18 +59,27 @@ public class NvidiaGpuControl : IGpuControl
         try
         {
             Process[] processes = internalGpu.GetActiveApplications();
-            foreach (Process process in processes) ProcessHelper.KillByProcess(process);
+            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);
         }
 
-        //NVIDIA.RestartDisplayDriver();
+        //GeneralApi.RestartDisplayDriver();
     }
 
 
-    public int GetClocks(out int core, out int memory)
+    public bool GetClocks(out int core, out int memory)
     {
         PhysicalGPU internalGpu = _internalGpu!;
 
@@ -79,27 +92,30 @@ public class NvidiaGpuControl : IGpuControl
             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}");
-            return 0;
+
+            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 -1;
+            return false;
         }
 
     }
 
 
-    public bool RestartGPU()
+    private bool RunPowershellCommand(string script)
     {
         try
         {
-            string script = @"$device = Get-PnpDevice | Where-Object { $_.FriendlyName -imatch 'NVIDIA' -and $_.Class -eq 'Display' }; Disable-PnpDevice $device.InstanceId -Confirm:$false; Start-Sleep -Seconds 3; Enable-PnpDevice $device.InstanceId -Confirm:$false";
-            Logger.WriteLine(script);
             ProcessHelper.RunCMD("powershell", script);
-            //Thread.Sleep(2000);
             return true;
         }
         catch (Exception ex)
@@ -107,26 +123,71 @@ public class NvidiaGpuControl : IGpuControl
             Logger.WriteLine(ex.ToString());
             return false;
         }
+
     }
 
-    public int SetClocksFromConfig()
+    public int GetMaxGPUCLock()
     {
-        int core = AppConfig.Get("gpu_core",0);
-        int memory = AppConfig.Get("gpu_memory",0);
-        int status = SetClocks(core, memory);
-        return status;
+        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 = { };
@@ -146,8 +207,6 @@ public class NvidiaGpuControl : IGpuControl
             return -1;
         }
 
-
-
         return 1;
     }
 

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/HardwareControl.cs

@@ -1,13 +1,29 @@
 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;
+using GHelper.Battery;
 
 public static class HardwareControl
 {
+
     public static IGpuControl? GpuControl;
 
     public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -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;
@@ -16,38 +32,7 @@ public static class HardwareControl
 
     public static int? gpuUse;
 
-    public static int GetFanMax()
-    {
-        int max = 58;
-        int configMax = AppConfig.Get("fan_max");
-        if (configMax > 100) configMax = 0; // skipping inadvequate settings
-
-        if (AppConfig.ContainsModel("401")) max = 72;
-        else if (AppConfig.ContainsModel("503")) max = 68;
-        return Math.Max(max, configMax);
-    }
-
-    public static void SetFanMax(int fan)
-    {
-        AppConfig.Set("fan_max", fan);
-    }
-    public 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 && fan < 110) SetFanMax(fan);
-
-        if (AppConfig.Is("fan_rpm"))
-            return GHelper.Properties.Strings.FanSpeed + (fan * 100).ToString() + "RPM";
-        else
-            return GHelper.Properties.Strings.FanSpeed + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
-    }
+    static long lastUpdate;
 
     private static int GetGpuUse()
     {
@@ -66,15 +51,115 @@ public static class HardwareControl
     }
 
 
-    public static void ReadSensors()
+    public static void GetBatteryStatus()
     {
-        batteryDischarge = -1;
-        gpuTemp = -1;
-        gpuUse = -1;
 
-        cpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.CPU_Fan));
-        gpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.GPU_Fan));
-        midFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.Mid_Fan));
+        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)
+        {
+            Debug.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)
+        {
+            Debug.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)
+        {
+            Debug.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);
 
@@ -90,6 +175,23 @@ public static class HardwareControl
                 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();
@@ -104,17 +206,16 @@ public static class HardwareControl
         if (gpuTemp is null || gpuTemp < 0)
             gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
 
-        try
+        ReadFullChargeCapacity();
+        GetBatteryStatus();
+
+        if (fullCapacity > 0 && chargeCapacity > 0)
         {
-            using (var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true))
-            {
-                batteryDischarge = cb.NextValue() / 1000;
-            }
-        }
-        catch
-        {
-            Debug.WriteLine("Failed reading Battery discharge");
+            batteryCapacity = Math.Min(100, ((decimal)chargeCapacity / (decimal)fullCapacity) * 100);
+            if (batteryCapacity > 99) BatteryControl.UnSetBatteryLimitFull();
         }
+
+
     }
 
     public static bool IsUsedGPU(int threshold = 10)
@@ -168,18 +269,20 @@ public static class HardwareControl
             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(ex.ToString());
+            Debug.WriteLine("Can't connect to GPU " + ex.ToString());
         }
     }
 
@@ -188,14 +291,6 @@ public static class HardwareControl
     {
 
         List<string> tokill = new() { "EADesktop", "RadeonSoftware", "epicgameslauncher", "ASUSSmartDisplayControl" };
-
-        if (AppConfig.Is("kill_gpu_apps"))
-        {
-            tokill.Add("nvdisplay.container");
-            tokill.Add("nvcontainer");
-            tokill.Add("nvcplui");
-        }
-
         foreach (string kill in tokill) ProcessHelper.KillByName(kill);
 
         if (AppConfig.Is("kill_gpu_apps") && GpuControl is not null)

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,142 @@
+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();
+
+            if (Program.settingsForm.Visible)
+                Program.screenControl.InitScreen();
+
+        }
+
+        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,193 @@
+using System.Runtime.CompilerServices;
+
+namespace GHelper.Helpers
+{
+    public class ColorUtils
+    {
+        // 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);
+        }
+
+        public static Color GetMidColor(Color color1, Color color2)
+        {
+            return Color.FromArgb((color1.R + color2.R) / 2,
+                (color1.G + color2.G) / 2,
+                (color1.B + color2.B) / 2);
+        }
+
+        public static Color GetDominantColor(Bitmap bmp)
+        {
+
+            //Used for tally
+            int r = 0;
+            int g = 0;
+            int b = 0;
+
+            int total = 0;
+
+            for (int x = 0; x < bmp.Width; x++)
+            {
+                for (int y = 0; y < bmp.Height; y++)
+                {
+                    Color clr = bmp.GetPixel(x, y);
+
+                    r += clr.R;
+                    g += clr.G;
+                    b += clr.B;
+
+                    total++;
+                }
+            }
+
+            //Calculate average
+            r /= total;
+            g /= total;
+            b /= total;
+
+            return Color.FromArgb(r, g, b);
+        }
+
+        public class HSV
+        {
+            public double Hue { get; set; }
+            public double Saturation { get; set; }
+            public double Value { get; set; }
+
+            public Color ToRGB()
+            {
+                var hue = Hue * 6;
+                var saturation = Saturation;
+                var value = Value;
+
+                double red;
+                double green;
+                double blue;
+
+                if (saturation == 0)
+                {
+                    red = green = blue = value;
+                }
+                else
+                {
+                    var i = Convert.ToInt32(Math.Floor(hue));
+                    var f = hue - i;
+                    var p = value * (1 - saturation);
+                    var q = value * (1 - saturation * f);
+                    var t = value * (1 - saturation * (1 - f));
+                    int mod = i % 6;
+
+                    red = new[] { value, q, p, p, t, value }[mod];
+                    green = new[] { t, value, value, q, p, p }[mod];
+                    blue = new[] { p, p, t, value, value, q }[mod];
+                }
+
+                return Color.FromArgb(Convert.ToInt32(red * 255), Convert.ToInt32(green * 255), Convert.ToInt32(blue * 255));
+            }
+
+            public static HSV ToHSV(Color rgb)
+            {
+                double red = rgb.R / 255.0;
+                double green = rgb.G / 255.0;
+                double blue = rgb.B / 255.0;
+                var min = Math.Min(red, Math.Min(green, blue));
+                var max = Math.Max(red, Math.Max(green, blue));
+                var delta = max - min;
+                double hue;
+                double saturation = 0;
+                var value = max;
+
+                if (max != 0)
+                    saturation = delta / max;
+
+                if (delta == 0)
+                    hue = 0;
+                else
+                {
+                    if (red == max)
+                        hue = (green - blue) / delta + (green < blue ? 6 : 0);
+                    else if (green == max)
+                        hue = 2 + (blue - red) / delta;
+                    else
+                        hue = 4 + (red - green) / delta;
+
+                    hue /= 6;
+                }
+
+                return new HSV { Hue = hue, Saturation = saturation, Value = value };
+            }
+
+            public static Color UpSaturation(Color rgb, float increse = 0.2f) //make color more colored
+            {
+                if (rgb.R == rgb.G && rgb.G == rgb.B)
+                    return rgb;
+                var hsv_color = ToHSV(rgb);
+                hsv_color.Saturation = Math.Min(hsv_color.Saturation + increse, 1.00f);
+                return hsv_color.ToRGB();
+            }
+
+        }
+
+        public class SmoothColor
+        {
+            public Color RGB
+            {
+                get { return Interpolate(); }
+                set { clr = value; }
+            }
+
+            Color Interpolate()
+            {
+                clr_ = ColorInterpolator.InterpolateBetween(clr, clr_, smooth);
+                return clr_;
+            }
+
+            private float smooth = 0.65f; //smooth
+            private Color clr = new Color();
+            private Color clr_ = new Color();
+
+            static class ColorInterpolator
+            {
+                delegate byte ComponentSelector(Color color);
+                static ComponentSelector _redSelector = color => color.R;
+                static ComponentSelector _greenSelector = color => color.G;
+                static ComponentSelector _blueSelector = color => color.B;
+
+                public static Color InterpolateBetween(Color endPoint1, Color endPoint2, double lambda)
+                {
+                    if (lambda < 0 || lambda > 1)
+                        throw new ArgumentOutOfRangeException("lambda");
+
+                    if (endPoint1 != endPoint2)
+                    {
+                        return Color.FromArgb(
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _redSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _greenSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _blueSelector)
+                        );
+                    }
+
+                    return endPoint1;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static byte InterpolateComponent(Color end1, Color end2, double lambda, ComponentSelector selector)
+                {
+                    return (byte)(selector(end1) + (selector(end2) - selector(end1)) * lambda);
+                }
+            }
+
+        }
+    }
+
+}

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)
     {

app/Helpers/OSDBase.cs

@@ -1,7 +1,7 @@
 using System.Drawing.Imaging;
 using System.Runtime.InteropServices;
 
-namespace OSD
+namespace GHelper.Helpers
 {
 
     public class OSDNativeForm : NativeWindow, IDisposable
@@ -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

@@ -3,12 +3,14 @@ using System.Diagnostics;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace GHelper
+namespace GHelper.Helpers
 {
     public static class OptimizationService
     {
 
         static List<string> services = new() {
+                "ArmouryCrateControlInterface",
+                "ASUSOptimization",
                 "AsusAppService",
                 "ASUSLinkNear",
                 "ASUSLinkRemote",
@@ -16,9 +18,7 @@ namespace GHelper
                 "ASUSSwitch",
                 "ASUSSystemAnalysis",
                 "ASUSSystemDiagnosis",
-                "ArmouryCrateControlInterface",
-                "AsusCertService",
-                "ASUSOptimization"
+                "AsusCertService"
         };
 
         public static void SetChargeLimit(int newValue)
@@ -52,9 +52,15 @@ namespace GHelper
 
         public static bool IsRunning()
         {
-            return (Process.GetProcessesByName("AsusOptimization").Count() > 0);
+            return Process.GetProcessesByName("AsusOptimization").Count() > 0;
         }
 
+        public static bool IsOSDRunning()
+        {
+            return Process.GetProcessesByName("AsusOSD").Count() > 0;
+        }
+
+
         public static int GetRunningCount()
         {
             int count = 0;
@@ -66,7 +72,7 @@ namespace GHelper
         }
 
 
-            public static void SetBacklightOffDelay(int value = 60)
+        public static void SetBacklightOffDelay(int value = 60)
         {
             try
             {

app/Helpers/ProcessHelper.cs

@@ -1,12 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
+using System.Diagnostics;
 using System.Security.Principal;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace GHelper
+namespace GHelper.Helpers
 {
     public static class ProcessHelper
     {
@@ -61,7 +56,8 @@ namespace GHelper
                 {
                     Process.Start(startInfo);
                     Application.Exit();
-                } catch (Exception ex)
+                }
+                catch (Exception ex)
                 {
                     Logger.WriteLine(ex.Message);
                 }
@@ -102,7 +98,7 @@ namespace GHelper
         {
             try
             {
-                string script = $"Set-Service -Name \"{serviceName}\" -Status stopped -StartupType disabled";
+                string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType Disabled";
                 Logger.WriteLine(script);
                 RunCMD("powershell", script);
             }
@@ -136,7 +132,13 @@ namespace GHelper
             cmd.StartInfo.FileName = name;
             cmd.StartInfo.Arguments = args;
             cmd.Start();
-            Logger.WriteLine(cmd.StandardOutput.ReadToEnd());
+
+            Logger.WriteLine(args);
+
+            string result = cmd.StandardOutput.ReadToEnd().Replace(Environment.NewLine, " ").Trim(' ');
+
+            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;
@@ -10,8 +10,8 @@ public class Startup
 
     public static bool IsScheduled()
     {
-        TaskService taskService = new TaskService();
-        return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
+        using (TaskService taskService = new TaskService())
+            return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
     }
 
     public static void ReScheduleAdmin()
@@ -23,6 +23,26 @@ public class Startup
         }
     }
 
+    public static void StartupCheck()
+    {
+        using (TaskService taskService = new TaskService())
+        {
+            var task = taskService.RootFolder.AllTasks.FirstOrDefault(t => t.Name == taskName);
+            if (task != null)
+            {
+                string strExeFilePath = Application.ExecutablePath.Trim();
+                string action = task.Definition.Actions.FirstOrDefault()!.ToString().Trim();
+                if (!strExeFilePath.Equals(action, StringComparison.OrdinalIgnoreCase) && !File.Exists(action))
+                {
+                    Logger.WriteLine("File doesn't exist: " + action);
+                    Logger.WriteLine("Rescheduling to: " + strExeFilePath);
+                    UnSchedule();
+                    Schedule();
+                }
+            }
+        }
+    }
+
     public static void Schedule()
     {
 
@@ -34,8 +54,9 @@ 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 (ProcessHelper.IsUserAdministrator()) 

app/Helpers/ToastForm.cs

@@ -1,9 +1,6 @@
-using OSD;
-using System.Diagnostics;
-using System.Drawing.Drawing2D;
+using System.Drawing.Drawing2D;
 
-
-namespace GHelper
+namespace GHelper.Helpers
 {
 
     static class Drawing
@@ -74,7 +71,7 @@ namespace GHelper
         protected override void PerformPaint(PaintEventArgs e)
         {
             Brush brush = new SolidBrush(Color.FromArgb(150, Color.Black));
-            Drawing.FillRoundedRectangle(e.Graphics, brush, this.Bound, 10);
+            e.Graphics.FillRoundedRectangle(brush, Bound, 10);
 
             StringFormat format = new StringFormat();
             format.LineAlignment = StringAlignment.Center;
@@ -128,34 +125,40 @@ namespace GHelper
             e.Graphics.DrawString(toastText,
                 new Font("Segoe UI", 36f, FontStyle.Bold, GraphicsUnit.Pixel),
                 new SolidBrush(Color.White),
-                new PointF(this.Bound.Width / 2 + shiftX, this.Bound.Height / 2),
+                new PointF(Bound.Width / 2 + shiftX, Bound.Height / 2),
             format);
 
         }
 
         public void RunToast(string text, ToastIcon? icon = null)
         {
-            //Hide();
-            timer.Stop();
 
-            toastText = text;
-            toastIcon = icon;
+            if (AppConfig.Is("disable_osd")) return;
 
-            Screen screen1 = Screen.FromHandle(base.Handle);
+            Program.settingsForm.Invoke(delegate
+            {
+                //Hide();
+                timer.Stop();
 
-            Width = Math.Max(300, 100 + toastText.Length * 22);
-            Height = 100;
-            X = (screen1.Bounds.Width - this.Width) / 2;
-            Y = screen1.Bounds.Height - 300 - this.Height;
+                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();
+            });
 
-            Show();
-            timer.Start();
         }
 
         private void timer_Tick(object? sender, EventArgs e)
         {
-            Debug.WriteLine("Toast end");
-
+            //Debug.WriteLine("Toast end");
             Hide();
             timer.Stop();
         }

app/Input/InputDispatcher.cs

@@ -0,0 +1,807 @@
+using GHelper.Display;
+using GHelper.Helpers;
+using GHelper.Mode;
+using GHelper.USB;
+using Microsoft.Win32;
+using System.Diagnostics;
+using System.Management;
+using System.Text.RegularExpressions;
+
+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;
+                Aura.ApplyBrightness(0, "Timeout");
+            }
+
+            if (!backlightActivity && iddle.TotalSeconds < kb_timeout)
+            {
+                backlightActivity = true;
+                SetBacklightAuto();
+            }
+
+            //Logger.WriteLine("Iddle: " + 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();
+
+            if (AppConfig.ContainsModel("VivoBook")) Program.acpi.DeviceSet(AsusACPI.FnLock, AppConfig.Is("fn_lock") ? 1 : 0, "FnLock");
+
+        }
+
+        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);
+
+            hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control | ModifierKeys.Alt, Keys.F14);
+            hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control | ModifierKeys.Alt, Keys.F15);
+
+            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);
+            }
+
+        }
+
+
+        public static int[] ParseHexValues(string input)
+        {
+            string pattern = @"\b(0x[0-9A-Fa-f]{1,2}|[0-9A-Fa-f]{1,2})\b";
+
+            if (!Regex.IsMatch(input, $"^{pattern}(\\s+{pattern})*$")) return new int[0];
+
+            MatchCollection matches = Regex.Matches(input, pattern);
+
+            int[] hexValues = new int[matches.Count];
+
+            for (int i = 0; i < matches.Count; i++)
+            {
+                string hexValueStr = matches[i].Value;
+                int hexValue = int.Parse(hexValueStr.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
+                    ? hexValueStr.Substring(2)
+                    : hexValueStr, System.Globalization.NumberStyles.HexNumber);
+
+                hexValues[i] = hexValue;
+            }
+
+            return hexValues;
+        }
+
+
+        static void CustomKey(string configKey = "m3")
+        {
+            string command = AppConfig.GetString(configKey + "_custom");
+            int[] hexKeys = new int[0];
+
+            try
+            {
+                hexKeys = ParseHexValues(command);
+            }
+            catch
+            {
+            }
+
+            switch (hexKeys.Length)
+            {
+                case 1:
+                    KeyboardHook.KeyPress((Keys)hexKeys[0]);
+                    break;
+                case 2:
+                    KeyboardHook.KeyKeyPress((Keys)hexKeys[0], (Keys)hexKeys[1]);
+                    break;
+                case 3:
+                    KeyboardHook.KeyKeyKeyPress((Keys)hexKeys[0], (Keys)hexKeys[1], (Keys)hexKeys[2]);
+                    break;
+                default:
+                    LaunchProcess(command);
+                    break;
+            }
+
+        }
+
+
+        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.KeyKeyPress(Keys.LWin, Keys.P);
+                        break;
+                    case Keys.F10:
+                        ToggleTouchpadEvent(true);
+                        break;
+                    case Keys.F11:
+                        SleepEvent();
+                        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);
+
+                switch (e.Key)
+                {
+                    case Keys.F14:
+                        Program.settingsForm.gpuControl.SetGPUMode(AsusACPI.GPUModeEco);
+                        break;
+                    case Keys.F15:
+                        Program.settingsForm.gpuControl.SetGPUMode(AsusACPI.GPUModeStandard);
+                        break;
+                }
+            }
+
+
+            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":
+                    try
+                    {
+                        Program.settingsForm.BeginInvoke(delegate
+                        {
+                            Program.SettingsToggle();
+                        });
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.WriteLine(ex);
+                    }
+                    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";
+            }
+        }
+
+        static void ToggleTouchpadEvent(bool hotkey = false)
+        {
+            if (hotkey || !AppConfig.IsHardwareTouchpadToggle()) ToggleTouchpad();
+            Thread.Sleep(200);
+            Program.toast.RunToast(GetTouchpadState() ? "On" : "Off", ToastIcon.Touchpad);
+        }
+
+        static void ToggleTouchpad()
+        {
+            KeyboardHook.KeyKeyKeyPress(Keys.LWin, Keys.LControlKey, Keys.F24, 50);
+        }
+
+        static void SleepEvent()
+        {
+            Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
+        }
+
+        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 ? 1 : 0, "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) ToggleTouchpad();
+
+        }
+
+        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 136:    // FN + F12
+                        Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Airplane, "Airplane");
+                        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 51:    // Fn+F6 on old TUFs
+                    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
+                    if (Control.ModifierKeys == Keys.Shift)
+                    {
+                        if (AppConfig.IsDUO()) SetScreenpad(-10);
+                        else Program.settingsForm.BeginInvoke(Program.settingsForm.CycleMatrix, -1);
+                    }
+                    else
+                        Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
+                    break;
+                case 32: // FN+F8
+                    if (Control.ModifierKeys == Keys.Shift)
+                    {
+                        if (AppConfig.IsDUO()) SetScreenpad(10);
+                        else Program.settingsForm.BeginInvoke(Program.settingsForm.CycleMatrix, 1);
+                    }
+                    else
+                        Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
+                    break;
+                case 107: // FN+F10
+                    ToggleTouchpadEvent();
+                    break;
+                case 108: // FN+F11
+                    SleepEvent();
+                    break;
+                case 106: // Screenpad button on DUO
+                    if (Control.ModifierKeys == Keys.Shift)
+                        ToggleScreenpad();
+                    else
+                        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) Aura.Init();
+            Aura.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())
+            {
+                Aura.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 ToggleScreenpad()
+        {
+            int toggle = AppConfig.Is("screenpad_toggle") ? 0 : 1;
+
+            Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, toggle, "ScreenpadToggle");
+            AppConfig.Set("screenpad_toggle", toggle);
+            Program.toast.RunToast($"Screen Pad " + (toggle == 1 ? "On" : "Off"), toggle > 0 ? ToastIcon.BrightnessUp : ToastIcon.BrightnessDown);
+        }
+
+
+        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

@@ -17,21 +17,38 @@ public sealed class KeyboardHook : IDisposable
 
     public const int KEYEVENTF_EXTENDEDKEY = 1;
     public const int KEYEVENTF_KEYUP = 2;
+
     private const byte VK_LWIN = 0x5B;
+    private const byte VK_LCONTROL = 0xA2;
 
     public static void KeyPress(Keys key)
     {
         keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
     }
 
-    public static void KeyWinPress(Keys key)
+    public static void KeyKeyPress(Keys key, Keys key2)
     {
-        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
         keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
         keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
-        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
     }
 
+    public static void KeyKeyKeyPress(Keys key, Keys key2, Keys key3, int sleep = 0)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+
+        if (sleep > 0)
+        {
+            Thread.Sleep(sleep);
+        }
+
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
 
     /// <summary>
     /// Represents the window that is used internally to get the messages.

app/Input/KeyboardListener.cs

@@ -0,0 +1,72 @@
+using HidSharp;
+using GHelper.USB;
+
+namespace GHelper.Input
+{
+    public class KeyboardListener
+    {
+
+        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+
+        public KeyboardListener(Action<int> KeyHandler)
+        {
+            HidStream? input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
+            
+            // Fallback
+            if (input == null)
+            {
+                Aura.Init();
+                Thread.Sleep(1000);
+                input = input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
+            }
+
+            if (input == null)
+            {
+                Logger.WriteLine($"Input device not found");
+                return;
+            }
+
+            Logger.WriteLine($"Input: {input.Device.DevicePath}");
+
+            var task = Task.Run(() =>
+            {
+                try
+                {
+                    while (!cancellationTokenSource.Token.IsCancellationRequested)
+                    {
+
+                        // Emergency break
+                        if (input == null || !input.CanRead)
+                        {
+                            Logger.WriteLine("Listener terminated");
+                            break;
+                        }
+
+                        input.ReadTimeout = int.MaxValue;
+
+                        var data = input.Read();
+                        if (data.Length > 1 && data[0] == AsusHid.INPUT_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/InputDispatcher.cs

@@ -1,539 +0,0 @@
-using HidLibrary;
-using Microsoft.Win32;
-using NAudio.CoreAudioApi;
-using System.Diagnostics;
-using System.Management;
-
-namespace GHelper
-{
-    public class KeyboardListener
-    {
-
-        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-
-        public KeyboardListener(Action<int> KeyHandler)
-        {
-            HidDevice? input = AsusUSB.GetDevice();
-            if (input == null) return;
-
-            Logger.WriteLine($"Input: {input.DevicePath}");
-
-            var task = Task.Run(() =>
-            {
-                try
-                {
-                    while (!cancellationTokenSource.Token.IsCancellationRequested)
-                    {
-                        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();
-        }
-    }
-
-
-    public class InputDispatcher
-    {
-        System.Timers.Timer timer = new System.Timers.Timer(1000);
-        public bool backlightActivity = true;
-
-        public static Keys keyProfile = Keys.F5;
-        public static Keys keyApp = Keys.F12;
-
-        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);
-            if (keyApp != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyApp);
-
-            if (!AppConfig.ContainsModel("Z13"))
-                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);
-
-        }
-
-        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);
-
-        }
-
-        public void KeyPressed(object sender, KeyPressedEventArgs e)
-        {
-
-            if (e.Modifier == ModifierKeys.None)
-            {
-                Logger.WriteLine(e.Key.ToString());
-
-                if (AppConfig.ContainsModel("Z13"))
-                {
-                    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;
-                        case Keys.F11:
-                            HandleEvent(199);
-                            return;
-                    }
-                }
-
-                if (AppConfig.ContainsModel("GA401I") && !AppConfig.ContainsModel("GA401IHR"))
-                {
-                    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:
-                        HandleEvent(197);
-                        break;
-                    case Keys.F3:
-                        HandleEvent(196);
-                        break;
-                    case Keys.F4:
-                        KeyProcess("fnf4");
-                        break;
-                    case Keys.F5:
-                        KeyProcess("fnf5");
-                        break;
-                    case Keys.F6:
-                        KeyboardHook.KeyPress(Keys.Snapshot);
-                        break;
-                    case Keys.F7:
-                        if (AppConfig.ContainsModel("TUF"))
-                            Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, ScreenBrightness.Adjust(-10) + "%", ToastIcon.BrightnessDown);
-                        HandleOptimizationEvent(16);
-                        break;
-                    case Keys.F8:
-                        if (AppConfig.ContainsModel("TUF")) 
-                            Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, ScreenBrightness.Adjust(+10) + "%", ToastIcon.BrightnessUp);
-                        HandleOptimizationEvent(32);
-                        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;
-                    default:
-                        break;
-                }
-            }
-
-            if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift))
-            {
-                if (e.Key == keyProfile) Program.settingsForm.CyclePerformanceMode();
-                if (e.Key == keyApp) Program.SettingsToggle();
-            }
-
-
-        }
-
-
-        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";
-            }
-
-            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(Program.settingsForm.Handle);
-                    break;
-                case "miniled":
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.ToogleMiniled);
-                    break;
-                case "aura":
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.CycleAuraMode);
-                    break;
-                case "performance":
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.CyclePerformanceMode);
-                    break;
-                case "ghelper":
-                    Program.settingsForm.BeginInvoke(delegate
-                    {
-                        Program.SettingsToggle();
-                    });
-                    break;
-                case "fnlock":
-                    ToggleFnLock();
-                    break;
-                case "micmute":
-                    using (var enumerator = new MMDeviceEnumerator())
-                    {
-                        var commDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
-                        bool muteStatus = !commDevice.AudioEndpointVolume.Mute;
-                        commDevice.AudioEndpointVolume.Mute = muteStatus;
-                        Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
-                    }
-                    break;
-                case "brightness_up":
-                    HandleOptimizationEvent(32);
-                    break;
-                case "brightness_down":
-                    HandleOptimizationEvent(16);
-                    break;
-                case "custom":
-                    CustomKey(name);
-                    break;
-
-                default:
-                    break;
-            }
-        }
-
-        static bool GetTouchpadState()
-        {
-            using (var key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\PrecisionTouchPad\Status", false))
-            {
-                return (key?.GetValue("Enabled")?.ToString() == "1");
-            }
-        }
-
-        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.RunToast, "Fn-Lock "+(fnLock==1?"On":"Off"), ToastIcon.FnLock);
-        }
-
-        public static void TabletMode()
-        {
-            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)
-        {
-            switch (EventID)
-            {
-                case 124:    // M3
-                    KeyProcess("m3");
-                    return;
-                case 56:    // M4 / Rog button
-                    KeyProcess("m4");
-                    return;
-                case 174:   // FN+F5
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.CyclePerformanceMode);
-                    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 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(Program.settingsForm.Handle);
-                    return;
-            }
-
-            if (!OptimizationService.IsRunning()) 
-                
-                HandleOptimizationEvent(EventID);
-
-            // Asus Optimization service Events 
-
-
-        }
-
-        static void HandleOptimizationEvent(int EventID)
-        {
-            switch (EventID)
-            {
-                case 16: // FN+F7
-                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
-                    break;
-                case 32: // FN+F8
-                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
-                    break;
-                case 107: // FN+F10
-                    bool touchpadState = GetTouchpadState();
-                    AsusUSB.TouchpadToggle();
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, touchpadState ? "Off" : "On", ToastIcon.Touchpad);
-                    break;
-                case 108: // FN+F11
-                    Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
-                    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();
-
-            //if (!OptimizationService.IsRunning()) 
-            AsusUSB.ApplyBrightness(GetBacklight(), "Auto");
-        }
-
-        public static void SetBacklight(int delta)
-        {
-            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 (!OptimizationService.IsRunning())
-            {
-                AsusUSB.ApplyBrightness(backlight, "HotKey");
-                string[] backlightNames = new string[] { "Off", "Low", "Mid", "Max" };
-                Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, backlightNames[backlight], delta > 0 ? ToastIcon.BacklightUp : ToastIcon.BacklightDown);
-            }
-
-        }
-
-        static void LaunchProcess(string command = "")
-        {
-
-            try
-            {
-                string executable = command.Split(' ')[0];
-                string arguments = command.Substring(executable.Length).Trim();
-                Process proc = Process.Start(executable, arguments);
-            }
-            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/Matrix.Designer.cs

@@ -0,0 +1,365 @@
+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();
+            panelContrast = new Panel();
+            labelContrast = new Label();
+            labelContrastTitle = new Label();
+            trackContrast = new TrackBar();
+            panelRotation = new Panel();
+            comboRotation = new UI.RComboBox();
+            labelRotation = new Label();
+            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();
+            panelContrast.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackContrast).BeginInit();
+            panelRotation.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.AutoSize = true;
+            panelMain.Controls.Add(panelButtons);
+            panelMain.Controls.Add(panelContrast);
+            panelMain.Controls.Add(panelRotation);
+            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, 959);
+            panelMain.TabIndex = 5;
+            // 
+            // panelButtons
+            // 
+            panelButtons.Controls.Add(buttonReset);
+            panelButtons.Controls.Add(buttonPicture);
+            panelButtons.Dock = DockStyle.Top;
+            panelButtons.Location = new Point(0, 865);
+            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;
+            // 
+            // panelContrast
+            // 
+            panelContrast.AutoSize = true;
+            panelContrast.Controls.Add(labelContrast);
+            panelContrast.Controls.Add(labelContrastTitle);
+            panelContrast.Controls.Add(trackContrast);
+            panelContrast.Dock = DockStyle.Top;
+            panelContrast.Location = new Point(0, 720);
+            panelContrast.Name = "panelContrast";
+            panelContrast.Size = new Size(834, 145);
+            panelContrast.TabIndex = 6;
+            // 
+            // labelContrast
+            // 
+            labelContrast.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelContrast.AutoSize = true;
+            labelContrast.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            labelContrast.Location = new Point(705, 17);
+            labelContrast.Name = "labelContrast";
+            labelContrast.Size = new Size(103, 32);
+            labelContrast.TabIndex = 4;
+            labelContrast.Text = "Contrast";
+            // 
+            // labelContrastTitle
+            // 
+            labelContrastTitle.AutoSize = true;
+            labelContrastTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelContrastTitle.Location = new Point(16, 17);
+            labelContrastTitle.Name = "labelContrastTitle";
+            labelContrastTitle.Size = new Size(111, 32);
+            labelContrastTitle.TabIndex = 3;
+            labelContrastTitle.Text = "Contrast";
+            // 
+            // trackContrast
+            // 
+            trackContrast.LargeChange = 50;
+            trackContrast.Location = new Point(16, 52);
+            trackContrast.Maximum = 200;
+            trackContrast.Minimum = 10;
+            trackContrast.Name = "trackContrast";
+            trackContrast.Size = new Size(782, 90);
+            trackContrast.SmallChange = 10;
+            trackContrast.TabIndex = 2;
+            trackContrast.TickFrequency = 20;
+            trackContrast.TickStyle = TickStyle.TopLeft;
+            trackContrast.Value = 100;
+            // 
+            // panelRotation
+            // 
+            panelRotation.Controls.Add(comboRotation);
+            panelRotation.Controls.Add(labelRotation);
+            panelRotation.Dock = DockStyle.Top;
+            panelRotation.Location = new Point(0, 642);
+            panelRotation.Name = "panelRotation";
+            panelRotation.Size = new Size(834, 78);
+            panelRotation.TabIndex = 8;
+            // 
+            // comboRotation
+            // 
+            comboRotation.BorderColor = Color.White;
+            comboRotation.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboRotation.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            comboRotation.FormattingEnabled = true;
+            comboRotation.ItemHeight = 32;
+            comboRotation.Items.AddRange(new object[] { "Straight", "Diagonal" });
+            comboRotation.Location = new Point(229, 17);
+            comboRotation.Margin = new Padding(4, 11, 4, 8);
+            comboRotation.Name = "comboRotation";
+            comboRotation.Size = new Size(322, 40);
+            comboRotation.TabIndex = 17;
+            // 
+            // labelRotation
+            // 
+            labelRotation.AutoSize = true;
+            labelRotation.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelRotation.Location = new Point(16, 20);
+            labelRotation.Name = "labelRotation";
+            labelRotation.Size = new Size(190, 32);
+            labelRotation.TabIndex = 4;
+            labelRotation.Text = "Image Rotation";
+            // 
+            // 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, 1006);
+            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);
+            panelContrast.ResumeLayout(false);
+            panelContrast.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackContrast).EndInit();
+            panelRotation.ResumeLayout(false);
+            panelRotation.PerformLayout();
+            panelScaling.ResumeLayout(false);
+            panelScaling.PerformLayout();
+            panelZoom.ResumeLayout(false);
+            panelZoom.PerformLayout();
+            ResumeLayout(false);
+            PerformLayout();
+        }
+
+        #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;
+        private Panel panelRotation;
+        private UI.RComboBox comboRotation;
+        private Label labelRotation;
+        private Panel panelContrast;
+        private Label labelContrast;
+        private Label labelContrastTitle;
+        private TrackBar trackContrast;
+    }
+}

app/Matrix.cs

@@ -0,0 +1,239 @@
+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));
+
+            trackContrast.MouseUp += TrackContrast_MouseUp; ;
+            trackContrast.ValueChanged += TrackContrast_ValueChanged; ;
+            trackContrast.Value = Math.Min(trackContrast.Maximum, AppConfig.Get("matrix_contrast", 100));
+
+            VisualiseMatrix();
+
+            comboScaling.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboScaling.SelectedIndex = AppConfig.Get("matrix_quality", 0);
+            comboScaling.SelectedValueChanged += ComboScaling_SelectedValueChanged;
+
+            comboRotation.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboRotation.SelectedIndex = AppConfig.Get("matrix_rotation", 0);
+            comboRotation.SelectedValueChanged += ComboRotation_SelectedValueChanged; ;
+
+
+            uiScale = panelPicture.Width / matrixControl.device.MaxColumns / 3;
+            panelPicture.Height = (int)(matrixControl.device.MaxRows * uiScale);
+
+        }
+
+        private void TrackContrast_ValueChanged(object? sender, EventArgs e)
+        {
+            VisualiseMatrix();
+        }
+
+        private void TrackContrast_MouseUp(object? sender, MouseEventArgs e)
+        {
+            AppConfig.Set("matrix_contrast", trackContrast.Value);
+            SetMatrixPicture();
+        }
+
+        private void ComboRotation_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_rotation", comboRotation.SelectedIndex);
+            SetMatrixPicture(false);
+        }
+
+        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 VisualiseMatrix()
+        {
+            labelZoom.Text = trackZoom.Value + "%";
+            labelContrast.Text = trackContrast.Value + "%";
+        }
+
+        private void ButtonReset_Click(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_contrast", 100);
+            AppConfig.Set("matrix_zoom", 100);
+            AppConfig.Set("matrix_x", 0);
+            AppConfig.Set("matrix_y", 0);
+
+            trackZoom.Value = 100;
+            trackContrast.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)
+        {
+            VisualiseMatrix();
+        }
+
+
+        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,442 @@
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using GHelper.USB;
+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()) XGM.Reset();
+
+            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())
+                {
+                    XGM.SetFan(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)
+        {
+
+            bool allAMD = Program.acpi.IsAllAmdPPT();
+
+            int limit_total = AppConfig.GetMode("limit_total");
+            int limit_cpu = AppConfig.GetMode("limit_cpu");
+            int limit_slow = AppConfig.GetMode("limit_slow");
+            int limit_fast = AppConfig.GetMode("limit_fast");
+
+            if (limit_slow < 0 || allAMD) limit_slow = limit_total;
+
+            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;
+
+            if (limit_slow > AsusACPI.MaxTotal) return;
+            if (limit_slow < AsusACPI.MinTotal) return;
+
+            // SPL and SPPT 
+            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_slow, "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 && clock_limit == -1) return;
+
+                //if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) { Logger.WriteLine("Clocks: Eco"); return; }
+                if (HardwareControl.GpuControl is null) { Logger.WriteLine("Clocks: NoGPUControl"); return; }
+                if (!HardwareControl.GpuControl!.IsNvidia) { Logger.WriteLine("Clocks: NotNvidia"); 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("Clocks Error:" + 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

@@ -1,6 +1,4 @@
-using Microsoft.VisualBasic.Devices;
-
-namespace GHelper
+namespace GHelper.Mode
 {
     internal class Modes
     {
@@ -41,9 +39,9 @@ namespace GHelper
                 "mode_base",
                 "mode_name",
                 "limit_total",
+                "limit_slow",
                 "limit_fast",
                 "limit_cpu",
-                "limit_total",
                 "fan_profile_cpu",
                 "fan_profile_gpu",
                 "fan_profile_mid",
@@ -53,7 +51,8 @@ namespace GHelper
                 "gpu_memory",
                 "auto_boost",
                 "auto_apply",
-                "auto_apply_power"
+                "auto_apply_power",
+                "powermode"
             };
 
             foreach (string clean in cleanup)

app/Mode/PowerNative.cs

@@ -0,0 +1,342 @@
+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 (GetBatterySaverStatus())
+            {
+                Logger.WriteLine("Battery Saver detected");
+                return;
+            }
+
+            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));
+        }
+
+        [DllImport("Kernel32")]
+        private static extern bool GetSystemPowerStatus(SystemPowerStatus sps);
+        public enum ACLineStatus : byte
+        {
+            Offline = 0, Online = 1, Unknown = 255
+        }
+
+        public enum BatteryFlag : byte
+        {
+            High = 1,
+            Low = 2,
+            Critical = 4,
+            Charging = 8,
+            NoSystemBattery = 128,
+            Unknown = 255
+        }
+
+        // Fields must mirror their unmanaged counterparts, in order
+        [StructLayout(LayoutKind.Sequential)]
+        public class SystemPowerStatus
+        {
+            public ACLineStatus ACLineStatus;
+            public BatteryFlag BatteryFlag;
+            public Byte BatteryLifePercent;
+            public Byte SystemStatusFlag;
+            public Int32 BatteryLifeTime;
+            public Int32 BatteryFullLifeTime;
+        }
+
+        public static bool GetBatterySaverStatus()
+        {
+            SystemPowerStatus sps = new SystemPowerStatus();
+            try
+            {
+                GetSystemPowerStatus(sps);
+                return (sps.SystemStatusFlag > 0);
+            } catch (Exception ex)
+            {
+                return false;
+            }
+
+        }
+
+    }
+}

app/NativeMethods.cs

@@ -1,310 +1,5 @@
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using static Tools.ScreenInterrogatory;
+using System.Runtime.InteropServices;
 
-namespace Tools
-{
-
-
-    public static class ScreenInterrogatory
-    {
-        public const int ERROR_SUCCESS = 0;
-
-        #region enums
-
-        public enum QUERY_DEVICE_CONFIG_FLAGS : uint
-        {
-            QDC_ALL_PATHS = 0x00000001,
-            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
-            QDC_DATABASE_CURRENT = 0x00000004
-        }
-
-        public enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY : uint
-        {
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = 0xFFFFFFFF,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
-            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_SCANLINE_ORDERING : uint
-        {
-            DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
-            DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST = DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
-            DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
-            DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_ROTATION : uint
-        {
-            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
-            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
-            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
-            DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
-            DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_SCALING : uint
-        {
-            DISPLAYCONFIG_SCALING_IDENTITY = 1,
-            DISPLAYCONFIG_SCALING_CENTERED = 2,
-            DISPLAYCONFIG_SCALING_STRETCHED = 3,
-            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
-            DISPLAYCONFIG_SCALING_CUSTOM = 5,
-            DISPLAYCONFIG_SCALING_PREFERRED = 128,
-            DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_PIXELFORMAT : uint
-        {
-            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
-            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
-            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
-            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
-            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
-            DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff
-        }
-
-        public enum DISPLAYCONFIG_MODE_INFO_TYPE : uint
-        {
-            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
-            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
-            DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        public enum DISPLAYCONFIG_DEVICE_INFO_TYPE : uint
-        {
-            DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
-            DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
-            DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
-            DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
-            DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
-        }
-
-        #endregion
-
-        #region structs
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct LUID
-        {
-            public uint LowPart;
-            public int HighPart;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_SOURCE_INFO
-        {
-            public LUID adapterId;
-            public uint id;
-            public uint modeInfoIdx;
-            public uint statusFlags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_TARGET_INFO
-        {
-            public LUID adapterId;
-            public uint id;
-            public uint modeInfoIdx;
-            private DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
-            private DISPLAYCONFIG_ROTATION rotation;
-            private DISPLAYCONFIG_SCALING scaling;
-            private DISPLAYCONFIG_RATIONAL refreshRate;
-            private DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
-            public bool targetAvailable;
-            public uint statusFlags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_RATIONAL
-        {
-            public uint Numerator;
-            public uint Denominator;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_PATH_INFO
-        {
-            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
-            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
-            public uint flags;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_2DREGION
-        {
-            public uint cx;
-            public uint cy;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
-        {
-            public ulong pixelRate;
-            public DISPLAYCONFIG_RATIONAL hSyncFreq;
-            public DISPLAYCONFIG_RATIONAL vSyncFreq;
-            public DISPLAYCONFIG_2DREGION activeSize;
-            public DISPLAYCONFIG_2DREGION totalSize;
-            public uint videoStandard;
-            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_TARGET_MODE
-        {
-            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct POINTL
-        {
-            private int x;
-            private int y;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_SOURCE_MODE
-        {
-            public uint width;
-            public uint height;
-            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
-            public POINTL position;
-        }
-
-        [StructLayout(LayoutKind.Explicit)]
-        public struct DISPLAYCONFIG_MODE_INFO_UNION
-        {
-            [FieldOffset(0)]
-            public DISPLAYCONFIG_TARGET_MODE targetMode;
-
-            [FieldOffset(0)]
-            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_MODE_INFO
-        {
-            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
-            public uint id;
-            public LUID adapterId;
-            public DISPLAYCONFIG_MODE_INFO_UNION modeInfo;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
-        {
-            public uint value;
-        }
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct DISPLAYCONFIG_DEVICE_INFO_HEADER
-        {
-            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
-            public uint size;
-            public LUID adapterId;
-            public uint id;
-        }
-
-        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-        public struct DISPLAYCONFIG_TARGET_DEVICE_NAME
-        {
-            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
-            public DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
-            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
-            public ushort edidManufactureId;
-            public ushort edidProductCodeId;
-            public uint connectorInstance;
-
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
-            public string monitorFriendlyDeviceName;
-
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
-            public string monitorDevicePath;
-        }
-
-        #endregion
-
-        #region DLL-Imports
-
-        [DllImport("user32.dll")]
-        public static extern int GetDisplayConfigBufferSizes(
-            QUERY_DEVICE_CONFIG_FLAGS flags, out uint numPathArrayElements, out uint numModeInfoArrayElements);
-
-        [DllImport("user32.dll")]
-        public static extern int QueryDisplayConfig(
-            QUERY_DEVICE_CONFIG_FLAGS flags,
-            ref uint numPathArrayElements, [Out] DISPLAYCONFIG_PATH_INFO[] PathInfoArray,
-            ref uint numModeInfoArrayElements, [Out] DISPLAYCONFIG_MODE_INFO[] ModeInfoArray,
-            IntPtr currentTopologyId
-            );
-
-        [DllImport("user32.dll")]
-        public static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName);
-
-        #endregion
-
-        private static DISPLAYCONFIG_TARGET_DEVICE_NAME DeviceName(LUID adapterId, uint targetId)
-        {
-            var deviceName = new DISPLAYCONFIG_TARGET_DEVICE_NAME
-            {
-                header =
-                {
-                    size = (uint)Marshal.SizeOf(typeof (DISPLAYCONFIG_TARGET_DEVICE_NAME)),
-                    adapterId = adapterId,
-                    id = targetId,
-                    type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
-                }
-            };
-            var error = DisplayConfigGetDeviceInfo(ref deviceName);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            return deviceName;
-        }
-
-        public static IEnumerable<DISPLAYCONFIG_TARGET_DEVICE_NAME> GetAllDevices()
-        {
-            uint pathCount, modeCount;
-            var error = GetDisplayConfigBufferSizes(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS, out pathCount, out modeCount);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            var displayPaths = new DISPLAYCONFIG_PATH_INFO[pathCount];
-            var displayModes = new DISPLAYCONFIG_MODE_INFO[modeCount];
-            error = QueryDisplayConfig(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS,
-                ref pathCount, displayPaths, ref modeCount, displayModes, IntPtr.Zero);
-            if (error != ERROR_SUCCESS)
-                throw new Win32Exception(error);
-
-            for (var i = 0; i < modeCount; i++)
-                if (displayModes[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE.DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
-                    yield return DeviceName(displayModes[i].adapterId, displayModes[i].id);
-        }
-
-
-    }
-
-}
 
 public class NativeMethods
 {
@@ -327,9 +22,6 @@ public class NativeMethods
 
     }
 
-    [DllImport("User32.dll")]
-    public static extern bool SetForegroundWindow(IntPtr handle);
-
     private const int WM_SYSCOMMAND = 0x0112;
     private const int SC_MONITORPOWER = 0xF170;
     private const int MONITOR_OFF = 2;
@@ -340,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();
@@ -414,430 +106,5 @@ public class NativeMethods
     }
 
 
-    [DllImport("Powrprof.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
-    public static extern bool SetSuspendState(bool hiberate, bool forceCritical, bool disableWakeEvent);
 
-
-    [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")]
-    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");
-
-    [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 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";
-
-    public static string FindLaptopScreen()
-    {
-        string laptopScreen = null;
-
-        try
-        {
-            var devices = GetAllDevices().ToArray();
-            int count = 0, displayNum = -1;
-
-            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)
-                {
-                    displayNum = count;
-                    AppConfig.Set("internal_display", device.monitorFriendlyDeviceName);
-                }
-                count++;
-                //Logger.WriteLine(device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString());
-            }
-
-            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++;
-            }
-
-            if (displayNum > 0 && count == 0) laptopScreen = defaultDevice;
-        }
-        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));
-
-            //Fallback scenario
-            if (iRet != 0)
-            {
-                Thread.Sleep(300);
-                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;
-
-    }
-
-    public static nint GetHuibernateAfter()
-    {
-        Guid activePolicyGuid = GetActiveScheme();
-        var type = 0;
-        nint value = 0;
-        var valueSize = 4u;
-
-        PowerReadACValue(IntPtr.Zero, activePolicyGuid,
-             GUID_SLEEP_SUBGROUP, GUID_HIBERNATEIDLE,
-            ref type, ref value, ref valueSize);
-
-        return value;
-    }
-
-    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 void SetPowerScheme(string scheme)
-    {
-        List<string> overlays = new() {
-            "00000000-0000-0000-0000-000000000000",
-            "ded574b5-45a0-4f42-8737-46345c09c238",
-            "961cc777-2547-4f9d-8174-7d86181b8a7a",
-            "3af9B8d9-7c97-431d-ad78-34a8bfea439f"
-        };
-
-        if (overlays.Contains(scheme))
-        {
-            PowerSetActiveOverlayScheme(new Guid(scheme));
-            Logger.WriteLine("Power mode:" + scheme);
-        }
-        else
-        {
-            PowerSetActiveScheme(IntPtr.Zero, new Guid(scheme));
-            Logger.WriteLine("Power plan:" + 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/Display/ColorData.cs

@@ -1,200 +0,0 @@
-using System;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <inheritdoc cref="IColorData" />
-    public class ColorData : IColorData, IEquatable<ColorData>
-    {
-        /// <summary>
-        ///     Creates an instance of <see cref="ColorData" /> to modify the color data
-        /// </summary>
-        /// <param name="colorFormat">The color data color format.</param>
-        /// <param name="colorimetry">The color data color space.</param>
-        /// <param name="dynamicRange">The color data dynamic range.</param>
-        /// <param name="colorDepth">The color data color depth.</param>
-        /// <param name="colorSelectionPolicy">The color data selection policy.</param>
-        /// <param name="desktopColorDepth">The color data desktop color depth.</param>
-        public ColorData(
-            ColorDataFormat colorFormat = ColorDataFormat.Auto,
-            ColorDataColorimetry colorimetry = ColorDataColorimetry.Auto,
-            ColorDataDynamicRange? dynamicRange = null,
-            ColorDataDepth? colorDepth = null,
-            ColorDataSelectionPolicy? colorSelectionPolicy = null,
-            ColorDataDesktopDepth? desktopColorDepth = null
-        )
-        {
-            ColorFormat = colorFormat;
-            Colorimetry = colorimetry;
-            DynamicRange = dynamicRange;
-            ColorDepth = colorDepth;
-            SelectionPolicy = colorSelectionPolicy;
-            DesktopColorDepth = desktopColorDepth;
-        }
-
-        internal ColorData(IColorData colorData)
-        {
-            ColorDepth = colorData.ColorDepth;
-            DynamicRange = colorData.DynamicRange;
-            ColorFormat = colorData.ColorFormat;
-            Colorimetry = colorData.Colorimetry;
-            SelectionPolicy = colorData.SelectionPolicy;
-            DesktopColorDepth = colorData.DesktopColorDepth;
-        }
-
-        /// <inheritdoc />
-        public ColorDataDepth? ColorDepth { get; }
-
-        /// <inheritdoc />
-        public ColorDataFormat ColorFormat { get; }
-
-        /// <inheritdoc />
-        public ColorDataColorimetry Colorimetry { get; }
-
-        /// <inheritdoc />
-        public ColorDataDesktopDepth? DesktopColorDepth { get; }
-
-        /// <inheritdoc />
-        public ColorDataDynamicRange? DynamicRange { get; }
-
-        /// <inheritdoc />
-        public ColorDataSelectionPolicy? SelectionPolicy { get; }
-
-        /// <inheritdoc />
-        public bool Equals(ColorData other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return ColorDepth == other.ColorDepth &&
-                   ColorFormat == other.ColorFormat &&
-                   Colorimetry == other.Colorimetry &&
-                   DesktopColorDepth == other.DesktopColorDepth &&
-                   DynamicRange == other.DynamicRange &&
-                   SelectionPolicy == other.SelectionPolicy;
-        }
-
-        /// <summary>
-        ///     Compares two instances of <see cref="ColorData" /> for equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns>true if two instances are equal; otherwise false.</returns>
-        public static bool operator ==(ColorData left, ColorData right)
-        {
-            return left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Compares two instances of <see cref="ColorData" /> for inequality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns>true if two instances are not equal; otherwise false.</returns>
-        public static bool operator !=(ColorData left, ColorData right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((ColorData) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = ColorDepth.GetHashCode();
-                hashCode = (hashCode * 397) ^ (int) ColorFormat;
-                hashCode = (hashCode * 397) ^ (int) Colorimetry;
-                hashCode = (hashCode * 397) ^ DesktopColorDepth.GetHashCode();
-                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
-                hashCode = (hashCode * 397) ^ SelectionPolicy.GetHashCode();
-
-                return hashCode;
-            }
-        }
-
-        internal ColorDataV1 AsColorDataV1(ColorDataCommand command)
-        {
-            return new ColorDataV1(
-                command,
-                ColorFormat,
-                Colorimetry
-            );
-        }
-
-        internal ColorDataV2 AsColorDataV2(ColorDataCommand command)
-        {
-            return new ColorDataV2(
-                command,
-                ColorFormat,
-                Colorimetry,
-                DynamicRange ?? ColorDataDynamicRange.Auto
-            );
-        }
-
-        internal ColorDataV3 AsColorDataV3(ColorDataCommand command)
-        {
-            return new ColorDataV3(
-                command,
-                ColorFormat,
-                Colorimetry,
-                DynamicRange ?? ColorDataDynamicRange.Auto,
-                ColorDepth ?? ColorDataDepth.Default
-            );
-        }
-
-        internal ColorDataV4 AsColorDataV4(ColorDataCommand command)
-        {
-            return new ColorDataV4(
-                command,
-                ColorFormat,
-                Colorimetry,
-                DynamicRange ?? ColorDataDynamicRange.Auto,
-                ColorDepth ?? ColorDataDepth.Default,
-                SelectionPolicy ?? ColorDataSelectionPolicy.Default
-            );
-        }
-
-        internal ColorDataV5 AsColorDataV5(ColorDataCommand command)
-        {
-            return new ColorDataV5(
-                command,
-                ColorFormat,
-                Colorimetry,
-                DynamicRange ?? ColorDataDynamicRange.Auto,
-                ColorDepth ?? ColorDataDepth.Default,
-                SelectionPolicy ?? ColorDataSelectionPolicy.Default,
-                DesktopColorDepth ?? ColorDataDesktopDepth.Default
-            );
-        }
-    }
-}

app/NvAPIWrapper/Display/CustomResolution.cs

@@ -1,245 +0,0 @@
-using System;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Hold information about a custom display resolution
-    /// </summary>
-    public class CustomResolution : IEquatable<CustomResolution>
-    {
-        /// <summary>
-        ///     Creates an instance of <see cref="CustomResolution" />.
-        /// </summary>
-        /// <param name="width">The screen width.</param>
-        /// <param name="height">The screen height.</param>
-        /// <param name="colorFormat">The color format.</param>
-        /// <param name="timing">The resolution timing.</param>
-        /// <param name="xRatio">The horizontal scaling ratio.</param>
-        /// <param name="yRatio">The vertical scaling ratio.</param>
-        public CustomResolution(
-            uint width,
-            uint height,
-            ColorFormat colorFormat,
-            Timing timing,
-            float xRatio = 1,
-            float yRatio = 1
-        )
-        {
-            if (xRatio <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(xRatio));
-            }
-
-            if (yRatio <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(yRatio));
-            }
-
-            Width = width;
-            Height = height;
-            ColorFormat = colorFormat;
-            XRatio = xRatio;
-            YRatio = yRatio;
-            Timing = timing;
-
-            switch (ColorFormat)
-            {
-                case ColorFormat.P8:
-                    ColorDepth = 8;
-
-                    break;
-                case ColorFormat.R5G6B5:
-                    ColorDepth = 16;
-
-                    break;
-                case ColorFormat.A8R8G8B8:
-                    ColorDepth = 24;
-
-                    break;
-                case ColorFormat.A16B16G16R16F:
-                    ColorDepth = 32;
-
-                    break;
-                default:
-                    throw new ArgumentException("Color format is invalid.", nameof(colorFormat));
-            }
-        }
-
-        /// <summary>
-        ///     Creates an instance of <see cref="CustomResolution" />.
-        /// </summary>
-        /// <param name="width">The screen width.</param>
-        /// <param name="height">The screen height.</param>
-        /// <param name="colorDepth">The color depth.</param>
-        /// <param name="timing">The resolution timing.</param>
-        /// <param name="xRatio">The horizontal scaling ratio.</param>
-        /// <param name="yRatio">The vertical scaling ratio.</param>
-        public CustomResolution(
-            uint width,
-            uint height,
-            uint colorDepth,
-            Timing timing,
-            float xRatio = 1,
-            float yRatio = 1)
-        {
-            if (xRatio <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(xRatio));
-            }
-
-            if (yRatio <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(yRatio));
-            }
-
-            if (colorDepth != 0 && colorDepth != 8 && colorDepth != 16 && colorDepth != 24 && colorDepth != 32)
-            {
-                throw new ArgumentOutOfRangeException(nameof(colorDepth));
-            }
-
-            Width = width;
-            Height = height;
-            ColorDepth = colorDepth;
-            ColorFormat = ColorFormat.Unknown;
-            XRatio = xRatio;
-            YRatio = yRatio;
-            Timing = timing;
-        }
-
-        internal CustomResolution(CustomDisplay customDisplay)
-        {
-            Width = customDisplay.Width;
-            Height = customDisplay.Height;
-            ColorDepth = customDisplay.Depth;
-            ColorFormat = customDisplay.ColorFormat;
-            Timing = customDisplay.Timing;
-            XRatio = customDisplay.XRatio;
-            YRatio = customDisplay.YRatio;
-        }
-
-        /// <summary>
-        ///     Gets the source surface color depth. "0" means all 8/16/32bpp.
-        /// </summary>
-        public uint ColorDepth { get; }
-
-        /// <summary>
-        ///     Gets the color format (optional)
-        /// </summary>
-        public ColorFormat ColorFormat { get; }
-
-        /// <summary>
-        ///     Gets the source surface (source mode) height.
-        /// </summary>
-        public uint Height { get; }
-
-        /// <summary>
-        ///     Gets the timing used to program TMDS/DAC/LVDS/HDMI/TVEncoder, etc.
-        /// </summary>
-        public Timing Timing { get; }
-
-        /// <summary>
-        ///     Gets the source surface (source mode) width.
-        /// </summary>
-        public uint Width { get; }
-
-        /// <summary>
-        ///     Gets the horizontal scaling ratio.
-        /// </summary>
-        public float XRatio { get; }
-
-        /// <summary>
-        ///     Gets the vertical scaling ratio.
-        /// </summary>
-        public float YRatio { get; }
-
-        /// <inheritdoc />
-        public bool Equals(CustomResolution other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Width == other.Width &&
-                   Height == other.Height &&
-                   ColorDepth == other.ColorDepth &&
-                   Timing.Equals(other.Timing) &&
-                   ColorFormat == other.ColorFormat &&
-                   XRatio.Equals(other.XRatio) &&
-                   YRatio.Equals(other.YRatio);
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="CustomResolution" /> for equality.
-        /// </summary>
-        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
-        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
-        /// <returns>True if both instances are equal, otherwise false.</returns>
-        public static bool operator ==(CustomResolution left, CustomResolution right)
-        {
-            return Equals(left, right);
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="CustomResolution" /> for inequality.
-        /// </summary>
-        /// <param name="left">An first instance of <see cref="CustomResolution" /> to compare.</param>
-        /// <param name="right">An Second instance of <see cref="CustomResolution" /> to compare.</param>
-        /// <returns>True if both instances are not equal, otherwise false.</returns>
-        public static bool operator !=(CustomResolution left, CustomResolution right)
-        {
-            return !Equals(left, right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((CustomResolution) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = (int) Width;
-                hashCode = (hashCode * 397) ^ (int) Height;
-                hashCode = (hashCode * 397) ^ (int) ColorDepth;
-                hashCode = (hashCode * 397) ^ Timing.GetHashCode();
-                hashCode = (hashCode * 397) ^ (int) ColorFormat;
-                hashCode = (hashCode * 397) ^ XRatio.GetHashCode();
-                hashCode = (hashCode * 397) ^ YRatio.GetHashCode();
-
-                return hashCode;
-            }
-        }
-
-        internal CustomDisplay AsCustomDisplay(bool hardwareModeSetOnly)
-        {
-            return new CustomDisplay(Width, Height, ColorDepth, ColorFormat, XRatio, YRatio, Timing,
-                hardwareModeSetOnly);
-        }
-    }
-}

app/NvAPIWrapper/Display/DVCInformation.cs

@@ -1,325 +0,0 @@
-using System;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     This class contains and provides a way to modify the Digital Vibrance Control information regarding the
-    ///     saturation level of the display or the output
-    /// </summary>
-    public class DVCInformation : IDisplayDVCInfo
-    {
-        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
-        private readonly OutputId _outputId = OutputId.Invalid;
-        private bool? _isLegacy;
-
-        /// <summary>
-        ///     Creates a new instance of the class using a DisplayHandle
-        /// </summary>
-        /// <param name="displayHandle">The handle of the display.</param>
-        public DVCInformation(DisplayHandle displayHandle)
-        {
-            _displayHandle = displayHandle;
-        }
-
-        /// <summary>
-        ///     Creates a new instance of this class using a OutputId
-        /// </summary>
-        /// <param name="outputId">The output identification of a display or an output</param>
-        public DVCInformation(OutputId outputId)
-        {
-            _outputId = outputId;
-        }
-
-        /// <summary>
-        ///     Gets and sets the normalized saturation level in the [-1,1] inclusive range.
-        ///     a -1 value corresponds to the minimum saturation level and maximum under-saturation and the
-        ///     a 1 value corresponds to the maximum saturation level and maximum over-saturation.
-        ///     The value of 0 indicates the default saturation level.
-        /// </summary>
-        public double NormalizedLevel
-        {
-            get
-            {
-                var info = GetInfo();
-
-                if (info == null)
-                {
-                    return double.NaN;
-                }
-
-                var deviance = info.CurrentLevel - info.DefaultLevel;
-                var range = deviance >= 0
-                    ? info.MaximumLevel - info.DefaultLevel
-                    : info.DefaultLevel - info.MinimumLevel;
-
-                if (deviance == 0 || range == 0)
-                {
-                    return 0;
-                }
-
-                return Math.Max(Math.Min((double) deviance / range, 1), -1);
-            }
-            set
-            {
-                if (double.IsNaN(value) || double.IsInfinity(value))
-                {
-                    throw new ArgumentOutOfRangeException(nameof(value));
-                }
-
-                var info = GetInfo();
-
-                if (info == null)
-                {
-                    return;
-                }
-
-                var range = value >= 0 ? info.MaximumLevel - info.DefaultLevel : info.DefaultLevel - info.MinimumLevel;
-                var level = Math.Max(Math.Min((int) (value * range) + info.DefaultLevel, info.MaximumLevel), info.MinimumLevel);
-
-                if (level == info.CurrentLevel)
-                {
-                    return;
-                }
-
-                SetLevel(level);
-            }
-        }
-
-        /// <summary>
-        ///     Gets and sets the current saturation level
-        /// </summary>
-        public int CurrentLevel
-        {
-            get => GetInfo()?.CurrentLevel ?? 0;
-            set
-            {
-                var info = GetInfo();
-
-                if (info == null)
-                {
-                    return;
-                }
-
-                value = Math.Max(Math.Min(value, info.MaximumLevel), info.MinimumLevel);
-
-                if (info.CurrentLevel == value)
-                {
-                    return;
-                }
-
-                SetLevel(value);
-            }
-        }
-
-        /// <inheritdoc />
-        public int DefaultLevel
-        {
-            get => GetInfo()?.DefaultLevel ?? 0;
-        }
-
-        /// <inheritdoc />
-        public int MaximumLevel
-        {
-            get => GetInfo()?.MaximumLevel ?? 0;
-        }
-
-        /// <inheritdoc />
-        public int MinimumLevel
-        {
-            get => GetInfo()?.MinimumLevel ?? 0;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"{CurrentLevel:D} @ [{MinimumLevel:D} <= {DefaultLevel:D} <= {MaximumLevel:D}] = {NormalizedLevel:F2}";
-        }
-
-        private IDisplayDVCInfo GetInfo()
-        {
-            if (_isLegacy == true)
-            {
-                return GetLegacyInfo();
-            }
-
-            if (_isLegacy == false)
-            {
-                return GetModernInfo();
-            }
-
-            var info = GetModernInfo() ?? GetLegacyInfo();
-
-            if (info == null)
-            {
-                // exception occured on both, force a mode
-                _isLegacy = false;
-
-                return GetInfo();
-            }
-
-            return info;
-        }
-
-        private IDisplayDVCInfo GetLegacyInfo()
-        {
-            try
-            {
-                var info = _outputId == OutputId.Invalid
-                    ? DisplayApi.GetDVCInfo(_displayHandle)
-                    : DisplayApi.GetDVCInfo(_outputId);
-
-                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
-                {
-                    return null;
-                }
-
-                if (!_isLegacy.HasValue)
-                {
-                    _isLegacy = true;
-                }
-
-
-                return info;
-            }
-            catch (Exception)
-            {
-                if (_isLegacy == true)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            return null;
-        }
-
-        private IDisplayDVCInfo GetModernInfo()
-        {
-            try
-            {
-                var info = _outputId == OutputId.Invalid
-                    ? DisplayApi.GetDVCInfoEx(_displayHandle)
-                    : DisplayApi.GetDVCInfoEx(_outputId);
-
-                if (info.MaximumLevel == 0 && info.MinimumLevel == 0 && info.CurrentLevel == 0)
-                {
-                    return null;
-                }
-
-                if (!_isLegacy.HasValue)
-                {
-                    _isLegacy = false;
-                }
-
-                return info;
-            }
-            catch (Exception)
-            {
-                if (_isLegacy == false)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            return null;
-        }
-
-        private bool SetLegacyLevel(int level)
-        {
-            try
-            {
-                if (_outputId == OutputId.Invalid)
-                {
-                    DisplayApi.SetDVCLevel(_displayHandle, level);
-                }
-                else
-                {
-                    DisplayApi.SetDVCLevel(_outputId, level);
-                }
-
-                if (!_isLegacy.HasValue)
-                {
-                    _isLegacy = true;
-                }
-
-                return true;
-            }
-            catch (Exception)
-            {
-                if (_isLegacy == true)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            return false;
-        }
-
-        private void SetLevel(int level)
-        {
-            if (_isLegacy == true)
-            {
-                SetLegacyLevel(level);
-            }
-            else if (_isLegacy == false)
-            {
-                SetModernLevel(level);
-            }
-            else
-            {
-                var success = SetModernLevel(level) || SetLegacyLevel(level);
-
-                if (!success)
-                {
-                    // exception occured on both, force a mode
-                    _isLegacy = false;
-
-                    SetLevel(level);
-                }
-            }
-        }
-
-        private bool SetModernLevel(int level)
-        {
-            try
-            {
-                if (_outputId == OutputId.Invalid)
-                {
-                    DisplayApi.SetDVCLevelEx(_displayHandle, level);
-                }
-                else
-                {
-                    DisplayApi.SetDVCLevelEx(_outputId, level);
-                }
-
-                if (!_isLegacy.HasValue)
-                {
-                    _isLegacy = false;
-                }
-
-                return true;
-            }
-            catch (Exception)
-            {
-                if (_isLegacy == false)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            return false;
-        }
-    }
-}

app/NvAPIWrapper/Display/Display.cs

@@ -1,232 +0,0 @@
-using System;
-using System.Linq;
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents an attached display
-    /// </summary>
-    public class Display : IEquatable<Display>
-    {
-        /// <summary>
-        ///     Creates a new Display
-        /// </summary>
-        /// <param name="handle">Handle of the display device</param>
-        public Display(DisplayHandle handle)
-        {
-            Handle = handle;
-        }
-
-        /// <summary>
-        ///     Creates a new Display
-        /// </summary>
-        /// <param name="displayName">Name of the display device</param>
-        public Display(string displayName)
-        {
-            Handle = DisplayApi.GetAssociatedNvidiaDisplayHandle(displayName);
-        }
-
-        /// <summary>
-        ///     Gets the corresponding Digital Vibrance Control information
-        /// </summary>
-        public DVCInformation DigitalVibranceControl
-        {
-            get => new DVCInformation(Handle);
-        }
-
-        /// <summary>
-        ///     Gets corresponding DisplayDevice based on display name
-        /// </summary>
-        public DisplayDevice DisplayDevice
-        {
-            get => new DisplayDevice(Name);
-        }
-
-        /// <summary>
-        ///     Gets display driver build title
-        /// </summary>
-        public string DriverBuildTitle
-        {
-            get => DisplayApi.GetDisplayDriverBuildTitle(Handle);
-        }
-
-        /// <summary>
-        ///     Gets display handle
-        /// </summary>
-        public DisplayHandle Handle { get; }
-
-        /// <summary>
-        ///     Gets the display HDMI support information
-        /// </summary>
-        public IHDMISupportInfo HDMISupportInfo
-        {
-            get
-            {
-                var outputId = OutputId.Invalid;
-                try
-                {
-                    outputId = DisplayApi.GetAssociatedDisplayOutputId(Handle);
-                }
-                catch (NVIDIAApiException)
-                {
-                    // ignore
-                }
-                return DisplayApi.GetHDMISupportInfo(Handle, outputId);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the corresponding HUE information
-        /// </summary>
-        public HUEInformation HUEControl
-        {
-            get => new HUEInformation(Handle);
-        }
-
-        /// <summary>
-        ///     Gets the driving logical GPU
-        /// </summary>
-        public LogicalGPU LogicalGPU
-        {
-            get => new LogicalGPU(GPUApi.GetLogicalGPUFromDisplay(Handle));
-        }
-
-        /// <summary>
-        ///     Gets display name
-        /// </summary>
-        public string Name
-        {
-            get => DisplayApi.GetAssociatedNvidiaDisplayName(Handle);
-        }
-
-        /// <summary>
-        ///     Gets the connected GPU output
-        /// </summary>
-        public GPUOutput Output
-        {
-            get => new GPUOutput(DisplayApi.GetAssociatedDisplayOutputId(Handle), PhysicalGPUs.FirstOrDefault());
-        }
-
-        /// <summary>
-        ///     Gets the list of all physical GPUs responsible for this display, with the first GPU returned as the one with the
-        ///     attached active output.
-        /// </summary>
-        public PhysicalGPU[] PhysicalGPUs
-        {
-            get => GPUApi.GetPhysicalGPUsFromDisplay(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
-        }
-
-        /// <inheritdoc />
-        public bool Equals(Display other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Handle.Equals(other.Handle);
-        }
-
-        /// <summary>
-        ///     This function returns all NVIDIA displays
-        ///     Note: Display handles can get invalidated on a modeset.
-        /// </summary>
-        /// <returns>An array of Display objects</returns>
-        public static Display[] GetDisplays()
-        {
-            return DisplayApi.EnumNvidiaDisplayHandle().Select(handle => new Display(handle)).ToArray();
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(Display left, Display right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(Display left, Display right)
-        {
-            return !(right == left);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((Display) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return Handle.GetHashCode();
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return Name;
-        }
-
-        /// <summary>
-        ///     Gets all the supported NVIDIA display views (nView and Dualview modes) for this display.
-        /// </summary>
-        /// <returns></returns>
-        public TargetViewMode[] GetSupportedViews()
-        {
-            return DisplayApi.GetSupportedViews(Handle);
-        }
-
-        /// <summary>
-        ///     Overrides the refresh rate on this display.
-        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
-        ///     mode-set.
-        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
-        /// </summary>
-        /// <param name="refreshRate">The refresh rate to be applied.</param>
-        /// <param name="isDeferred">
-        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
-        ///     mode-set.
-        /// </param>
-        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
-        {
-            DisplayApi.SetRefreshRateOverride(Handle, refreshRate, isDeferred);
-        }
-    }
-}

app/NvAPIWrapper/Display/DisplayDevice.cs

@@ -1,893 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-using NvAPIWrapper.Native.Interfaces.Display;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents an NVIDIA display device
-    /// </summary>
-    public class DisplayDevice : IEquatable<DisplayDevice>
-    {
-        /// <summary>
-        ///     Creates a new DisplayDevice
-        /// </summary>
-        /// <param name="displayId">Display identification of the device</param>
-        public DisplayDevice(uint displayId)
-        {
-            DisplayId = displayId;
-            var extraInformation = PhysicalGPU.GetDisplayDevices().FirstOrDefault(ids => ids.DisplayId == DisplayId);
-
-            if (extraInformation != null)
-            {
-                IsAvailable = true;
-                ScanOutInformation = new ScanOutInformation(this);
-                ConnectionType = extraInformation.ConnectionType;
-                IsDynamic = extraInformation.IsDynamic;
-                IsMultiStreamRootNode = extraInformation.IsMultiStreamRootNode;
-                IsActive = extraInformation.IsActive;
-                IsCluster = extraInformation.IsCluster;
-                IsOSVisible = extraInformation.IsOSVisible;
-                IsWFD = extraInformation.IsWFD;
-                IsConnected = extraInformation.IsConnected;
-                IsPhysicallyConnected = extraInformation.IsPhysicallyConnected;
-            }
-        }
-
-        /// <summary>
-        ///     Creates a new DisplayDevice
-        /// </summary>
-        /// <param name="displayIds">Display identification and attributes of the display device</param>
-        public DisplayDevice(IDisplayIds displayIds)
-        {
-            IsAvailable = true;
-            DisplayId = displayIds.DisplayId;
-            ScanOutInformation = new ScanOutInformation(this);
-            ConnectionType = displayIds.ConnectionType;
-            IsDynamic = displayIds.IsDynamic;
-            IsMultiStreamRootNode = displayIds.IsMultiStreamRootNode;
-            IsActive = displayIds.IsActive;
-            IsCluster = displayIds.IsCluster;
-            IsOSVisible = displayIds.IsOSVisible;
-            IsWFD = displayIds.IsWFD;
-            IsConnected = displayIds.IsConnected;
-            IsPhysicallyConnected = displayIds.IsPhysicallyConnected;
-        }
-
-        /// <summary>
-        ///     Creates a new DisplayDevice
-        /// </summary>
-        /// <param name="displayName">Display name of the display device</param>
-        public DisplayDevice(string displayName) : this(DisplayApi.GetDisplayIdByDisplayName(displayName))
-        {
-        }
-
-        /// <summary>
-        ///     Gets the display device connection type
-        /// </summary>
-        public MonitorConnectionType ConnectionType { get; }
-
-        /// <summary>
-        ///     Gets the current display color data
-        /// </summary>
-        public ColorData CurrentColorData
-        {
-            get
-            {
-                var instances = new IColorData[]
-                {
-                    new ColorDataV5(ColorDataCommand.Get),
-                    new ColorDataV4(ColorDataCommand.Get),
-                    new ColorDataV3(ColorDataCommand.Get),
-                    new ColorDataV2(ColorDataCommand.Get),
-                    new ColorDataV1(ColorDataCommand.Get)
-                };
-
-                var instance = DisplayApi.ColorControl(DisplayId, instances);
-
-                return new ColorData(instance);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the current display device timing
-        /// </summary>
-        public Timing CurrentTiming
-        {
-            get => DisplayApi.GetTiming(DisplayId, new TimingInput(TimingOverride.Current));
-        }
-
-        /// <summary>
-        ///     Gets the default display color data
-        /// </summary>
-        public ColorData DefaultColorData
-        {
-            get
-            {
-                var instances = new IColorData[]
-                {
-                    new ColorDataV5(ColorDataCommand.GetDefault),
-                    new ColorDataV4(ColorDataCommand.GetDefault),
-                    new ColorDataV3(ColorDataCommand.GetDefault),
-                    new ColorDataV2(ColorDataCommand.GetDefault),
-                    new ColorDataV1(ColorDataCommand.GetDefault)
-                };
-
-                var instance = DisplayApi.ColorControl(DisplayId, instances);
-
-                return new ColorData(instance);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the NVIDIA display identification
-        /// </summary>
-        public uint DisplayId { get; }
-
-        /// <summary>
-        ///     Gets the monitor Display port capabilities
-        /// </summary>
-        public MonitorColorData[] DisplayPortColorCapabilities
-        {
-            get
-            {
-                if (ConnectionType != MonitorConnectionType.DisplayPort)
-                {
-                    return null;
-                }
-
-                return DisplayApi.GetMonitorColorCapabilities(DisplayId);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the display driver EDID specified HDR capabilities
-        /// </summary>
-        public HDRCapabilitiesV1 DriverHDRCapabilities
-        {
-            get => DisplayApi.GetHDRCapabilities(DisplayId, true);
-        }
-
-        /// <summary>
-        ///     Gets the display currently effective HDR capabilities
-        /// </summary>
-        public HDRCapabilitiesV1 EffectiveHDRCapabilities
-        {
-            get => DisplayApi.GetHDRCapabilities(DisplayId, false);
-        }
-
-        /// <summary>
-        ///     Gets the HDMI audio info-frame current information
-        /// </summary>
-        public InfoFrameAudio? HDMIAudioFrameCurrentInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AudioInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AudioInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-
-        /// <summary>
-        ///     Gets the HDMI audio info-frame default information
-        /// </summary>
-        public InfoFrameAudio? HDMIAudioFrameDefaultInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault, InfoFrameDataType.AudioInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AudioInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDMI audio info-frame override information
-        /// </summary>
-        public InfoFrameAudio? HDMIAudioFrameOverrideInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride, InfoFrameDataType.AudioInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AudioInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDMI audio info-frame property information
-        /// </summary>
-        public InfoFrameProperty? HDMIAudioFramePropertyInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty, InfoFrameDataType.AudioInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.PropertyInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the device HDMI support information
-        /// </summary>
-        public IHDMISupportInfo HDMISupportInfo
-        {
-            get => DisplayApi.GetHDMISupportInfo(DisplayId);
-        }
-
-
-        /// <summary>
-        ///     Gets the HDMI auxiliary video info-frame current information
-        /// </summary>
-        public InfoFrameVideo? HDMIVideoFrameCurrentInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame =
-                        new InfoFrameData(InfoFrameCommand.Get, InfoFrameDataType.AuxiliaryVideoInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AuxiliaryVideoInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDMI auxiliary video info-frame default information
-        /// </summary>
-        public InfoFrameVideo? HDMIVideoFrameDefaultInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetDefault,
-                        InfoFrameDataType.AuxiliaryVideoInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AuxiliaryVideoInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDMI auxiliary video info-frame override information
-        /// </summary>
-        public InfoFrameVideo? HDMIVideoFrameOverrideInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetOverride,
-                        InfoFrameDataType.AuxiliaryVideoInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.AuxiliaryVideoInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDMI auxiliary video info-frame property information
-        /// </summary>
-        public InfoFrameProperty? HDMIVideoFramePropertyInformation
-        {
-            get
-            {
-                try
-                {
-                    var infoFrame = new InfoFrameData(InfoFrameCommand.GetProperty,
-                        InfoFrameDataType.AuxiliaryVideoInformation);
-                    DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-
-                    return infoFrame.PropertyInformation;
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the HDR color data, or null if the HDR is disabled or unavailable
-        /// </summary>
-        public HDRColorData HDRColorData
-        {
-            get
-            {
-                try
-                {
-                    var instances = new IHDRColorData[]
-                    {
-                        new HDRColorDataV2(ColorDataHDRCommand.Get),
-                        new HDRColorDataV1(ColorDataHDRCommand.Get)
-                    };
-
-                    var instance = DisplayApi.HDRColorControl(DisplayId, instances);
-
-                    if (instance.HDRMode == ColorDataHDRMode.Off)
-                    {
-                        return null;
-                    }
-
-                    return new HDRColorData(instance);
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status == Status.NotSupported)
-                    {
-                        return null;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Indicates if the display is being actively driven
-        /// </summary>
-        public bool IsActive { get; }
-
-        /// <summary>
-        ///     Indicates if the display device is currently available
-        /// </summary>
-        public bool IsAvailable { get; }
-
-        /// <summary>
-        ///     Indicates if the display is the representative display
-        /// </summary>
-        public bool IsCluster { get; }
-
-        /// <summary>
-        ///     Indicates if the display is connected
-        /// </summary>
-        public bool IsConnected { get; }
-
-        /// <summary>
-        ///     Indicates if the display is part of MST topology and it's a dynamic
-        /// </summary>
-        public bool IsDynamic { get; }
-
-        /// <summary>
-        ///     Indicates if the display identification belongs to a multi stream enabled connector (root node). Note that when
-        ///     multi stream is enabled and a single multi stream capable monitor is connected to it, the monitor will share the
-        ///     display id with the RootNode.
-        ///     When there is more than one monitor connected in a multi stream topology, then the root node will have a separate
-        ///     displayId.
-        /// </summary>
-        public bool IsMultiStreamRootNode { get; }
-
-        /// <summary>
-        ///     Indicates if the display is reported to the OS
-        /// </summary>
-        public bool IsOSVisible { get; }
-
-        /// <summary>
-        ///     Indicates if the display is a physically connected display; Valid only when IsConnected is true
-        /// </summary>
-        public bool IsPhysicallyConnected { get; }
-
-        /// <summary>
-        ///     Indicates if the display is wireless
-        /// </summary>
-        public bool IsWFD { get; }
-
-        /// <summary>
-        ///     Gets the connected GPU output
-        /// </summary>
-        public GPUOutput Output
-        {
-            get
-            {
-                PhysicalGPUHandle handle;
-                var outputId = GPUApi.GetGPUAndOutputIdFromDisplayId(DisplayId, out handle);
-
-                return new GPUOutput(outputId, new PhysicalGPU(handle));
-            }
-        }
-
-        /// <summary>
-        ///     Gets the connected physical GPU
-        /// </summary>
-        public PhysicalGPU PhysicalGPU
-        {
-            get
-            {
-                try
-                {
-                    var gpuHandle = GPUApi.GetPhysicalGPUFromDisplayId(DisplayId);
-
-                    return new PhysicalGPU(gpuHandle);
-                }
-                catch
-                {
-                    // ignored
-                }
-
-                return Output.PhysicalGPU;
-            }
-        }
-
-        /// <summary>
-        ///     Gets information regarding the scan-out settings of this display device
-        /// </summary>
-        public ScanOutInformation ScanOutInformation { get; }
-
-        /// <summary>
-        ///     Gets monitor capabilities from the Video Capability Data Block if available, otherwise null
-        /// </summary>
-        public MonitorVCDBCapabilities? VCDBMonitorCapabilities
-        {
-            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VCDB)?.VCDBCapabilities;
-        }
-
-        /// <summary>
-        ///     Gets monitor capabilities from the Vendor Specific Data Block if available, otherwise null
-        /// </summary>
-        public MonitorVSDBCapabilities? VSDBMonitorCapabilities
-        {
-            get => DisplayApi.GetMonitorCapabilities(DisplayId, MonitorCapabilitiesType.VSDB)?.VSDBCapabilities;
-        }
-
-        /// <inheritdoc />
-        public bool Equals(DisplayDevice other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return DisplayId == other.DisplayId;
-        }
-
-        /// <summary>
-        ///     Deletes a custom resolution.
-        /// </summary>
-        /// <param name="customResolution">The custom resolution to delete.</param>
-        /// <param name="displayIds">A list of display ids to remove the custom resolution from.</param>
-        public static void DeleteCustomResolution(CustomResolution customResolution, uint[] displayIds)
-        {
-            var customDisplay = customResolution.AsCustomDisplay(false);
-            DisplayApi.DeleteCustomDisplay(displayIds, customDisplay);
-        }
-
-        /// <summary>
-        ///     Returns an instance of <see cref="DisplayDevice" /> representing the primary GDI display device.
-        /// </summary>
-        /// <returns>An instance of <see cref="DisplayDevice" />.</returns>
-        public static DisplayDevice GetGDIPrimaryDisplayDevice()
-        {
-            var displayId = DisplayApi.GetGDIPrimaryDisplayId();
-
-            if (displayId == 0)
-            {
-                return null;
-            }
-
-            return new DisplayDevice(displayId);
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(DisplayDevice left, DisplayDevice right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(DisplayDevice left, DisplayDevice right)
-        {
-            return !(right == left);
-        }
-
-        /// <summary>
-        ///     Reverts the custom resolution currently on trial.
-        /// </summary>
-        /// <param name="displayIds">A list of display ids to revert the custom resolution from.</param>
-        public static void RevertCustomResolution(uint[] displayIds)
-        {
-            DisplayApi.RevertCustomDisplayTrial(displayIds);
-        }
-
-        /// <summary>
-        ///     Saves the custom resolution currently on trial.
-        /// </summary>
-        /// <param name="displayIds">A list of display ids to save the custom resolution for.</param>
-        /// <param name="isThisOutputIdOnly">
-        ///     If set, the saved custom display will only be applied on the monitor with the same
-        ///     outputId.
-        /// </param>
-        /// <param name="isThisMonitorOnly">
-        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
-        ///     ID or the same TV connector in case of analog TV.
-        /// </param>
-        public static void SaveCustomResolution(uint[] displayIds, bool isThisOutputIdOnly, bool isThisMonitorOnly)
-        {
-            DisplayApi.SaveCustomDisplay(displayIds, isThisOutputIdOnly, isThisMonitorOnly);
-        }
-
-        /// <summary>
-        ///     Applies a custom resolution into trial
-        /// </summary>
-        /// <param name="customResolution">The custom resolution to apply.</param>
-        /// <param name="displayIds">A list of display ids to apply the custom resolution on.</param>
-        /// <param name="hardwareModeSetOnly">
-        ///     A boolean value indicating that a hardware mode-set without OS update should be
-        ///     performed.
-        /// </param>
-        public static void TrialCustomResolution(
-            CustomResolution customResolution,
-            uint[] displayIds,
-            bool hardwareModeSetOnly = true)
-        {
-            var customDisplay = customResolution.AsCustomDisplay(hardwareModeSetOnly);
-            DisplayApi.TryCustomDisplay(displayIds.ToDictionary(u => u, u => customDisplay));
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((DisplayDevice) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return (int) DisplayId;
-        }
-
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"Display #{DisplayId}";
-        }
-
-        /// <summary>
-        ///     Calculates a valid timing based on the argument passed
-        /// </summary>
-        /// <param name="width">The preferred width.</param>
-        /// <param name="height">The preferred height.</param>
-        /// <param name="refreshRate">The preferred refresh rate.</param>
-        /// <param name="isInterlaced">The boolean value indicating if the preferred resolution is an interlaced resolution.</param>
-        /// <returns>Returns a valid instance of <see cref="Timing" />.</returns>
-        public Timing CalculateTiming(uint width, uint height, float refreshRate, bool isInterlaced)
-        {
-            return DisplayApi.GetTiming(
-                DisplayId,
-                new TimingInput(width, height, refreshRate, TimingOverride.Auto, isInterlaced)
-            );
-        }
-
-        /// <summary>
-        ///     Deletes a custom resolution.
-        /// </summary>
-        /// <param name="customResolution">The custom resolution to delete.</param>
-        public void DeleteCustomResolution(CustomResolution customResolution)
-        {
-            DeleteCustomResolution(customResolution, new[] {DisplayId});
-        }
-
-        /// <summary>
-        ///     Retrieves the list of custom resolutions saved for this display device
-        /// </summary>
-        /// <returns>A list of <see cref="CustomResolution" /> instances.</returns>
-        public IEnumerable<CustomResolution> GetCustomResolutions()
-        {
-            return DisplayApi.EnumCustomDisplays(DisplayId).Select(custom => new CustomResolution(custom));
-        }
-
-        /// <summary>
-        ///     Checks if a color data is supported on this display
-        /// </summary>
-        /// <param name="colorData">The color data to be checked.</param>
-        /// <returns>true if the color data passed is supported; otherwise false</returns>
-        public bool IsColorDataSupported(ColorData colorData)
-        {
-            var instances = new IColorData[]
-            {
-                colorData.AsColorDataV5(ColorDataCommand.IsSupportedColor),
-                colorData.AsColorDataV4(ColorDataCommand.IsSupportedColor),
-                colorData.AsColorDataV3(ColorDataCommand.IsSupportedColor),
-                colorData.AsColorDataV2(ColorDataCommand.IsSupportedColor),
-                colorData.AsColorDataV1(ColorDataCommand.IsSupportedColor)
-            };
-
-            try
-            {
-                DisplayApi.ColorControl(DisplayId, instances);
-
-                return true;
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status == Status.NotSupported)
-                {
-                    return false;
-                }
-
-                throw;
-            }
-        }
-
-        /// <summary>
-        ///     Resets the HDMI audio info-frame information to default
-        /// </summary>
-        public void ResetHDMIAudioFrameInformation()
-        {
-            var infoFrame = new InfoFrameData(
-                InfoFrameCommand.Reset,
-                InfoFrameDataType.AudioInformation
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Resets the HDMI auxiliary video info-frame information to default
-        /// </summary>
-        public void ResetHDMIVideoFrameInformation()
-        {
-            var infoFrame = new InfoFrameData(
-                InfoFrameCommand.Reset,
-                InfoFrameDataType.AuxiliaryVideoInformation
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Reverts the custom resolution currently on trial.
-        /// </summary>
-        public void RevertCustomResolution()
-        {
-            RevertCustomResolution(new[] {DisplayId});
-        }
-
-        /// <summary>
-        ///     Saves the custom resolution currently on trial.
-        /// </summary>
-        /// <param name="isThisOutputIdOnly">
-        ///     If set, the saved custom display will only be applied on the monitor with the same
-        ///     outputId.
-        /// </param>
-        /// <param name="isThisMonitorOnly">
-        ///     If set, the saved custom display will only be applied on the monitor with the same EDID
-        ///     ID or the same TV connector in case of analog TV.
-        /// </param>
-        public void SaveCustomResolution(bool isThisOutputIdOnly = true, bool isThisMonitorOnly = true)
-        {
-            SaveCustomResolution(new[] {DisplayId}, isThisOutputIdOnly, isThisMonitorOnly);
-        }
-
-        /// <summary>
-        ///     Changes the display current color data configuration
-        /// </summary>
-        /// <param name="colorData">The color data to be set.</param>
-        public void SetColorData(ColorData colorData)
-        {
-            var instances = new IColorData[]
-            {
-                colorData.AsColorDataV5(ColorDataCommand.Set),
-                colorData.AsColorDataV4(ColorDataCommand.Set),
-                colorData.AsColorDataV3(ColorDataCommand.Set),
-                colorData.AsColorDataV2(ColorDataCommand.Set),
-                colorData.AsColorDataV1(ColorDataCommand.Set)
-            };
-
-            DisplayApi.ColorControl(DisplayId, instances);
-        }
-
-        /// <summary>
-        ///     Sets the HDMI video info-frame current or override information
-        /// </summary>
-        /// <param name="audio">The new information.</param>
-        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
-        public void SetHDMIAudioFrameInformation(InfoFrameAudio audio, bool isOverride = false)
-        {
-            var infoFrame = new InfoFrameData(
-                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
-                audio
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Sets the HDMI audio info-frame property information
-        /// </summary>
-        /// <param name="property">The new property information.</param>
-        public void SetHDMIAudioFramePropertyInformation(InfoFrameProperty property)
-        {
-            var infoFrame = new InfoFrameData(
-                InfoFrameCommand.SetProperty,
-                InfoFrameDataType.AudioInformation,
-                property
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Sets the HDMI auxiliary video info-frame current or override information
-        /// </summary>
-        /// <param name="video">The new information.</param>
-        /// <param name="isOverride">A boolean value indicating if the changes should persist mode-set and OS restart.</param>
-        public void SetHDMIVideoFrameInformation(InfoFrameVideo video, bool isOverride = false)
-        {
-            var infoFrame = new InfoFrameData(
-                isOverride ? InfoFrameCommand.SetOverride : InfoFrameCommand.Set,
-                video
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Sets the HDMI auxiliary video info-frame property information
-        /// </summary>
-        /// <param name="property">The new property information.</param>
-        public void SetHDMIVideoFramePropertyInformation(InfoFrameProperty property)
-        {
-            var infoFrame = new InfoFrameData(
-                InfoFrameCommand.SetProperty,
-                InfoFrameDataType.AuxiliaryVideoInformation,
-                property
-            );
-            DisplayApi.InfoFrameControl(DisplayId, ref infoFrame);
-        }
-
-        /// <summary>
-        ///     Changes the display HDR color data configuration
-        /// </summary>
-        /// <param name="colorData">The color data to be set.</param>
-        public void SetHDRColorData(HDRColorData colorData)
-        {
-            var instances = new IHDRColorData[]
-            {
-                colorData.AsHDRColorDataV2(ColorDataHDRCommand.Set),
-                colorData.AsHDRColorDataV1(ColorDataHDRCommand.Set)
-            };
-
-            DisplayApi.HDRColorControl(DisplayId, instances);
-        }
-
-        /// <summary>
-        ///     Applies a custom resolution into trial.
-        /// </summary>
-        /// <param name="customResolution">The custom resolution to apply.</param>
-        /// <param name="hardwareModeSetOnly">
-        ///     A boolean value indicating that a hardware mode-set without OS update should be
-        ///     performed.
-        /// </param>
-        public void TrialCustomResolution(CustomResolution customResolution, bool hardwareModeSetOnly = true)
-        {
-            TrialCustomResolution(customResolution, new[] {DisplayId}, hardwareModeSetOnly);
-        }
-    }
-}

app/NvAPIWrapper/Display/FloatTexture.cs

@@ -1,183 +0,0 @@
-using System;
-using System.Linq;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a texture of float values
-    /// </summary>
-    public class FloatTexture : IEquatable<FloatTexture>
-    {
-        /// <summary>
-        ///     Underlying float array containing the values of all channels in all pixels
-        /// </summary>
-        protected readonly float[] UnderlyingArray;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="FloatTexture" />.
-        /// </summary>
-        /// <param name="width">The texture width.</param>
-        /// <param name="height">The texture height.</param>
-        /// <param name="channels">The number of texture channels.</param>
-        public FloatTexture(int width, int height, int channels) : this(width, height, channels, null)
-        {
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="FloatTexture" />.
-        /// </summary>
-        /// <param name="width">The texture width.</param>
-        /// <param name="height">The texture height.</param>
-        /// <param name="channels">The number of texture channels.</param>
-        /// <param name="array">The underlying array containing all float values.</param>
-        // ReSharper disable once TooManyDependencies
-        protected FloatTexture(int width, int height, int channels, float[] array)
-        {
-            Width = width;
-            Height = height;
-            Channels = channels;
-            UnderlyingArray = array ?? new float[width * height * channels];
-        }
-
-        /// <summary>
-        ///     Gets the number of texture channels
-        /// </summary>
-        public int Channels { get; }
-
-        /// <summary>
-        ///     Gets the texture height in pixel
-        /// </summary>
-        public int Height { get; }
-
-        /// <summary>
-        ///     Gets the texture width in pixels
-        /// </summary>
-        public int Width { get; }
-
-        /// <inheritdoc />
-        public bool Equals(FloatTexture other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            if (other.UnderlyingArray.Length != UnderlyingArray.Length)
-            {
-                return false;
-            }
-
-            if (other.Width != Width || other.Height != Height || other.Channels != Channels)
-            {
-                return false;
-            }
-
-            return !UnderlyingArray.Where((t, i) => Math.Abs(other.UnderlyingArray[i] - t) > 0.0001).Any();
-        }
-
-        /// <summary>
-        ///     Returns a new instance of FloatTexture from the passed array of float values.
-        /// </summary>
-        /// <param name="width">The texture width.</param>
-        /// <param name="height">The texture height.</param>
-        /// <param name="channels">The texture channels.</param>
-        /// <param name="floats">The array of float values.</param>
-        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
-        // ReSharper disable once TooManyArguments
-        public static FloatTexture FromFloatArray(int width, int height, int channels, float[] floats)
-        {
-            if (floats.Length != width * height * channels)
-            {
-                throw new ArgumentOutOfRangeException(nameof(floats));
-            }
-
-            return new FloatTexture(width, height, channels, floats.ToArray());
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="FloatTexture" /> for equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
-        public static bool operator ==(FloatTexture left, FloatTexture right)
-        {
-            return Equals(left, right) || left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="FloatTexture" /> for in-equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
-        public static bool operator !=(FloatTexture left, FloatTexture right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return Equals(obj as FloatTexture);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return UnderlyingArray.GetHashCode();
-        }
-
-        /// <summary>
-        ///     Gets the values of each channel at a specific location
-        /// </summary>
-        /// <param name="x">The horizontal location.</param>
-        /// <param name="y">The vertical location.</param>
-        /// <returns>An array of float values each representing a channel value.</returns>
-        public float[] GetValues(int x, int y)
-        {
-            return UnderlyingArray.Skip(y * Width + x).Take(Channels).ToArray();
-        }
-
-        /// <summary>
-        ///     Sets the value of each channel at a specific location
-        /// </summary>
-        /// <param name="x">The horizontal location.</param>
-        /// <param name="y">The vertical location.</param>
-        /// <param name="floats">An array of float values each representing a channel value.</param>
-        public void SetValues(int x, int y, params float[] floats)
-        {
-            var index = y * Width + x;
-
-            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
-            {
-                UnderlyingArray[index + i] = floats[i];
-            }
-        }
-
-        /// <summary>
-        ///     Returns this instance of <see cref="FloatTexture" /> as an array of float values.
-        /// </summary>
-        /// <returns>An array of float values representing this instance of <see cref="FloatTexture" />.</returns>
-        public float[] ToFloatArray()
-        {
-            // Returns a copy of the underlying array
-            return UnderlyingArray.ToArray();
-        }
-    }
-}

app/NvAPIWrapper/Display/HDRColorData.cs

@@ -1,157 +0,0 @@
-using System;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <inheritdoc cref="IHDRColorData" />
-    public class HDRColorData : IHDRColorData, IEquatable<HDRColorData>
-    {
-        /// <summary>
-        ///     Creates an instance of <see cref="HDRColorData" />.
-        /// </summary>
-        /// <param name="hdrMode">The hdr mode.</param>
-        /// <param name="masteringDisplayData">The display color space configurations.</param>
-        /// <param name="colorFormat">The color data color format.</param>
-        /// <param name="dynamicRange">The color data dynamic range.</param>
-        /// <param name="colorDepth">The color data color depth.</param>
-        public HDRColorData(
-            ColorDataHDRMode hdrMode,
-            MasteringDisplayColorData masteringDisplayData,
-            ColorDataFormat? colorFormat = null,
-            ColorDataDynamicRange? dynamicRange = null,
-            ColorDataDepth? colorDepth = null
-        )
-        {
-            HDRMode = hdrMode;
-            MasteringDisplayData = masteringDisplayData;
-            ColorFormat = colorFormat;
-            DynamicRange = dynamicRange;
-            ColorDepth = colorDepth;
-        }
-
-        internal HDRColorData(IHDRColorData colorData)
-        {
-            HDRMode = colorData.HDRMode;
-            MasteringDisplayData = colorData.MasteringDisplayData;
-            ColorDepth = colorData.ColorDepth;
-            ColorFormat = colorData.ColorFormat;
-            DynamicRange = colorData.DynamicRange;
-        }
-
-        /// <inheritdoc />
-        public bool Equals(HDRColorData other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return ColorDepth == other.ColorDepth &&
-                   ColorFormat == other.ColorFormat &&
-                   DynamicRange == other.DynamicRange &&
-                   HDRMode == other.HDRMode &&
-                   MasteringDisplayData.Equals(other.MasteringDisplayData);
-        }
-
-        /// <inheritdoc />
-        public ColorDataDepth? ColorDepth { get; }
-
-        /// <inheritdoc />
-        public ColorDataFormat? ColorFormat { get; }
-
-        /// <inheritdoc />
-        public ColorDataDynamicRange? DynamicRange { get; }
-
-        /// <inheritdoc />
-        public ColorDataHDRMode HDRMode { get; }
-
-        /// <inheritdoc />
-        public MasteringDisplayColorData MasteringDisplayData { get; }
-
-        /// <summary>
-        ///     Compares two instances of <see cref="HDRColorData" /> for equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns>true if two instances are equal; otherwise false.</returns>
-        public static bool operator ==(HDRColorData left, HDRColorData right)
-        {
-            return left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Compares two instances of <see cref="HDRColorData" /> for inequality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns>true if two instances are not equal; otherwise false.</returns>
-        public static bool operator !=(HDRColorData left, HDRColorData right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((HDRColorData) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = ColorDepth.GetHashCode();
-                hashCode = (hashCode * 397) ^ ColorFormat.GetHashCode();
-                hashCode = (hashCode * 397) ^ DynamicRange.GetHashCode();
-                hashCode = (hashCode * 397) ^ (int) HDRMode;
-                hashCode = (hashCode * 397) ^ MasteringDisplayData.GetHashCode();
-
-                return hashCode;
-            }
-        }
-
-        internal HDRColorDataV1 AsHDRColorDataV1(ColorDataHDRCommand command)
-        {
-            return new HDRColorDataV1(
-                command,
-                HDRMode,
-                MasteringDisplayData
-            );
-        }
-
-        internal HDRColorDataV2 AsHDRColorDataV2(ColorDataHDRCommand command)
-        {
-            return new HDRColorDataV2(
-                command,
-                HDRMode,
-                MasteringDisplayData,
-                ColorFormat ?? ColorDataFormat.Auto,
-                DynamicRange ?? ColorDataDynamicRange.Auto,
-                ColorDepth ?? ColorDataDepth.Default
-            );
-        }
-    }
-}

app/NvAPIWrapper/Display/HUEInformation.cs

@@ -1,97 +0,0 @@
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.GPU;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     This class contains and provides a way to modify the HUE angle
-    /// </summary>
-    public class HUEInformation
-    {
-        private readonly DisplayHandle _displayHandle = DisplayHandle.DefaultHandle;
-        private readonly OutputId _outputId = OutputId.Invalid;
-
-        /// <summary>
-        ///     Creates a new instance of the class using a DisplayHandle
-        /// </summary>
-        /// <param name="displayHandle">The handle of the display.</param>
-        public HUEInformation(DisplayHandle displayHandle)
-        {
-            _displayHandle = displayHandle;
-        }
-
-        /// <summary>
-        ///     Creates a new instance of this class using a OutputId
-        /// </summary>
-        /// <param name="outputId">The output identification of a display or an output</param>
-        public HUEInformation(OutputId outputId)
-        {
-            _outputId = outputId;
-        }
-
-        /// <summary>
-        ///     Gets or sets the current HUE offset angle [0-359]
-        /// </summary>
-        public int CurrentAngle
-        {
-            get
-            {
-                PrivateDisplayHUEInfo? hueInfo = null;
-
-                if (_displayHandle != DisplayHandle.DefaultHandle)
-                {
-                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
-                }
-                else if (_outputId != OutputId.Invalid)
-                {
-                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
-                }
-
-                return hueInfo?.CurrentAngle ?? 0;
-            }
-            set
-            {
-                value %= 360;
-
-                if (_displayHandle != DisplayHandle.DefaultHandle)
-                {
-                    DisplayApi.SetHUEAngle(_displayHandle, value);
-                }
-                else if (_outputId != OutputId.Invalid)
-                {
-                    DisplayApi.SetHUEAngle(_outputId, value);
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the default HUE offset angle [0-359]
-        /// </summary>
-        public int DefaultAngle
-        {
-            get
-            {
-                PrivateDisplayHUEInfo? hueInfo = null;
-
-                if (_displayHandle != DisplayHandle.DefaultHandle)
-                {
-                    hueInfo = DisplayApi.GetHUEInfo(_displayHandle);
-                }
-                else if (_outputId != OutputId.Invalid)
-                {
-                    hueInfo = DisplayApi.GetHUEInfo(_outputId);
-                }
-
-                return hueInfo?.DefaultAngle ?? 0;
-            }
-        }
-
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{CurrentAngle:D}º [{DefaultAngle:D}º]";
-        }
-    }
-}

app/NvAPIWrapper/Display/IntensityTexture.cs

@@ -1,70 +0,0 @@
-using System;
-using System.Linq;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a texture of intensity values
-    /// </summary>
-    public class IntensityTexture : FloatTexture
-    {
-        /// <summary>
-        ///     Creates a new instance of <see cref="IntensityTexture" />.
-        /// </summary>
-        /// <param name="width">The texture width.</param>
-        /// <param name="height">The texture height.</param>
-        public IntensityTexture(int width, int height) : base(width, height, 3)
-        {
-        }
-
-        private IntensityTexture(int width, int height, float[] floats) : base(width, height, 3, floats)
-        {
-        }
-
-        /// <summary>
-        ///     Returns a new instance of FloatTexture from the passed array of float values.
-        /// </summary>
-        /// <param name="width">The texture width.</param>
-        /// <param name="height">The texture height.</param>
-        /// <param name="floats">The array of float values.</param>
-        /// <returns>A new instance of <see cref="FloatTexture" />.</returns>
-        // ReSharper disable once TooManyArguments
-        public static IntensityTexture FromFloatArray(int width, int height, float[] floats)
-        {
-            if (floats.Length != width * height * 3)
-            {
-                throw new ArgumentOutOfRangeException(nameof(floats));
-            }
-
-            return new IntensityTexture(width, height, floats.ToArray());
-        }
-
-        /// <summary>
-        ///     Gets the value of intensity pixel at a specific location.
-        /// </summary>
-        /// <param name="x">The horizontal location.</param>
-        /// <param name="y">The vertical location.</param>
-        /// <returns>An instance of <see cref="IntensityTexturePixel" />.</returns>
-        public IntensityTexturePixel GetPixel(int x, int y)
-        {
-            return IntensityTexturePixel.FromFloatArray(UnderlyingArray, y * Width + x);
-        }
-
-        /// <summary>
-        ///     Sets the value of intensity pixel at a specific location
-        /// </summary>
-        /// <param name="x">The horizontal location.</param>
-        /// <param name="y">The vertical location.</param>
-        /// <param name="pixel">An instance of <see cref="IntensityTexturePixel" />.</param>
-        public void SetPixel(int x, int y, IntensityTexturePixel pixel)
-        {
-            var index = y * Width + x;
-            var floats = pixel.ToFloatArray();
-
-            for (var i = 0; i < Math.Min(Channels, floats.Length); i++)
-            {
-                UnderlyingArray[index + i] = floats[i];
-            }
-        }
-    }
-}

app/NvAPIWrapper/Display/IntensityTexturePixel.cs

@@ -1,117 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a RGB intensity texture pixel
-    /// </summary>
-    public class IntensityTexturePixel : IEquatable<IntensityTexturePixel>
-    {
-        /// <summary>
-        ///     Creates a new instance of <see cref="IntensityTexturePixel" />.
-        /// </summary>
-        /// <param name="redIntensity">The intensity of the red light (0-1)</param>
-        /// <param name="greenIntensity">The intensity of the green light (0-1)</param>
-        /// <param name="blueIntensity">The intensity of the blue light (0-1)</param>
-        public IntensityTexturePixel(float redIntensity, float greenIntensity, float blueIntensity)
-        {
-            RedIntensity = Math.Max(Math.Min(redIntensity, 1), 0);
-            GreenIntensity = Math.Max(Math.Min(greenIntensity, 1), 0);
-            BlueIntensity = Math.Max(Math.Min(blueIntensity, 1), 0);
-        }
-
-        /// <summary>
-        ///     Gets the intensity of the blue light (0-1)
-        /// </summary>
-        public float BlueIntensity { get; }
-
-        /// <summary>
-        ///     Gets the intensity of the green light (0-1)
-        /// </summary>
-        public float GreenIntensity { get; }
-
-        /// <summary>
-        ///     Gets the intensity of the red light (0-1)
-        /// </summary>
-        public float RedIntensity { get; }
-
-        /// <inheritdoc />
-        public bool Equals(IntensityTexturePixel other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Math.Abs(RedIntensity - other.RedIntensity) < 0.0001 &&
-                   Math.Abs(GreenIntensity - other.GreenIntensity) < 0.0001 &&
-                   Math.Abs(BlueIntensity - other.BlueIntensity) < 0.0001;
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
-        public static bool operator ==(IntensityTexturePixel left, IntensityTexturePixel right)
-        {
-            return Equals(left, right) || left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="IntensityTexturePixel" /> for in-equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
-        public static bool operator !=(IntensityTexturePixel left, IntensityTexturePixel right)
-        {
-            return !(left == right);
-        }
-
-        internal static IntensityTexturePixel FromFloatArray(float[] floats, int index)
-        {
-            return new IntensityTexturePixel(floats[index], floats[index + 1], floats[index + 2]);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return Equals(obj as IntensityTexturePixel);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = RedIntensity.GetHashCode();
-                hashCode = (hashCode * 397) ^ GreenIntensity.GetHashCode();
-                hashCode = (hashCode * 397) ^ BlueIntensity.GetHashCode();
-
-                return hashCode;
-            }
-        }
-
-        internal float[] ToFloatArray()
-        {
-            return new[] {RedIntensity, GreenIntensity, BlueIntensity};
-        }
-    }
-}

app/NvAPIWrapper/Display/PathInfo.cs

@@ -1,288 +0,0 @@
-using System;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a configuration path
-    /// </summary>
-    public class PathInfo : IEquatable<PathInfo>
-    {
-        /// <summary>
-        ///     Creates a new PathInfo
-        /// </summary>
-        /// <param name="resolution">Display resolution</param>
-        /// <param name="colorFormat">Display color format</param>
-        /// <param name="targetInfos">Target configuration informations</param>
-        public PathInfo(Resolution resolution, ColorFormat colorFormat, PathTargetInfo[] targetInfos)
-        {
-            Resolution = resolution;
-            ColorFormat = colorFormat;
-            TargetsInfo = targetInfos;
-        }
-
-        /// <summary>
-        ///     Creates a new PathInfo
-        /// </summary>
-        /// <param name="info">IPathInfo implamented object</param>
-        public PathInfo(IPathInfo info)
-        {
-            SourceId = info.SourceId;
-            Resolution = info.SourceModeInfo.Resolution;
-            ColorFormat = info.SourceModeInfo.ColorFormat;
-            Position = info.SourceModeInfo.Position;
-            SpanningOrientation = info.SourceModeInfo.SpanningOrientation;
-            IsGDIPrimary = info.SourceModeInfo.IsGDIPrimary;
-            IsSLIFocus = info.SourceModeInfo.IsSLIFocus;
-            TargetsInfo =
-                info.TargetsInfo.Select(targetInfo => new PathTargetInfo(targetInfo)).ToArray();
-
-            if (info is PathInfoV2)
-            {
-                OSAdapterLUID = ((PathInfoV2) info).OSAdapterLUID;
-            }
-        }
-
-        /// <summary>
-        ///     Gets or sets the display color format
-        /// </summary>
-        public ColorFormat ColorFormat { get; set; }
-
-        /// <summary>
-        ///     Gets or sets a boolean value indicating if the this is the primary GDI display
-        /// </summary>
-        public bool IsGDIPrimary { get; set; }
-
-        /// <summary>
-        ///     Gets or sets a boolean value indicating if the this is the SLI focus display
-        /// </summary>
-        public bool IsSLIFocus { get; set; }
-
-        /// <summary>
-        ///     Gets OS Adapter of LUID for Non-NVIDIA adapters
-        /// </summary>
-        public LUID? OSAdapterLUID { get; }
-
-        /// <summary>
-        ///     Gets or sets the display position
-        /// </summary>
-        public Position Position { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the display resolution
-        /// </summary>
-        public Resolution Resolution { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the Windows CCD display source identification. This can be optionally set.
-        /// </summary>
-        public uint SourceId { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the display spanning orientation, valid for XP only
-        /// </summary>
-        public SpanningOrientation SpanningOrientation { get; set; }
-
-
-        /// <summary>
-        ///     Gets information about path targets
-        /// </summary>
-        public PathTargetInfo[] TargetsInfo { get; }
-
-
-        /// <summary>
-        ///     Checks for equality with a PathInfo instance
-        /// </summary>
-        /// <param name="other">The PathInfo object to check with</param>
-        /// <returns>true if both objects are equal, otherwise false</returns>
-        public bool Equals(PathInfo other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Resolution.Equals(other.Resolution) &&
-                   ColorFormat == other.ColorFormat &&
-                   Position.Equals(other.Position) &&
-                   SpanningOrientation == other.SpanningOrientation &&
-                   IsGDIPrimary == other.IsGDIPrimary &&
-                   IsSLIFocus == other.IsSLIFocus &&
-                   TargetsInfo.SequenceEqual(other.TargetsInfo);
-        }
-
-
-        /// <summary>
-        ///     Creates and fills a PathInfo object
-        /// </summary>
-        /// <returns>The newly created PathInfo object</returns>
-        public static PathInfo[] GetDisplaysConfig()
-        {
-            var configs = DisplayApi.GetDisplayConfig();
-            var logicalDisplays = configs.Select(info => new PathInfo(info)).ToArray();
-            configs.DisposeAll();
-
-            return logicalDisplays;
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(PathInfo left, PathInfo right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(PathInfo left, PathInfo right)
-        {
-            return !(left == right);
-        }
-
-        /// <summary>
-        ///     Applies one or more path information configurations
-        /// </summary>
-        /// <param name="pathInfos">An array of path information configuration</param>
-        /// <param name="flags">DisplayConfigFlags flags</param>
-        public static void SetDisplaysConfig(PathInfo[] pathInfos, DisplayConfigFlags flags)
-        {
-            try
-            {
-                var configsV2 = pathInfos.Select(config => config.GetPathInfoV2()).Cast<IPathInfo>().ToArray();
-                DisplayApi.SetDisplayConfig(configsV2, flags);
-                configsV2.DisposeAll();
-            }
-            catch (NVIDIAApiException ex)
-            {
-                if (ex.Status != Status.IncompatibleStructureVersion)
-                {
-                    throw;
-                }
-            }
-            catch (NVIDIANotSupportedException)
-            {
-                // ignore
-            }
-
-            var configsV1 = pathInfos.Select(config => config.GetPathInfoV1()).Cast<IPathInfo>().ToArray();
-            DisplayApi.SetDisplayConfig(configsV1, flags);
-            configsV1.DisposeAll();
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((PathInfo) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = Resolution.GetHashCode();
-                hashCode = (hashCode * 397) ^ (int) ColorFormat;
-                hashCode = (hashCode * 397) ^ Position.GetHashCode();
-                hashCode = (hashCode * 397) ^ (int) SpanningOrientation;
-                hashCode = (hashCode * 397) ^ IsGDIPrimary.GetHashCode();
-                hashCode = (hashCode * 397) ^ IsSLIFocus.GetHashCode();
-                hashCode = (hashCode * 397) ^ (TargetsInfo?.GetHashCode() ?? 0);
-
-                return hashCode;
-            }
-        }
-
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{Resolution} @ {Position} [{TargetsInfo.Length}]";
-        }
-
-        /// <summary>
-        ///     Creates and fills a GetPathInfoV1 object
-        /// </summary>
-        /// <returns>The newly created GetPathInfoV1 object</returns>
-        public PathInfoV1 GetPathInfoV1()
-        {
-            var sourceModeInfo = GetSourceModeInfo();
-            var pathTargetInfoV1 = GetPathTargetInfoV1Array();
-
-            return new PathInfoV1(pathTargetInfoV1, sourceModeInfo, SourceId);
-        }
-
-        /// <summary>
-        ///     Creates and fills a GetPathInfoV2 object
-        /// </summary>
-        /// <returns>The newly created GetPathInfoV2 object</returns>
-        public PathInfoV2 GetPathInfoV2()
-        {
-            var sourceModeInfo = GetSourceModeInfo();
-            var pathTargetInfoV2 = GetPathTargetInfoV2Array();
-
-            return new PathInfoV2(pathTargetInfoV2, sourceModeInfo, SourceId);
-        }
-
-        /// <summary>
-        ///     Creates and fills an array of GetPathTargetInfoV1 object
-        /// </summary>
-        /// <returns>The newly created array of GetPathTargetInfoV1 objects</returns>
-        public PathTargetInfoV1[] GetPathTargetInfoV1Array()
-        {
-            return TargetsInfo.Select(config => config.GetPathTargetInfoV1()).ToArray();
-        }
-
-        /// <summary>
-        ///     Creates and fills an array of GetPathTargetInfoV2 object
-        /// </summary>
-        /// <returns>The newly created array of GetPathTargetInfoV2 objects</returns>
-        public PathTargetInfoV2[] GetPathTargetInfoV2Array()
-        {
-            return TargetsInfo.Select(config => config.GetPathTargetInfoV2()).ToArray();
-        }
-
-        /// <summary>
-        ///     Creates and fills a SourceModeInfo object
-        /// </summary>
-        /// <returns>The newly created SourceModeInfo object</returns>
-        public SourceModeInfo GetSourceModeInfo()
-        {
-            return new SourceModeInfo(Resolution, ColorFormat, Position, SpanningOrientation, IsGDIPrimary, IsSLIFocus);
-        }
-    }
-}

app/NvAPIWrapper/Display/PathTargetInfo.cs

@@ -1,304 +0,0 @@
-using System;
-using System.Collections.Generic;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.Display;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a display configuration on a path
-    /// </summary>
-    public class PathTargetInfo : IEquatable<PathTargetInfo>
-    {
-        private TimingOverride _timingOverride;
-
-        /// <summary>
-        ///     Creates a new PathTargetInfo
-        /// </summary>
-        /// <param name="info">IPathTargetInfo implamented object</param>
-        public PathTargetInfo(IPathTargetInfo info)
-        {
-            DisplayDevice = new DisplayDevice(info.DisplayId);
-
-            if (info.Details.HasValue)
-            {
-                Rotation = info.Details.Value.Rotation;
-                Scaling = info.Details.Value.Scaling;
-                TVConnectorType = info.Details.Value.ConnectorType;
-                TVFormat = info.Details.Value.TVFormat;
-                RefreshRateInMillihertz = info.Details.Value.RefreshRateInMillihertz;
-                TimingOverride = info.Details.Value.TimingOverride;
-                IsInterlaced = info.Details.Value.IsInterlaced;
-                IsClonePrimary = info.Details.Value.IsClonePrimary;
-                IsClonePanAndScanTarget = info.Details.Value.IsClonePanAndScanTarget;
-                DisableVirtualModeSupport = info.Details.Value.DisableVirtualModeSupport;
-                IsPreferredUnscaledTarget = info.Details.Value.IsPreferredUnscaledTarget;
-            }
-
-            if (info is PathTargetInfoV2)
-            {
-                WindowsCCDTargetId = ((PathTargetInfoV2) info).WindowsCCDTargetId;
-            }
-        }
-
-        /// <summary>
-        ///     Creates a new PathTargetInfo
-        /// </summary>
-        /// <param name="device">DisplayDevice object</param>
-        public PathTargetInfo(DisplayDevice device)
-        {
-            DisplayDevice = device;
-        }
-
-        /// <summary>
-        ///     Gets or sets the virtual mode support
-        /// </summary>
-        public bool DisableVirtualModeSupport { get; set; }
-
-        /// <summary>
-        ///     Gets corresponding DisplayDevice
-        /// </summary>
-        public DisplayDevice DisplayDevice { get; }
-
-        /// <summary>
-        ///     Gets or sets the pan and scan is availability. Valid only when the target is part of clone
-        ///     topology.
-        /// </summary>
-        public bool IsClonePanAndScanTarget { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the primary display in clone configuration. This is *NOT* GDI Primary.
-        ///     Only one target can be primary per source. If no primary is specified, the first target will automatically be
-        ///     primary.
-        /// </summary>
-        public bool IsClonePrimary { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the interlaced mode flag, ignored if refreshRate == 0
-        /// </summary>
-        public bool IsInterlaced { get; set; }
-
-        /// <summary>
-        ///     Gets or sets the preferred unscaled mode of target
-        /// </summary>
-        public bool IsPreferredUnscaledTarget { get; set; }
-
-        /// <summary>
-        ///     Gets and sets the non-interlaced Refresh Rate of the mode, multiplied by 1000, 0 = ignored
-        ///     This is the value which driver reports to the OS.
-        /// </summary>
-        public uint RefreshRateInMillihertz { get; set; }
-
-        /// <summary>
-        ///     Gets and sets the rotation setting
-        /// </summary>
-        public Rotate Rotation { get; set; }
-
-        /// <summary>
-        ///     Gets and sets the scaling setting
-        /// </summary>
-        public Scaling Scaling { get; set; }
-
-        /// <summary>
-        ///     Gets and sets the custom timing of display
-        ///     Ignored if TimingOverride == TimingOverride.Current
-        /// </summary>
-        public TimingOverride TimingOverride
-        {
-            get => _timingOverride;
-            set
-            {
-                if (value == TimingOverride.Custom)
-                {
-                    throw new NVIDIANotSupportedException("Custom timing is not supported yet.");
-                }
-
-                _timingOverride = value;
-            }
-        }
-
-        /// <summary>
-        ///     Gets and sets the connector type. For TV only, ignored if TVFormat == TVFormat.None.
-        /// </summary>
-        public ConnectorType TVConnectorType { get; set; }
-
-        /// <summary>
-        ///     Gets and sets the TV format. For TV only, otherwise set to TVFormat.None
-        /// </summary>
-        public TVFormat TVFormat { get; set; }
-
-        /// <summary>
-        ///     Gets the Windows CCD target ID. Must be present only for non-NVIDIA adapter, for NVIDIA adapter this parameter is
-        ///     ignored.
-        /// </summary>
-        public uint WindowsCCDTargetId { get; }
-
-        /// <summary>
-        ///     Checks for equality with a PathTargetInfo instance
-        /// </summary>
-        /// <param name="other">The PathTargetInfo object to check with</param>
-        /// <returns>true if both objects are equal, otherwise false</returns>
-        public bool Equals(PathTargetInfo other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return _timingOverride == other._timingOverride &&
-                   Rotation == other.Rotation &&
-                   Scaling == other.Scaling &&
-                   RefreshRateInMillihertz == other.RefreshRateInMillihertz &&
-                   (TVFormat == TVFormat.None || TVConnectorType == other.TVConnectorType) &&
-                   TVFormat == other.TVFormat &&
-                   DisplayDevice.Equals(other.DisplayDevice) &&
-                   IsInterlaced == other.IsInterlaced &&
-                   IsClonePrimary == other.IsClonePrimary &&
-                   IsClonePanAndScanTarget == other.IsClonePanAndScanTarget &&
-                   DisableVirtualModeSupport == other.DisableVirtualModeSupport &&
-                   IsPreferredUnscaledTarget == other.IsPreferredUnscaledTarget;
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(PathTargetInfo left, PathTargetInfo right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(PathTargetInfo left, PathTargetInfo right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((PathTargetInfo) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = (int) _timingOverride;
-                hashCode = (hashCode * 397) ^ (int) Rotation;
-                hashCode = (hashCode * 397) ^ (int) Scaling;
-                hashCode = (hashCode * 397) ^ (int) RefreshRateInMillihertz;
-                hashCode = (hashCode * 397) ^ (int) TVFormat;
-                hashCode = (hashCode * 397) ^ (TVFormat != TVFormat.None ? (int) TVConnectorType : 0);
-                hashCode = (hashCode * 397) ^ (DisplayDevice?.GetHashCode() ?? 0);
-                hashCode = (hashCode * 397) ^ IsInterlaced.GetHashCode();
-                hashCode = (hashCode * 397) ^ IsClonePrimary.GetHashCode();
-                hashCode = (hashCode * 397) ^ IsClonePanAndScanTarget.GetHashCode();
-                hashCode = (hashCode * 397) ^ DisableVirtualModeSupport.GetHashCode();
-                hashCode = (hashCode * 397) ^ IsPreferredUnscaledTarget.GetHashCode();
-
-                return hashCode;
-            }
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var strs = new List<string>
-            {
-                DisplayDevice.ToString()
-            };
-
-            if (RefreshRateInMillihertz > 0)
-            {
-                strs.Add($"@ {RefreshRateInMillihertz / 1000}hz");
-            }
-
-            if (TVFormat != TVFormat.None)
-            {
-                strs.Add($"- TV {TVFormat}");
-            }
-
-            strs.Add(IsInterlaced ? "Interlaced" : "Progressive");
-
-            if (Rotation != Rotate.Degree0)
-            {
-                strs.Add($"- Rotation: {Rotation}");
-            }
-
-            return string.Join(" ", strs);
-        }
-
-
-        /// <summary>
-        ///     Creates and fills a PathAdvancedTargetInfo object
-        /// </summary>
-        /// <returns>The newly created PathAdvancedTargetInfo object</returns>
-        public PathAdvancedTargetInfo GetPathAdvancedTargetInfo()
-        {
-            if (TVFormat == TVFormat.None)
-            {
-                return new PathAdvancedTargetInfo(Rotation, Scaling, RefreshRateInMillihertz, TimingOverride,
-                    IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
-                    IsPreferredUnscaledTarget);
-            }
-
-            return new PathAdvancedTargetInfo(Rotation, Scaling, TVFormat, TVConnectorType, RefreshRateInMillihertz,
-                TimingOverride, IsInterlaced, IsClonePrimary, IsClonePanAndScanTarget, DisableVirtualModeSupport,
-                IsPreferredUnscaledTarget);
-        }
-
-        /// <summary>
-        ///     Creates and fills a PathTargetInfoV1 object
-        /// </summary>
-        /// <returns>The newly created PathTargetInfoV1 object</returns>
-        public PathTargetInfoV1 GetPathTargetInfoV1()
-        {
-            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
-
-            return new PathTargetInfoV1(DisplayDevice.DisplayId, pathAdvancedTargetInfo);
-        }
-
-        /// <summary>
-        ///     Creates and fills a PathTargetInfoV2 object
-        /// </summary>
-        /// <returns>The newly created PathTargetInfoV2 object</returns>
-        public PathTargetInfoV2 GetPathTargetInfoV2()
-        {
-            var pathAdvancedTargetInfo = GetPathAdvancedTargetInfo();
-
-            return new PathTargetInfoV2(DisplayDevice.DisplayId, WindowsCCDTargetId, pathAdvancedTargetInfo);
-        }
-    }
-}

app/NvAPIWrapper/Display/ScanOutInformation.cs

@@ -1,218 +0,0 @@
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display;
-using NvAPIWrapper.Native.Display.Structures;
-using NvAPIWrapper.Native.General.Structures;
-using Rectangle = NvAPIWrapper.Native.General.Structures.Rectangle;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Contains information regarding the scan-out buffer settings of a display device
-    /// </summary>
-    public class ScanOutInformation
-    {
-        internal ScanOutInformation(DisplayDevice displayDevice)
-        {
-            DisplayDevice = displayDevice;
-        }
-
-        /// <summary>
-        ///     Gets the clone importance assigned to the target if the target is a cloned view of the SourceDesktopRectangle
-        ///     (0:primary,1 secondary,...).
-        /// </summary>
-        public uint CloneImportance
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).CloneImportance;
-        }
-
-        /// <summary>
-        ///     Gets the display device that this instance describes
-        /// </summary>
-        public DisplayDevice DisplayDevice { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the display device scan out output is warped
-        /// </summary>
-        public bool IsDisplayWarped
-        {
-            get => DisplayApi.GetScanOutWarpingState(DisplayDevice.DisplayId).IsEnabled;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the display device intensity is modified
-        /// </summary>
-        public bool IsIntensityModified
-        {
-            get => DisplayApi.GetScanOutIntensityState(DisplayDevice.DisplayId).IsEnabled;
-        }
-
-        /// <summary>
-        ///     Gets the operating system display device rectangle in desktop coordinates displayId is scanning out from.
-        /// </summary>
-        public Rectangle SourceDesktopRectangle
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceDesktopRectangle;
-        }
-
-        /// <summary>
-        ///     Gets the rotation performed between the SourceViewPortRectangle and the TargetViewPortRectangle.
-        /// </summary>
-        public Rotate SourceToTargetRotation
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceToTargetRotation;
-        }
-
-        /// <summary>
-        ///     Gets the area inside the SourceDesktopRectangle which is scanned out to the display.
-        /// </summary>
-        public Rectangle SourceViewPortRectangle
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).SourceViewPortRectangle;
-        }
-
-        /// <summary>
-        ///     Gets the vertical size of the active resolution scanned out to the display.
-        /// </summary>
-        public uint TargetDisplayHeight
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayHeight;
-        }
-
-        /// <summary>
-        ///     Gets the horizontal size of the active resolution scanned out to the display.
-        /// </summary>
-        public uint TargetDisplayWidth
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetDisplayWidth;
-        }
-
-        /// <summary>
-        ///     Gets the area inside the rectangle described by targetDisplayWidth/Height SourceViewPortRectangle is scanned out
-        ///     to.
-        /// </summary>
-        public Rectangle TargetViewPortRectangle
-        {
-            get => DisplayApi.GetScanOutConfiguration(DisplayDevice.DisplayId).TargetViewPortRectangle;
-        }
-
-        /// <summary>
-        ///     Disables the intensity modification on the display device scan-out buffer.
-        /// </summary>
-        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
-        public void DisableIntensityModifications(out bool isSticky)
-        {
-            DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, null, out isSticky);
-        }
-
-        /// <summary>
-        ///     Disables the warping of display device scan-out buffer.
-        /// </summary>
-        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
-        public void DisableWarping(out bool isSticky)
-        {
-            var vorticesCount = 0;
-            DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, null, ref vorticesCount, out isSticky);
-        }
-
-        /// <summary>
-        ///     Enables the intensity modification on the display device scan-out buffer.
-        /// </summary>
-        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
-        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
-        public void EnableIntensityModifications(IntensityTexture intensityTexture, out bool isSticky)
-        {
-            using (
-                var intensity = new ScanOutIntensityV1(
-                    (uint) intensityTexture.Width,
-                    (uint) intensityTexture.Height,
-                    intensityTexture.ToFloatArray()
-                )
-            )
-            {
-                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
-            }
-        }
-
-        /// <summary>
-        ///     Enables the intensity modification on the display device scan-out buffer.
-        /// </summary>
-        /// <param name="intensityTexture">The intensity texture to apply to the scan-out buffer.</param>
-        /// <param name="offsetTexture">The offset texture to apply to the scan-out buffer.</param>
-        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
-        public void EnableIntensityModifications(
-            IntensityTexture intensityTexture,
-            FloatTexture offsetTexture,
-            out bool isSticky)
-        {
-            using (
-                var intensity = new ScanOutIntensityV2(
-                    (uint) intensityTexture.Width,
-                    (uint) intensityTexture.Height,
-                    intensityTexture.ToFloatArray(),
-                    (uint) offsetTexture.Channels,
-                    offsetTexture.ToFloatArray()
-                )
-            )
-            {
-                DisplayApi.SetScanOutIntensity(DisplayDevice.DisplayId, intensity, out isSticky);
-            }
-        }
-
-        /// <summary>
-        ///     Enables the warping of display device scan-out buffer
-        /// </summary>
-        /// <param name="warpingVerticeFormat">The type of warping vortexes.</param>
-        /// <param name="vortices">An array of warping vortexes.</param>
-        /// <param name="textureRectangle">The rectangle in desktop coordinates describing the source area for the warping.</param>
-        /// <param name="isSticky">A boolean value that indicates whether the settings will be kept over a reboot.</param>
-        // ReSharper disable once TooManyArguments
-        public void EnableWarping(
-            WarpingVerticeFormat warpingVerticeFormat,
-            XYUVRQVortex[] vortices,
-            Rectangle textureRectangle,
-            out bool isSticky)
-        {
-            using (
-                var warping = new ScanOutWarpingV1(
-                    warpingVerticeFormat,
-                    vortices.SelectMany(vortex => vortex.AsFloatArray()).ToArray(),
-                    textureRectangle
-                )
-            )
-            {
-                var vorticesCount = vortices.Length;
-                DisplayApi.SetScanOutWarping(DisplayDevice.DisplayId, warping, ref vorticesCount, out isSticky);
-            }
-        }
-
-        /// <summary>
-        ///     Queries the current state of one of the various scan-out composition parameters.
-        /// </summary>
-        /// <param name="parameter">The scan-out composition parameter.</param>
-        /// <param name="additionalValue">The additional value included with the parameter value.</param>
-        /// <returns>The scan-out composition parameter value.</returns>
-        public ScanOutCompositionParameterValue GetCompositionParameterValue(
-            ScanOutCompositionParameter parameter,
-            out float additionalValue)
-        {
-            return DisplayApi.GetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, out additionalValue);
-        }
-
-
-        /// <summary>
-        ///     Sets the current state of one of the various scan-out composition parameters.
-        /// </summary>
-        /// <param name="parameter">The scan-out composition parameter.</param>
-        /// <param name="parameterValue">The scan-out composition parameter value.</param>
-        /// <param name="additionalValue">The additional value included with the parameter value.</param>
-        public void SetCompositionParameterValue(
-            ScanOutCompositionParameter parameter,
-            ScanOutCompositionParameterValue parameterValue,
-            float additionalValue)
-        {
-            DisplayApi.SetScanOutCompositionParameter(DisplayDevice.DisplayId, parameter, parameterValue,
-                ref additionalValue);
-        }
-    }
-}

app/NvAPIWrapper/Display/UnAttachedDisplay.cs

@@ -1,150 +0,0 @@
-using System;
-using System.Linq;
-using NvAPIWrapper.GPU;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Display.Structures;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents an unattached display
-    /// </summary>
-    public class UnAttachedDisplay : IEquatable<UnAttachedDisplay>
-    {
-        /// <summary>
-        ///     Creates a new UnAttachedDisplay
-        /// </summary>
-        /// <param name="handle">Handle of the unattached display device</param>
-        public UnAttachedDisplay(UnAttachedDisplayHandle handle)
-        {
-            Handle = handle;
-        }
-
-        /// <summary>
-        ///     Creates a new UnAttachedDisplay
-        /// </summary>
-        /// <param name="displayName">Name of the unattached display device</param>
-        public UnAttachedDisplay(string displayName)
-        {
-            Handle = DisplayApi.GetAssociatedUnAttachedNvidiaDisplayHandle(displayName);
-        }
-
-        /// <summary>
-        ///     Gets display handle
-        /// </summary>
-        public UnAttachedDisplayHandle Handle { get; }
-
-        /// <summary>
-        ///     Gets display name
-        /// </summary>
-        public string Name
-        {
-            get => DisplayApi.GetUnAttachedAssociatedDisplayName(Handle);
-        }
-
-        /// <summary>
-        ///     Gets corresponding physical GPU
-        /// </summary>
-        public PhysicalGPU PhysicalGPU
-        {
-            get => new PhysicalGPU(GPUApi.GetPhysicalGPUFromUnAttachedDisplay(Handle));
-        }
-
-        /// <summary>
-        ///     Checks for equality with a UnAttachedDisplay instance
-        /// </summary>
-        /// <param name="other">The Display object to check with</param>
-        /// <returns>true if both objects are equal, otherwise false</returns>
-        public bool Equals(UnAttachedDisplay other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Handle.Equals(other.Handle);
-        }
-
-        /// <summary>
-        ///     This function returns all unattached NVIDIA displays
-        ///     Note: Display handles can get invalidated on a modeset.
-        /// </summary>
-        /// <returns>An array of Display objects</returns>
-        public static UnAttachedDisplay[] GetUnAttachedDisplays()
-        {
-            return
-                DisplayApi.EnumNvidiaUnAttachedDisplayHandle().Select(handle => new UnAttachedDisplay(handle))
-                    .ToArray();
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(UnAttachedDisplay left, UnAttachedDisplay right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(UnAttachedDisplay left, UnAttachedDisplay right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((UnAttachedDisplay) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return Handle.GetHashCode();
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return Name;
-        }
-
-        /// <summary>
-        ///     Creates a new active attached display from this unattached display
-        ///     At least one GPU must be present in the system and running an NVIDIA display driver.
-        /// </summary>
-        /// <returns>An active attached display</returns>
-        public Display CreateDisplay()
-        {
-            return new Display(DisplayApi.CreateDisplayFromUnAttachedDisplay(Handle));
-        }
-    }
-}

app/NvAPIWrapper/Display/XYUVRQVortex.cs

@@ -1,165 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace NvAPIWrapper.Display
-{
-    /// <summary>
-    ///     Represents a XYUVRQ scan-out warping vortex
-    /// </summary>
-    public class XYUVRQVortex : IEquatable<XYUVRQVortex>
-    {
-        /// <summary>
-        ///     Creates a new instance of <see cref="XYUVRQVortex" />.
-        /// </summary>
-        /// <param name="x">The target view port mesh horizontal coordinate</param>
-        /// <param name="y">The target view port mesh vertical coordinate</param>
-        /// <param name="u">The desktop view port texture horizontal coordinate</param>
-        /// <param name="v">The desktop view port texture vertical coordinate</param>
-        /// <param name="r">The 3D warp perspective R factor</param>
-        /// <param name="q">The 3D warp perspective Q factor</param>
-        // ReSharper disable once TooManyDependencies
-        public XYUVRQVortex(int x, int y, int u, int v, float r, float q)
-        {
-            X = x;
-            Y = y;
-            U = u;
-            V = v;
-            R = r;
-            Q = q;
-        }
-
-        /// <summary>
-        ///     3D warp perspective Q factor
-        /// </summary>
-        public float Q { get; }
-
-        /// <summary>
-        ///     3D warp perspective R factor
-        /// </summary>
-        public float R { get; }
-
-        /// <summary>
-        ///     Desktop view port texture horizontal coordinate
-        /// </summary>
-        public int U { get; }
-
-        /// <summary>
-        ///     Desktop view port texture vertical coordinate
-        /// </summary>
-        public int V { get; }
-
-        /// <summary>
-        ///     Target view port mesh horizontal coordinate
-        /// </summary>
-        public int X { get; }
-
-        /// <summary>
-        ///     Target view port mesh vertical coordinate
-        /// </summary>
-        public int Y { get; }
-
-        /// <inheritdoc />
-        public bool Equals(XYUVRQVortex other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Math.Abs(Q - other.Q) < 0.0001 &&
-                   Math.Abs(R - other.R) < 0.0001 &&
-                   U == other.U &&
-                   V == other.V &&
-                   X == other.X &&
-                   Y == other.Y;
-        }
-
-        /// <summary>
-        ///     Parses an array of floats and returns the corresponding <see cref="XYUVRQVortex" />s.
-        /// </summary>
-        /// <param name="floats">The array of float representing one or more <see cref="XYUVRQVortex" />s.</param>
-        /// <returns>Instances of <see cref="XYUVRQVortex" />.</returns>
-        public static IEnumerable<XYUVRQVortex> FromFloatArray(float[] floats)
-        {
-            for (var i = 0; i + 6 <= floats.Length; i += 6)
-            {
-                yield return new XYUVRQVortex(
-                    (int) floats[i],
-                    (int) floats[i + 1],
-                    (int) floats[i + 2],
-                    (int) floats[i + 3],
-                    floats[i + 4],
-                    floats[i + 5]
-                );
-            }
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="XYUVRQVortex" /> for equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are equal, otherwise <see langword="false" /></returns>
-        public static bool operator ==(XYUVRQVortex left, XYUVRQVortex right)
-        {
-            return Equals(left, right) || left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Compares two instance of <see cref="XYUVRQVortex" /> for in-equality.
-        /// </summary>
-        /// <param name="left">The first instance.</param>
-        /// <param name="right">The second instance.</param>
-        /// <returns><see langword="true" /> if both instances are not equal, otherwise <see langword="false" /></returns>
-        public static bool operator !=(XYUVRQVortex left, XYUVRQVortex right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return Equals(obj as XYUVRQVortex);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = Q.GetHashCode();
-                hashCode = (hashCode * 397) ^ R.GetHashCode();
-                hashCode = (hashCode * 397) ^ U;
-                hashCode = (hashCode * 397) ^ V;
-                hashCode = (hashCode * 397) ^ X;
-                hashCode = (hashCode * 397) ^ Y;
-
-                return hashCode;
-            }
-        }
-
-        /// <summary>
-        /// Returns this instance of <see cref="XYUVRQVortex"/> as a float array.
-        /// </summary>
-        /// <returns>An array of float values representing this instance of <see cref="XYUVRQVortex"/>.</returns>
-        public float[] AsFloatArray()
-        {
-            return new[] {X, Y, U, V, R, Q};
-        }
-    }
-}

app/NvAPIWrapper/GPU/AGPInformation.cs

@@ -1,30 +0,0 @@
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the accelerated graphics connection
-    /// </summary>
-    public class AGPInformation
-    {
-        internal AGPInformation(int aperture, int currentRate)
-        {
-            ApertureInMB = aperture;
-            CurrentRate = currentRate;
-        }
-
-        /// <summary>
-        ///     Gets AGP aperture in megabytes
-        /// </summary>
-        public int ApertureInMB { get; }
-
-        /// <summary>
-        ///     Gets current AGP Rate (0 = AGP not present, 1 = 1x, 2 = 2x, etc.)
-        /// </summary>
-        public int CurrentRate { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"AGP Aperture: {ApertureInMB}MB, Current Rate: {CurrentRate}x";
-        }
-    }
-}

app/NvAPIWrapper/GPU/ECCMemoryInformation.cs

@@ -1,201 +0,0 @@
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the ECC memory
-    /// </summary>
-    public class ECCMemoryInformation
-    {
-        internal ECCMemoryInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the number of aggregated ECC memory double bit errors
-        /// </summary>
-        public ulong AggregatedDoubleBitErrors
-        {
-            get
-            {
-                if (!IsSupported || !IsEnabled)
-                {
-                    return 0;
-                }
-
-                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.DoubleBitErrors;
-            }
-        }
-
-
-        /// <summary>
-        ///     Gets the number of aggregated ECC memory single bit errors
-        /// </summary>
-        public ulong AggregatedSingleBitErrors
-        {
-            get
-            {
-                if (!IsSupported || !IsEnabled)
-                {
-                    return 0;
-                }
-
-                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).AggregatedErrors.SingleBitErrors;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the ECC memory configuration in regard to how changes are applied
-        /// </summary>
-        public ECCConfiguration Configuration
-        {
-            get
-            {
-                try
-                {
-                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).ConfigurationOptions;
-                }
-                catch
-                {
-                    return ECCConfiguration.NotSupported;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the number of current ECC memory double bit errors
-        /// </summary>
-        public ulong CurrentDoubleBitErrors
-        {
-            get
-            {
-                if (!IsSupported || !IsEnabled)
-                {
-                    return 0;
-                }
-
-                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.DoubleBitErrors;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the number of current ECC memory single bit errors
-        /// </summary>
-        public ulong CurrentSingleBitErrors
-        {
-            get
-            {
-                if (!IsSupported || !IsEnabled)
-                {
-                    return 0;
-                }
-
-                return GPUApi.GetECCErrorInfo(PhysicalGPU.Handle).CurrentErrors.SingleBitErrors;
-            }
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if ECC memory error correction is enabled
-        /// </summary>
-
-        public bool IsEnabled
-        {
-            get => IsSupported &&
-                   GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsEnabled &&
-                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabled;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if ECC memory is enabled by default
-        /// </summary>
-        public bool IsEnabledByDefault
-        {
-            get => IsSupported &&
-                   GPUApi.GetECCConfigurationInfo(PhysicalGPU.Handle).IsEnabledByDefault;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if ECC memory is supported and available
-        /// </summary>
-        public bool IsSupported
-        {
-            get
-            {
-                try
-                {
-                    return GPUApi.GetECCStatusInfo(PhysicalGPU.Handle).IsSupported;
-                }
-                catch
-                {
-                    return false;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (!IsSupported)
-            {
-                return "[Not Supported]";
-            }
-
-            if (!IsEnabled)
-            {
-                return "[Disabled]";
-            }
-
-            return
-                $"{CurrentSingleBitErrors}, {CurrentDoubleBitErrors} ({AggregatedSingleBitErrors}, {AggregatedDoubleBitErrors})";
-        }
-
-        /// <summary>
-        ///     Clears aggregated error counters.
-        /// </summary>
-        public void ClearAggregatedErrors()
-        {
-            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, false, true);
-        }
-
-        /// <summary>
-        ///     Clears current error counters.
-        /// </summary>
-        public void ClearCurrentErrors()
-        {
-            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, false);
-        }
-
-        /// <summary>
-        ///     Clears all error counters.
-        /// </summary>
-        public void ClearErrors()
-        {
-            GPUApi.ResetECCErrorInfo(PhysicalGPU.Handle, true, true);
-        }
-
-        /// <summary>
-        ///     Disables ECC memory error correction.
-        /// </summary>
-        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
-        public void Disable(bool immediate)
-        {
-            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, false, immediate);
-        }
-
-        /// <summary>
-        ///     Enables ECC memory error correction.
-        /// </summary>
-        /// <param name="immediate">A boolean value to indicate if this change should get applied immediately</param>
-        public void Enable(bool immediate)
-        {
-            GPUApi.SetECCConfiguration(PhysicalGPU.Handle, true, immediate);
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUArchitectInformation.cs

@@ -1,115 +0,0 @@
-using NvAPIWrapper.Native;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains physical GPU architect information
-    /// </summary>
-    public class GPUArchitectInformation
-    {
-        internal GPUArchitectInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets total number of cores defined for this GPU, or zero for older architectures
-        /// </summary>
-        public int NumberOfCores
-        {
-            get => (int) GPUApi.GetGPUCoreCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the number of graphics processing clusters (aka GPU Partitions)
-        /// </summary>
-        public int NumberOfGPC
-        {
-            get => (int) GPUApi.GetPartitionCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the number of render output units
-        /// </summary>
-        public int NumberOfROPs
-        {
-            get => (int) GPUApi.GetROPCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the number of shader pipelines
-        /// </summary>
-        public int NumberOfShaderPipelines
-        {
-            get => (int) GPUApi.GetShaderPipeCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the number of shader sub pipelines
-        /// </summary>
-        public int NumberOfShaderSubPipelines
-        {
-            get => (int) GPUApi.GetShaderSubPipeCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the number of video processing engines
-        /// </summary>
-        public int NumberOfVPEs
-        {
-            get => (int) GPUApi.GetVPECount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets the GPU revision number (should be displayed as a hex string)
-        /// </summary>
-        public int Revision
-        {
-            get => (int) GPUApi.GetArchitectInfo(PhysicalGPU.Handle).Revision;
-        }
-
-        /// <summary>
-        ///     Gets the GPU short name (aka Codename)
-        /// </summary>
-        public string ShortName
-        {
-            get => GPUApi.GetShortName(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the total number of streaming multiprocessors
-        /// </summary>
-        public int TotalNumberOfSMs
-        {
-            get => (int) GPUApi.GetTotalSMCount(PhysicalGPU.Handle);
-        }
-
-
-        /// <summary>
-        ///     Gets the total number of streaming processors
-        /// </summary>
-        public int TotalNumberOfSPs
-        {
-            get => (int) GPUApi.GetTotalSPCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the total number of texture processing clusters
-        /// </summary>
-        public int TotalNumberOfTPCs
-        {
-            get => (int) GPUApi.GetTotalTPCCount(PhysicalGPU.Handle);
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"[{ShortName} REV{Revision:X}] Cores: {NumberOfCores}";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUBusInformation.cs

@@ -1,118 +0,0 @@
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the GPU bus
-    /// </summary>
-    public class GPUBusInformation
-    {
-        internal GPUBusInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets accelerated graphics port information
-        /// </summary>
-        public AGPInformation AGPInformation
-        {
-            get
-            {
-                if (BusType != GPUBusType.AGP)
-                {
-                    return null;
-                }
-
-                return new AGPInformation(
-                    GPUApi.GetAGPAperture(PhysicalGPU.Handle),
-                    GPUApi.GetCurrentAGPRate(PhysicalGPU.Handle)
-                );
-            }
-        }
-
-        /// <summary>
-        ///     Gets the bus identification
-        /// </summary>
-        public int BusId
-        {
-            get => GPUApi.GetBusId(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the bus slot identification
-        /// </summary>
-        public int BusSlot
-        {
-            get => GPUApi.GetBusSlotId(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the the bus type
-        /// </summary>
-        public GPUBusType BusType
-        {
-            get => GPUApi.GetBusType(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets number of PCIe lanes being used for the PCIe interface downstream
-        /// </summary>
-        public int CurrentPCIeLanes
-        {
-            get
-            {
-                if (BusType == GPUBusType.PCIExpress)
-                {
-                    return GPUApi.GetCurrentPCIEDownStreamWidth(PhysicalGPU.Handle);
-                }
-
-                return 0;
-            }
-        }
-
-        /// <summary>
-        ///     Gets GPU interrupt number
-        /// </summary>
-        public int IRQ
-        {
-            get => GPUApi.GetIRQ(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the PCI identifiers
-        /// </summary>
-        public PCIIdentifiers PCIIdentifiers
-        {
-            get
-            {
-                if (BusType == GPUBusType.FPCI || BusType == GPUBusType.PCI || BusType == GPUBusType.PCIExpress)
-                {
-                    GPUApi.GetPCIIdentifiers(
-                        PhysicalGPU.Handle,
-                        out var deviceId,
-                        out var subSystemId,
-                        out var revisionId,
-                        out var extDeviceId
-                    );
-
-                    return new PCIIdentifiers(deviceId, subSystemId, revisionId, (int) extDeviceId);
-                }
-
-                return null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"[{BusType}] Bus #{BusId}, Slot #{BusSlot}";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUCooler.cs

@@ -1,130 +0,0 @@
-using System;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding a GPU cooler entry
-    /// </summary>
-    public class GPUCooler
-    {
-        internal GPUCooler(int coolerId, PrivateCoolerSettingsV1.CoolerSetting coolerSetting, int currentRPM = -1)
-        {
-            CoolerId = coolerId;
-            CurrentLevel = (int) coolerSetting.CurrentLevel;
-            DefaultMinimumLevel = (int) coolerSetting.DefaultMinimumLevel;
-            DefaultMaximumLevel = (int) coolerSetting.DefaultMaximumLevel;
-            CurrentMinimumLevel = (int) coolerSetting.CurrentMinimumLevel;
-            CurrentMaximumLevel = (int) coolerSetting.CurrentMaximumLevel;
-            CoolerType = coolerSetting.CoolerType;
-            CoolerController = coolerSetting.CoolerController;
-            DefaultPolicy = coolerSetting.DefaultPolicy;
-            CurrentPolicy = coolerSetting.CurrentPolicy;
-            Target = coolerSetting.Target;
-            ControlMode = coolerSetting.ControlMode;
-            CurrentFanSpeedInRPM = currentRPM;
-        }
-
-        // ReSharper disable once TooManyDependencies
-        internal GPUCooler(
-            PrivateFanCoolersInfoV1.FanCoolersInfoEntry infoEntry,
-            PrivateFanCoolersStatusV1.FanCoolersStatusEntry statusEntry,
-            PrivateFanCoolersControlV1.FanCoolersControlEntry controlEntry)
-        {
-            if (infoEntry.CoolerId != statusEntry.CoolerId || statusEntry.CoolerId != controlEntry.CoolerId)
-            {
-                throw new ArgumentException("Passed arguments are meant to be for different coolers.");
-            }
-
-            CoolerId = (int) statusEntry.CoolerId;
-            CurrentLevel = (int) statusEntry.CurrentLevel;
-            DefaultMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
-            DefaultMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
-            CurrentMinimumLevel = (int) statusEntry.CurrentMinimumLevel;
-            CurrentMaximumLevel = (int) statusEntry.CurrentMaximumLevel;
-            CoolerType = CoolerType.Fan;
-            CoolerController = CoolerController.Internal;
-            DefaultPolicy = CoolerPolicy.None;
-            CurrentPolicy = controlEntry.ControlMode == FanCoolersControlMode.Manual
-                ? CoolerPolicy.Manual
-                : CoolerPolicy.None;
-            Target = CoolerTarget.All;
-            ControlMode = CoolerControlMode.Variable;
-            CurrentFanSpeedInRPM = (int) statusEntry.CurrentRPM;
-        }
-
-        /// <summary>
-        ///     Gets the cooler control mode
-        /// </summary>
-        public CoolerControlMode ControlMode { get; }
-
-        /// <summary>
-        ///     Gets the cooler controller
-        /// </summary>
-        public CoolerController CoolerController { get; }
-
-        /// <summary>
-        ///     Gets the cooler identification number or index
-        /// </summary>
-        public int CoolerId { get; }
-
-        /// <summary>
-        ///     Gets the cooler type
-        /// </summary>
-        public CoolerType CoolerType { get; }
-
-        /// <summary>
-        ///     Gets the GPU fan speed in revolutions per minute
-        /// </summary>
-        public int CurrentFanSpeedInRPM { get; }
-
-        /// <summary>
-        ///     Gets the cooler current level in percentage
-        /// </summary>
-        public int CurrentLevel { get; }
-
-
-        /// <summary>
-        ///     Gets the cooler current maximum level in percentage
-        /// </summary>
-        public int CurrentMaximumLevel { get; }
-
-
-        /// <summary>
-        ///     Gets the cooler current minimum level in percentage
-        /// </summary>
-        public int CurrentMinimumLevel { get; }
-
-        /// <summary>
-        ///     Gets the cooler current policy
-        /// </summary>
-        public CoolerPolicy CurrentPolicy { get; }
-
-        /// <summary>
-        ///     Gets the cooler default maximum level in percentage
-        /// </summary>
-        public int DefaultMaximumLevel { get; }
-
-        /// <summary>
-        ///     Gets the cooler default minimum level in percentage
-        /// </summary>
-        public int DefaultMinimumLevel { get; }
-
-        /// <summary>
-        ///     Gets the cooler default policy
-        /// </summary>
-        public CoolerPolicy DefaultPolicy { get; }
-
-        /// <summary>
-        ///     Gets the cooler target
-        /// </summary>
-        public CoolerTarget Target { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"[{CoolerId} @ {CoolerController}] {Target}: {CurrentLevel}%";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUCoolerInformation.cs

@@ -1,340 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the GPU coolers and current fan speed
-    /// </summary>
-    public class GPUCoolerInformation
-    {
-        internal GPUCoolerInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-
-            // TODO: Add Support For Pascal Only Policy Table Method
-            // TODO: GPUApi.GetCoolerPolicyTable & GPUApi.SetCoolerPolicyTable & GPUApi.RestoreCoolerPolicyTable
-            // TODO: Better support of ClientFanCoolers set of APIs
-        }
-
-        /// <summary>
-        ///     Gets a list of all available coolers along with their current settings and status
-        /// </summary>
-        public IEnumerable<GPUCooler> Coolers
-        {
-            get
-            {
-                PrivateCoolerSettingsV1? settings = null;
-
-                try
-                {
-                    settings = GPUApi.GetCoolerSettings(PhysicalGPU.Handle);
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status != Status.NotSupported)
-                    {
-                        throw;
-                    }
-                }
-
-                if (settings != null)
-                {
-                    for (var i = 0; i < settings.Value.CoolerSettings.Length; i++)
-                    {
-                        if (i == 0)
-                        {
-                            var currentRPM = -1;
-                            try
-                            {
-                                currentRPM = (int)GPUApi.GetTachReading(PhysicalGPU.Handle);
-                            }
-                            catch (NVIDIAApiException)
-                            {
-                                // ignored
-                            }
-
-                            if (currentRPM >= 0)
-                            {
-                                yield return new GPUCooler(
-                                    i,
-                                    settings.Value.CoolerSettings[i],
-                                    currentRPM
-                                );
-                                continue;
-                            }
-                        }
-
-                        yield return new GPUCooler(
-                            i,
-                            settings.Value.CoolerSettings[i]
-                        );
-                    }
-
-                    yield break;
-                }
-
-                PrivateFanCoolersStatusV1? status = null;
-                PrivateFanCoolersInfoV1? info = null;
-                PrivateFanCoolersControlV1? control = null;
-
-                try
-                {
-                    status = GPUApi.GetClientFanCoolersStatus(PhysicalGPU.Handle);
-                    info = GPUApi.GetClientFanCoolersInfo(PhysicalGPU.Handle);
-                    control = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
-                }
-                catch (NVIDIAApiException e)
-                {
-                    if (e.Status != Status.NotSupported)
-                    {
-                        throw;
-                    }
-                }
-
-                if (status != null && info != null && control != null)
-                {
-                    for (var i = 0; i < status.Value.FanCoolersStatusEntries.Length; i++)
-                    {
-                        if (info.Value.FanCoolersInfoEntries.Length > i &&
-                            control.Value.FanCoolersControlEntries.Length > i)
-                        {
-                            yield return new GPUCooler(
-                                info.Value.FanCoolersInfoEntries[i],
-                                status.Value.FanCoolersStatusEntries[i],
-                                control.Value.FanCoolersControlEntries[i]
-                            );
-                        }
-                    }
-
-                    yield break;
-                }
-
-                throw new NVIDIAApiException(Status.NotSupported);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the GPU fan speed in revolutions per minute
-        /// </summary>
-        public int CurrentFanSpeedInRPM
-        {
-            get
-            {
-                try
-                {
-                    return (int) GPUApi.GetTachReading(PhysicalGPU.Handle);
-                }
-                catch
-                {
-                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentFanSpeedInRPM ??
-                           0;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the current fan speed in percentage if available
-        /// </summary>
-        public int CurrentFanSpeedLevel
-        {
-            get
-            {
-                try
-                {
-                    return (int) GPUApi.GetCurrentFanSpeedLevel(PhysicalGPU.Handle);
-                }
-                catch
-                {
-                    return Coolers.FirstOrDefault(cooler => cooler.Target == CoolerTarget.All)?.CurrentLevel ?? 0;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{CurrentFanSpeedInRPM} RPM ({CurrentFanSpeedLevel}%)";
-        }
-
-        /// <summary>
-        ///     Resets all cooler settings to default.
-        /// </summary>
-        public void RestoreCoolerSettingsToDefault()
-        {
-            RestoreCoolerSettingsToDefault(Coolers.Select(cooler => cooler.CoolerId).ToArray());
-        }
-
-        /// <summary>
-        ///     Resets one or more cooler settings to default.
-        /// </summary>
-        /// <param name="coolerIds">The cooler identification numbers (indexes) to reset their settings to default.</param>
-        public void RestoreCoolerSettingsToDefault(params int[] coolerIds)
-        {
-            var availableCoolerIds = Coolers.Select(cooler => cooler.CoolerId).ToArray();
-
-            if (coolerIds.Any(i => !availableCoolerIds.Contains(i)))
-            {
-                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerIds));
-            }
-
-            try
-            {
-                GPUApi.RestoreCoolerSettings(PhysicalGPU.Handle, coolerIds.Select(i => (uint) i).ToArray());
-
-                return;
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status != Status.NotSupported)
-                {
-                    throw;
-                }
-            }
-
-            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
-            var newControl = new PrivateFanCoolersControlV1(
-                currentControl.FanCoolersControlEntries.Select(
-                        entry => coolerIds.Contains((int) entry.CoolerId)
-                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
-                                entry.CoolerId,
-                                FanCoolersControlMode.Auto
-                            )
-                            : entry
-                    )
-                    .ToArray(),
-                currentControl.UnknownUInt
-            );
-            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
-        }
-
-        /// <summary>
-        ///     Changes a cooler settings by modifying the policy and the current level
-        /// </summary>
-        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
-        /// <param name="policy">The new cooler policy.</param>
-        /// <param name="newLevel">The new cooler level. Valid only if policy is set to manual.</param>
-        // ReSharper disable once TooManyDeclarations
-        public void SetCoolerSettings(int coolerId, CoolerPolicy policy, int newLevel)
-        {
-            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
-            {
-                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
-            }
-
-            try
-            {
-                GPUApi.SetCoolerLevels(
-                    PhysicalGPU.Handle,
-                    (uint) coolerId,
-                    new PrivateCoolerLevelsV1(new[]
-                        {
-                            new PrivateCoolerLevelsV1.CoolerLevel(policy, (uint) newLevel)
-                        }
-                    ),
-                    1
-                );
-
-                return;
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status != Status.NotSupported)
-                {
-                    throw;
-                }
-            }
-
-            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
-            var newControl = new PrivateFanCoolersControlV1(
-                currentControl.FanCoolersControlEntries.Select(
-                        entry => entry.CoolerId == coolerId
-                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
-                                entry.CoolerId,
-                                policy == CoolerPolicy.Manual
-                                    ? FanCoolersControlMode.Manual
-                                    : FanCoolersControlMode.Auto,
-                                policy == CoolerPolicy.Manual ? (uint)newLevel : 0u)
-                            : entry
-                    )
-                    .ToArray(),
-                currentControl.UnknownUInt
-            );
-            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
-        }
-
-        /// <summary>
-        ///     Changes a cooler setting by modifying the policy
-        /// </summary>
-        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
-        /// <param name="policy">The new cooler policy.</param>
-        // ReSharper disable once TooManyDeclarations
-        public void SetCoolerSettings(int coolerId, CoolerPolicy policy)
-        {
-            if (Coolers.All(cooler => cooler.CoolerId != coolerId))
-            {
-                throw new ArgumentException("Invalid cooler identification number provided.", nameof(coolerId));
-            }
-
-            try
-            {
-                GPUApi.SetCoolerLevels(
-                    PhysicalGPU.Handle,
-                    (uint) coolerId,
-                    new PrivateCoolerLevelsV1(new[]
-                        {
-                            new PrivateCoolerLevelsV1.CoolerLevel(policy)
-                        }
-                    ),
-                    1
-                );
-
-                return;
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status != Status.NotSupported)
-                {
-                    throw;
-                }
-            }
-
-            var currentControl = GPUApi.GetClientFanCoolersControl(PhysicalGPU.Handle);
-            var newControl = new PrivateFanCoolersControlV1(
-                currentControl.FanCoolersControlEntries.Select(
-                        entry => entry.CoolerId == coolerId
-                            ? new PrivateFanCoolersControlV1.FanCoolersControlEntry(
-                                entry.CoolerId,
-                                policy == CoolerPolicy.Manual
-                                    ? FanCoolersControlMode.Manual
-                                    : FanCoolersControlMode.Auto)
-                            : entry
-                    )
-                    .ToArray(),
-                currentControl.UnknownUInt
-            );
-            GPUApi.SetClientFanCoolersControl(PhysicalGPU.Handle, newControl);
-        }
-
-        /// <summary>
-        ///     Changes a cooler settings by modifying the policy to manual and sets a new level
-        /// </summary>
-        /// <param name="coolerId">The cooler identification number (index) to change the settings.</param>
-        /// <param name="newLevel">The new cooler level.</param>
-        public void SetCoolerSettings(int coolerId, int newLevel)
-        {
-            SetCoolerSettings(coolerId, CoolerPolicy.Manual, newLevel);
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUMemoryInformation.cs

@@ -1,222 +0,0 @@
-using System;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information regarding the available and total memory as well as the type of memory and other information
-    ///     regarding the GPU RAM and frame buffer
-    /// </summary>
-    public class GPUMemoryInformation : IDisplayDriverMemoryInfo
-    {
-        internal GPUMemoryInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the frame buffer bandwidth
-        /// </summary>
-
-        public int FrameBufferBandwidth
-        {
-            get
-            {
-                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out var width, out _);
-
-                return (int) width;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the frame buffer location index
-        /// </summary>
-        public int FrameBufferLocation
-        {
-            get
-            {
-                GPUApi.GetFrameBufferWidthAndLocation(PhysicalGPU.Handle, out _, out var location);
-
-                return (int) location;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the internal clock to bus clock factor based on the type of RAM
-        /// </summary>
-        public int InternalClockToBusClockFactor
-        {
-            get => GetMemoryBusClockFactor(RAMType);
-        }
-
-        /// <summary>
-        ///     Gets the internal clock to transfer rate factor based on the type of RAM
-        /// </summary>
-        public int InternalClockToTransferRateFactor
-        {
-            get => GetMemoryTransferRateFactor(RAMType);
-        }
-
-        /// <summary>
-        ///     Gets GPU physical frame buffer size in KB. This does NOT include any system RAM that may be dedicated for use by
-        ///     the GPU.
-        /// </summary>
-        public int PhysicalFrameBufferSizeInkB
-        {
-            get => GPUApi.GetPhysicalFrameBufferSize(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets the number of memory banks
-        /// </summary>
-        public uint RAMBanks
-        {
-            get => GPUApi.GetRAMBankCount(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the memory bus width
-        /// </summary>
-        public uint RAMBusWidth
-        {
-            get => GPUApi.GetRAMBusWidth(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the memory maker (brand)
-        /// </summary>
-        public GPUMemoryMaker RAMMaker
-        {
-            get => GPUApi.GetRAMMaker(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the memory type
-        /// </summary>
-        public GPUMemoryType RAMType
-        {
-            get => GPUApi.GetRAMType(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets virtual size of frame-buffer in KB for this GPU. This includes the physical RAM plus any system RAM that has
-        ///     been dedicated for use by the GPU.
-        /// </summary>
-        public int VirtualFrameBufferSizeInkB
-        {
-            get => GPUApi.GetVirtualFrameBufferSize(PhysicalGPU.Handle);
-        }
-
-        /// <inheritdoc />
-        public uint AvailableDedicatedVideoMemoryInkB
-        {
-            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).AvailableDedicatedVideoMemoryInkB;
-        }
-
-        /// <inheritdoc />
-        public uint CurrentAvailableDedicatedVideoMemoryInkB
-        {
-            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).CurrentAvailableDedicatedVideoMemoryInkB;
-        }
-
-        /// <inheritdoc />
-        public uint DedicatedVideoMemoryInkB
-        {
-            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).DedicatedVideoMemoryInkB;
-        }
-
-        /// <inheritdoc />
-        public uint SharedSystemMemoryInkB
-        {
-            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SharedSystemMemoryInkB;
-        }
-
-        /// <inheritdoc />
-        public uint SystemVideoMemoryInkB
-        {
-            get => GPUApi.GetMemoryInfo(PhysicalGPU.Handle).SystemVideoMemoryInkB;
-        }
-
-        /// <summary>
-        ///     Gets the memory bus clock to internal memory clock factor
-        /// </summary>
-        /// <param name="memoryType"></param>
-        /// <returns>The value of X in X(InternalMemoryClock)=(BusMemoryClock)</returns>
-        public static int GetMemoryBusClockFactor(GPUMemoryType memoryType)
-        {
-            switch (memoryType)
-            {
-                case GPUMemoryType.SDRAM:
-
-                    // Bus Clocks Per Internal Clock = 1
-                    return 1;
-                case GPUMemoryType.DDR1:
-                case GPUMemoryType.DDR2:
-                case GPUMemoryType.DDR3:
-                case GPUMemoryType.GDDR2:
-                case GPUMemoryType.GDDR3:
-                case GPUMemoryType.GDDR4:
-                case GPUMemoryType.LPDDR2:
-                case GPUMemoryType.GDDR5:
-                case GPUMemoryType.GDDR5X:
-
-                    // Bus Clocks Per Internal Clock = 2
-                    return 2;
-                default:
-
-                    throw new ArgumentOutOfRangeException(nameof(memoryType));
-            }
-        }
-
-        /// <summary>
-        ///     Gets the number of transfers per internal memory clock factor
-        /// </summary>
-        /// <param name="memoryType"></param>
-        /// <returns>The value of X in X(InternalMemoryClock)=(OperationsPerSecond)</returns>
-        public static int GetMemoryTransferRateFactor(GPUMemoryType memoryType)
-        {
-            switch (memoryType)
-            {
-                case GPUMemoryType.SDRAM:
-
-                    // Transfers Per Internal Clock = 1
-                    return 1;
-                case GPUMemoryType.DDR1:
-                case GPUMemoryType.DDR2:
-                case GPUMemoryType.DDR3:
-                case GPUMemoryType.GDDR2:
-                case GPUMemoryType.GDDR3:
-                case GPUMemoryType.GDDR4:
-                case GPUMemoryType.LPDDR2:
-
-                    // Transfers Per Internal Clock = 1
-                    return 2;
-                case GPUMemoryType.GDDR5:
-
-                    // Transfers Per Internal Clock = 2
-                    return 4;
-                case GPUMemoryType.GDDR5X:
-
-                    // Transfers Per Internal Clock = 4
-                    return 8;
-                default:
-
-                    throw new ArgumentOutOfRangeException(nameof(memoryType));
-            }
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"[{RAMMaker} {RAMType}] Total: {AvailableDedicatedVideoMemoryInkB:N0} kB - Available: {CurrentAvailableDedicatedVideoMemoryInkB:N0} kB";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUOutput.cs

@@ -1,264 +0,0 @@
-using System;
-using NvAPIWrapper.Display;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a single GPU output
-    /// </summary>
-    public class GPUOutput : IEquatable<GPUOutput>
-    {
-        internal GPUOutput(OutputId outputId, PhysicalGPUHandle gpuHandle)
-        {
-            OutputId = outputId;
-            OutputType = !gpuHandle.IsNull ? GPUApi.GetOutputType(gpuHandle, outputId) : OutputType.Unknown;
-            PhysicalGPU = new PhysicalGPU(gpuHandle);
-        }
-
-        internal GPUOutput(OutputId outputId, PhysicalGPU gpu)
-            : this(outputId, gpu?.Handle ?? PhysicalGPUHandle.DefaultHandle)
-        {
-            PhysicalGPU = gpu;
-        }
-
-        /// <summary>
-        ///     Gets the corresponding Digital Vibrance Control information
-        /// </summary>
-        public DVCInformation DigitalVibranceControl
-        {
-            get => new DVCInformation(OutputId);
-        }
-
-        /// <summary>
-        ///     Gets the corresponding HUE information
-        /// </summary>
-        public HUEInformation HUEControl
-        {
-            get => new HUEInformation(OutputId);
-        }
-
-        /// <summary>
-        ///     Gets the output identification as a single bit unsigned integer
-        /// </summary>
-        public OutputId OutputId { get; }
-
-        /// <summary>
-        ///     Gets the output type
-        /// </summary>
-        public OutputType OutputType { get; }
-
-        /// <summary>
-        ///     Gets the corresponding physical GPU
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <inheritdoc />
-        public bool Equals(GPUOutput other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return PhysicalGPU.Equals(other.PhysicalGPU) && OutputId == other.OutputId;
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(GPUOutput left, GPUOutput right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(GPUOutput left, GPUOutput right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((GPUOutput) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                return ((PhysicalGPU != null ? PhysicalGPU.GetHashCode() : 0) * 397) ^ (int) OutputId;
-            }
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{OutputId} {OutputType} @ {PhysicalGPU}";
-        }
-
-        /// <summary>
-        ///     Overrides the refresh rate on this output.
-        ///     The new refresh rate can be applied right away or deferred to be applied with the next OS
-        ///     mode-set.
-        ///     The override is good for only one mode-set (regardless whether it's deferred or immediate).
-        /// </summary>
-        /// <param name="refreshRate">The refresh rate to be applied.</param>
-        /// <param name="isDeferred">
-        ///     A boolean value indicating if the refresh rate override should be deferred to the next OS
-        ///     mode-set.
-        /// </param>
-        public void OverrideRefreshRate(float refreshRate, bool isDeferred = false)
-        {
-            DisplayApi.SetRefreshRateOverride(OutputId, refreshRate, isDeferred);
-        }
-
-        /// <summary>
-        ///     Reads data from the I2C bus
-        /// </summary>
-        /// <param name="portId">The port id on which device is connected</param>
-        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
-        /// <param name="deviceAddress">The device I2C slave address</param>
-        /// <param name="registerAddress">The target I2C register address</param>
-        /// <param name="readDataLength">The length of the buffer to allocate for the read operation.</param>
-        /// <param name="speed">The target speed of the transaction in kHz</param>
-        public byte[] ReadI2C(
-            byte? portId,
-            bool useDDCPort,
-            byte deviceAddress,
-            byte[] registerAddress,
-            uint readDataLength,
-            I2CSpeed speed = I2CSpeed.Default
-        )
-        {
-            try
-            {
-                // ReSharper disable once InconsistentNaming
-                var i2cInfoV3 = new I2CInfoV3(
-                    OutputId,
-                    portId,
-                    useDDCPort,
-                    deviceAddress,
-                    registerAddress,
-                    readDataLength,
-                    speed
-                );
-
-                return PhysicalGPU.ReadI2C(i2cInfoV3);
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            // ReSharper disable once InconsistentNaming
-            var i2cInfoV2 = new I2CInfoV2(
-                OutputId,
-                useDDCPort,
-                deviceAddress,
-                registerAddress,
-                readDataLength,
-                speed
-            );
-
-            return PhysicalGPU.ReadI2C(i2cInfoV2);
-        }
-
-        /// <summary>
-        ///     Writes data to the I2C bus
-        /// </summary>
-        /// <param name="portId">The port id on which device is connected</param>
-        /// <param name="useDDCPort">A boolean value indicating that the DDC port should be used instead of the communication port</param>
-        /// <param name="deviceAddress">The device I2C slave address</param>
-        /// <param name="registerAddress">The target I2C register address</param>
-        /// <param name="data">The payload data</param>
-        /// <param name="speed">The target speed of the transaction in kHz</param>
-        public void WriteI2C(
-            byte? portId,
-            bool useDDCPort,
-            byte deviceAddress,
-            byte[] registerAddress,
-            byte[] data,
-            I2CSpeed speed = I2CSpeed.Default
-        )
-        {
-            try
-            {
-                // ReSharper disable once InconsistentNaming
-                var i2cInfoV3 = new I2CInfoV3(
-                    OutputId,
-                    portId,
-                    useDDCPort,
-                    deviceAddress,
-                    registerAddress,
-                    data,
-                    speed
-                );
-
-                PhysicalGPU.WriteI2C(i2cInfoV3);
-
-                return;
-            }
-            catch (NVIDIAApiException e)
-            {
-                if (e.Status != Status.IncompatibleStructureVersion || portId != null)
-                {
-                    throw;
-                }
-
-                // ignore
-            }
-
-            // ReSharper disable once InconsistentNaming
-            var i2cInfoV2 = new I2CInfoV2(
-                OutputId,
-                useDDCPort,
-                deviceAddress,
-                registerAddress,
-                data,
-                speed
-            );
-
-            PhysicalGPU.WriteI2C(i2cInfoV2);
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceControl.cs

@@ -1,124 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information regarding the GPU performance control and limitations
-    /// </summary>
-    public class GPUPerformanceControl
-    {
-        internal GPUPerformanceControl(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the current active performance limitation
-        /// </summary>
-        public PerformanceLimit CurrentActiveLimit
-        {
-            get => GPUApi.PerformancePoliciesGetStatus(PhysicalGPU.Handle).PerformanceLimit;
-        }
-
-        /// <summary>
-        ///     Gets the current performance decrease reason
-        /// </summary>
-        public PerformanceDecreaseReason CurrentPerformanceDecreaseReason
-        {
-            get => GPUApi.GetPerformanceDecreaseInfo(PhysicalGPU.Handle);
-        }
-
-
-        /// <summary>
-        ///     Gets a boolean value indicating if no load limit is supported with this GPU
-        /// </summary>
-        public bool IsNoLoadLimitSupported
-        {
-            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsNoLoadLimitSupported;
-        }
-
-
-        /// <summary>
-        ///     Gets a boolean value indicating if power limit is supported with this GPU
-        /// </summary>
-        public bool IsPowerLimitSupported
-        {
-            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsPowerLimitSupported;
-        }
-
-
-        /// <summary>
-        ///     Gets a boolean value indicating if temperature limit is supported with this GPU
-        /// </summary>
-        public bool IsTemperatureLimitSupported
-        {
-            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsTemperatureLimitSupported;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if voltage limit is supported with this GPU
-        /// </summary>
-        public bool IsVoltageLimitSupported
-        {
-            get => GPUApi.PerformancePoliciesGetInfo(PhysicalGPU.Handle).IsVoltageLimitSupported;
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets information regarding possible power limit policies and their acceptable range
-        /// </summary>
-        public IEnumerable<GPUPowerLimitInfo> PowerLimitInformation
-        {
-            get
-            {
-                return GPUApi.ClientPowerPoliciesGetInfo(PhysicalGPU.Handle).PowerPolicyInfoEntries
-                    .Select(entry => new GPUPowerLimitInfo(entry));
-            }
-        }
-
-        /// <summary>
-        ///     Gets the current active power limit policies
-        /// </summary>
-        public IEnumerable<GPUPowerLimitPolicy> PowerLimitPolicies
-        {
-            get
-            {
-                // TODO: GPUApi.ClientPowerPoliciesSetStatus();
-                return GPUApi.ClientPowerPoliciesGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
-                    .Select(entry => new GPUPowerLimitPolicy(entry));
-            }
-        }
-
-        /// <summary>
-        ///     Gets information regarding possible thermal limit policies and their acceptable range
-        /// </summary>
-        public IEnumerable<GPUThermalLimitInfo> ThermalLimitInformation
-        {
-            get
-            {
-                return GPUApi.GetThermalPoliciesInfo(PhysicalGPU.Handle).ThermalPoliciesInfoEntries
-                    .Select(entry => new GPUThermalLimitInfo(entry));
-            }
-        }
-
-        /// <summary>
-        ///     Gets the current active thermal limit policies
-        /// </summary>
-        public IEnumerable<GPUThermalLimitPolicy> ThermalLimitPolicies
-        {
-            get
-            {
-                // TODO: GPUApi.SetThermalPoliciesStatus();
-                return GPUApi.GetThermalPoliciesStatus(PhysicalGPU.Handle).ThermalPoliciesStatusEntries
-                    .Select(entry => new GPUThermalLimitPolicy(entry));
-            }
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceState.cs

@@ -1,70 +0,0 @@
-using System.Linq;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a performance state
-    /// </summary>
-    public class GPUPerformanceState
-    {
-        // ReSharper disable once TooManyDependencies
-        internal GPUPerformanceState(
-            int index,
-            IPerformanceState20 performanceState,
-            IPerformanceStates20ClockEntry[] statesClockEntries,
-            IPerformanceStates20VoltageEntry[] baseVoltageEntries,
-            PCIeInformation pcieInformation)
-        {
-            StateIndex = index;
-            StateId = performanceState.StateId;
-            IsReadOnly = !performanceState.IsEditable;
-            Clocks = statesClockEntries.Select(entry => new GPUPerformanceStateClock(entry)).ToArray();
-            Voltages = baseVoltageEntries.Select(entry => new GPUPerformanceStateVoltage(entry)).ToArray();
-            PCIeInformation = pcieInformation;
-        }
-
-        /// <summary>
-        ///     Gets a list of clocks associated with this performance state
-        /// </summary>
-
-        public GPUPerformanceStateClock[] Clocks { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this performance state is readonly
-        /// </summary>
-        public bool IsReadOnly { get; }
-
-        /// <summary>
-        ///     Gets the PCI-e information regarding this performance state.
-        /// </summary>
-        public PCIeInformation PCIeInformation { get; }
-
-        /// <summary>
-        ///     Gets the performance state identification
-        /// </summary>
-        public PerformanceStateId StateId { get; }
-
-        /// <summary>
-        ///     Gets the state index
-        /// </summary>
-        public int StateIndex { get; }
-
-        /// <summary>
-        ///     Gets a list of voltages associated with this performance state
-        /// </summary>
-        public GPUPerformanceStateVoltage[] Voltages { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (IsReadOnly)
-            {
-                return $"{StateId} (ReadOnly)";
-            }
-
-            return StateId.ToString();
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceStateClock.cs

@@ -1,99 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a performance state clock settings
-    /// </summary>
-    public class GPUPerformanceStateClock
-    {
-        internal GPUPerformanceStateClock(IPerformanceStates20ClockEntry states20ClockEntry)
-        {
-            ClockDomain = states20ClockEntry.DomainId;
-            IsReadOnly = !states20ClockEntry.IsEditable;
-            ClockDeltaInkHz = states20ClockEntry.FrequencyDeltaInkHz.DeltaValue;
-            ClockDeltaRangeInkHz = new GPUPerformanceStateValueRange(
-                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Minimum,
-                states20ClockEntry.FrequencyDeltaInkHz.DeltaRange.Maximum
-            );
-
-            if (states20ClockEntry.ClockType == PerformanceStates20ClockType.Range)
-            {
-                CurrentClockInkHz = new GPUPerformanceStateValueRange(
-                    states20ClockEntry.FrequencyRange.MinimumFrequencyInkHz,
-                    states20ClockEntry.FrequencyRange.MaximumFrequencyInkHz
-                );
-                BaseClockInkHz = new GPUPerformanceStateValueRange(
-                    CurrentClockInkHz.Minimum - ClockDeltaInkHz,
-                    CurrentClockInkHz.Maximum - ClockDeltaInkHz
-                );
-                DependentVoltageDomain = states20ClockEntry.FrequencyRange.VoltageDomainId;
-                DependentVoltageRangeInMicroVolt = new GPUPerformanceStateValueRange(
-                    states20ClockEntry.FrequencyRange.MinimumVoltageInMicroVolt,
-                    states20ClockEntry.FrequencyRange.MaximumVoltageInMicroVolt
-                );
-            }
-            else
-            {
-                CurrentClockInkHz = new GPUPerformanceStateValueRange(
-                    states20ClockEntry.SingleFrequency.FrequencyInkHz
-                );
-                BaseClockInkHz = new GPUPerformanceStateValueRange(
-                    CurrentClockInkHz.Minimum - ClockDeltaInkHz
-                );
-                DependentVoltageDomain = PerformanceVoltageDomain.Undefined;
-                DependentVoltageRangeInMicroVolt = null;
-            }
-        }
-
-        /// <summary>
-        ///     Gets the base clock frequency in kHz
-        /// </summary>
-        public GPUPerformanceStateValueRange BaseClockInkHz { get; }
-
-        /// <summary>
-        ///     Gets the clock frequency delta in kHz
-        /// </summary>
-        public int ClockDeltaInkHz { get; }
-
-        /// <summary>
-        ///     Gets the clock frequency delta range in kHz
-        /// </summary>
-        public GPUPerformanceStateValueRange ClockDeltaRangeInkHz { get; }
-
-        /// <summary>
-        ///     Gets the clock domain
-        /// </summary>
-        public PublicClockDomain ClockDomain { get; }
-
-        /// <summary>
-        ///     Gets the current clock frequency in kHz
-        /// </summary>
-        public GPUPerformanceStateValueRange CurrentClockInkHz { get; }
-
-        /// <summary>
-        ///     Gets the dependent voltage domain
-        /// </summary>
-        public PerformanceVoltageDomain DependentVoltageDomain { get; }
-
-        /// <summary>
-        ///     Gets the dependent voltage range in uV
-        /// </summary>
-        public GPUPerformanceStateValueRange DependentVoltageRangeInMicroVolt { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this clock setting is readonly
-        /// </summary>
-        public bool IsReadOnly { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var title = IsReadOnly ? $"{ClockDomain} (ReadOnly)" : ClockDomain.ToString();
-
-            return
-                $"{title}: {BaseClockInkHz} + ({ClockDeltaInkHz}) = {CurrentClockInkHz}";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceStateValueRange.cs

@@ -1,115 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents an integer value range
-    /// </summary>
-    public class GPUPerformanceStateValueRange : IEquatable<GPUPerformanceStateValueRange>
-    {
-        /// <summary>
-        ///     Creates a new instance of <see cref="GPUPerformanceStateValueRange" />.
-        /// </summary>
-        /// <param name="min">The lower bound of the range.</param>
-        /// <param name="max">The upper bound of the range.</param>
-        public GPUPerformanceStateValueRange(long min, long max)
-        {
-            Minimum = min;
-            Maximum = max;
-        }
-
-        /// <summary>
-        ///     Creates a new single value instance of <see cref="GPUPerformanceStateValueRange" />.
-        /// </summary>
-        /// <param name="value">The only value in the range</param>
-        public GPUPerformanceStateValueRange(long value)
-        {
-            Minimum = value;
-            Maximum = value;
-        }
-
-        /// <summary>
-        ///     Gets the upper bound of the inclusive range
-        /// </summary>
-        public long Maximum { get; }
-
-        /// <summary>
-        ///     Gets the lower bound of the inclusive range
-        /// </summary>
-        public long Minimum { get; }
-
-        /// <inheritdoc />
-        public bool Equals(GPUPerformanceStateValueRange other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Maximum == other.Maximum && Minimum == other.Minimum;
-        }
-
-        /// <summary>
-        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for equality.
-        /// </summary>
-        /// <param name="left">The left side of the comparison.</param>
-        /// <param name="right">The right side of the comparison.</param>
-        /// <returns>true if instances are equal, otherwise false</returns>
-        public static bool operator ==(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
-        {
-            return Equals(left, right) || left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Checks two instances of <see cref="GPUPerformanceStateValueRange" /> for inequality.
-        /// </summary>
-        /// <param name="left">The left side of the comparison.</param>
-        /// <param name="right">The right side of the comparison.</param>
-        /// <returns>true if instances are in-equal, otherwise false</returns>
-        public static bool operator !=(GPUPerformanceStateValueRange left, GPUPerformanceStateValueRange right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return Equals(obj as GPUPerformanceStateValueRange);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                return ((int) Maximum * 397) ^ (int) Minimum;
-            }
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (Minimum == Maximum)
-            {
-                return $"({Minimum})";
-            }
-
-            return $"[({Minimum}) - ({Maximum})]";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceStateVoltage.cs

@@ -1,65 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a performance state voltage settings
-    /// </summary>
-    public class GPUPerformanceStateVoltage
-    {
-        internal GPUPerformanceStateVoltage(IPerformanceStates20VoltageEntry states20BaseVoltageEntry)
-        {
-            VoltageDomain = states20BaseVoltageEntry.DomainId;
-            IsReadOnly = !states20BaseVoltageEntry.IsEditable;
-
-            CurrentVoltageInMicroVolt = states20BaseVoltageEntry.ValueInMicroVolt;
-            VoltageDeltaInMicroVolt = states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaValue;
-            BaseVoltageInMicroVolt = (int) (CurrentVoltageInMicroVolt - VoltageDeltaInMicroVolt);
-
-            VoltageDeltaRangeInMicroVolt = new GPUPerformanceStateValueRange(
-                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Minimum,
-                states20BaseVoltageEntry.ValueDeltaInMicroVolt.DeltaRange.Maximum
-            );
-        }
-
-        /// <summary>
-        ///     Gets the base voltage in uV
-        /// </summary>
-        public int BaseVoltageInMicroVolt { get; }
-
-        /// <summary>
-        ///     Gets the current voltage in uV
-        /// </summary>
-        public uint CurrentVoltageInMicroVolt { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this voltage is readonly
-        /// </summary>
-        public bool IsReadOnly { get; }
-
-        /// <summary>
-        ///     Gets the voltage delta in uV
-        /// </summary>
-        public int VoltageDeltaInMicroVolt { get; }
-
-        /// <summary>
-        ///     Gets the voltage delta range in uV
-        /// </summary>
-        public GPUPerformanceStateValueRange VoltageDeltaRangeInMicroVolt { get; }
-
-        /// <summary>
-        ///     Gets the voltage domain
-        /// </summary>
-        public PerformanceVoltageDomain VoltageDomain { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var title = IsReadOnly ? $"{VoltageDomain} (ReadOnly)" : VoltageDomain.ToString();
-
-            return
-                $"{title}: ({BaseVoltageInMicroVolt}) + ({VoltageDeltaInMicroVolt}) = ({CurrentVoltageInMicroVolt})";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPerformanceStatesInfo.cs

@@ -1,107 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds the retrieved performance states information
-    /// </summary>
-    public class GPUPerformanceStatesInformation
-    {
-        internal GPUPerformanceStatesInformation(
-            IPerformanceStates20Info states20Info,
-            PerformanceStateId currentPerformanceStateId,
-            PrivatePCIeInfoV2? pciInformation)
-        {
-            IsReadOnly = !states20Info.IsEditable;
-
-            GlobalVoltages = states20Info.GeneralVoltages
-                .Select(entry => new GPUPerformanceStateVoltage(entry))
-                .ToArray();
-
-            var clocks = states20Info.Clocks;
-            var baseVoltages = states20Info.Voltages;
-
-            PerformanceStates = states20Info.PerformanceStates.Select((state20, i) =>
-            {
-                PCIeInformation statePCIeInfo = null;
-
-                if (pciInformation != null && pciInformation.Value.PCIePerformanceStateInfos.Length > i)
-                {
-                    statePCIeInfo = new PCIeInformation(pciInformation.Value.PCIePerformanceStateInfos[i]);
-                }
-
-                return new GPUPerformanceState(
-                    i,
-                    state20,
-                    clocks[state20.StateId],
-                    baseVoltages[state20.StateId],
-                    statePCIeInfo
-                );
-            }).ToArray();
-
-            CurrentPerformanceState =
-                PerformanceStates.FirstOrDefault(performanceState =>
-                    performanceState.StateId == currentPerformanceStateId);
-        }
-
-        /// <summary>
-        ///     Gets the currently active performance state
-        /// </summary>
-        public GPUPerformanceState CurrentPerformanceState { get; }
-
-        /// <summary>
-        ///     Gets a list of global voltage settings
-        /// </summary>
-        public GPUPerformanceStateVoltage[] GlobalVoltages { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if performance states are readonly
-        /// </summary>
-        public bool IsReadOnly { get; }
-
-        /// <summary>
-        ///     Gets a list of all available performance states
-        /// </summary>
-        public GPUPerformanceState[] PerformanceStates { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            if (PerformanceStates.Length == 0)
-            {
-                return "No Performance State Available";
-            }
-
-            return string.Join(
-                ", ",
-                PerformanceStates
-                    .Select(
-                        state =>
-                        {
-                            var attributes = new List<string>();
-
-                            if (state.IsReadOnly)
-                            {
-                                attributes.Add("ReadOnly");
-                            }
-
-                            if (CurrentPerformanceState.StateId == state.StateId)
-                            {
-                                attributes.Add("Active");
-                            }
-
-                            if (attributes.Any())
-                            {
-                                return $"{state.StateId} ({string.Join(" - ", attributes)})";
-                            }
-
-                            return state.StateId.ToString();
-                        })
-            );
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPowerLimitInfo.cs

@@ -1,70 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding a possible power limit policy and its acceptable range
-    /// </summary>
-    public class GPUPowerLimitInfo
-    {
-        internal GPUPowerLimitInfo(PrivatePowerPoliciesInfoV1.PowerPolicyInfoEntry powerPolicyInfoEntry)
-        {
-            PerformanceStateId = powerPolicyInfoEntry.PerformanceStateId;
-            MinimumPowerInPCM = powerPolicyInfoEntry.MinimumPowerInPCM;
-            DefaultPowerInPCM = powerPolicyInfoEntry.DefaultPowerInPCM;
-            MaximumPowerInPCM = powerPolicyInfoEntry.MaximumPowerInPCM;
-        }
-
-        /// <summary>
-        ///     Gets the default policy target power in per cent mille (PCM)
-        /// </summary>
-        public uint DefaultPowerInPCM { get; }
-
-        /// <summary>
-        ///     Gets the default policy target power in percentage
-        /// </summary>
-        public float DefaultPowerInPercent
-        {
-            get => DefaultPowerInPCM / 1000f;
-        }
-
-        /// <summary>
-        ///     Gets the maximum possible policy target power in per cent mille (PCM)
-        /// </summary>
-        public uint MaximumPowerInPCM { get; }
-
-        /// <summary>
-        ///     Gets the maximum possible policy target power in percentage
-        /// </summary>
-        public float MaximumPowerInPercent
-        {
-            get => MaximumPowerInPCM / 1000f;
-        }
-
-        /// <summary>
-        ///     Gets the minimum possible policy target power in per cent mille (PCM)
-        /// </summary>
-        public uint MinimumPowerInPCM { get; }
-
-        /// <summary>
-        ///     Gets the minimum possible policy target power in percentage
-        /// </summary>
-        public float MinimumPowerInPercent
-        {
-            get => MinimumPowerInPCM / 1000f;
-        }
-
-        /// <summary>
-        ///     Gets the corresponding performance state identification
-        /// </summary>
-        public PerformanceStateId PerformanceStateId { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"[{PerformanceStateId}] Default: {DefaultPowerInPercent}% - Range: ({MinimumPowerInPercent}% - {MaximumPowerInPercent}%)";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPowerLimitPolicy.cs

@@ -1,41 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding a currently active power limit policy
-    /// </summary>
-    public class GPUPowerLimitPolicy
-    {
-        internal GPUPowerLimitPolicy(PrivatePowerPoliciesStatusV1.PowerPolicyStatusEntry powerPolicyStatusEntry)
-        {
-            PerformanceStateId = powerPolicyStatusEntry.PerformanceStateId;
-            PowerTargetInPCM = powerPolicyStatusEntry.PowerTargetInPCM;
-        }
-
-        /// <summary>
-        ///     Gets the corresponding performance state identification
-        /// </summary>
-        public PerformanceStateId PerformanceStateId { get; }
-
-        /// <summary>
-        ///     Gets the current policy target power in per cent mille (PCM)
-        /// </summary>
-        public uint PowerTargetInPCM { get; }
-
-        /// <summary>
-        ///     Gets the current policy target power in percentage
-        /// </summary>
-        public float PowerTargetInPercent
-        {
-            get => PowerTargetInPCM / 1000f;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"{PerformanceStateId} Target: {PowerTargetInPercent}%";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPowerTopologyInformation.cs

@@ -1,34 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding current power topology and their current power usage
-    /// </summary>
-    public class GPUPowerTopologyInformation
-    {
-        internal GPUPowerTopologyInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets the current power topology entries
-        /// </summary>
-        public IEnumerable<GPUPowerTopologyStatus> PowerTopologyEntries
-        {
-            get
-            {
-                return GPUApi.ClientPowerTopologyGetStatus(PhysicalGPU.Handle).PowerPolicyStatusEntries
-                    .Select(entry => new GPUPowerTopologyStatus(entry));
-            }
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUPowerTopologyStatus.cs

@@ -1,42 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about a power domain usage
-    /// </summary>
-    public class GPUPowerTopologyStatus
-    {
-        internal GPUPowerTopologyStatus(
-            PrivatePowerTopologiesStatusV1.PowerTopologiesStatusEntry powerTopologiesStatusEntry)
-        {
-            Domain = powerTopologiesStatusEntry.Domain;
-            PowerUsageInPCM = powerTopologiesStatusEntry.PowerUsageInPCM;
-        }
-
-        /// <summary>
-        ///     Gets the power usage domain
-        /// </summary>
-        public PowerTopologyDomain Domain { get; }
-
-        /// <summary>
-        ///     Gets the current power usage in per cent mille (PCM)
-        /// </summary>
-        public uint PowerUsageInPCM { get; }
-
-        /// <summary>
-        ///     Gets the current power usage in percentage
-        /// </summary>
-        public float PowerUsageInPercent
-        {
-            get => PowerUsageInPCM / 1000f;
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"[{Domain}] {PowerUsageInPercent}%";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUThermalInformation.cs

@@ -1,42 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding the available thermal sensors and current thermal level of a GPU
-    /// </summary>
-    public class GPUThermalInformation
-    {
-        internal GPUThermalInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the current thermal level of the GPU
-        /// </summary>
-        public int CurrentThermalLevel
-        {
-            get => (int) GPUApi.GetCurrentThermalLevel(PhysicalGPU.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets the list of available thermal sensors
-        /// </summary>
-        public IEnumerable<GPUThermalSensor> ThermalSensors
-        {
-            get
-            {
-                return GPUApi.GetThermalSettings(PhysicalGPU.Handle).Sensors
-                    .Select((sensor, i) => new GPUThermalSensor(i, sensor));
-            }
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUThermalLimitInfo.cs

@@ -1,47 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding a possible thermal limit policy and its acceptable range
-    /// </summary>
-    public class GPUThermalLimitInfo
-    {
-        internal GPUThermalLimitInfo(PrivateThermalPoliciesInfoV2.ThermalPoliciesInfoEntry policiesInfoEntry)
-        {
-            Controller = policiesInfoEntry.Controller;
-            MinimumTemperature = policiesInfoEntry.MinimumTemperature;
-            DefaultTemperature = policiesInfoEntry.DefaultTemperature;
-            MaximumTemperature = policiesInfoEntry.MaximumTemperature;
-        }
-
-        /// <summary>
-        ///     Gets the policy's thermal controller
-        /// </summary>
-        public ThermalController Controller { get; }
-
-        /// <summary>
-        ///     Gets the default policy target temperature in degree Celsius
-        /// </summary>
-        public int DefaultTemperature { get; }
-
-
-        /// <summary>
-        ///     Gets the maximum possible policy target temperature in degree Celsius
-        /// </summary>
-        public int MaximumTemperature { get; }
-
-        /// <summary>
-        ///     Gets the minimum possible policy target temperature in degree Celsius
-        /// </summary>
-        public int MinimumTemperature { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"[{Controller}] Default: {DefaultTemperature}°C - Range: ({MinimumTemperature}°C - {MaximumTemperature}°C)";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUThermalLimitPolicy.cs

@@ -1,40 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information regarding a currently active temperature limit policy
-    /// </summary>
-    public class GPUThermalLimitPolicy
-    {
-        internal GPUThermalLimitPolicy(PrivateThermalPoliciesStatusV2.ThermalPoliciesStatusEntry thermalPoliciesEntry)
-        {
-            Controller = thermalPoliciesEntry.Controller;
-            PerformanceStateId = thermalPoliciesEntry.PerformanceStateId;
-            TargetTemperature = thermalPoliciesEntry.TargetTemperature;
-        }
-
-        /// <summary>
-        ///     Gets the policy's thermal controller
-        /// </summary>
-        public ThermalController Controller { get; }
-
-        /// <summary>
-        ///     Gets the corresponding performance state identification
-        /// </summary>
-        public PerformanceStateId PerformanceStateId { get; }
-
-        /// <summary>
-        ///     Gets the current policy target temperature in degree Celsius
-        /// </summary>
-        public int TargetTemperature { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"{PerformanceStateId} [{Controller}] Target: {TargetTemperature}°C";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUThermalSensor.cs

@@ -1,48 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a thermal sensor
-    /// </summary>
-    public class GPUThermalSensor : IThermalSensor
-    {
-        internal GPUThermalSensor(int sensorId, IThermalSensor thermalSensor)
-        {
-            SensorId = sensorId;
-            Controller = thermalSensor.Controller;
-            DefaultMinimumTemperature = thermalSensor.DefaultMinimumTemperature;
-            DefaultMaximumTemperature = thermalSensor.DefaultMaximumTemperature;
-            CurrentTemperature = thermalSensor.CurrentTemperature;
-            Target = thermalSensor.Target;
-        }
-
-        /// <summary>
-        ///     Gets the sensor identification number or index
-        /// </summary>
-        public int SensorId { get; set; }
-
-        /// <inheritdoc />
-        public ThermalController Controller { get; }
-
-        /// <inheritdoc />
-        public int CurrentTemperature { get; }
-
-        /// <inheritdoc />
-        public int DefaultMaximumTemperature { get; }
-
-        /// <inheritdoc />
-        public int DefaultMinimumTemperature { get; }
-
-        /// <inheritdoc />
-        public ThermalSettingsTarget Target { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"[{Target} @ {Controller}] Current: {CurrentTemperature}°C - Default Range: [({DefaultMinimumTemperature}°C) , ({DefaultMaximumTemperature}°C)]";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUUsageDomainStatus.cs

@@ -1,33 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information about a utilization domain
-    /// </summary>
-    public class GPUUsageDomainStatus
-    {
-        internal GPUUsageDomainStatus(UtilizationDomain domain, IUtilizationDomainInfo utilizationDomainInfo)
-        {
-            Domain = domain;
-            Percentage = (int) utilizationDomainInfo.Percentage;
-        }
-
-        /// <summary>
-        ///     Gets the utilization domain that this instance describes
-        /// </summary>
-        public UtilizationDomain Domain { get; }
-
-        /// <summary>
-        ///     Gets the percentage of time where the domain is considered busy in the last 1 second interval.
-        /// </summary>
-        public int Percentage { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"[{Domain}] {Percentage}%";
-        }
-    }
-}

app/NvAPIWrapper/GPU/GPUUsageInformation.cs

@@ -1,99 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Holds information about the GPU utilization domains
-    /// </summary>
-    public class GPUUsageInformation
-    {
-        internal GPUUsageInformation(PhysicalGPU physicalGPU)
-        {
-            PhysicalGPU = physicalGPU;
-        }
-
-        /// <summary>
-        ///     Gets the Bus interface (BUS) utilization
-        /// </summary>
-        public GPUUsageDomainStatus BusInterface
-        {
-            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.BusInterface);
-        }
-
-        /// <summary>
-        ///     Gets the frame buffer (FB) utilization
-        /// </summary>
-        public GPUUsageDomainStatus FrameBuffer
-        {
-            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.FrameBuffer);
-        }
-
-        /// <summary>
-        ///     Gets the graphic engine (GPU) utilization
-        /// </summary>
-        public GPUUsageDomainStatus GPU
-        {
-            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.GPU);
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the dynamic performance states is enabled
-        /// </summary>
-        public bool IsDynamicPerformanceStatesEnabled
-        {
-            get => GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle).IsDynamicPerformanceStatesEnabled;
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU that this instance describes
-        /// </summary>
-        public PhysicalGPU PhysicalGPU { get; }
-
-        /// <summary>
-        ///     Gets all valid utilization domains and information
-        /// </summary>
-        public IEnumerable<GPUUsageDomainStatus> UtilizationDomainsStatus
-        {
-            get
-            {
-                try
-                {
-                    var dynamicPerformanceStates = GPUApi.GetDynamicPerformanceStatesInfoEx(PhysicalGPU.Handle);
-
-                    if (dynamicPerformanceStates.IsDynamicPerformanceStatesEnabled)
-                    {
-                        return dynamicPerformanceStates.Domains
-                            .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
-                    }
-                }
-                catch
-                {
-                    // ignored
-                }
-
-                return GPUApi.GetUsages(PhysicalGPU.Handle).Domains
-                    .Select(pair => new GPUUsageDomainStatus(pair.Key, pair.Value));
-            }
-        }
-
-
-        /// <summary>
-        ///     Gets the Video engine (VID) utilization
-        /// </summary>
-        public GPUUsageDomainStatus VideoEngine
-        {
-            get => UtilizationDomainsStatus.FirstOrDefault(status => status.Domain == UtilizationDomain.VideoEngine);
-        }
-
-        /// <summary>
-        ///     Enables dynamic performance states
-        /// </summary>
-        public void EnableDynamicPerformanceStates()
-        {
-            GPUApi.EnableDynamicPStates(PhysicalGPU.Handle);
-        }
-    }
-}

app/NvAPIWrapper/GPU/LogicalGPU.cs

@@ -1,119 +0,0 @@
-using System;
-using System.Linq;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a logical NVIDIA GPU
-    /// </summary>
-    public class LogicalGPU : IEquatable<LogicalGPU>
-    {
-        /// <summary>
-        ///     Creates a new LogicalGPU
-        /// </summary>
-        /// <param name="handle">Logical GPU handle</param>
-        public LogicalGPU(LogicalGPUHandle handle)
-        {
-            Handle = handle;
-        }
-
-        /// <summary>
-        ///     Gets a list of all corresponding physical GPUs
-        /// </summary>
-        public PhysicalGPU[] CorrespondingPhysicalGPUs
-        {
-            get
-            {
-                return GPUApi.GetPhysicalGPUsFromLogicalGPU(Handle).Select(handle => new PhysicalGPU(handle)).ToArray();
-            }
-        }
-
-        /// <summary>
-        ///     Gets the logical GPU handle
-        /// </summary>
-        public LogicalGPUHandle Handle { get; }
-
-        /// <inheritdoc />
-        public bool Equals(LogicalGPU other)
-        {
-            if (ReferenceEquals(null, other))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Handle.Equals(other.Handle);
-        }
-
-        /// <summary>
-        ///     Gets all logical GPUs
-        /// </summary>
-        /// <returns>An array of logical GPUs</returns>
-        public static LogicalGPU[] GetLogicalGPUs()
-        {
-            return GPUApi.EnumLogicalGPUs().Select(handle => new LogicalGPU(handle)).ToArray();
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(LogicalGPU left, LogicalGPU right)
-        {
-            return right?.Equals(left) ?? ReferenceEquals(left, null);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(LogicalGPU left, LogicalGPU right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            if (obj.GetType() != GetType())
-            {
-                return false;
-            }
-
-            return Equals((LogicalGPU) obj);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return Handle.GetHashCode();
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return
-                $"Logical GPU [{CorrespondingPhysicalGPUs.Length}] {{{string.Join(", ", CorrespondingPhysicalGPUs.Select(gpu => gpu.FullName).ToArray())}}}";
-        }
-    }
-}

app/NvAPIWrapper/GPU/PCIIdentifiers.cs

@@ -1,114 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the PCI connection
-    /// </summary>
-    public class PCIIdentifiers : IEquatable<PCIIdentifiers>
-    {
-        // ReSharper disable once TooManyDependencies
-        internal PCIIdentifiers(uint deviceId, uint subSystemId, uint revisionId, int externalDeviceId = 0)
-        {
-            DeviceId = deviceId;
-            SubSystemId = subSystemId;
-            RevisionId = revisionId;
-
-            if (externalDeviceId > 0)
-            {
-                ExternalDeviceId = (ushort) externalDeviceId;
-            }
-            else
-            {
-                ExternalDeviceId = (ushort) (deviceId >> 16);
-            }
-
-            VendorId = (ushort) ((DeviceId << 16) >> 16);
-        }
-
-        /// <summary>
-        ///     Gets the internal PCI device identifier
-        /// </summary>
-        public uint DeviceId { get; }
-
-        /// <summary>
-        ///     Gets the external PCI device identifier
-        /// </summary>
-        public ushort ExternalDeviceId { get; }
-
-        /// <summary>
-        ///     Gets the internal PCI device-specific revision identifier
-        /// </summary>
-        public uint RevisionId { get; }
-
-        /// <summary>
-        ///     Gets the internal PCI subsystem identifier
-        /// </summary>
-        public uint SubSystemId { get; }
-
-        /// <summary>
-        ///     Gets the vendor identification calculated from internal device identification
-        /// </summary>
-        public ushort VendorId { get; }
-
-        /// <inheritdoc />
-        public bool Equals(PCIIdentifiers other)
-        {
-            return DeviceId == other.DeviceId &&
-                   SubSystemId == other.SubSystemId &&
-                   RevisionId == other.RevisionId;
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(PCIIdentifiers left, PCIIdentifiers right)
-        {
-            return left.Equals(right);
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(PCIIdentifiers left, PCIIdentifiers right)
-        {
-            return !left.Equals(right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            return obj is PCIIdentifiers identifiers && Equals(identifiers);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = (int) DeviceId;
-                hashCode = (hashCode * 397) ^ (int) SubSystemId;
-                hashCode = (hashCode * 397) ^ (int) RevisionId;
-
-                return hashCode;
-            }
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"PCI\\VEN_{VendorId:X}&DEV_{ExternalDeviceId:X}&SUBSYS_{SubSystemId:X}&REV_{RevisionId:X}";
-        }
-    }
-}

app/NvAPIWrapper/GPU/PCIeInformation.cs

@@ -1,67 +0,0 @@
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the PCI-e connection
-    /// </summary>
-    public class PCIeInformation
-    {
-        internal PCIeInformation(PrivatePCIeInfoV2.PCIePerformanceStateInfo stateInfo)
-        {
-            TransferRateInMTps = stateInfo.TransferRateInMTps;
-            Generation = stateInfo.Generation;
-            Lanes = stateInfo.Lanes;
-            Version = stateInfo.Version;
-        }
-
-        /// <summary>
-        ///     Gets the PCI-e generation
-        /// </summary>
-        public PCIeGeneration Generation { get; }
-
-        /// <summary>
-        ///     Gets the PCI-e down stream lanes
-        /// </summary>
-        public uint Lanes { get; }
-
-        /// <summary>
-        ///     Gets the PCIe transfer rate in Mega Transfers per Second
-        /// </summary>
-        public uint TransferRateInMTps { get; }
-
-        /// <summary>
-        ///     Gets the PCI-e version
-        /// </summary>
-        public PCIeGeneration Version { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var v = "Unknown";
-
-            switch (Version)
-            {
-                case PCIeGeneration.PCIe1:
-                    v = "PCIe 1.0";
-
-                    break;
-                case PCIeGeneration.PCIe1Minor1:
-                    v = "PCIe 1.1";
-
-                    break;
-                case PCIeGeneration.PCIe2:
-                    v = "PCIe 2.0";
-
-                    break;
-                case PCIeGeneration.PCIe3:
-                    v = "PCIe 3.0";
-
-                    break;
-            }
-
-            return $"{v} x{Lanes} - {TransferRateInMTps} MTps";
-        }
-    }
-}

app/NvAPIWrapper/GPU/PhysicalGPU.cs

@@ -1,559 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using NvAPIWrapper.Display;
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.GPU;
-using NvAPIWrapper.Native.GPU.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces.GPU;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Represents a physical NVIDIA GPU
-    /// </summary>
-    public class PhysicalGPU : IEquatable<PhysicalGPU>
-    {
-        /// <summary>
-        ///     Creates a new PhysicalGPU
-        /// </summary>
-        /// <param name="handle">Physical GPU handle</param>
-        public PhysicalGPU(PhysicalGPUHandle handle)
-        {
-            Handle = handle;
-            UsageInformation = new GPUUsageInformation(this);
-            ThermalInformation = new GPUThermalInformation(this);
-            BusInformation = new GPUBusInformation(this);
-            ArchitectInformation = new GPUArchitectInformation(this);
-            MemoryInformation = new GPUMemoryInformation(this);
-            CoolerInformation = new GPUCoolerInformation(this);
-            ECCMemoryInformation = new ECCMemoryInformation(this);
-            PerformanceControl = new GPUPerformanceControl(this);
-            PowerTopologyInformation = new GPUPowerTopologyInformation(this);
-        }
-
-        /// <summary>
-        ///     Gets all active outputs of this GPU
-        /// </summary>
-        public GPUOutput[] ActiveOutputs
-        {
-            get
-            {
-                var outputs = new List<GPUOutput>();
-                var allOutputs = GPUApi.GetActiveOutputs(Handle);
-
-                foreach (OutputId outputId in Enum.GetValues(typeof(OutputId)))
-                {
-                    if (outputId != OutputId.Invalid && allOutputs.HasFlag(outputId))
-                    {
-                        outputs.Add(new GPUOutput(outputId, this));
-                    }
-                }
-
-                return outputs.ToArray();
-            }
-        }
-
-        /// <summary>
-        ///     Gets GPU architect information
-        /// </summary>
-        public GPUArchitectInformation ArchitectInformation { get; }
-
-        /// <summary>
-        ///     Gets GPU base clock frequencies
-        /// </summary>
-        public IClockFrequencies BaseClockFrequencies
-        {
-            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BaseClock));
-        }
-
-        /// <summary>
-        ///     Gets GPU video BIOS information
-        /// </summary>
-        public VideoBIOS Bios
-        {
-            get => new VideoBIOS(
-                GPUApi.GetVBIOSRevision(Handle),
-                (int) GPUApi.GetVBIOSOEMRevision(Handle),
-                GPUApi.GetVBIOSVersionString(Handle)
-            );
-        }
-
-        /// <summary>
-        ///     Gets the board information
-        /// </summary>
-        public BoardInfo Board
-        {
-            get
-            {
-                try
-                {
-                    return GPUApi.GetBoardInfo(Handle);
-                }
-                catch (NVIDIAApiException ex)
-                {
-                    if (ex.Status == Status.NotSupported)
-                    {
-                        return default;
-                    }
-
-                    throw;
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets GPU boost clock frequencies
-        /// </summary>
-        public IClockFrequencies BoostClockFrequencies
-        {
-            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.BoostClock));
-        }
-
-        /// <summary>
-        ///     Gets GPU bus information
-        /// </summary>
-        public GPUBusInformation BusInformation { get; }
-
-        /// <summary>
-        ///     Gets GPU coolers information
-        /// </summary>
-        public GPUCoolerInformation CoolerInformation { get; }
-
-        /// <summary>
-        ///     Gets corresponding logical GPU
-        /// </summary>
-        public LogicalGPU CorrespondingLogicalGPU
-        {
-            get => new LogicalGPU(GPUApi.GetLogicalGPUFromPhysicalGPU(Handle));
-        }
-
-        /// <summary>
-        ///     Gets GPU current clock frequencies
-        /// </summary>
-        public IClockFrequencies CurrentClockFrequencies
-        {
-            get => GPUApi.GetAllClockFrequencies(Handle, new ClockFrequenciesV2(ClockType.CurrentClock));
-        }
-
-        /// <summary>
-        ///     Gets the driver model number for this GPU
-        /// </summary>
-        public uint DriverModel
-        {
-            get => GPUApi.GetDriverModel(Handle);
-        }
-
-        /// <summary>
-        ///     Gets GPU ECC memory information
-        /// </summary>
-        public ECCMemoryInformation ECCMemoryInformation { get; }
-
-        /// <summary>
-        ///     Gets the chipset foundry
-        /// </summary>
-        public GPUFoundry Foundry
-        {
-            get => GPUApi.GetFoundry(Handle);
-        }
-
-        /// <summary>
-        ///     Gets GPU full name
-        /// </summary>
-        public string FullName
-        {
-            get => GPUApi.GetFullName(Handle);
-        }
-
-        /// <summary>
-        ///     Gets the GPU identification number
-        /// </summary>
-        public uint GPUId
-        {
-            get => GPUApi.GetGPUIDFromPhysicalGPU(Handle);
-        }
-
-        /// <summary>
-        ///     Gets GPU type
-        /// </summary>
-        public GPUType GPUType
-        {
-            get => GPUApi.GetGPUType(Handle);
-        }
-
-        /// <summary>
-        ///     Gets the physical GPU handle
-        /// </summary>
-        public PhysicalGPUHandle Handle { get; }
-
-        /// <summary>
-        ///     Gets a boolean value indicating the Quadro line of products
-        /// </summary>
-        public bool IsQuadro
-        {
-            get => GPUApi.GetQuadroStatus(Handle);
-        }
-
-        /// <summary>
-        ///     Gets GPU memory and RAM information as well as frame-buffer information
-        /// </summary>
-        public GPUMemoryInformation MemoryInformation { get; }
-
-        /// <summary>
-        ///     Gets GPU performance control status and configurations
-        /// </summary>
-        public GPUPerformanceControl PerformanceControl { get; }
-
-
-        /// <summary>
-        ///     Gets the GPU performance states information and configurations
-        /// </summary>
-        public GPUPerformanceStatesInformation PerformanceStatesInfo
-        {
-            get
-            {
-                var performanceStates20Info = GPUApi.GetPerformanceStates20(Handle);
-                var currentPerformanceState = GPUApi.GetCurrentPerformanceState(Handle);
-                PrivatePCIeInfoV2? pcieInformation = null;
-
-                if (BusInformation.BusType == GPUBusType.PCIExpress)
-                {
-                    try
-                    {
-                        pcieInformation = GPUApi.GetPCIEInfo(Handle);
-                    }
-                    catch
-                    {
-                        // ignore
-                    }
-                }
-
-                return new GPUPerformanceStatesInformation(performanceStates20Info, currentPerformanceState,
-                    pcieInformation);
-            }
-        }
-
-        /// <summary>
-        ///     Gets GPU coolers information
-        /// </summary>
-        public GPUPowerTopologyInformation PowerTopologyInformation { get; }
-
-        /// <summary>
-        ///     Gets GPU system type
-        /// </summary>
-        public SystemType SystemType
-        {
-            get => GPUApi.GetSystemType(Handle);
-        }
-
-        /// <summary>
-        ///     Gets GPU thermal sensors information
-        /// </summary>
-        public GPUThermalInformation ThermalInformation { get; }
-
-        /// <summary>
-        ///     Gets the GPU utilization domains and usages
-        /// </summary>
-        public GPUUsageInformation UsageInformation { get; }
-
-        /// <inheritdoc />
-        public bool Equals(PhysicalGPU other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            return Handle.Equals(other.Handle);
-        }
-
-        /// <summary>
-        ///     Gets the corresponding <see cref="PhysicalGPU" /> instance from a GPU identification number.
-        /// </summary>
-        /// <param name="gpuId">The GPU identification number.</param>
-        /// <returns>An instance of <see cref="PhysicalGPU" /> or <see langword="null" /> if operation failed.</returns>
-        public static PhysicalGPU FromGPUId(uint gpuId)
-        {
-            var handle = GPUApi.GetPhysicalGPUFromGPUID(gpuId);
-
-            if (handle.IsNull)
-            {
-                return null;
-            }
-
-            return new PhysicalGPU(handle);
-        }
-
-        /// <summary>
-        ///     Gets all physical GPUs
-        /// </summary>
-        /// <returns>An array of physical GPUs</returns>
-        public static PhysicalGPU[] GetPhysicalGPUs()
-        {
-            return GPUApi.EnumPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
-        }
-
-        /// <summary>
-        ///     Gets all physical GPUs in TCC state
-        /// </summary>
-        /// <returns>An array of physical GPUs</returns>
-        public static PhysicalGPU[] GetTCCPhysicalGPUs()
-        {
-            return GPUApi.EnumTCCPhysicalGPUs().Select(handle => new PhysicalGPU(handle)).ToArray();
-        }
-
-        /// <summary>
-        ///     Checks for equality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are equal, otherwise false</returns>
-        public static bool operator ==(PhysicalGPU left, PhysicalGPU right)
-        {
-            return Equals(left, right) || left?.Equals(right) == true;
-        }
-
-        /// <summary>
-        ///     Checks for inequality between two objects of same type
-        /// </summary>
-        /// <param name="left">The first object</param>
-        /// <param name="right">The second object</param>
-        /// <returns>true, if both objects are not equal, otherwise false</returns>
-        public static bool operator !=(PhysicalGPU left, PhysicalGPU right)
-        {
-            return !(left == right);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, obj))
-            {
-                return true;
-            }
-
-            return Equals(obj as PhysicalGPU);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return Handle.GetHashCode();
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return FullName;
-        }
-
-        /// <summary>
-        ///     Get a list of all active applications for this GPU
-        /// </summary>
-        /// <returns>An array of processes</returns>
-        public Process[] GetActiveApplications()
-        {
-            return GPUApi.QueryActiveApps(Handle).Select(app => Process.GetProcessById(app.ProcessId)).ToArray();
-        }
-
-        /// <summary>
-        ///     Get a list of all connected display devices on this GPU
-        /// </summary>
-        /// <param name="flags">ConnectedIdsFlag flag</param>
-        /// <returns>An array of display devices</returns>
-        public DisplayDevice[] GetConnectedDisplayDevices(ConnectedIdsFlag flags)
-        {
-            return GPUApi.GetConnectedDisplayIds(Handle, flags).Select(display => new DisplayDevice(display)).ToArray();
-        }
-
-        /// <summary>
-        ///     Get the display device connected to a specific GPU output
-        /// </summary>
-        /// <param name="output">The GPU output to get connected display device for</param>
-        /// <returns>DisplayDevice connected to the specified GPU output</returns>
-        public DisplayDevice GetDisplayDeviceByOutput(GPUOutput output)
-        {
-            return new DisplayDevice(GPUApi.GetDisplayIdFromGPUAndOutputId(Handle, output.OutputId));
-        }
-
-        /// <summary>
-        ///     Get a list of all display devices on any possible output
-        /// </summary>
-        /// <returns>An array of display devices</returns>
-        public DisplayDevice[] GetDisplayDevices()
-        {
-            return GPUApi.GetAllDisplayIds(Handle).Select(display => new DisplayDevice(display)).ToArray();
-        }
-
-        /// <summary>
-        ///     Reads EDID data of an output
-        /// </summary>
-        /// <param name="output">The GPU output to read EDID information for</param>
-        /// <returns>A byte array containing EDID data</returns>
-        public byte[] ReadEDIDData(GPUOutput output)
-        {
-            try
-            {
-                var data = new byte[0];
-                var identification = 0;
-                var totalSize = EDIDV3.MaxDataSize;
-
-                for (var offset = 0; offset < totalSize; offset += EDIDV3.MaxDataSize)
-                {
-                    var edid = GPUApi.GetEDID(Handle, output.OutputId, offset, identification);
-                    identification = edid.Identification;
-                    totalSize = edid.TotalSize;
-
-                    var edidData = edid.Data;
-                    Array.Resize(ref data, data.Length + edidData.Length);
-                    Array.Copy(edidData, 0, data, data.Length - edidData.Length, edidData.Length);
-                }
-
-                return data;
-            }
-            catch (NVIDIAApiException ex)
-            {
-                if (ex.Status == Status.IncompatibleStructureVersion)
-                {
-                    return GPUApi.GetEDID(Handle, output.OutputId).Data;
-                }
-
-                throw;
-            }
-        }
-
-        /// <summary>
-        ///     Reads data from the I2C bus
-        /// </summary>
-        /// <param name="i2cInfo">Information required to read from the I2C bus.</param>
-        /// <returns>The returned payload.</returns>
-        // ReSharper disable once InconsistentNaming
-        public byte[] ReadI2C(II2CInfo i2cInfo)
-        {
-            GPUApi.I2CRead(Handle, ref i2cInfo);
-
-            return i2cInfo.Data;
-        }
-
-        /// <summary>
-        ///     Validates a set of GPU outputs to check if they can be active simultaneously
-        /// </summary>
-        /// <param name="outputs">GPU outputs to check</param>
-        /// <returns>true if all specified outputs can be active simultaneously, otherwise false</returns>
-        public bool ValidateOutputCombination(GPUOutput[] outputs)
-        {
-            var gpuOutpudIds =
-                outputs.Aggregate(OutputId.Invalid, (current, gpuOutput) => current | gpuOutput.OutputId);
-
-            return GPUApi.ValidateOutputCombination(Handle, gpuOutpudIds);
-        }
-
-        /// <summary>
-        ///     Writes EDID data of an output
-        /// </summary>
-        /// <param name="output">The GPU output to write EDID information for</param>
-        /// <param name="edidData">A byte array containing EDID data</param>
-        public void WriteEDIDData(GPUOutput output, byte[] edidData)
-        {
-            WriteEDIDData((uint) output.OutputId, edidData);
-        }
-
-        /// <summary>
-        ///     Writes EDID data of an display
-        /// </summary>
-        /// <param name="display">The display device to write EDID information for</param>
-        /// <param name="edidData">A byte array containing EDID data</param>
-        public void WriteEDIDData(DisplayDevice display, byte[] edidData)
-        {
-            WriteEDIDData(display.DisplayId, edidData);
-        }
-
-        /// <summary>
-        ///     Writes data to the I2C bus
-        /// </summary>
-        /// <param name="i2cInfo">Information required to write to the I2C bus including data payload.</param>
-        // ReSharper disable once InconsistentNaming
-        public void WriteI2C(II2CInfo i2cInfo)
-        {
-            GPUApi.I2CWrite(Handle, i2cInfo);
-        }
-
-        private void WriteEDIDData(uint displayOutputId, byte[] edidData)
-        {
-            try
-            {
-                if (edidData.Length == 0)
-                {
-                    var instance = typeof(EDIDV3).Instantiate<EDIDV3>();
-                    GPUApi.SetEDID(Handle, displayOutputId, instance);
-                }
-
-                for (var offset = 0; offset < edidData.Length; offset += EDIDV3.MaxDataSize)
-                {
-                    var array = new byte[Math.Min(EDIDV3.MaxDataSize, edidData.Length - offset)];
-                    Array.Copy(edidData, offset, array, 0, array.Length);
-                    var instance = EDIDV3.CreateWithData(0, (uint) offset, array, edidData.Length);
-                    GPUApi.SetEDID(Handle, displayOutputId, instance);
-                }
-
-                return;
-            }
-            catch (NVIDIAApiException ex)
-            {
-                if (ex.Status != Status.IncompatibleStructureVersion)
-                {
-                    throw;
-                }
-            }
-            catch (NVIDIANotSupportedException)
-            {
-                // ignore
-            }
-
-            try
-            {
-                if (edidData.Length == 0)
-                {
-                    var instance = typeof(EDIDV2).Instantiate<EDIDV2>();
-                    GPUApi.SetEDID(Handle, displayOutputId, instance);
-                }
-
-                for (var offset = 0; offset < edidData.Length; offset += EDIDV2.MaxDataSize)
-                {
-                    var array = new byte[Math.Min(EDIDV2.MaxDataSize, edidData.Length - offset)];
-                    Array.Copy(edidData, offset, array, 0, array.Length);
-                    GPUApi.SetEDID(Handle, displayOutputId, EDIDV2.CreateWithData(array, edidData.Length));
-                }
-
-                return;
-            }
-            catch (NVIDIAApiException ex)
-            {
-                if (ex.Status != Status.IncompatibleStructureVersion)
-                {
-                    throw;
-                }
-            }
-            catch (NVIDIANotSupportedException)
-            {
-                // ignore
-            }
-
-            GPUApi.SetEDID(Handle, displayOutputId, EDIDV1.CreateWithData(edidData));
-        }
-    }
-}

app/NvAPIWrapper/GPU/VideoBIOS.cs

@@ -1,52 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.GPU
-{
-    /// <summary>
-    ///     Contains information about the GPU Video BIOS
-    /// </summary>
-    public class VideoBIOS
-    {
-        internal VideoBIOS(uint revision, int oemRevision, string versionString)
-        {
-            Revision = revision;
-            OEMRevision = oemRevision;
-            VersionString = versionString.ToUpper();
-        }
-
-        /// <summary>
-        ///     Gets the the OEM revision of the video BIOS
-        /// </summary>
-        public int OEMRevision { get; }
-
-        /// <summary>
-        ///     Gets the revision of the video BIOS
-        /// </summary>
-        public uint Revision { get; }
-
-        /// <summary>
-        ///     Gets the full video BIOS version string
-        /// </summary>
-        public string VersionString { get; }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return AsVersion().ToString();
-        }
-
-        /// <summary>
-        ///     Returns the video BIOS version as a .Net Version object
-        /// </summary>
-        /// <returns>A Version object representing the video BIOS version</returns>
-        public Version AsVersion()
-        {
-            return new Version(
-                (int) ((Revision >> 28) + ((Revision << 4) >> 28) * 16), // 8 bit little endian
-                (int) (((Revision << 8) >> 28) + ((Revision << 12) >> 28) * 16), // 8 bit little endian
-                (int) ((Revision << 16) >> 16), // 16 bit big endian
-                OEMRevision // 8 bit integer
-            );
-        }
-    }
-}