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

Updated German translation

.github/workflows/release.yml

@@ -20,9 +20,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-windows8.0/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

@@ -8,21 +8,26 @@ using System.Timers;
 namespace GHelper.AnimeMatrix
 {
 
-    public class AniMatrix
+    public class AniMatrixControl
     {
-        System.Timers.Timer matrixTimer = default!;
-        AnimeMatrixDevice mat;
 
-        double[] AudioValues;
-        WasapiCapture AudioDevice;
+        SettingsForm settings;
+
+        System.Timers.Timer matrixTimer = default!;
+        AnimeMatrixDevice? mat;
+
+        double[]? AudioValues;
+        WasapiCapture? AudioDevice;
 
         public bool IsValid => mat != null;
 
         private long lastPresent;
         private List<double> maxes = new List<double>();
 
-        public AniMatrix()
+        public AniMatrixControl(SettingsForm settingsForm)
         {
+            settings = settingsForm;
+
             try
             {
                 mat = new AnimeMatrixDevice();
@@ -251,12 +256,43 @@ 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();
         }
 
 
+        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)
         {
 

app/AppConfig.cs

@@ -1,4 +1,4 @@
-using GHelper;
+using GHelper.Mode;
 using System.Diagnostics;
 using System.Management;
 using System.Text.Json;
@@ -68,6 +68,15 @@ public static class AppConfig
 
         return _model;
     }
+
+    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)
     {
 

app/AsusACPI.cs

@@ -106,8 +106,7 @@ public class AsusACPI
     public const int GPUModeStandard = 1;
     public const int GPUModeUltimate = 2;
 
-
-    public const int MaxTotal = 150;
+    public static int MaxTotal => AppConfig.ContainsModel("G513QY") ? 250 : 150;
     public const int MinTotal = 5;
     public const int DefaultTotal = 125;
 
@@ -428,6 +427,7 @@ public class AsusACPI
         return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
     }
 
+
     public void ScanRange()
     {
         int value;

app/AsusUSB.cs

@@ -118,7 +118,7 @@ namespace GHelper
                 _modes.Remove(3);
             }
 
-            if (AppConfig.ContainsModel("401"))
+            if (AppConfig.ContainsModel("401") || AppConfig.ContainsModel("X13"))
             {
                 _modes.Remove(2);
                 _modes.Remove(3);
@@ -150,6 +150,11 @@ namespace GHelper
             }
         }
 
+        public static bool HasColor()
+        {
+            return AppConfig.ContainsModel("GA401") || AppConfig.ContainsModel("X13");
+        }
+
         public static bool HasSecondColor()
         {
             return (mode == 1 && !AppConfig.ContainsModel("TUF"));
@@ -179,13 +184,11 @@ namespace GHelper
         }
 
 
-        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minInput = 18, int minFeatures = 1)
+        private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minFeatures = 1)
         {
             HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
             foreach (HidDevice device in HidDeviceList)
-                if (device.IsConnected
-                    && device.Capabilities.FeatureReportByteLength >= minFeatures
-                    && device.Capabilities.InputReportByteLength >= minInput)
+                if (device.IsConnected && device.Capabilities.FeatureReportByteLength >= minFeatures)
                     yield return device;
         }
 
@@ -235,7 +238,7 @@ namespace GHelper
         {
             Task.Run(async () =>
             {
-                var devices = GetHidDevices(deviceIds, 0);
+                var devices = GetHidDevices(deviceIds);
                 foreach (HidDevice device in devices)
                 {
                     device.OpenDevice();
@@ -263,7 +266,7 @@ namespace GHelper
                 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);
+                var devices = GetHidDevices(deviceIds);
                 foreach (HidDevice device in devices)
                 {
                     device.OpenDevice();
@@ -289,7 +292,7 @@ namespace GHelper
                 {
                     byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
 
-                    var devicesBackup = GetHidDevices(deviceIds, 0);
+                    var devicesBackup = GetHidDevices(deviceIds);
                     foreach (HidDevice device in devicesBackup)
                     {
                         device.OpenDevice();
@@ -312,13 +315,15 @@ namespace GHelper
 
 
             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));
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    device.WriteFeatureData(msg);
+                    Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                }
                 device.CloseDevice();
             }
 
@@ -351,23 +356,19 @@ namespace GHelper
             }
 
             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);
+                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                {
+                    device.WriteFeatureData(msg);
+                    device.WriteFeatureData(MESSAGE_SET);
+                    device.WriteFeatureData(MESSAGE_APPLY);
+                    Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+                }
                 device.CloseDevice();
-                Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
             }
 
             if (AppConfig.ContainsModel("TUF"))
@@ -385,7 +386,7 @@ namespace GHelper
             var payload = new byte[300];
             Array.Copy(msg, payload, msg.Length);
 
-            foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }, 0, 300))
+            foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }, 300))
             {
                 device.OpenDevice();
                 Logger.WriteLine("XGM " + device.Attributes.ProductHexId + "|" + device.Capabilities.FeatureReportByteLength + ":" + BitConverter.ToString(msg));

app/AutoUpdate/AutoUpdateControl.cs

@@ -0,0 +1,130 @@
+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;
+            settings.SetVersionLabel(Properties.Strings.VersionLabel + ": " + Assembly.GetExecutingAssembly().GetName().Version);
+        }
+
+        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()
+        {
+
+            try
+            {
+
+                using (var httpClient = new HttpClient())
+                {
+                    httpClient.DefaultRequestHeaders.Add("User-Agent", "C# App");
+                    var json = await httpClient.GetStringAsync("https://api.github.com/repos/seerge/g-helper/releases/latest");
+                    var config = JsonSerializer.Deserialize<JsonElement>(json);
+                    var tag = config.GetProperty("tag_name").ToString().Replace("v", "");
+                    var assets = config.GetProperty("assets");
+
+                    string url = null;
+
+                    for (int i = 0; i < assets.GetArrayLength(); i++)
+                    {
+                        if (assets[i].GetProperty("browser_download_url").ToString().Contains(".zip"))
+                            url = assets[i].GetProperty("browser_download_url").ToString();
+                    }
+
+                    if (url is null)
+                        url = assets[0].GetProperty("browser_download_url").ToString();
+
+                    var gitVersion = new Version(tag);
+                    var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+                    //appVersion = new Version("0.50.0.0"); 
+
+                    if (gitVersion.CompareTo(appVersion) > 0)
+                    {
+                        versionUrl = url;
+                        settings.SetVersionLabel(Properties.Strings.DownloadUpdate + ": " + tag, true);
+
+                        if (AppConfig.GetString("skip_version") != tag)
+                        {
+                            DialogResult dialogResult = MessageBox.Show(Properties.Strings.DownloadUpdate + ": G-Helper " + tag + "?", "Update", MessageBoxButtons.YesNo);
+                            if (dialogResult == DialogResult.Yes)
+                                AutoUpdate(url);
+                            else
+                                AppConfig.Set("skip_version", tag);
+                        }
+
+                    }
+                    else
+                    {
+                        Logger.WriteLine($"Latest version {appVersion}");
+                    }
+
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine("Failed to check for updates:" + ex.Message);
+            }
+
+        }
+
+
+        async void AutoUpdate(string requestUri)
+        {
+
+            Uri uri = new Uri(requestUri);
+            string zipName = Path.GetFileName(uri.LocalPath);
+
+            string exeLocation = Application.ExecutablePath;
+            string exeDir = Path.GetDirectoryName(exeLocation);
+            string zipLocation = exeDir + "\\" + zipName;
+
+            using (WebClient client = new WebClient())
+            {
+                client.DownloadFile(uri, zipLocation);
+
+                Logger.WriteLine(requestUri);
+                Logger.WriteLine(zipLocation);
+                Logger.WriteLine(exeLocation);
+
+                var cmd = new Process();
+                cmd.StartInfo.UseShellExecute = false;
+                cmd.StartInfo.CreateNoWindow = true;
+                cmd.StartInfo.FileName = "powershell";
+                cmd.StartInfo.Arguments = $"Start-Sleep -Seconds 1; Expand-Archive {zipLocation} -DestinationPath {exeDir} -Force; Remove-Item {zipLocation} -Force; {exeLocation}";
+                cmd.Start();
+
+                Application.Exit();
+            }
+
+        }
+
+    }
+}

app/Display/ScreenControl.cs

@@ -0,0 +1,99 @@
+using System.Diagnostics;
+
+namespace GHelper.Display
+{
+    public class ScreenControl
+    {
+        public void AutoScreen(bool force = false)
+        {
+            if (force || AppConfig.Is("screen_auto"))
+            {
+                if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
+                    SetScreen(1000, 1);
+                else
+                    SetScreen(60, 0);
+            }
+            else
+            {
+                SetScreen(overdrive: AppConfig.Get("overdrive"));
+            }
+        }
+
+        public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
+        {
+
+            if (ScreenNative.GetRefreshRate() < 0) // Laptop screen not detected or has unknown refresh rate
+            {
+                InitScreen();
+                return;
+            }
+
+            if (frequency >= 1000)
+            {
+                frequency = ScreenNative.GetRefreshRate(true);
+            }
+
+            if (frequency > 0)
+            {
+                ScreenNative.SetRefreshRate(frequency);
+            }
+
+            if (overdrive >= 0)
+            {
+                if (AppConfig.Get("no_overdrive") == 1) overdrive = 0;
+                Program.acpi.DeviceSet(AsusACPI.ScreenOverdrive, overdrive, "ScreenOverdrive");
+
+            }
+
+            if (miniled >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.ScreenMiniled, miniled, "Miniled");
+                Debug.WriteLine("Miniled " + miniled);
+            }
+
+            InitScreen();
+        }
+
+
+        public void ToogleMiniled()
+        {
+            int miniled = (AppConfig.Get("miniled") == 1) ? 0 : 1;
+            AppConfig.Set("miniled", miniled);
+            SetScreen(-1, -1, miniled);
+        }
+
+        public void InitScreen()
+        {
+            int frequency = ScreenNative.GetRefreshRate();
+            int maxFrequency = ScreenNative.GetRefreshRate(true);
+
+            bool screenAuto = AppConfig.Is("screen_auto");
+            bool overdriveSetting = !AppConfig.Is("no_overdrive");
+
+            int overdrive = Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
+            int miniled = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled);
+
+            if (miniled >= 0)
+                AppConfig.Set("miniled", miniled);
+
+            bool screenEnabled = (frequency >= 0);
+
+            AppConfig.Set("frequency", frequency);
+            AppConfig.Set("overdrive", overdrive);
+
+            Program.settingsForm.Invoke(delegate
+            {
+                Program.settingsForm.VisualiseScreen(
+                    screenEnabled: screenEnabled,
+                    screenAuto: screenAuto,
+                    frequency: frequency,
+                    maxFrequency: maxFrequency,
+                    overdrive: overdrive,
+                    overdriveSetting: overdriveSetting,
+                    miniled: miniled
+                );
+            });
+
+        }
+    }
+}

app/Display/ScreenInterrogatory.cs

@@ -0,0 +1,303 @@
+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
+
+        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);
+        }
+
+
+    }
+
+}

app/Display/ScreenNative.cs

@@ -0,0 +1,233 @@
+using System.Runtime.InteropServices;
+using static GHelper.Display.ScreenInterrogatory;
+
+namespace GHelper.Display
+{
+    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";
+
+        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 != EnumDisplaySettingsEx(laptopScreen, i, ref dm))
+                {
+                    if (dm.dmDisplayFrequency > frequency) frequency = dm.dmDisplayFrequency;
+                    i++;
+                }
+            }
+            else
+            {
+                if (0 != EnumDisplaySettingsEx(laptopScreen, 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 != 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));
+
+                //Fallback scenario
+                if (iRet != 0)
+                {
+                    Thread.Sleep(300);
+                    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.Designer.cs

@@ -1,5 +1,5 @@
-using CustomControls;
-using GHelper.Properties;
+using GHelper.Properties;
+using GHelper.UI;
 
 namespace GHelper
 {

app/Extra.cs

@@ -1,5 +1,8 @@
-using CustomControls;
-using GHelper.Gpu;
+using GHelper.Display;
+using GHelper.Gpu.AMD;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.UI;
 using System.Diagnostics;
 
 namespace GHelper
@@ -7,6 +10,8 @@ namespace GHelper
     public partial class Extra : RForm
     {
 
+        ScreenControl screenControl = new ScreenControl();
+
         Dictionary<string, string> customActions = new Dictionary<string, string>
         {
           {"","--------------" },
@@ -369,7 +374,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);
         }
 
 

app/Fans.Designer.cs

@@ -1,4 +1,4 @@
-using CustomControls;
+using GHelper.UI;
 using System.Windows.Forms.DataVisualization.Charting;
 
 namespace GHelper
@@ -31,14 +31,14 @@ namespace GHelper
         /// </summary>
         private void InitializeComponent()
         {
-            ChartArea chartArea5 = new ChartArea();
-            Title title5 = new Title();
-            ChartArea chartArea6 = new ChartArea();
-            Title title6 = new Title();
-            ChartArea chartArea7 = new ChartArea();
-            Title title7 = new Title();
-            ChartArea chartArea8 = new ChartArea();
-            Title title8 = new Title();
+            ChartArea chartArea1 = new ChartArea();
+            Title title1 = new Title();
+            ChartArea chartArea2 = new ChartArea();
+            Title title2 = new Title();
+            ChartArea chartArea3 = new ChartArea();
+            Title title3 = new Title();
+            ChartArea chartArea4 = new ChartArea();
+            Title title4 = new Title();
             System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Fans));
             panelFans = new Panel();
             labelTip = new Label();
@@ -61,13 +61,6 @@ namespace GHelper
             comboBoost = new RComboBox();
             panelSliders = new Panel();
             panelAdvanced = new Panel();
-            panelTemperature = new Panel();
-            labelTemp = new Label();
-            labelLeftTemp = new Label();
-            trackTemp = new TrackBar();
-            panelTitleTemp = new Panel();
-            pictureTemp = new PictureBox();
-            labelTempLimit = new Label();
             panelAdvancedApply = new Panel();
             checkApplyUV = new RCheckBox();
             buttonApplyAdvanced = new RButton();
@@ -83,6 +76,13 @@ namespace GHelper
             panelTitleAdvanced = new Panel();
             pictureUV = new PictureBox();
             labelTitleUV = new Label();
+            panelTemperature = new Panel();
+            labelTemp = new Label();
+            labelLeftTemp = new Label();
+            trackTemp = new TrackBar();
+            panelTitleTemp = new Panel();
+            pictureTemp = new PictureBox();
+            labelTempLimit = new Label();
             panelPower = new Panel();
             panelApplyPower = new Panel();
             checkApplyPower = new RCheckBox();
@@ -141,10 +141,6 @@ namespace GHelper
             panelApplyFans.SuspendLayout();
             panelSliders.SuspendLayout();
             panelAdvanced.SuspendLayout();
-            panelTemperature.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)trackTemp).BeginInit();
-            panelTitleTemp.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureTemp).BeginInit();
             panelAdvancedApply.SuspendLayout();
             panelUViGPU.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)trackUViGPU).BeginInit();
@@ -152,6 +148,10 @@ namespace GHelper
             ((System.ComponentModel.ISupportInitialize)trackUV).BeginInit();
             panelTitleAdvanced.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)pictureUV).BeginInit();
+            panelTemperature.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackTemp).BeginInit();
+            panelTitleTemp.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureTemp).BeginInit();
             panelPower.SuspendLayout();
             panelApplyPower.SuspendLayout();
             panelB0.SuspendLayout();
@@ -234,8 +234,8 @@ namespace GHelper
             // 
             // chartGPU
             // 
-            chartArea5.Name = "ChartArea1";
-            chartGPU.ChartAreas.Add(chartArea5);
+            chartArea1.Name = "ChartArea1";
+            chartGPU.ChartAreas.Add(chartArea1);
             chartGPU.Dock = DockStyle.Fill;
             chartGPU.Location = new Point(12, 467);
             chartGPU.Margin = new Padding(2, 10, 2, 10);
@@ -243,13 +243,13 @@ namespace GHelper
             chartGPU.Size = new Size(782, 437);
             chartGPU.TabIndex = 17;
             chartGPU.Text = "chartGPU";
-            title5.Name = "Title1";
-            chartGPU.Titles.Add(title5);
+            title1.Name = "Title1";
+            chartGPU.Titles.Add(title1);
             // 
             // chartCPU
             // 
-            chartArea6.Name = "ChartArea1";
-            chartCPU.ChartAreas.Add(chartArea6);
+            chartArea2.Name = "ChartArea1";
+            chartCPU.ChartAreas.Add(chartArea2);
             chartCPU.Dock = DockStyle.Fill;
             chartCPU.Location = new Point(12, 10);
             chartCPU.Margin = new Padding(2, 10, 2, 10);
@@ -257,13 +257,13 @@ namespace GHelper
             chartCPU.Size = new Size(782, 437);
             chartCPU.TabIndex = 14;
             chartCPU.Text = "chartCPU";
-            title6.Name = "Title1";
-            chartCPU.Titles.Add(title6);
+            title2.Name = "Title1";
+            chartCPU.Titles.Add(title2);
             // 
             // chartXGM
             // 
-            chartArea7.Name = "ChartAreaXGM";
-            chartXGM.ChartAreas.Add(chartArea7);
+            chartArea3.Name = "ChartAreaXGM";
+            chartXGM.ChartAreas.Add(chartArea3);
             chartXGM.Dock = DockStyle.Fill;
             chartXGM.Location = new Point(12, 1381);
             chartXGM.Margin = new Padding(2, 10, 2, 10);
@@ -271,14 +271,14 @@ namespace GHelper
             chartXGM.Size = new Size(782, 440);
             chartXGM.TabIndex = 14;
             chartXGM.Text = "chartXGM";
-            title7.Name = "Title4";
-            chartXGM.Titles.Add(title7);
+            title3.Name = "Title4";
+            chartXGM.Titles.Add(title3);
             chartXGM.Visible = false;
             // 
             // chartMid
             // 
-            chartArea8.Name = "ChartArea3";
-            chartMid.ChartAreas.Add(chartArea8);
+            chartArea4.Name = "ChartArea3";
+            chartMid.ChartAreas.Add(chartArea4);
             chartMid.Dock = DockStyle.Fill;
             chartMid.Location = new Point(12, 924);
             chartMid.Margin = new Padding(2, 10, 2, 10);
@@ -286,8 +286,8 @@ namespace GHelper
             chartMid.Size = new Size(782, 437);
             chartMid.TabIndex = 14;
             chartMid.Text = "chartMid";
-            title8.Name = "Title3";
-            chartMid.Titles.Add(title8);
+            title4.Name = "Title3";
+            chartMid.Titles.Add(title4);
             chartMid.Visible = false;
             // 
             // panelTitleFans
@@ -494,87 +494,6 @@ namespace GHelper
             panelAdvanced.TabIndex = 14;
             panelAdvanced.Visible = false;
             // 
-            // panelTemperature
-            // 
-            panelTemperature.AutoSize = true;
-            panelTemperature.AutoSizeMode = AutoSizeMode.GrowAndShrink;
-            panelTemperature.Controls.Add(labelTemp);
-            panelTemperature.Controls.Add(labelLeftTemp);
-            panelTemperature.Controls.Add(trackTemp);
-            panelTemperature.Dock = DockStyle.Top;
-            panelTemperature.Location = new Point(0, 66);
-            panelTemperature.Margin = new Padding(4);
-            panelTemperature.MaximumSize = new Size(0, 124);
-            panelTemperature.Name = "panelTemperature";
-            panelTemperature.Size = new Size(520, 124);
-            panelTemperature.TabIndex = 51;
-            // 
-            // labelTemp
-            // 
-            labelTemp.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelTemp.Location = new Point(347, 13);
-            labelTemp.Margin = new Padding(4, 0, 4, 0);
-            labelTemp.Name = "labelTemp";
-            labelTemp.Size = new Size(148, 32);
-            labelTemp.TabIndex = 13;
-            labelTemp.Text = "T";
-            labelTemp.TextAlign = ContentAlignment.TopRight;
-            // 
-            // labelLeftTemp
-            // 
-            labelLeftTemp.AutoSize = true;
-            labelLeftTemp.Location = new Point(10, 10);
-            labelLeftTemp.Margin = new Padding(4, 0, 4, 0);
-            labelLeftTemp.Name = "labelLeftTemp";
-            labelLeftTemp.Size = new Size(183, 32);
-            labelLeftTemp.TabIndex = 12;
-            labelLeftTemp.Text = "CPU Temp Limit";
-            // 
-            // trackTemp
-            // 
-            trackTemp.Location = new Point(6, 48);
-            trackTemp.Margin = new Padding(4, 2, 4, 2);
-            trackTemp.Maximum = 0;
-            trackTemp.Minimum = -40;
-            trackTemp.Name = "trackTemp";
-            trackTemp.Size = new Size(508, 90);
-            trackTemp.TabIndex = 11;
-            trackTemp.TickFrequency = 5;
-            trackTemp.TickStyle = TickStyle.TopLeft;
-            // 
-            // panelTitleTemp
-            // 
-            panelTitleTemp.Controls.Add(pictureTemp);
-            panelTitleTemp.Controls.Add(labelTempLimit);
-            panelTitleTemp.Dock = DockStyle.Top;
-            panelTitleTemp.Location = new Point(0, 0);
-            panelTitleTemp.Name = "panelTitleTemp";
-            panelTitleTemp.Size = new Size(520, 66);
-            panelTitleTemp.TabIndex = 50;
-            // 
-            // pictureTemp
-            // 
-            pictureTemp.BackgroundImage = Properties.Resources.icons8_temperature_48;
-            pictureTemp.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureTemp.InitialImage = null;
-            pictureTemp.Location = new Point(10, 18);
-            pictureTemp.Margin = new Padding(4, 2, 4, 10);
-            pictureTemp.Name = "pictureTemp";
-            pictureTemp.Size = new Size(36, 38);
-            pictureTemp.TabIndex = 48;
-            pictureTemp.TabStop = false;
-            // 
-            // labelTempLimit
-            // 
-            labelTempLimit.AutoSize = true;
-            labelTempLimit.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelTempLimit.Location = new Point(51, 20);
-            labelTempLimit.Margin = new Padding(4, 0, 4, 0);
-            labelTempLimit.Name = "labelTempLimit";
-            labelTempLimit.Size = new Size(140, 32);
-            labelTempLimit.TabIndex = 47;
-            labelTempLimit.Text = "Temp Limit";
-            // 
             // panelAdvancedApply
             // 
             panelAdvancedApply.Controls.Add(checkApplyUV);
@@ -618,11 +537,14 @@ namespace GHelper
             // 
             // labelRisky
             // 
+            labelRisky.BackColor = Color.IndianRed;
             labelRisky.Dock = DockStyle.Top;
+            labelRisky.ForeColor = SystemColors.ControlLightLight;
             labelRisky.Location = new Point(0, 504);
+            labelRisky.Margin = new Padding(0, 0, 0, 0);
             labelRisky.Name = "labelRisky";
             labelRisky.Padding = new Padding(10, 10, 10, 5);
-            labelRisky.Size = new Size(520, 198);
+            labelRisky.Size = new Size(520, 220);
             labelRisky.TabIndex = 46;
             labelRisky.Text = resources.GetString("labelRisky.Text");
             // 
@@ -755,6 +677,87 @@ namespace GHelper
             labelTitleUV.TabIndex = 47;
             labelTitleUV.Text = "Undervolting";
             // 
+            // panelTemperature
+            // 
+            panelTemperature.AutoSize = true;
+            panelTemperature.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelTemperature.Controls.Add(labelTemp);
+            panelTemperature.Controls.Add(labelLeftTemp);
+            panelTemperature.Controls.Add(trackTemp);
+            panelTemperature.Dock = DockStyle.Top;
+            panelTemperature.Location = new Point(0, 66);
+            panelTemperature.Margin = new Padding(4);
+            panelTemperature.MaximumSize = new Size(0, 124);
+            panelTemperature.Name = "panelTemperature";
+            panelTemperature.Size = new Size(520, 124);
+            panelTemperature.TabIndex = 51;
+            // 
+            // labelTemp
+            // 
+            labelTemp.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelTemp.Location = new Point(347, 13);
+            labelTemp.Margin = new Padding(4, 0, 4, 0);
+            labelTemp.Name = "labelTemp";
+            labelTemp.Size = new Size(148, 32);
+            labelTemp.TabIndex = 13;
+            labelTemp.Text = "T";
+            labelTemp.TextAlign = ContentAlignment.TopRight;
+            // 
+            // labelLeftTemp
+            // 
+            labelLeftTemp.AutoSize = true;
+            labelLeftTemp.Location = new Point(10, 10);
+            labelLeftTemp.Margin = new Padding(4, 0, 4, 0);
+            labelLeftTemp.Name = "labelLeftTemp";
+            labelLeftTemp.Size = new Size(183, 32);
+            labelLeftTemp.TabIndex = 12;
+            labelLeftTemp.Text = "CPU Temp Limit";
+            // 
+            // trackTemp
+            // 
+            trackTemp.Location = new Point(6, 48);
+            trackTemp.Margin = new Padding(4, 2, 4, 2);
+            trackTemp.Maximum = 0;
+            trackTemp.Minimum = -40;
+            trackTemp.Name = "trackTemp";
+            trackTemp.Size = new Size(508, 90);
+            trackTemp.TabIndex = 11;
+            trackTemp.TickFrequency = 5;
+            trackTemp.TickStyle = TickStyle.TopLeft;
+            // 
+            // panelTitleTemp
+            // 
+            panelTitleTemp.Controls.Add(pictureTemp);
+            panelTitleTemp.Controls.Add(labelTempLimit);
+            panelTitleTemp.Dock = DockStyle.Top;
+            panelTitleTemp.Location = new Point(0, 0);
+            panelTitleTemp.Name = "panelTitleTemp";
+            panelTitleTemp.Size = new Size(520, 66);
+            panelTitleTemp.TabIndex = 50;
+            // 
+            // pictureTemp
+            // 
+            pictureTemp.BackgroundImage = Properties.Resources.icons8_temperature_48;
+            pictureTemp.BackgroundImageLayout = ImageLayout.Zoom;
+            pictureTemp.InitialImage = null;
+            pictureTemp.Location = new Point(10, 18);
+            pictureTemp.Margin = new Padding(4, 2, 4, 10);
+            pictureTemp.Name = "pictureTemp";
+            pictureTemp.Size = new Size(36, 38);
+            pictureTemp.TabIndex = 48;
+            pictureTemp.TabStop = false;
+            // 
+            // labelTempLimit
+            // 
+            labelTempLimit.AutoSize = true;
+            labelTempLimit.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelTempLimit.Location = new Point(51, 20);
+            labelTempLimit.Margin = new Padding(4, 0, 4, 0);
+            labelTempLimit.Name = "labelTempLimit";
+            labelTempLimit.Size = new Size(140, 32);
+            labelTempLimit.TabIndex = 47;
+            labelTempLimit.Text = "Temp Limit";
+            // 
             // panelPower
             // 
             panelPower.AutoSize = true;
@@ -1393,12 +1396,6 @@ namespace GHelper
             panelSliders.PerformLayout();
             panelAdvanced.ResumeLayout(false);
             panelAdvanced.PerformLayout();
-            panelTemperature.ResumeLayout(false);
-            panelTemperature.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)trackTemp).EndInit();
-            panelTitleTemp.ResumeLayout(false);
-            panelTitleTemp.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)pictureTemp).EndInit();
             panelAdvancedApply.ResumeLayout(false);
             panelUViGPU.ResumeLayout(false);
             panelUViGPU.PerformLayout();
@@ -1409,6 +1406,12 @@ namespace GHelper
             panelTitleAdvanced.ResumeLayout(false);
             panelTitleAdvanced.PerformLayout();
             ((System.ComponentModel.ISupportInitialize)pictureUV).EndInit();
+            panelTemperature.ResumeLayout(false);
+            panelTemperature.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackTemp).EndInit();
+            panelTitleTemp.ResumeLayout(false);
+            panelTitleTemp.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)pictureTemp).EndInit();
             panelPower.ResumeLayout(false);
             panelPower.PerformLayout();
             panelApplyPower.ResumeLayout(false);

app/Fans.cs

@@ -1,10 +1,8 @@
-using CustomControls;
-using GHelper.Gpu;
+using GHelper.Gpu.NVidia;
+using GHelper.Mode;
+using GHelper.UI;
 using Ryzen;
-using System;
 using System.Diagnostics;
-using System.Net.Sockets;
-using System.Windows.Forms;
 using System.Windows.Forms.DataVisualization.Charting;
 
 namespace GHelper
@@ -13,7 +11,7 @@ namespace GHelper
     {
 
         int curIndex = -1;
-        DataPoint curPoint = null;
+        DataPoint? curPoint = null;
 
         Series seriesCPU;
         Series seriesGPU;
@@ -27,6 +25,7 @@ namespace GHelper
         const int fansMax = 100;
 
         NvidiaGpuControl? nvControl = null;
+        ModeControl modeControl = Program.modeControl;
 
         public Fans()
         {
@@ -53,6 +52,8 @@ namespace GHelper
             labelGPUBoostTitle.Text = Properties.Strings.GPUBoost;
             labelGPUTempTitle.Text = Properties.Strings.GPUTempTarget;
 
+            labelRisky.Text = Properties.Strings.UndervoltingRisky;
+
             InitTheme(true);
 
             MinRPM = 18;
@@ -133,14 +134,14 @@ namespace GHelper
             labelFansResult.Visible = false;
 
 
-            trackUV.Minimum = -30;
-            trackUV.Maximum = 0;
+            trackUV.Minimum = RyzenControl.MinCPUUV;
+            trackUV.Maximum = RyzenControl.MaxCPUUV;
 
-            trackUViGPU.Minimum = -20;
-            trackUViGPU.Maximum = 0;
+            trackUViGPU.Minimum = RyzenControl.MinIGPUUV;
+            trackUViGPU.Maximum = RyzenControl.MaxIGPUUV;
 
-            trackTemp.Minimum = 75;
-            trackTemp.Maximum = 97;
+            trackTemp.Minimum = RyzenControl.MinTemp;
+            trackTemp.Maximum = RyzenControl.MaxTemp;
 
 
             FillModes();
@@ -177,11 +178,20 @@ namespace GHelper
 
             ToggleNavigation(0);
 
+            FormClosed += Fans_FormClosed;
+
+        }
+
+        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()
@@ -244,7 +254,7 @@ namespace GHelper
 
         private void ButtonApplyAdvanced_Click(object? sender, EventArgs e)
         {
-            Program.settingsForm.SetUV(true);
+            modeControl.SetRyzen(true);
             checkApplyUV.Enabled = true;
         }
 
@@ -255,7 +265,9 @@ 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 = Math.Max(trackTemp.Minimum, Math.Min(trackTemp.Maximum, AppConfig.GetMode("cpu_temp", 96)));
+
+            int temp = AppConfig.GetMode("cpu_temp");
+            if (temp < trackTemp.Minimum || temp > trackTemp.Maximum) temp = 96;
 
             checkApplyUV.Enabled = checkApplyUV.Checked = AppConfig.IsMode("auto_uv");
 
@@ -269,12 +281,11 @@ namespace GHelper
             labelTemp.Text = trackTemp.Value.ToString() + "°C";
 
 
-            buttonAdvanced.Visible = Undervolter.IsAMD();
+            buttonAdvanced.Visible = RyzenControl.IsAMD();
 
         }
 
-
-        private void TrackUV_Scroll(object? sender, EventArgs e)
+        private void AdvancedScroll()
         {
             AppConfig.SetMode("auto_uv", 0);
             checkApplyUV.Enabled = checkApplyUV.Checked = false;
@@ -286,7 +297,12 @@ namespace GHelper
             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)
+        {
+            AdvancedScroll();
         }
 
         private void ComboModes_KeyPress(object? sender, KeyPressEventArgs e)
@@ -326,7 +342,7 @@ namespace GHelper
             Modes.Remove(mode);
             FillModes();
 
-            Program.settingsForm.SetPerformanceMode(AsusACPI.PerformanceBalanced);
+            modeControl.SetPerformanceMode(AsusACPI.PerformanceBalanced);
 
         }
 
@@ -342,7 +358,7 @@ namespace GHelper
         {
             int mode = Modes.Add();
             FillModes();
-            Program.settingsForm.SetPerformanceMode(mode);
+            modeControl.SetPerformanceMode(mode);
         }
 
         public void InitMode()
@@ -361,13 +377,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()
@@ -555,13 +571,13 @@ namespace GHelper
 
         private void TrackPower_MouseUp(object? sender, MouseEventArgs e)
         {
-            Program.settingsForm.AutoPower();
+            modeControl.AutoPower();
         }
 
 
         public void InitBoost()
         {
-            int boost = NativeMethods.GetCPUBoost();
+            int boost = PowerNative.GetCPUBoost();
             if (boost >= 0)
                 comboBoost.SelectedIndex = Math.Min(boost, comboBoost.Items.Count - 1);
         }
@@ -570,7 +586,7 @@ namespace GHelper
         {
             if (AppConfig.GetMode("auto_boost") != comboBoost.SelectedIndex)
             {
-                NativeMethods.SetCPUBoost(comboBoost.SelectedIndex);
+                PowerNative.SetCPUBoost(comboBoost.SelectedIndex);
             }
             AppConfig.SetMode("auto_boost", comboBoost.SelectedIndex);
         }
@@ -581,7 +597,7 @@ namespace GHelper
             CheckBox chk = (CheckBox)sender;
 
             AppConfig.SetMode("auto_apply_power", chk.Checked ? 1 : 0);
-            Program.settingsForm.SetPerformanceMode();
+            modeControl.SetPerformanceMode();
 
         }
 
@@ -591,7 +607,7 @@ namespace GHelper
             CheckBox chk = (CheckBox)sender;
 
             AppConfig.SetMode("auto_apply", chk.Checked ? 1 : 0);
-            Program.settingsForm.SetPerformanceMode();
+            modeControl.SetPerformanceMode();
 
         }
 
@@ -617,13 +633,15 @@ 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 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)
@@ -821,15 +839,18 @@ namespace GHelper
             AppConfig.SetMode("auto_apply", 0);
             AppConfig.SetMode("auto_apply_power", 0);
 
-            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
-
-            if (Program.acpi.IsXGConnected())
-                AsusUSB.ResetXGM();
 
             trackUV.Value = 0;
             trackUViGPU.Value = 0;
-            AppConfig.SetMode("cpu_uv", 0);
-            AppConfig.SetMode("igpu_uv", 0);
+            trackTemp.Value = 96;
+
+            AdvancedScroll();
+            AppConfig.SetMode("cpu_temp", -1);
+
+            modeControl.ResetPerformanceMode();
+            
+            if (Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
+
 
             if (gpuVisible)
             {
@@ -844,8 +865,8 @@ namespace GHelper
                 AppConfig.SetMode("gpu_memory", trackGPUMemory.Value);
 
                 VisualiseGPUSettings();
-                Program.settingsForm.SetGPUClocks(true);
-                Program.settingsForm.SetGPUPower();
+                modeControl.SetGPUClocks(true);
+                modeControl.SetGPUPower();
             }
 
         }
@@ -866,7 +887,7 @@ namespace GHelper
             if (AppConfig.Is("xgm_fan"))
                 SaveProfile(seriesXGM, AsusFan.XGM);
 
-            Program.settingsForm.AutoFans();
+            modeControl.AutoFans();
 
 
         }
@@ -963,8 +984,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/GHelper.csproj

@@ -16,7 +16,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.88</AssemblyVersion>
+    <AssemblyVersion>0.93</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -63,6 +63,7 @@
     <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,325 @@
+using GHelper.Display;
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using System.Diagnostics;
+
+namespace GHelper.Gpu
+{
+    public class GPUModeControl
+    {
+        SettingsForm settings;
+        ScreenControl screenControl = new ScreenControl();
+
+        public GPUModeControl(SettingsForm settingsForm)
+        {
+            settings = settingsForm;
+        }
+
+        public void InitGPUMode()
+        {
+            int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+            int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
+
+            Logger.WriteLine("Eco flag : " + eco);
+            Logger.WriteLine("Mux flag : " + mux);
+
+            int GpuMode;
+
+            if (mux == 0)
+            {
+                GpuMode = AsusACPI.GPUModeUltimate;
+            }
+            else
+            {
+                if (eco == 1)
+                    GpuMode = AsusACPI.GPUModeEco;
+                else
+                    GpuMode = AsusACPI.GPUModeStandard;
+
+                // Ultimate mode not suported
+                if (mux != 1) settings.HideUltimateMode();
+                // GPU mode not supported
+                if (eco < 0 && mux < 0) settings.HideGPUModes();
+            }
+
+            AppConfig.Set("gpu_mode", GpuMode);
+
+            InitXGM();
+            settings.VisualiseGPUMode(GpuMode);
+        }
+
+
+        public void SetGPUMode(int GPUMode)
+        {
+
+            int CurrentGPU = AppConfig.Get("gpu_mode");
+            AppConfig.Set("gpu_auto", 0);
+
+            if (CurrentGPU == GPUMode)
+            {
+                settings.VisualiseGPUMode();
+                return;
+            }
+
+            var restart = false;
+            var changed = false;
+
+            if (CurrentGPU == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+            }
+            else if (GPUMode == AsusACPI.GPUModeUltimate)
+            {
+                DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+                if (dialogResult == DialogResult.Yes)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
+                    restart = true;
+                    changed = true;
+                }
+
+            }
+            else if (GPUMode == AsusACPI.GPUModeEco)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(1, true);
+                changed = true;
+            }
+            else if (GPUMode == AsusACPI.GPUModeStandard)
+            {
+                settings.VisualiseGPUMode(GPUMode);
+                SetGPUEco(0);
+                changed = true;
+            }
+
+            if (changed)
+            {
+                AppConfig.Set("gpu_mode", GPUMode);
+            }
+
+            if (restart)
+            {
+                settings.VisualiseGPUMode();
+                Process.Start("shutdown", "/r /t 1");
+            }
+
+        }
+
+
+
+        public void SetGPUEco(int eco, bool hardWay = false)
+        {
+
+            settings.LockGPUModes();
+
+            Task.Run(async () =>
+            {
+
+                int status = 1;
+
+                if (eco == 1)
+                {
+                    if (NvidiaSmi.GetDisplayActiveStatus())
+                    {
+                        DialogResult dialogResult = MessageBox.Show(Properties.Strings.EnableOptimusText, Properties.Strings.EnableOptimusTitle, MessageBoxButtons.YesNo);
+                        if (dialogResult == DialogResult.No)
+                        {
+                            InitGPUMode();
+                            return;
+                        }
+                    }
+
+                    HardwareControl.KillGPUApps();
+                }
+
+                Logger.WriteLine($"Running eco command {eco}");
+
+                status = Program.acpi.SetGPUEco(eco);
+
+                if (status == 0 && eco == 1 && hardWay) RestartGPU();
+
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                    screenControl.AutoScreen();
+                });
+
+                if (eco == 0)
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    HardwareControl.RecreateGpuControl();
+                    Program.modeControl.SetGPUClocks(false);
+                }
+
+            });
+
+
+        }
+
+        public static bool IsPlugged()
+        {
+            bool optimizedUSBC = AppConfig.Get("optimized_usbc") != 1;
+
+            return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online &&
+                   (optimizedUSBC || Program.acpi.DeviceGet(AsusACPI.ChargerMode) < AsusACPI.ChargerUSB);
+
+        }
+
+        public bool AutoGPUMode(bool optimized = false)
+        {
+
+            bool GpuAuto = AppConfig.Is("gpu_auto");
+            bool ForceGPU = AppConfig.ContainsModel("503");
+
+            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);
+                return false;
+            }
+            else
+            {
+
+                if (ReEnableGPU()) return true;
+
+                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 bool ReEnableGPU()
+        {
+
+            if (AppConfig.Get("gpu_reenable") != 1) return false;
+            if (Screen.AllScreens.Length <= 1) return false;
+
+            Logger.WriteLine("Re-enabling gpu for 503 model");
+
+            Thread.Sleep(1000);
+            SetGPUEco(1);
+            Thread.Sleep(1000);
+            SetGPUEco(0);
+            return true;
+        }
+
+        public void InitXGM()
+        {
+            bool connected = Program.acpi.IsXGConnected();
+            int activated = Program.acpi.DeviceGet(AsusACPI.GPUXG);
+            settings.VisualizeXGM(connected, activated == 1);
+        }
+
+        public void ToggleXGM()
+        {
+
+            Task.Run(async () =>
+            {
+                settings.LockGPUModes();
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
+                {
+                    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
+                {
+                    Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
+                    AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
+
+                    await Task.Delay(TimeSpan.FromSeconds(15));
+
+                    if (AppConfig.IsMode("auto_apply"))
+                        AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                }
+
+                settings.Invoke(delegate
+                {
+                    InitGPUMode();
+                });
+            });
+        }
+
+        public void KillGPUApps()
+        {
+            if (HardwareControl.GpuControl is not null)
+            {
+                HardwareControl.GpuControl.KillGPUApps();
+            }
+        }
+
+    }
+}

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,13 +7,13 @@ 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;
@@ -55,7 +56,16 @@ 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)
         {
@@ -79,6 +89,12 @@ 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}");
+
+            foreach (var delta in states.Voltages[PerformanceStateId.P0_3DPerformance])
+            {
+                Logger.WriteLine("GPU VOLT:" + delta.IsEditable + " - " + delta.ValueDeltaInMicroVolt.DeltaValue);
+            }
+
             return 0;
 
         }
@@ -111,13 +127,13 @@ public class NvidiaGpuControl : IGpuControl
 
     public int SetClocksFromConfig()
     {
-        int core = AppConfig.Get("gpu_core",0);
-        int memory = AppConfig.Get("gpu_memory",0);
+        int core = AppConfig.Get("gpu_core", 0);
+        int memory = AppConfig.Get("gpu_memory", 0);
         int status = SetClocks(core, memory);
         return status;
     }
 
-    public int SetClocks(int core, int memory)
+    public int SetClocks(int core, int memory, int voltage = 0)
     {
 
         if (core < MinCoreOffset || core > MaxCoreOffset) return 0;
@@ -127,6 +143,7 @@ public class NvidiaGpuControl : IGpuControl
 
         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 = { };

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,5 +1,9 @@
 using GHelper;
 using GHelper.Gpu;
+using GHelper.Gpu.NVidia;
+using GHelper.Gpu.AMD;
+
+using GHelper.Helpers;
 using System.Diagnostics;
 
 public static class HardwareControl
@@ -20,7 +24,7 @@ public static class HardwareControl
     {
         int max = 58;
         int configMax = AppConfig.Get("fan_max");
-        if (configMax > 100) configMax = 0; // skipping inadvequate settings
+        if (configMax > 80) configMax = 0; // skipping inadvequate settings
 
         if (AppConfig.ContainsModel("401")) max = 72;
         else if (AppConfig.ContainsModel("503")) max = 68;
@@ -41,7 +45,7 @@ public static class HardwareControl
         }
 
         int fanMax = GetFanMax();
-        if (fan > fanMax && fan < 110) SetFanMax(fan);
+        if (fan > fanMax && fan < 80) SetFanMax(fan);
 
         if (AppConfig.Is("fan_rpm"))
             return GHelper.Properties.Strings.FanSpeed + (fan * 100).ToString() + "RPM";
@@ -188,14 +192,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/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,7 +3,7 @@ using System.Diagnostics;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace GHelper
+namespace GHelper.Helpers
 {
     public static class OptimizationService
     {
@@ -52,7 +52,7 @@ namespace GHelper
 
         public static bool IsRunning()
         {
-            return (Process.GetProcessesByName("AsusOptimization").Count() > 0);
+            return Process.GetProcessesByName("AsusOptimization").Count() > 0;
         }
 
         public static int GetRunningCount()
@@ -66,7 +66,7 @@ namespace GHelper
         }
 
 
-            public static void SetBacklightOffDelay(int value = 60)
+        public static void SetBacklightOffDelay(int value = 60)
         {
             try
             {

app/Helpers/ProcessHelper.cs

@@ -6,7 +6,7 @@ using System.Security.Principal;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace GHelper
+namespace GHelper.Helpers
 {
     public static class ProcessHelper
     {
@@ -61,7 +61,8 @@ namespace GHelper
                 {
                     Process.Start(startInfo);
                     Application.Exit();
-                } catch (Exception ex)
+                }
+                catch (Exception ex)
                 {
                     Logger.WriteLine(ex.Message);
                 }

app/Helpers/ScreenBrightness.cs

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

app/Helpers/Startup.cs

@@ -1,4 +1,4 @@
-using GHelper;
+using GHelper.Helpers;
 using Microsoft.Win32.TaskScheduler;
 using System.Diagnostics;
 using System.Security.Principal;
@@ -34,8 +34,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,37 @@ 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();
+            Program.settingsForm.Invoke(delegate
+            {
+                //Hide();
+                timer.Stop();
 
-            toastText = text;
-            toastIcon = icon;
+                toastText = text;
+                toastIcon = icon;
 
-            Screen screen1 = Screen.FromHandle(base.Handle);
+                Screen screen1 = Screen.FromHandle(Handle);
 
-            Width = Math.Max(300, 100 + toastText.Length * 22);
-            Height = 100;
-            X = (screen1.Bounds.Width - this.Width) / 2;
-            Y = screen1.Bounds.Height - 300 - this.Height;
+                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

@@ -1,54 +1,13 @@
-using HidLibrary;
+using GHelper.Display;
+using GHelper.Helpers;
+using GHelper.Mode;
 using Microsoft.Win32;
 using NAudio.CoreAudioApi;
 using System.Diagnostics;
 using System.Management;
 
-namespace GHelper
+namespace GHelper.Input
 {
-    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
     {
@@ -58,6 +17,9 @@ namespace GHelper
         public static Keys keyProfile = Keys.F5;
         public static Keys keyApp = Keys.F12;
 
+        static ModeControl modeControl = Program.modeControl;
+        static ScreenControl screenControl = new ScreenControl();
+
         KeyboardListener listener;
         KeyboardHook hook = new KeyboardHook();
 
@@ -123,8 +85,8 @@ namespace GHelper
 
         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);
+            timer.Enabled = AppConfig.Get("keyboard_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online ||
+                            AppConfig.Get("keyboard_ac_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
         }
 
 
@@ -145,7 +107,7 @@ namespace GHelper
 
             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);
+            if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
 
             // FN-Lock group
 
@@ -241,12 +203,12 @@ namespace GHelper
                         break;
                     case Keys.F7:
                         if (AppConfig.ContainsModel("TUF"))
-                            Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, ScreenBrightness.Adjust(-10) + "%", ToastIcon.BrightnessDown);
+                            Program.toast.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);
+                        if (AppConfig.ContainsModel("TUF"))
+                            Program.toast.RunToast(ScreenBrightness.Adjust(+10) + "%", ToastIcon.BrightnessUp);
                         HandleOptimizationEvent(32);
                         break;
                     case Keys.F9:
@@ -274,7 +236,7 @@ namespace GHelper
 
             if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift))
             {
-                if (e.Key == keyProfile) Program.settingsForm.CyclePerformanceMode();
+                if (e.Key == keyProfile) modeControl.CyclePerformanceMode();
                 if (e.Key == keyApp) Program.SettingsToggle();
             }
 
@@ -316,13 +278,13 @@ namespace GHelper
                     NativeMethods.TurnOffScreen(Program.settingsForm.Handle);
                     break;
                 case "miniled":
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.ToogleMiniled);
+                    screenControl.ToogleMiniled();
                     break;
                 case "aura":
                     Program.settingsForm.BeginInvoke(Program.settingsForm.CycleAuraMode);
                     break;
                 case "performance":
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.CyclePerformanceMode);
+                    modeControl.CyclePerformanceMode();
                     break;
                 case "ghelper":
                     Program.settingsForm.BeginInvoke(delegate
@@ -339,7 +301,7 @@ namespace GHelper
                         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);
+                        Program.toast.RunToast(muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
                     }
                     break;
                 case "brightness_up":
@@ -361,7 +323,7 @@ namespace GHelper
         {
             using (var key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\PrecisionTouchPad\Status", false))
             {
-                return (key?.GetValue("Enabled")?.ToString() == "1");
+                return key?.GetValue("Enabled")?.ToString() == "1";
             }
         }
 
@@ -371,11 +333,11 @@ namespace GHelper
             AppConfig.Set("fn_lock", fnLock);
 
             if (AppConfig.ContainsModel("VivoBook"))
-                Program.acpi.DeviceSet(AsusACPI.FnLock, (fnLock == 1) ? 0 : 1, "FnLock");
+                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);
+            Program.toast.RunToast("Fn-Lock " + (fnLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
         }
 
         public static void TabletMode()
@@ -385,7 +347,7 @@ namespace GHelper
 
             Logger.WriteLine("Tablet: " + tabletState + " Touchpad: " + touchpadState);
 
-            if ((tabletState && touchpadState) || (!tabletState && !touchpadState)) AsusUSB.TouchpadToggle();
+            if (tabletState && touchpadState || !tabletState && !touchpadState) AsusUSB.TouchpadToggle();
 
         }
 
@@ -400,7 +362,7 @@ namespace GHelper
                     KeyProcess("m4");
                     return;
                 case 174:   // FN+F5
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.CyclePerformanceMode);
+                    modeControl.CyclePerformanceMode();
                     return;
                 case 179:   // FN+F4
                 case 178:   // FN+F4
@@ -429,29 +391,28 @@ namespace GHelper
                     return;
             }
 
-            if (!OptimizationService.IsRunning()) 
-                
+            if (!OptimizationService.IsRunning())
                 HandleOptimizationEvent(EventID);
 
-            // Asus Optimization service Events 
-
-
         }
 
+        // Asus Optimization service Events 
         static void HandleOptimizationEvent(int EventID)
         {
             switch (EventID)
             {
                 case 16: // FN+F7
+                    //ScreenBrightness.Adjust(-10);
                     Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
                     break;
                 case 32: // FN+F8
+                    //ScreenBrightness.Adjust(+10);
                     Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
                     break;
                 case 107: // FN+F10
                     bool touchpadState = GetTouchpadState();
                     AsusUSB.TouchpadToggle();
-                    Program.settingsForm.BeginInvoke(Program.settingsForm.RunToast, touchpadState ? "Off" : "On", ToastIcon.Touchpad);
+                    Program.toast.RunToast(touchpadState ? "Off" : "On", ToastIcon.Touchpad);
                     break;
                 case 108: // FN+F11
                     Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
@@ -491,8 +452,8 @@ namespace GHelper
             int backlight = onBattery ? backlight_battery : backlight_power;
 
             if (delta >= 4)
-                backlight = (++backlight % 4);
-            else 
+                backlight = ++backlight % 4;
+            else
                 backlight = Math.Max(Math.Min(3, backlight + delta), 0);
 
             if (onBattery)
@@ -504,7 +465,7 @@ namespace GHelper
             {
                 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);
+                Program.toast.RunToast(backlightNames[backlight], delta > 0 ? ToastIcon.BacklightUp : ToastIcon.BacklightDown);
             }
 
         }

app/Input/KeyboardListener.cs

@@ -0,0 +1,56 @@
+using HidLibrary;
+
+namespace GHelper.Input
+{
+    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)
+                    {
+
+                        // Emergency break
+                        if (input == null || !input.IsConnected)
+                        {
+                            Logger.WriteLine("Listener terminated");
+                            break;
+                        }
+
+                        var data = input.Read().Data;
+                        if (data.Length > 1 && data[0] == AsusUSB.INPUT_HID_ID && data[1] > 0 && data[1] != 236)
+                        {
+                            Logger.WriteLine($"Key: {data[1]}");
+                            KeyHandler(data[1]);
+                        }
+                    }
+
+                    Logger.WriteLine("Listener stopped");
+
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.ToString());
+                }
+            });
+
+
+        }
+
+        public void Dispose()
+        {
+            cancellationTokenSource?.Cancel();
+        }
+    }
+}

app/Mode/ModeControl.cs

@@ -0,0 +1,407 @@
+using GHelper.Gpu.NVidia;
+using GHelper.Helpers;
+using Ryzen;
+
+namespace GHelper.Mode
+{
+    public class ModeControl
+    {
+
+        static SettingsForm settings = Program.settingsForm;
+
+        private static bool customFans = false;
+        private static int customPower = 0;
+
+        private int _cpuUV = 0;
+        private int _igpuUV = 0;
+
+        static System.Timers.Timer reapplyTimer = default!;
+
+        public ModeControl()
+        {
+            reapplyTimer = new System.Timers.Timer(AppConfig.GetMode("reapply_time", 30) * 1000);
+            reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
+            reapplyTimer.Enabled = false;
+        }
+
+        private void ReapplyTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            SetCPUTemp(AppConfig.GetMode("cpu_temp"), false);
+        }
+
+        public void AutoPerformance(bool powerChanged = false)
+        {
+            var Plugged = SystemInformation.PowerStatus.PowerLineStatus;
+
+            int mode = AppConfig.Get("performance_" + (int)Plugged);
+
+            if (mode != -1)
+                SetPerformanceMode(mode, powerChanged);
+            else
+                SetPerformanceMode(Modes.GetCurrent());
+        }
+
+
+        public void ResetPerformanceMode()
+        {
+            ResetRyzen();
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
+        }
+
+        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);
+
+            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
+
+            if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
+
+            if (notify)
+                Program.toast.RunToast(Modes.GetCurrentName(), SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online ? ToastIcon.Charger : ToastIcon.Battery);
+
+            SetGPUClocks();
+            AutoFans();
+            AutoPower(1000);
+
+            if (AppConfig.Get("auto_apply_power_plan") != 0)
+            {
+                if (AppConfig.GetModeString("scheme") is not null)
+                    PowerNative.SetPowerScheme(AppConfig.GetModeString("scheme"));
+                else
+                    PowerNative.SetPowerScheme(Modes.GetBase(mode));
+            }
+
+            if (AppConfig.GetMode("auto_boost") != -1)
+            {
+                PowerNative.SetCPUBoost(AppConfig.GetMode("auto_boost"));
+            }
+
+            /*
+            if (NativeMethods.PowerGetEffectiveOverlayScheme(out Guid activeScheme) == 0)
+            {
+                Debug.WriteLine("Effective :" + activeScheme);
+            }
+            */
+
+            settings.FansInit();
+        }
+
+
+        public void CyclePerformanceMode()
+        {
+            SetPerformanceMode(Modes.GetNext(Control.ModifierKeys == Keys.Shift), true);
+        }
+
+        public void AutoFans(bool force = false)
+        {
+            customFans = false;
+
+            if (AppConfig.IsMode("auto_apply") || force)
+            {
+
+                bool xgmFan = false;
+                if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected())
+                {
+                    AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                    xgmFan = true;
+                }
+
+                int cpuResult = Program.acpi.SetFanCurve(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
+                int gpuResult = Program.acpi.SetFanCurve(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
+
+                if (AppConfig.Is("mid_fan"))
+                    Program.acpi.SetFanCurve(AsusFan.Mid, AppConfig.GetFanConfig(AsusFan.Mid));
+
+
+                // something went wrong, resetting to default profile
+                if (cpuResult != 1 || gpuResult != 1)
+                {
+                    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.ContainsModel("FX507") || AppConfig.ContainsModel("FX517") || 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();
+
+        }
+
+        private static bool IsManualModeRequired()
+        {
+            if (!AppConfig.IsMode("auto_apply_power"))
+                return false;
+
+            return
+                AppConfig.Is("manual_mode") ||
+                AppConfig.ContainsModel("GU603") ||
+                AppConfig.ContainsModel("GU604") ||
+                AppConfig.ContainsModel("G733");
+        }
+
+        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)
+            {
+                // force fan curve for misbehaving bios PPTs on G513
+                if (AppConfig.ContainsModel("G513") && !applyFans)
+                {
+                    delay = 500;
+                    AutoFans(true);
+                }
+
+                // Fix for models that don't support PPT settings in all modes, setting a "manual" mode for them
+                if (IsManualModeRequired() && !applyFans)
+                {
+                    AutoFans(true);
+                }
+            }
+
+            if (delay > 0)
+            {
+                var timer = new System.Timers.Timer(delay);
+                timer.Elapsed += delegate
+                {
+                    timer.Stop();
+                    timer.Dispose();
+
+                    if (applyPower) SetPower();
+                    SetGPUPower();
+                    AutoRyzen();
+                };
+                timer.Start();
+            }
+            else
+            {
+                if (applyPower) SetPower(true);
+                SetGPUPower();
+                AutoRyzen();
+            }
+
+        }
+
+        public void SetModeLabel()
+        {
+            settings.SetModeLabel(Properties.Strings.PerformanceMode + ": " + Modes.GetCurrentName() + (customFans ? "+" : "") + ((customPower > 0) ? " " + customPower + "W" : ""));
+        }
+
+        public void SetPower(bool launchAsAdmin = false)
+        {
+
+            int limit_total = AppConfig.GetMode("limit_total");
+            int limit_cpu = AppConfig.GetMode("limit_cpu");
+            int limit_fast = AppConfig.GetMode("limit_fast");
+
+            if (limit_total > AsusACPI.MaxTotal) return;
+            if (limit_total < AsusACPI.MinTotal) return;
+
+            if (limit_cpu > AsusACPI.MaxCPU) return;
+            if (limit_cpu < AsusACPI.MinCPU) return;
+
+            if (limit_fast > AsusACPI.MaxTotal) return;
+            if (limit_fast < AsusACPI.MinTotal) return;
+
+            // SPL + SPPT togeher in one slider
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0)
+            {
+                Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, limit_total, "PowerLimit A0");
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, limit_total, "PowerLimit A3");
+                customPower = limit_total;
+            }
+            else if (RyzenControl.IsAMD())
+            {
+
+                if (ProcessHelper.IsUserAdministrator())
+                {
+                    SendCommand.set_stapm_limit((uint)limit_total * 1000);
+                    SendCommand.set_stapm2_limit((uint)limit_total * 1000);
+                    SendCommand.set_slow_limit((uint)limit_total * 1000);
+                    SendCommand.set_fast_limit((uint)limit_total * 1000);
+                    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)
+        {
+
+            int gpu_core = AppConfig.GetMode("gpu_core");
+            int gpu_memory = AppConfig.GetMode("gpu_memory");
+
+            if (gpu_core == -1 && gpu_memory == -1) return;
+
+            //if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
+
+            if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) return;
+            if (HardwareControl.GpuControl is null) return;
+            if (!HardwareControl.GpuControl!.IsNvidia) return;
+
+            using NvidiaGpuControl nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+            try
+            {
+                int getStatus = nvControl.GetClocks(out int current_core, out int current_memory);
+                if (getStatus != -1)
+                {
+                    if (Math.Abs(gpu_core - current_core) < 5 && Math.Abs(gpu_memory - current_memory) < 5) return;
+                }
+
+                int setStatus = nvControl.SetClocks(gpu_core, gpu_memory);
+                if (launchAsAdmin && setStatus == -1) ProcessHelper.RunAsAdmin("gpu");
+
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+        }
+
+        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 (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 (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
     {

app/Mode/PowerNative.cs

@@ -0,0 +1,161 @@
+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");
+
+        [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);
+
+
+        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/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;
@@ -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
-            );
-        }
-    }
-}

app/NvAPIWrapper/NVIDIA.cs

@@ -1,81 +0,0 @@
-using NvAPIWrapper.Native;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Interfaces.General;
-
-namespace NvAPIWrapper
-{
-    /// <summary>
-    ///     .Net friendly version of system and general functions of NVAPI library
-    /// </summary>
-    public static class NVIDIA
-    {
-        /// <summary>
-        ///     Gets information about the system's chipset.
-        /// </summary>
-        public static IChipsetInfo ChipsetInfo
-        {
-            get => GeneralApi.GetChipsetInfo();
-        }
-
-        /// <summary>
-        ///     Gets NVIDIA driver branch version as string
-        /// </summary>
-        public static string DriverBranchVersion
-        {
-            get
-            {
-                GeneralApi.GetDriverAndBranchVersion(out var branchVersion);
-
-                return branchVersion;
-            }
-        }
-
-        /// <summary>
-        ///     Gets NVIDIA driver version
-        /// </summary>
-        public static uint DriverVersion
-        {
-            get => GeneralApi.GetDriverAndBranchVersion(out _);
-        }
-
-        /// <summary>
-        ///     Gets NVAPI interface version as string
-        /// </summary>
-        public static string InterfaceVersionString
-        {
-            get => GeneralApi.GetInterfaceVersionString();
-        }
-
-        /// <summary>
-        ///     Gets the current lid and dock information.
-        /// </summary>
-        public static LidDockParameters LidAndDockParameters
-        {
-            get => GeneralApi.GetLidAndDockInfo();
-        }
-
-        /// <summary>
-        ///     Initializes the NvAPI library (if not already initialized) but always increments the ref-counter.
-        /// </summary>
-        public static void Initialize()
-        {
-            GeneralApi.Initialize();
-        }
-
-        /// <summary>
-        ///     PRIVATE - Requests to restart the display driver
-        /// </summary>
-        public static void RestartDisplayDriver()
-        {
-            GeneralApi.RestartDisplayDriver();
-        }
-
-        /// <summary>
-        ///     Decrements the ref-counter and when it reaches ZERO, unloads NVAPI library.
-        /// </summary>
-        public static void Unload()
-        {
-            GeneralApi.Unload();
-        }
-    }
-}

app/NvAPIWrapper/Native/Attributes/AcceptsAttribute.cs

@@ -1,15 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.Native.Attributes
-{
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Delegate)]
-    internal class AcceptsAttribute : Attribute
-    {
-        public AcceptsAttribute(params Type[] types)
-        {
-            Types = types;
-        }
-
-        public Type[] Types { get; set; }
-    }
-}

app/NvAPIWrapper/Native/Attributes/FunctionIdAttribute.cs

@@ -1,16 +0,0 @@
-using System;
-using NvAPIWrapper.Native.Helpers;
-
-namespace NvAPIWrapper.Native.Attributes
-{
-    [AttributeUsage(AttributeTargets.Delegate)]
-    internal class FunctionIdAttribute : Attribute
-    {
-        public FunctionIdAttribute(FunctionId functionId)
-        {
-            FunctionId = functionId;
-        }
-
-        public FunctionId FunctionId { get; set; }
-    }
-}

app/NvAPIWrapper/Native/Attributes/StructureVersionAttribute.cs

@@ -1,19 +0,0 @@
-using System;
-
-namespace NvAPIWrapper.Native.Attributes
-{
-    [AttributeUsage(AttributeTargets.Struct)]
-    internal class StructureVersionAttribute : Attribute
-    {
-        public StructureVersionAttribute()
-        {
-        }
-
-        public StructureVersionAttribute(int versionNumber)
-        {
-            VersionNumber = versionNumber;
-        }
-
-        public int VersionNumber { get; set; }
-    }
-}

app/NvAPIWrapper/Native/Constants/Display.cs

@@ -1,8 +0,0 @@
-namespace NvAPIWrapper.Native.Constants
-{
-    internal static class Display
-    {
-        public const int AdvancedDisplayHeads = 4;
-        public const int MaxDisplayHeads = 2;
-    }
-}

app/NvAPIWrapper/Native/Constants/General.cs

@@ -1,8 +0,0 @@
-namespace NvAPIWrapper.Native.Constants
-{
-    internal static class General
-    {
-        public const int BinaryDataMax = 4096;
-        public const int UnicodeStringLength = 2048;
-    }
-}

app/NvAPIWrapper/Native/DRS/DRSSettingLocation.cs

@@ -1,28 +0,0 @@
-namespace NvAPIWrapper.Native.DRS
-{
-    /// <summary>
-    ///     Holds possible values for the setting location
-    /// </summary>
-    public enum DRSSettingLocation : uint
-    {
-        /// <summary>
-        ///     Setting is part of the current profile
-        /// </summary>
-        CurrentProfile = 0,
-
-        /// <summary>
-        ///     Setting is part of the global profile
-        /// </summary>
-        GlobalProfile,
-
-        /// <summary>
-        ///     Setting is part of the base profile
-        /// </summary>
-        BaseProfile,
-
-        /// <summary>
-        ///     Setting is part of the default profile
-        /// </summary>
-        DefaultProfile
-    }
-}

app/NvAPIWrapper/Native/DRS/DRSSettingType.cs

@@ -1,28 +0,0 @@
-namespace NvAPIWrapper.Native.DRS
-{
-    /// <summary>
-    ///     Holds a list of possible setting value types
-    /// </summary>
-    public enum DRSSettingType : uint
-    {
-        /// <summary>
-        ///     Integer value type
-        /// </summary>
-        Integer = 0,
-
-        /// <summary>
-        ///     Binary value type
-        /// </summary>
-        Binary,
-
-        /// <summary>
-        ///     ASCII string value type
-        /// </summary>
-        String,
-
-        /// <summary>
-        ///     Unicode string value type
-        /// </summary>
-        UnicodeString
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV1.cs

@@ -1,77 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <inheritdoc cref="IDRSApplication" />
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(1)]
-    public struct DRSApplicationV1 : IInitializable, IDRSApplication
-    {
-        internal StructureVersion _Version;
-        internal uint _IsPredefined;
-        internal UnicodeString _ApplicationName;
-        internal UnicodeString _FriendlyName;
-        internal UnicodeString _LauncherName;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSApplicationV1" />
-        /// </summary>
-        /// <param name="applicationName">The application file name.</param>
-        /// <param name="friendlyName">The application friendly name.</param>
-        /// <param name="launcherName">The application launcher name.</param>
-        public DRSApplicationV1(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null
-        )
-        {
-            this = typeof(DRSApplicationV1).Instantiate<DRSApplicationV1>();
-            IsPredefined = false;
-            ApplicationName = applicationName;
-            FriendlyName = friendlyName ?? string.Empty;
-            LauncherName = launcherName ?? string.Empty;
-        }
-
-        /// <inheritdoc />
-        public bool IsPredefined
-        {
-            get => _IsPredefined > 0;
-            private set => _IsPredefined = value ? 1u : 0u;
-        }
-
-        /// <inheritdoc />
-        public string ApplicationName
-        {
-            get => _ApplicationName.Value;
-            private set
-            {
-                if (string.IsNullOrEmpty(value))
-                {
-                    throw new ArgumentException("Name can not be empty or null.");
-                }
-
-                _ApplicationName = new UnicodeString(value);
-            }
-        }
-
-        /// <inheritdoc />
-        public string FriendlyName
-        {
-            get => _FriendlyName.Value;
-            private set => _FriendlyName = new UnicodeString(value);
-        }
-
-        /// <inheritdoc />
-        public string LauncherName
-        {
-            get => _LauncherName.Value;
-            private set => _LauncherName = new UnicodeString(value);
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV2.cs

@@ -1,93 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <inheritdoc cref="IDRSApplication" />
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(2)]
-    public struct DRSApplicationV2 : IInitializable, IDRSApplication
-    {
-        internal const char FileInFolderSeparator = ':';
-        internal StructureVersion _Version;
-        internal uint _IsPredefined;
-        internal UnicodeString _ApplicationName;
-        internal UnicodeString _FriendlyName;
-        internal UnicodeString _LauncherName;
-        internal UnicodeString _FileInFolder;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSApplicationV2" />
-        /// </summary>
-        /// <param name="applicationName">The application file name.</param>
-        /// <param name="friendlyName">The application friendly name.</param>
-        /// <param name="launcherName">The application launcher name.</param>
-        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
-        // ReSharper disable once TooManyDependencies
-        public DRSApplicationV2(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null
-        )
-        {
-            this = typeof(DRSApplicationV2).Instantiate<DRSApplicationV2>();
-            IsPredefined = false;
-            ApplicationName = applicationName;
-            FriendlyName = friendlyName ?? string.Empty;
-            LauncherName = launcherName ?? string.Empty;
-            FilesInFolder = fileInFolders ?? new string[0];
-        }
-
-        /// <inheritdoc />
-        public bool IsPredefined
-        {
-            get => _IsPredefined > 0;
-            private set => _IsPredefined = value ? 1u : 0u;
-        }
-
-        /// <inheritdoc />
-        public string ApplicationName
-        {
-            get => _ApplicationName.Value;
-            private set
-            {
-                if (string.IsNullOrEmpty(value))
-                {
-                    throw new ArgumentException("Name can not be empty or null.");
-                }
-
-                _ApplicationName = new UnicodeString(value);
-            }
-        }
-
-        /// <inheritdoc />
-        public string FriendlyName
-        {
-            get => _FriendlyName.Value;
-            private set => _FriendlyName = new UnicodeString(value);
-        }
-
-        /// <inheritdoc />
-        public string LauncherName
-        {
-            get => _LauncherName.Value;
-            private set => _LauncherName = new UnicodeString(value);
-        }
-
-        /// <summary>
-        ///     Gets the list of files that are necessary to be present in the application parent directory.
-        /// </summary>
-        public string[] FilesInFolder
-        {
-            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
-                   new string[0];
-            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV3.cs

@@ -1,114 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <inheritdoc cref="IDRSApplication" />
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(3)]
-    public struct DRSApplicationV3 : IInitializable, IDRSApplication
-    {
-        internal const char FileInFolderSeparator = DRSApplicationV2.FileInFolderSeparator;
-        internal StructureVersion _Version;
-        internal uint _IsPredefined;
-        internal UnicodeString _ApplicationName;
-        internal UnicodeString _FriendlyName;
-        internal UnicodeString _LauncherName;
-        internal UnicodeString _FileInFolder;
-        internal uint _Flags;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSApplicationV3" />
-        /// </summary>
-        /// <param name="applicationName">The application file name.</param>
-        /// <param name="friendlyName">The application friendly name.</param>
-        /// <param name="launcherName">The application launcher name.</param>
-        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
-        /// <param name="isMetro">A boolean value indicating if this application is a metro application.</param>
-        // ReSharper disable once TooManyDependencies
-        public DRSApplicationV3(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false
-        )
-        {
-            this = typeof(DRSApplicationV3).Instantiate<DRSApplicationV3>();
-            IsPredefined = false;
-            ApplicationName = applicationName;
-            FriendlyName = friendlyName ?? string.Empty;
-            LauncherName = launcherName ?? string.Empty;
-            FilesInFolder = fileInFolders ?? new string[0];
-            IsMetroApplication = isMetro;
-        }
-
-        /// <inheritdoc />
-        public bool IsPredefined
-        {
-            get => _IsPredefined > 0;
-            private set => _IsPredefined = value ? 1u : 0u;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application is a metro application
-        /// </summary>
-        public bool IsMetroApplication
-        {
-            get => _Flags.GetBit(0);
-            private set => _Flags = _Flags.SetBit(0, value);
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application has command line arguments
-        /// </summary>
-        public bool HasCommandLine
-        {
-            get => _Flags.GetBit(1);
-        }
-
-        /// <inheritdoc />
-        public string ApplicationName
-        {
-            get => _ApplicationName.Value;
-            private set
-            {
-                if (string.IsNullOrEmpty(value))
-                {
-                    throw new ArgumentException("Name can not be empty or null.");
-                }
-
-                _ApplicationName = new UnicodeString(value);
-            }
-        }
-
-        /// <inheritdoc />
-        public string FriendlyName
-        {
-            get => _FriendlyName.Value;
-            private set => _FriendlyName = new UnicodeString(value);
-        }
-
-        /// <inheritdoc />
-        public string LauncherName
-        {
-            get => _LauncherName.Value;
-            private set => _LauncherName = new UnicodeString(value);
-        }
-
-        /// <summary>
-        ///     Gets the list of files that are necessary to be present in the application parent directory.
-        /// </summary>
-        public string[] FilesInFolder
-        {
-            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
-                   new string[0];
-            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSApplicationV4.cs

@@ -1,148 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <inheritdoc cref="IDRSApplication" />
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(4)]
-    public struct DRSApplicationV4 : IInitializable, IDRSApplication
-    {
-        internal const char FileInFolderSeparator = DRSApplicationV3.FileInFolderSeparator;
-        internal StructureVersion _Version;
-        internal uint _IsPredefined;
-        internal UnicodeString _ApplicationName;
-        internal UnicodeString _FriendlyName;
-        internal UnicodeString _LauncherName;
-        internal UnicodeString _FileInFolder;
-        internal uint _Flags;
-        internal UnicodeString _CommandLine;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSApplicationV4" />
-        /// </summary>
-        /// <param name="applicationName">The application file name.</param>
-        /// <param name="friendlyName">The application friendly name.</param>
-        /// <param name="launcherName">The application launcher name.</param>
-        /// <param name="fileInFolders">The list of files that are necessary to be present in the application parent directory.</param>
-        /// <param name="isMetro">A boolean value indicating if this application is a metro application.</param>
-        /// <param name="commandLine">The application's command line arguments.</param>
-        // ReSharper disable once TooManyDependencies
-        public DRSApplicationV4(
-            string applicationName,
-            string friendlyName = null,
-            string launcherName = null,
-            string[] fileInFolders = null,
-            bool isMetro = false,
-            string commandLine = null
-        )
-        {
-            this = typeof(DRSApplicationV4).Instantiate<DRSApplicationV4>();
-            IsPredefined = false;
-            ApplicationName = applicationName;
-            FriendlyName = friendlyName ?? string.Empty;
-            LauncherName = launcherName ?? string.Empty;
-            FilesInFolder = fileInFolders ?? new string[0];
-            IsMetroApplication = isMetro;
-            ApplicationCommandLine = commandLine ?? string.Empty;
-        }
-
-        /// <inheritdoc />
-        public bool IsPredefined
-        {
-            get => _IsPredefined > 0;
-            private set => _IsPredefined = value ? 1u : 0u;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application is a metro application
-        /// </summary>
-        public bool IsMetroApplication
-        {
-            get => _Flags.GetBit(0);
-            private set => _Flags = _Flags.SetBit(0, value);
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this application has command line arguments
-        /// </summary>
-        public bool HasCommandLine
-        {
-            get => _Flags.GetBit(1);
-            private set => _Flags = _Flags.SetBit(1, value);
-        }
-
-        /// <inheritdoc />
-        public string ApplicationName
-        {
-            get => _ApplicationName.Value;
-            private set
-            {
-                if (string.IsNullOrEmpty(value))
-                {
-                    throw new ArgumentException("Name can not be empty or null.");
-                }
-
-                _ApplicationName = new UnicodeString(value);
-            }
-        }
-
-        /// <summary>
-        ///     Gets the application command line arguments
-        /// </summary>
-        public string ApplicationCommandLine
-        {
-            get => (HasCommandLine ? _CommandLine.Value : null) ?? string.Empty;
-            private set
-            {
-                if (string.IsNullOrEmpty(value))
-                {
-                    _CommandLine = new UnicodeString(null);
-
-                    if (HasCommandLine)
-                    {
-                        HasCommandLine = false;
-                    }
-                }
-                else
-                {
-                    _CommandLine = new UnicodeString(value);
-
-                    if (!HasCommandLine)
-                    {
-                        HasCommandLine = true;
-                    }
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        public string FriendlyName
-        {
-            get => _FriendlyName.Value;
-            private set => _FriendlyName = new UnicodeString(value);
-        }
-
-        /// <inheritdoc />
-        public string LauncherName
-        {
-            get => _LauncherName.Value;
-            private set => _LauncherName = new UnicodeString(value);
-        }
-
-        /// <summary>
-        ///     Gets the list of files that are necessary to be present in the application parent directory.
-        /// </summary>
-        public string[] FilesInFolder
-        {
-            get => _FileInFolder.Value?.Split(new[] {FileInFolderSeparator}, StringSplitOptions.RemoveEmptyEntries) ??
-                   new string[0];
-            private set => _FileInFolder = new UnicodeString(string.Join(FileInFolderSeparator.ToString(), value));
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSGPUSupport.cs

@@ -1,71 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Helpers;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     Contains a list of supported GPU series by a NVIDIA driver setting profile
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    public struct DRSGPUSupport
-    {
-        internal uint _Flags;
-
-        /// <summary>
-        ///     Gets or sets a value indicating if the GeForce line of products are supported
-        /// </summary>
-        public bool IsGeForceSupported
-        {
-            get => _Flags.GetBit(0);
-            set => _Flags = _Flags.SetBit(0, value);
-        }
-
-        /// <summary>
-        ///     Gets or sets a value indicating if the Quadro line of products are supported
-        /// </summary>
-        public bool IsQuadroSupported
-        {
-            get => _Flags.GetBit(1);
-            set => _Flags = _Flags.SetBit(1, value);
-        }
-
-        /// <summary>
-        ///     Gets or sets a value indicating if the NVS line of products are supported
-        /// </summary>
-        public bool IsNVSSupported
-        {
-            get => _Flags.GetBit(2);
-            set => _Flags = _Flags.SetBit(2, value);
-        }
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            var supportedGPUs = new List<string>();
-
-            if (IsGeForceSupported)
-            {
-                supportedGPUs.Add("GeForce");
-            }
-
-            if (IsQuadroSupported)
-            {
-                supportedGPUs.Add("Quadro");
-            }
-
-            if (IsNVSSupported)
-            {
-                supportedGPUs.Add("NVS");
-            }
-
-            if (supportedGPUs.Any())
-            {
-                return $"[{_Flags}] = {string.Join(", ", supportedGPUs)}";
-            }
-
-            return $"[{_Flags}]";
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSProfileHandle.cs

@@ -1,100 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     DRSProfileHandle is a reference to a DRS profile.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    public struct DRSProfileHandle : IHandle, IEquatable<DRSProfileHandle>
-    {
-        internal readonly IntPtr _MemoryAddress;
-
-        private DRSProfileHandle(IntPtr memoryAddress)
-        {
-            _MemoryAddress = memoryAddress;
-        }
-
-        /// <inheritdoc />
-        public bool Equals(DRSProfileHandle other)
-        {
-            return _MemoryAddress.Equals(other._MemoryAddress);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            return obj is DRSProfileHandle handle && Equals(handle);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return _MemoryAddress.GetHashCode();
-        }
-
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"DRSProfileHandle #{MemoryAddress.ToInt64()}";
-        }
-
-        /// <inheritdoc />
-        public IntPtr MemoryAddress
-        {
-            get => _MemoryAddress;
-        }
-
-        /// <inheritdoc />
-        public bool IsNull
-        {
-            get => _MemoryAddress == IntPtr.Zero;
-        }
-
-        /// <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 ==(DRSProfileHandle left, DRSProfileHandle 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 !=(DRSProfileHandle left, DRSProfileHandle right)
-        {
-            return !left.Equals(right);
-        }
-
-        /// <summary>
-        ///     Gets default DRSProfileHandle with a null pointer
-        /// </summary>
-        public static DRSProfileHandle DefaultHandle
-        {
-            get => default(DRSProfileHandle);
-        }
-
-        /// <summary>
-        ///     Gets the default global profile handle
-        /// </summary>
-        public static DRSProfileHandle DefaultGlobalProfileHandle
-        {
-            get => new DRSProfileHandle(new IntPtr(-1));
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSProfileV1.cs

@@ -1,76 +0,0 @@
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     Represents a NVIDIA driver settings profile
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(1)]
-    public struct DRSProfileV1 : IInitializable
-    {
-        internal StructureVersion _Version;
-        internal UnicodeString _ProfileName;
-        internal DRSGPUSupport _GPUSupport;
-        internal uint _IsPredefined;
-        internal uint _NumberOfApplications;
-        internal uint _NumberOfSettings;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSProfileV1" /> with the passed name and GPU series support list.
-        /// </summary>
-        /// <param name="name">The name of the profile.</param>
-        /// <param name="gpuSupport">An instance of <see cref="DRSGPUSupport" /> containing the list of supported GPU series.</param>
-        public DRSProfileV1(string name, DRSGPUSupport gpuSupport)
-        {
-            this = typeof(DRSProfileV1).Instantiate<DRSProfileV1>();
-            _ProfileName = new UnicodeString(name);
-            _GPUSupport = gpuSupport;
-        }
-
-        /// <summary>
-        ///     Gets the name of the profile
-        /// </summary>
-        public string Name
-        {
-            get => _ProfileName.Value;
-        }
-
-        /// <summary>
-        ///     Gets or sets the GPU series support list
-        /// </summary>
-        public DRSGPUSupport GPUSupport
-        {
-            get => _GPUSupport;
-            set => _GPUSupport = value;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if this profile is predefined
-        /// </summary>
-        public bool IsPredefined
-        {
-            get => _IsPredefined > 0;
-        }
-
-        /// <summary>
-        ///     Gets the number of applications registered under this profile
-        /// </summary>
-        public int NumberOfApplications
-        {
-            get => (int) _NumberOfApplications;
-        }
-
-        /// <summary>
-        ///     Gets the number of setting registered under this profile
-        /// </summary>
-        public int NumberOfSettings
-        {
-            get => (int) _NumberOfSettings;
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSSessionHandle.cs

@@ -1,87 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     DRSSessionHandle is a reference to a DRS session.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    public struct DRSSessionHandle : IHandle, IEquatable<DRSSessionHandle>
-    {
-        internal readonly IntPtr _MemoryAddress;
-
-        /// <inheritdoc />
-        public bool Equals(DRSSessionHandle other)
-        {
-            return _MemoryAddress.Equals(other._MemoryAddress);
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj))
-            {
-                return false;
-            }
-
-            return obj is DRSSessionHandle handle && Equals(handle);
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            return _MemoryAddress.GetHashCode();
-        }
-
-
-        /// <inheritdoc />
-        public override string ToString()
-        {
-            return $"DRSSessionHandle #{MemoryAddress.ToInt64()}";
-        }
-
-        /// <inheritdoc />
-        public IntPtr MemoryAddress
-        {
-            get => _MemoryAddress;
-        }
-
-        /// <inheritdoc />
-        public bool IsNull
-        {
-            get => _MemoryAddress == IntPtr.Zero;
-        }
-
-        /// <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 ==(DRSSessionHandle left, DRSSessionHandle 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 !=(DRSSessionHandle left, DRSSessionHandle right)
-        {
-            return !left.Equals(right);
-        }
-
-        /// <summary>
-        ///     Gets default DRSSessionHandle with a null pointer
-        /// </summary>
-        public static DRSSessionHandle DefaultHandle
-        {
-            get => default(DRSSessionHandle);
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingV1.cs

@@ -1,329 +0,0 @@
-using System;
-using System.Linq;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     Represents a NVIDIA driver setting
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(1)]
-    public struct DRSSettingV1 : IInitializable
-    {
-        internal StructureVersion _Version;
-        internal UnicodeString _SettingName;
-        internal uint _SettingId;
-        internal DRSSettingType _SettingType;
-        internal DRSSettingLocation _SettingLocation;
-        internal uint _IsCurrentPredefined;
-        internal uint _IsPredefinedValid;
-        internal DRSSettingValue _PredefinedValue;
-        internal DRSSettingValue _CurrentValue;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
-        /// </summary>
-        /// <param name="id">The setting identification number.</param>
-        /// <param name="settingType">The type of the setting's value</param>
-        /// <param name="value">The setting's value</param>
-        public DRSSettingV1(uint id, DRSSettingType settingType, object value)
-        {
-            this = typeof(DRSSettingV1).Instantiate<DRSSettingV1>();
-            Id = id;
-            IsPredefinedValueValid = false;
-            _SettingType = settingType;
-            CurrentValue = value;
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
-        /// </summary>
-        /// <param name="id">The setting identification number.</param>
-        /// <param name="value">The setting's value</param>
-        public DRSSettingV1(uint id, string value) : this(id, DRSSettingType.String, value)
-        {
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
-        /// </summary>
-        /// <param name="id">The setting identification number.</param>
-        /// <param name="value">The setting's value</param>
-        public DRSSettingV1(uint id, uint value) : this(id, DRSSettingType.Integer, value)
-        {
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingV1" /> containing the passed value.
-        /// </summary>
-        /// <param name="id">The setting identification number.</param>
-        /// <param name="value">The setting's value</param>
-        public DRSSettingV1(uint id, byte[] value) : this(id, DRSSettingType.Binary, value)
-        {
-        }
-
-        /// <summary>
-        ///     Gets the name of the setting
-        /// </summary>
-        public string Name
-        {
-            get => _SettingName.Value;
-        }
-
-        /// <summary>
-        ///     Gets the identification number of the setting
-        /// </summary>
-        public uint Id
-        {
-            get => _SettingId;
-            private set => _SettingId = value;
-        }
-
-        /// <summary>
-        ///     Gets the setting's value type
-        /// </summary>
-        public DRSSettingType SettingType
-        {
-            get => _SettingType;
-            private set => _SettingType = value;
-        }
-
-        /// <summary>
-        ///     Gets the setting location
-        /// </summary>
-        public DRSSettingLocation SettingLocation
-        {
-            get => _SettingLocation;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the current value is the predefined value
-        /// </summary>
-        public bool IsCurrentValuePredefined
-        {
-            get => _IsCurrentPredefined > 0;
-            private set => _IsCurrentPredefined = value ? 1u : 0u;
-        }
-
-        /// <summary>
-        ///     Gets a boolean value indicating if the predefined value is available and valid
-        /// </summary>
-        public bool IsPredefinedValueValid
-        {
-            get => _IsPredefinedValid > 0;
-            private set => _IsPredefinedValid = value ? 1u : 0u;
-        }
-
-        /// <summary>
-        ///     Returns the predefined value as an integer
-        /// </summary>
-        /// <returns>An integer representing the predefined value</returns>
-        public uint GetPredefinedValueAsInteger()
-        {
-            return _PredefinedValue.AsInteger();
-        }
-
-        /// <summary>
-        ///     Returns the predefined value as an array of bytes
-        /// </summary>
-        /// <returns>An byte array representing the predefined value</returns>
-        public byte[] GetPredefinedValueAsBinary()
-        {
-            return _PredefinedValue.AsBinary();
-        }
-
-        /// <summary>
-        ///     Returns the predefined value as an unicode string
-        /// </summary>
-        /// <returns>An unicode string representing the predefined value</returns>
-        public string GetPredefinedValueAsUnicodeString()
-        {
-            return _PredefinedValue.AsUnicodeString();
-        }
-
-        /// <summary>
-        ///     Gets the setting's predefined value
-        /// </summary>
-        public object PredefinedValue
-        {
-            get
-            {
-                if (!IsPredefinedValueValid)
-                {
-                    return null;
-                }
-
-                switch (_SettingType)
-                {
-                    case DRSSettingType.Integer:
-
-                        return GetPredefinedValueAsInteger();
-                    case DRSSettingType.Binary:
-
-                        return GetPredefinedValueAsBinary();
-                    case DRSSettingType.String:
-                    case DRSSettingType.UnicodeString:
-
-                        return GetPredefinedValueAsUnicodeString();
-                    default:
-
-                        throw new ArgumentOutOfRangeException(nameof(SettingType));
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Returns the current value as an integer
-        /// </summary>
-        /// <returns>An integer representing the current value</returns>
-        public uint GetCurrentValueAsInteger()
-        {
-            return _CurrentValue.AsInteger();
-        }
-
-        /// <summary>
-        ///     Returns the current value as an array of bytes
-        /// </summary>
-        /// <returns>An byte array representing the current value</returns>
-        public byte[] GetCurrentValueAsBinary()
-        {
-            return _CurrentValue.AsBinary();
-        }
-
-        /// <summary>
-        ///     Returns the current value as an unicode string
-        /// </summary>
-        /// <returns>An unicode string representing the current value</returns>
-        public string GetCurrentValueAsUnicodeString()
-        {
-            return _CurrentValue.AsUnicodeString();
-        }
-
-        /// <summary>
-        ///     Sets the passed value as the current value
-        /// </summary>
-        /// <param name="value">The new value for the setting</param>
-        public void SetCurrentValueAsInteger(uint value)
-        {
-            if (SettingType != DRSSettingType.Integer)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
-            }
-
-            _CurrentValue = new DRSSettingValue(value);
-            IsCurrentValuePredefined = IsPredefinedValueValid && (uint) CurrentValue == (uint) PredefinedValue;
-        }
-
-        /// <summary>
-        ///     Sets the passed value as the current value
-        /// </summary>
-        /// <param name="value">The new value for the setting</param>
-        public void SetCurrentValueAsBinary(byte[] value)
-        {
-            if (SettingType != DRSSettingType.Binary)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
-            }
-
-            _CurrentValue = new DRSSettingValue(value);
-            IsCurrentValuePredefined =
-                IsPredefinedValueValid &&
-                ((byte[]) CurrentValue)?.SequenceEqual((byte[]) PredefinedValue ?? new byte[0]) == true;
-        }
-
-        /// <summary>
-        ///     Sets the passed value as the current value
-        /// </summary>
-        /// <param name="value">The new value for the setting</param>
-        public void SetCurrentValueAsUnicodeString(string value)
-        {
-            if (SettingType != DRSSettingType.UnicodeString)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "Passed argument is invalid for this setting.");
-            }
-
-            _CurrentValue = new DRSSettingValue(value);
-            IsCurrentValuePredefined =
-                IsPredefinedValueValid &&
-                string.Equals(
-                    (string) CurrentValue,
-                    (string) PredefinedValue,
-                    StringComparison.InvariantCulture
-                );
-        }
-
-        /// <summary>
-        ///     Gets or sets the setting's current value
-        /// </summary>
-        public object CurrentValue
-        {
-            get
-            {
-                switch (_SettingType)
-                {
-                    case DRSSettingType.Integer:
-
-                        return GetCurrentValueAsInteger();
-                    case DRSSettingType.Binary:
-
-                        return GetCurrentValueAsBinary();
-                    case DRSSettingType.String:
-                    case DRSSettingType.UnicodeString:
-
-                        return GetCurrentValueAsUnicodeString();
-                    default:
-
-                        throw new ArgumentOutOfRangeException(nameof(SettingType));
-                }
-            }
-            private set
-            {
-                if (value is int intValue)
-                {
-                    SetCurrentValueAsInteger((uint) intValue);
-                }
-                else if (value is uint unsignedIntValue)
-                {
-                    SetCurrentValueAsInteger(unsignedIntValue);
-                }
-                else if (value is short shortValue)
-                {
-                    SetCurrentValueAsInteger((uint) shortValue);
-                }
-                else if (value is ushort unsignedShortValue)
-                {
-                    SetCurrentValueAsInteger(unsignedShortValue);
-                }
-                else if (value is long longValue)
-                {
-                    SetCurrentValueAsInteger((uint) longValue);
-                }
-                else if (value is ulong unsignedLongValue)
-                {
-                    SetCurrentValueAsInteger((uint) unsignedLongValue);
-                }
-                else if (value is byte byteValue)
-                {
-                    SetCurrentValueAsInteger(byteValue);
-                }
-                else if (value is string stringValue)
-                {
-                    SetCurrentValueAsUnicodeString(stringValue);
-                }
-                else if (value is byte[] binaryValue)
-                {
-                    SetCurrentValueAsBinary(binaryValue);
-                }
-                else
-                {
-                    throw new ArgumentException("Unacceptable argument type.", nameof(value));
-                }
-            }
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingValue.cs

@@ -1,97 +0,0 @@
-using System;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     Represents a setting value
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    public struct DRSSettingValue : IInitializable
-    {
-        private const int UnicodeStringLength = UnicodeString.UnicodeStringLength;
-        private const int BinaryDataMax = 4096;
-
-        // Math.Max(BinaryDataMax + sizeof(uint), UnicodeStringLength * sizeof(ushort))
-        private const int FullStructureSize = 4100;
-
-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = FullStructureSize, ArraySubType = UnmanagedType.U1)]
-        internal byte[] _BinaryValue;
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed unicode string as the value
-        /// </summary>
-        /// <param name="value">The unicode string value</param>
-        public DRSSettingValue(string value)
-        {
-            if (value?.Length > UnicodeStringLength)
-            {
-                value = value.Substring(0, UnicodeStringLength);
-            }
-
-            _BinaryValue = new byte[FullStructureSize];
-
-            var stringBytes = Encoding.Unicode.GetBytes(value ?? string.Empty);
-            Array.Copy(stringBytes, 0, _BinaryValue, 0, Math.Min(stringBytes.Length, _BinaryValue.Length));
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed byte array as the value
-        /// </summary>
-        /// <param name="value">The byte array value</param>
-        public DRSSettingValue(byte[] value)
-        {
-            _BinaryValue = new byte[FullStructureSize];
-
-            if (value?.Length > 0)
-            {
-                var arrayLength = Math.Min(value.Length, BinaryDataMax);
-                var arrayLengthBytes = BitConverter.GetBytes((uint) arrayLength);
-                Array.Copy(arrayLengthBytes, 0, _BinaryValue, 0, arrayLengthBytes.Length);
-                Array.Copy(value, 0, _BinaryValue, arrayLengthBytes.Length, arrayLength);
-            }
-        }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="DRSSettingValue" /> containing the passed integer as the value
-        /// </summary>
-        /// <param name="value">The integer value</param>
-        public DRSSettingValue(uint value)
-        {
-            _BinaryValue = new byte[FullStructureSize];
-            var arrayLengthBytes = BitConverter.GetBytes(value);
-            Array.Copy(arrayLengthBytes, 0, _BinaryValue, 0, arrayLengthBytes.Length);
-        }
-
-        /// <summary>
-        ///     Returns the value as an integer
-        /// </summary>
-        /// <returns>An integer representing the value</returns>
-        public uint AsInteger()
-        {
-            return BitConverter.ToUInt32(_BinaryValue, 0);
-        }
-
-        /// <summary>
-        ///     Returns the value as an array of bytes
-        /// </summary>
-        /// <returns>An array of bytes representing the value</returns>
-        public byte[] AsBinary()
-        {
-            return _BinaryValue.Skip(sizeof(uint)).Take((int) AsInteger()).ToArray();
-        }
-
-        /// <summary>
-        ///     Returns the value as an unicode string
-        /// </summary>
-        /// <returns>An unicode string representing the value</returns>
-        public string AsUnicodeString()
-        {
-            return Encoding.Unicode.GetString(_BinaryValue).TrimEnd('\0');
-        }
-    }
-}

app/NvAPIWrapper/Native/DRS/Structures/DRSSettingValues.cs

@@ -1,140 +0,0 @@
-using System;
-using System.Linq;
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Interfaces;
-
-namespace NvAPIWrapper.Native.DRS.Structures
-{
-    /// <summary>
-    ///     Contains a list of all possible values for a setting as well as its default value
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 8)]
-    [StructureVersion(1)]
-    public struct DRSSettingValues : IInitializable
-    {
-        internal const int MaximumNumberOfValues = 100;
-        internal StructureVersion _Version;
-        internal uint _NumberOfValues;
-        internal DRSSettingType _SettingType;
-        internal DRSSettingValue _DefaultValue;
-
-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = MaximumNumberOfValues)]
-        internal DRSSettingValue[] _Values;
-
-        /// <summary>
-        ///     Gets the setting's value type
-        /// </summary>
-        public DRSSettingType SettingType
-        {
-            get => _SettingType;
-        }
-
-        /// <summary>
-        ///     Gets a list of possible values for the setting
-        /// </summary>
-        public object[] Values
-        {
-            get
-            {
-                switch (_SettingType)
-                {
-                    case DRSSettingType.Integer:
-
-                        return ValuesAsInteger().Cast<object>().ToArray();
-                    case DRSSettingType.Binary:
-
-                        return ValuesAsBinary().Cast<object>().ToArray();
-                    case DRSSettingType.String:
-                    case DRSSettingType.UnicodeString:
-
-                        return ValuesAsUnicodeString().Cast<object>().ToArray();
-                    default:
-
-                        throw new ArgumentOutOfRangeException(nameof(SettingType));
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Gets the default value of the setting
-        /// </summary>
-        public object DefaultValue
-        {
-            get
-            {
-                switch (_SettingType)
-                {
-                    case DRSSettingType.Integer:
-
-                        return DefaultValueAsInteger();
-                    case DRSSettingType.Binary:
-
-                        return DefaultValueAsBinary();
-                    case DRSSettingType.String:
-                    case DRSSettingType.UnicodeString:
-
-                        return DefaultValueAsUnicodeString();
-                    default:
-
-                        throw new ArgumentOutOfRangeException(nameof(SettingType));
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Returns the default value as an integer
-        /// </summary>
-        /// <returns>An integer representing the default value</returns>
-        public uint DefaultValueAsInteger()
-        {
-            return _DefaultValue.AsInteger();
-        }
-
-        /// <summary>
-        ///     Returns the default value as a byte array
-        /// </summary>
-        /// <returns>An array of bytes representing the default value</returns>
-        public byte[] DefaultValueAsBinary()
-        {
-            return _DefaultValue.AsBinary();
-        }
-
-        /// <summary>
-        ///     Returns the default value as an unicode string
-        /// </summary>
-        /// <returns>A string representing the default value</returns>
-        public string DefaultValueAsUnicodeString()
-        {
-            return _DefaultValue.AsUnicodeString();
-        }
-
-        /// <summary>
-        ///     Returns the setting's possible values as an array of integers
-        /// </summary>
-        /// <returns>An array of integers representing the possible values</returns>
-        public uint[] ValuesAsInteger()
-        {
-            return _Values.Take((int) _NumberOfValues).Select(value => value.AsInteger()).ToArray();
-        }
-
-        /// <summary>
-        ///     Returns the setting's possible values as an array of byte arrays
-        /// </summary>
-        /// <returns>An array of byte arrays representing the possible values</returns>
-        public byte[][] ValuesAsBinary()
-        {
-            return _Values.Take((int) _NumberOfValues).Select(value => value.AsBinary()).ToArray();
-        }
-
-        /// <summary>
-        ///     Returns the setting's possible values as an array of unicode strings
-        /// </summary>
-        /// <returns>An array of unicode strings representing the possible values</returns>
-        public string[] ValuesAsUnicodeString()
-        {
-            return _Values.Take((int) _NumberOfValues).Select(value => value.AsUnicodeString()).ToArray();
-        }
-    }
-}

app/NvAPIWrapper/Native/DRSApi.cs

@@ -1,936 +0,0 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using NvAPIWrapper.Native.DRS.Structures;
-using NvAPIWrapper.Native.Exceptions;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Helpers.Structures;
-using NvAPIWrapper.Native.Interfaces.DRS;
-
-namespace NvAPIWrapper.Native
-{
-    /// <summary>
-    ///     Contains driver settings static functions
-    /// </summary>
-    // ReSharper disable once ClassTooBig
-    public static class DRSApi
-    {
-        /// <summary>
-        ///     This API adds an executable name to a profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="application">Input <see cref="IDRSApplication" /> instance containing the executable name.</param>
-        /// <returns>The newly created instance of <see cref="IDRSApplication" />.</returns>
-        public static IDRSApplication CreateApplication(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            IDRSApplication application)
-        {
-            using (var applicationReference = ValueTypeReference.FromValueType(application, application.GetType()))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateApplication>()(
-                    sessionHandle,
-                    profileHandle,
-                    applicationReference
-                );
-
-                if (status == Status.IncompatibleStructureVersion)
-                {
-                    throw new NVIDIANotSupportedException("This operation is not supported.");
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return applicationReference.ToValueType<IDRSApplication>(application.GetType());
-            }
-        }
-
-        /// <summary>
-        ///     This API creates an empty profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profile">Input to the <see cref="DRSProfileV1" /> instance.</param>
-        /// <returns>The newly created profile handle.</returns>
-        public static DRSProfileHandle CreateProfile(DRSSessionHandle sessionHandle, DRSProfileV1 profile)
-        {
-            using (var profileReference = ValueTypeReference.FromValueType(profile))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateProfile>()(
-                    sessionHandle,
-                    profileReference,
-                    out var profileHandle
-                );
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return profileHandle;
-            }
-        }
-
-        /// <summary>
-        ///     This API allocates memory and initializes the session.
-        /// </summary>
-        /// <returns>The newly created session handle.</returns>
-        public static DRSSessionHandle CreateSession()
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_CreateSession>()(out var sessionHandle);
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return sessionHandle;
-        }
-
-        /// <summary>
-        ///     This API removes an executable from a profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="application">Input all the information about the application to be removed.</param>
-        public static void DeleteApplication(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            IDRSApplication application)
-        {
-            using (var applicationReference = ValueTypeReference.FromValueType(application, application.GetType()))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteApplicationEx>()(
-                    sessionHandle,
-                    profileHandle,
-                    applicationReference
-                );
-
-                if (status == Status.IncompatibleStructureVersion)
-                {
-                    throw new NVIDIANotSupportedException("This operation is not supported.");
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-            }
-        }
-
-        /// <summary>
-        ///     This API removes an executable name from a profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="applicationName">Input the executable name to be removed.</param>
-        public static void DeleteApplication(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            string applicationName)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteApplication>()(
-                sessionHandle,
-                profileHandle,
-                new UnicodeString(applicationName)
-            );
-
-            if (status == Status.IncompatibleStructureVersion)
-            {
-                throw new NVIDIANotSupportedException("This operation is not supported.");
-            }
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API deletes a profile or sets it back to a predefined value.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        public static void DeleteProfile(DRSSessionHandle sessionHandle, DRSProfileHandle profileHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteProfile>()(
-                sessionHandle,
-                profileHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API deletes a setting or sets it back to predefined value.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="settingId">Input settingId to be deleted.</param>
-        public static void DeleteProfileSetting(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            uint settingId)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DeleteProfileSetting>()(
-                sessionHandle,
-                profileHandle,
-                settingId
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API frees the allocated resources for the session handle.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        public static void DestroySession(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_DestroySession>()(sessionHandle);
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API enumerates all the applications in a given profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <returns>Instances of <see cref="IDRSApplication" /> with all the attributes filled.</returns>
-        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
-        public static IEnumerable<IDRSApplication> EnumApplications(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle)
-        {
-            var maxApplicationsPerRequest = 8;
-            var enumApplications = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumApplications>();
-
-            foreach (var acceptType in enumApplications.Accepts())
-            {
-                var i = 0u;
-
-                while (true)
-                {
-                    var instances = acceptType.Instantiate<IDRSApplication>().Repeat(maxApplicationsPerRequest);
-
-                    using (var applicationsReference = ValueTypeArray.FromArray(instances, acceptType))
-                    {
-                        var count = (uint) instances.Length;
-                        var status = enumApplications(
-                            sessionHandle,
-                            profileHandle,
-                            i,
-                            ref count,
-                            applicationsReference
-                        );
-
-                        if (status == Status.IncompatibleStructureVersion)
-                        {
-                            break;
-                        }
-
-                        if (status == Status.EndEnumeration)
-                        {
-                            yield break;
-                        }
-
-                        if (status != Status.Ok)
-                        {
-                            throw new NVIDIAApiException(status);
-                        }
-
-                        foreach (var application in applicationsReference.ToArray<IDRSApplication>(
-                            (int) count,
-                            acceptType))
-                        {
-                            yield return application;
-                            i++;
-                        }
-
-                        if (count < maxApplicationsPerRequest)
-                        {
-                            yield break;
-                        }
-                    }
-                }
-            }
-
-            throw new NVIDIANotSupportedException("This operation is not supported.");
-        }
-
-        /// <summary>
-        ///     This API enumerates all the Ids of all the settings recognized by NVAPI.
-        /// </summary>
-        /// <returns>An array of <see cref="uint" />s filled with the settings identification numbers of available settings.</returns>
-        public static uint[] EnumAvailableSettingIds()
-        {
-            var settingIdsCount = (uint) ushort.MaxValue;
-            var settingIds = 0u.Repeat((int) settingIdsCount);
-
-            using (var settingIdsArray = ValueTypeArray.FromArray(settingIds))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumAvailableSettingIds>()(
-                    settingIdsArray,
-                    ref settingIdsCount
-                );
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return settingIdsArray.ToArray<uint>((int) settingIdsCount);
-            }
-        }
-
-        /// <summary>
-        ///     This API enumerates all available setting values for a given setting.
-        /// </summary>
-        /// <param name="settingId">Input settingId.</param>
-        /// <returns>All available setting values.</returns>
-        public static DRSSettingValues EnumAvailableSettingValues(uint settingId)
-        {
-            var settingValuesCount = (uint) DRSSettingValues.MaximumNumberOfValues;
-            var settingValues = typeof(DRSSettingValues).Instantiate<DRSSettingValues>();
-
-            using (var settingValuesReference = ValueTypeReference.FromValueType(settingValues))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumAvailableSettingValues>()(
-                    settingId,
-                    ref settingValuesCount,
-                    settingValuesReference
-                );
-
-                if (status == Status.IncompatibleStructureVersion)
-                {
-                    throw new NVIDIANotSupportedException("This operation is not supported.");
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return settingValuesReference.ToValueType<DRSSettingValues>(typeof(DRSSettingValues));
-            }
-        }
-
-        /// <summary>
-        ///     This API enumerates through all the profiles in the session.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <returns>Instances of <see cref="DRSProfileHandle" /> each representing a profile.</returns>
-        public static IEnumerable<DRSProfileHandle> EnumProfiles(DRSSessionHandle sessionHandle)
-        {
-            var i = 0u;
-
-            while (true)
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumProfiles>()(
-                    sessionHandle,
-                    i,
-                    out var profileHandle
-                );
-
-                if (status == Status.EndEnumeration)
-                {
-                    yield break;
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                yield return profileHandle;
-                i++;
-            }
-        }
-
-        /// <summary>
-        ///     This API enumerates all the settings of a given profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <returns>Instances of <see cref="DRSSettingV1" />.</returns>
-        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
-        public static IEnumerable<DRSSettingV1> EnumSettings(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle)
-        {
-            var maxSettingsPerRequest = 32;
-            var enumSettings = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_EnumSettings>();
-
-            var i = 0u;
-
-            while (true)
-            {
-                var instances = typeof(DRSSettingV1).Instantiate<DRSSettingV1>().Repeat(maxSettingsPerRequest);
-
-                using (var applicationsReference = ValueTypeArray.FromArray(instances))
-                {
-                    var count = (uint) instances.Length;
-                    var status = enumSettings(
-                        sessionHandle,
-                        profileHandle,
-                        i,
-                        ref count,
-                        applicationsReference
-                    );
-
-                    if (status == Status.IncompatibleStructureVersion)
-                    {
-                        throw new NVIDIANotSupportedException("This operation is not supported.");
-                    }
-
-                    if (status == Status.EndEnumeration)
-                    {
-                        yield break;
-                    }
-
-                    if (status != Status.Ok)
-                    {
-                        throw new NVIDIAApiException(status);
-                    }
-
-                    foreach (var application in applicationsReference.ToArray<DRSSettingV1>(
-                        (int) count,
-                        typeof(DRSSettingV1))
-                    )
-                    {
-                        yield return application;
-                        i++;
-                    }
-
-                    if (count < maxSettingsPerRequest)
-                    {
-                        yield break;
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        ///     This API searches the application and the associated profile for the given application name.
-        ///     If a fully qualified path is provided, this function will always return the profile
-        ///     the driver will apply upon running the application (on the path provided).
-        /// </summary>
-        /// <param name="sessionHandle">Input to the hSession handle</param>
-        /// <param name="applicationName">Input appName. For best results, provide a fully qualified path of the type</param>
-        /// <param name="profileHandle">The profile handle of the profile that the found application belongs to.</param>
-        /// <returns>An instance of <see cref="IDRSApplication" />.</returns>
-        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
-        public static IDRSApplication FindApplicationByName(
-            DRSSessionHandle sessionHandle,
-            string applicationName,
-            out DRSProfileHandle? profileHandle)
-        {
-            var findApplicationByName = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_FindApplicationByName>();
-
-            foreach (var acceptType in findApplicationByName.Accepts())
-            {
-                var instance = acceptType.Instantiate<IDRSApplication>();
-
-                using (var applicationReference = ValueTypeReference.FromValueType(instance, acceptType))
-                {
-                    var status = findApplicationByName(
-                        sessionHandle,
-                        new UnicodeString(applicationName),
-                        out var applicationProfileHandle,
-                        applicationReference
-                    );
-
-                    if (status == Status.IncompatibleStructureVersion)
-                    {
-                        continue;
-                    }
-
-                    if (status == Status.ExecutableNotFound)
-                    {
-                        profileHandle = null;
-
-                        return null;
-                    }
-
-                    if (status != Status.Ok)
-                    {
-                        throw new NVIDIAApiException(status);
-                    }
-
-                    profileHandle = applicationProfileHandle;
-
-                    return applicationReference.ToValueType<IDRSApplication>(acceptType);
-                }
-            }
-
-            throw new NVIDIANotSupportedException("This operation is not supported.");
-        }
-
-        /// <summary>
-        ///     This API finds a profile in the current session.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileName">Input profileName.</param>
-        /// <returns>The profile handle.</returns>
-        public static DRSProfileHandle FindProfileByName(DRSSessionHandle sessionHandle, string profileName)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_FindProfileByName>()(
-                sessionHandle,
-                new UnicodeString(profileName),
-                out var profileHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return profileHandle;
-        }
-
-        /// <summary>
-        ///     This API gets information about the given application.  The input application name
-        ///     must match exactly what the Profile has stored for the application.
-        ///     This function is better used to retrieve application information from a previous
-        ///     enumeration.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="applicationName">Input application name.</param>
-        /// <returns>
-        ///     An instance of <see cref="IDRSApplication" /> with all attributes filled if found; otherwise
-        ///     <see langword="null" />.
-        /// </returns>
-        [SuppressMessage("ReSharper", "EventExceptionNotDocumented")]
-        public static IDRSApplication GetApplicationInfo(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            string applicationName)
-        {
-            var getApplicationInfo = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetApplicationInfo>();
-
-            foreach (var acceptType in getApplicationInfo.Accepts())
-            {
-                var instance = acceptType.Instantiate<IDRSApplication>();
-
-                using (var applicationReference = ValueTypeReference.FromValueType(instance, acceptType))
-                {
-                    var status = getApplicationInfo(
-                        sessionHandle,
-                        profileHandle,
-                        new UnicodeString(applicationName),
-                        applicationReference
-                    );
-
-                    if (status == Status.IncompatibleStructureVersion)
-                    {
-                        continue;
-                    }
-
-                    if (status == Status.ExecutableNotFound)
-                    {
-                        return null;
-                    }
-
-                    if (status != Status.Ok)
-                    {
-                        throw new NVIDIAApiException(status);
-                    }
-
-                    return applicationReference.ToValueType<IDRSApplication>(acceptType);
-                }
-            }
-
-            throw new NVIDIANotSupportedException("This operation is not supported.");
-        }
-
-        /// <summary>
-        ///     Returns the handle to the current global profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <returns>Base profile handle.</returns>
-        public static DRSProfileHandle GetBaseProfile(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetBaseProfile>()(
-                sessionHandle,
-                out var profileHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return profileHandle;
-        }
-
-        /// <summary>
-        ///     This API returns the handle to the current global profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <returns>Current global profile handle.</returns>
-        public static DRSProfileHandle GetCurrentGlobalProfile(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetCurrentGlobalProfile>()(
-                sessionHandle,
-                out var profileHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return profileHandle;
-        }
-
-        /// <summary>
-        ///     This API obtains the number of profiles in the current session object.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <returns>Number of profiles in the current session.</returns>
-        public static int GetNumberOfProfiles(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetNumProfiles>()(
-                sessionHandle,
-                out var profileCount
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return (int) profileCount;
-        }
-
-        /// <summary>
-        ///     This API gets information about the given profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <returns>An instance of <see cref="DRSProfileV1" /> with all attributes filled.</returns>
-        public static DRSProfileV1 GetProfileInfo(DRSSessionHandle sessionHandle, DRSProfileHandle profileHandle)
-        {
-            var profile = typeof(DRSProfileV1).Instantiate<DRSProfileV1>();
-
-            using (var profileReference = ValueTypeReference.FromValueType(profile))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetProfileInfo>()(
-                    sessionHandle,
-                    profileHandle,
-                    profileReference
-                );
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return profileReference.ToValueType<DRSProfileV1>().GetValueOrDefault();
-            }
-        }
-
-        /// <summary>
-        ///     This API gets information about the given setting.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="settingId">Input settingId.</param>
-        /// <returns>An instance of <see cref="DRSSettingV1" /> describing the setting if found; otherwise <see langword="null" />.</returns>
-        public static DRSSettingV1? GetSetting(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            uint settingId)
-        {
-            var instance = typeof(DRSSettingV1).Instantiate<DRSSettingV1>();
-
-            using (var settingReference = ValueTypeReference.FromValueType(instance, typeof(DRSSettingV1)))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSetting>()(
-                    sessionHandle,
-                    profileHandle,
-                    settingId,
-                    settingReference
-                );
-
-                if (status == Status.IncompatibleStructureVersion)
-                {
-                    throw new NVIDIANotSupportedException("This operation is not supported.");
-                }
-
-                if (status == Status.SettingNotFound)
-                {
-                    return null;
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-
-                return settingReference.ToValueType<DRSSettingV1>(typeof(DRSSettingV1));
-            }
-        }
-
-        /// <summary>
-        ///     This API gets the binary identification number of a setting given the setting name.
-        /// </summary>
-        /// <param name="settingName">Input Unicode settingName.</param>
-        /// <returns>The corresponding settingId.</returns>
-        public static uint GetSettingIdFromName(string settingName)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSettingIdFromName>()(
-                new UnicodeString(settingName),
-                out var settingId
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return settingId;
-        }
-
-        /// <summary>
-        ///     This API gets the setting name given the binary identification number.
-        /// </summary>
-        /// <param name="settingId">Input settingId.</param>
-        /// <returns>Corresponding settingName.</returns>
-        public static string GetSettingNameFromId(uint settingId)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_GetSettingNameFromId>()(
-                settingId,
-                out var settingName
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-
-            return settingName.Value;
-        }
-
-        /// <summary>
-        ///     This API loads and parses the settings data.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        public static void LoadSettings(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_LoadSettings>()(sessionHandle);
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API loads settings from the given file path.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle</param>
-        /// <param name="fileName">Binary full file path.</param>
-        public static void LoadSettings(DRSSessionHandle sessionHandle, string fileName)
-        {
-            var unicodeFileName = new UnicodeString(fileName);
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_LoadSettingsFromFile>()(
-                sessionHandle,
-                unicodeFileName
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API restores the whole system to predefined(default) values.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        public static void RestoreDefaults(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreAllDefaults>()(
-                sessionHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API restores the given profile to predefined(default) values.
-        ///     Any and all user specified modifications will be removed.
-        ///     If the whole profile was set by the user, the profile will be removed.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        public static void RestoreDefaults(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreProfileDefault>()(
-                sessionHandle,
-                profileHandle
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API restores the given profile setting to predefined(default) values.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="settingId">Input settingId.</param>
-        public static void RestoreDefaults(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            uint settingId)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_RestoreProfileDefaultSetting>()(
-                sessionHandle,
-                profileHandle,
-                settingId
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API saves the settings data to the system.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        public static void SaveSettings(DRSSessionHandle sessionHandle)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SaveSettings>()(sessionHandle);
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API saves settings to the given file path.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="fileName">Binary full file path.</param>
-        public static void SaveSettings(DRSSessionHandle sessionHandle, string fileName)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SaveSettingsToFile>()(
-                sessionHandle,
-                new UnicodeString(fileName)
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     This API sets the current global profile in the driver.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileName">Input the new current global profile name.</param>
-        public static void SetCurrentGlobalProfile(DRSSessionHandle sessionHandle, string profileName)
-        {
-            var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetCurrentGlobalProfile>()(
-                sessionHandle,
-                new UnicodeString(profileName)
-            );
-
-            if (status != Status.Ok)
-            {
-                throw new NVIDIAApiException(status);
-            }
-        }
-
-        /// <summary>
-        ///     Specifies flags for a given profile. Currently only the GPUSupport is
-        ///     used to update the profile. Neither the name, number of settings or applications
-        ///     or other profile information can be changed with this function.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="profile">Input the new profile info.</param>
-        public static void SetProfileInfo(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            DRSProfileV1 profile)
-        {
-            using (var profileReference = ValueTypeReference.FromValueType(profile))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetProfileInfo>()(
-                    sessionHandle,
-                    profileHandle,
-                    profileReference
-                );
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-            }
-        }
-
-        /// <summary>
-        ///     This API adds/modifies a setting to a profile.
-        /// </summary>
-        /// <param name="sessionHandle">Input to the session handle.</param>
-        /// <param name="profileHandle">Input profile handle.</param>
-        /// <param name="setting">
-        ///     An instance of <see cref="DRSSettingV1" /> containing the setting identification number and new
-        ///     value for the setting.
-        /// </param>
-        public static void SetSetting(
-            DRSSessionHandle sessionHandle,
-            DRSProfileHandle profileHandle,
-            DRSSettingV1 setting)
-        {
-            using (var settingReference = ValueTypeReference.FromValueType(setting, setting.GetType()))
-            {
-                var status = DelegateFactory.GetDelegate<Delegates.DRS.NvAPI_DRS_SetSetting>()(
-                    sessionHandle,
-                    profileHandle,
-                    settingReference
-                );
-
-                if (status == Status.IncompatibleStructureVersion)
-                {
-                    throw new NVIDIANotSupportedException("This operation is not supported.");
-                }
-
-                if (status != Status.Ok)
-                {
-                    throw new NVIDIAApiException(status);
-                }
-            }
-        }
-    }
-}

app/NvAPIWrapper/Native/Delegates/DRS.cs

@@ -1,255 +0,0 @@
-using System.Runtime.InteropServices;
-using NvAPIWrapper.Native.Attributes;
-using NvAPIWrapper.Native.DRS.Structures;
-using NvAPIWrapper.Native.General;
-using NvAPIWrapper.Native.General.Structures;
-using NvAPIWrapper.Native.Helpers;
-using NvAPIWrapper.Native.Helpers.Structures;
-
-namespace NvAPIWrapper.Native.Delegates
-{
-    // ReSharper disable InconsistentNaming
-    internal static class DRS
-    {
-        [FunctionId(FunctionId.NvAPI_DRS_CreateApplication)]
-        public delegate Status NvAPI_DRS_CreateApplication(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In]
-            [Accepts(
-                typeof(DRSApplicationV4),
-                typeof(DRSApplicationV3),
-                typeof(DRSApplicationV2),
-                typeof(DRSApplicationV1)
-            )]
-            ValueTypeReference application
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_CreateProfile)]
-        public delegate Status NvAPI_DRS_CreateProfile(
-            [In] DRSSessionHandle sessionHandle,
-            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile,
-            [Out] out DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_CreateSession)]
-        public delegate Status NvAPI_DRS_CreateSession([Out] out DRSSessionHandle sessionHandle);
-
-        [FunctionId(FunctionId.NvAPI_DRS_DeleteApplication)]
-        public delegate Status NvAPI_DRS_DeleteApplication(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] UnicodeString applicationName
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_DeleteApplicationEx)]
-        public delegate Status NvAPI_DRS_DeleteApplicationEx(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In]
-            [Accepts(typeof(DRSApplicationV1), typeof(DRSApplicationV2), typeof(DRSApplicationV3),
-                typeof(DRSApplicationV4))]
-            ValueTypeReference application
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_DeleteProfile)]
-        public delegate Status NvAPI_DRS_DeleteProfile(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_DeleteProfileSetting)]
-        public delegate Status NvAPI_DRS_DeleteProfileSetting(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] uint settingId
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_DestroySession)]
-        public delegate Status NvAPI_DRS_DestroySession([In] DRSSessionHandle sessionHandle);
-
-        [FunctionId(FunctionId.NvAPI_DRS_EnumApplications)]
-        public delegate Status NvAPI_DRS_EnumApplications(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] uint index,
-            [In] [Out] ref uint count,
-            [In]
-            [Accepts(
-                typeof(DRSApplicationV4),
-                typeof(DRSApplicationV3),
-                typeof(DRSApplicationV2),
-                typeof(DRSApplicationV1)
-            )]
-            ValueTypeArray applications
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_EnumAvailableSettingIds)]
-        public delegate Status NvAPI_DRS_EnumAvailableSettingIds(
-            [In] [Accepts(typeof(uint))] ValueTypeArray settingIds,
-            [In] [Out] ref uint count
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_EnumAvailableSettingValues)]
-        public delegate Status NvAPI_DRS_EnumAvailableSettingValues(
-            [In] uint settingId,
-            [In] [Out] ref uint count,
-            [In] [Out] [Accepts(typeof(DRSSettingValues))]
-            ValueTypeReference settingValues
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_EnumProfiles)]
-        public delegate Status NvAPI_DRS_EnumProfiles(
-            [In] DRSSessionHandle sessionHandle,
-            [In] uint index,
-            [Out] out DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_EnumSettings)]
-        public delegate Status NvAPI_DRS_EnumSettings(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] uint index,
-            [In] [Out] ref uint count,
-            [In] [Out] [Accepts(typeof(DRSSettingV1))]
-            ValueTypeArray settings
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_FindApplicationByName)]
-        public delegate Status NvAPI_DRS_FindApplicationByName(
-            [In] DRSSessionHandle sessionHandle,
-            [In] UnicodeString applicationName,
-            [Out] out DRSProfileHandle profileHandle,
-            [In]
-            [Accepts(
-                typeof(DRSApplicationV4),
-                typeof(DRSApplicationV3),
-                typeof(DRSApplicationV2),
-                typeof(DRSApplicationV1)
-            )]
-            ValueTypeReference application
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_FindProfileByName)]
-        public delegate Status NvAPI_DRS_FindProfileByName(
-            [In] DRSSessionHandle sessionHandle,
-            [In] UnicodeString profileName,
-            [Out] out DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetApplicationInfo)]
-        public delegate Status NvAPI_DRS_GetApplicationInfo(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] UnicodeString applicationName,
-            [In]
-            [Accepts(
-                typeof(DRSApplicationV4),
-                typeof(DRSApplicationV3),
-                typeof(DRSApplicationV2),
-                typeof(DRSApplicationV1)
-            )]
-            ValueTypeReference application
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetBaseProfile)]
-        public delegate Status NvAPI_DRS_GetBaseProfile(
-            [In] DRSSessionHandle sessionHandle,
-            [Out] out DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetCurrentGlobalProfile)]
-        public delegate Status NvAPI_DRS_GetCurrentGlobalProfile(
-            [In] DRSSessionHandle sessionHandle,
-            [Out] out DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetNumProfiles)]
-        public delegate Status NvAPI_DRS_GetNumProfiles([In] DRSSessionHandle sessionHandle, [Out] out uint count);
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetProfileInfo)]
-        public delegate Status NvAPI_DRS_GetProfileInfo(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetSetting)]
-        public delegate Status NvAPI_DRS_GetSetting(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] uint settingId,
-            [Out] [Accepts(typeof(DRSSettingV1))] ValueTypeReference setting
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetSettingIdFromName)]
-        public delegate Status NvAPI_DRS_GetSettingIdFromName(
-            [In] UnicodeString settingName,
-            [Out] out uint settingId
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_GetSettingNameFromId)]
-        public delegate Status NvAPI_DRS_GetSettingNameFromId(
-            [In] uint settingId,
-            [Out] out UnicodeString settingName
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_LoadSettings)]
-        public delegate Status NvAPI_DRS_LoadSettings([In] DRSSessionHandle sessionHandle);
-
-        [FunctionId(FunctionId.NvAPI_DRS_LoadSettingsFromFile)]
-        public delegate Status NvAPI_DRS_LoadSettingsFromFile(
-            [In] DRSSessionHandle sessionHandle,
-            [In] UnicodeString fileName
-        );
-
-
-        [FunctionId(FunctionId.NvAPI_DRS_RestoreAllDefaults)]
-        public delegate Status NvAPI_DRS_RestoreAllDefaults(
-            [In] DRSSessionHandle sessionHandle
-        );
-
-
-        [FunctionId(FunctionId.NvAPI_DRS_RestoreProfileDefault)]
-        public delegate Status NvAPI_DRS_RestoreProfileDefault(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_RestoreProfileDefaultSetting)]
-        public delegate Status NvAPI_DRS_RestoreProfileDefaultSetting(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] uint settingId
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_SaveSettings)]
-        public delegate Status NvAPI_DRS_SaveSettings([In] DRSSessionHandle sessionHandle);
-
-        [FunctionId(FunctionId.NvAPI_DRS_SaveSettingsToFile)]
-        public delegate Status NvAPI_DRS_SaveSettingsToFile(
-            [In] DRSSessionHandle sessionHandle,
-            [In] UnicodeString fileName
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_SetCurrentGlobalProfile)]
-        public delegate Status NvAPI_DRS_SetCurrentGlobalProfile(
-            [In] DRSSessionHandle sessionHandle,
-            [In] UnicodeString profileName
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_SetProfileInfo)]
-        public delegate Status NvAPI_DRS_SetProfileInfo(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] [Accepts(typeof(DRSProfileV1))] ValueTypeReference profile
-        );
-
-        [FunctionId(FunctionId.NvAPI_DRS_SetSetting)]
-        public delegate Status NvAPI_DRS_SetSetting(
-            [In] DRSSessionHandle sessionHandle,
-            [In] DRSProfileHandle profileHandle,
-            [In] [Accepts(typeof(DRSSettingV1))] ValueTypeReference setting
-        );
-    }
-}