From 9655ffde6afd68fadfc33d02497cb83611af3246 Mon Sep 17 00:00:00 2001
From: CasperH <casperhofstede@gmail.com>
Date: Fri, 31 May 2024 12:25:34 +0200
Subject: [PATCH] EA to Public files move

---
 HandheldCompanion/App.xaml                    |    3 +-
 HandheldCompanion/App.xaml.cs                 |    6 +-
 .../Controllers/DualSenseController.cs        |    4 +-
 .../Controllers/IController.xaml.cs           |   74 +-
 HandheldCompanion/Controls/Hints/IHint.xaml   |  122 +-
 .../Controls/Hints/IHint.xaml.cs              |   44 +-
 .../Converters/InverseAppThemeConverter.cs    |   52 +-
 .../Devices/AOKZOE/AOKZOEA1Pro.cs             |   32 +-
 HandheldCompanion/Devices/ASUS/AsusACPI.cs    | 1022 +++++------
 .../Devices/AYANEO/AYANEOAIR1S.cs             |    4 +-
 .../Devices/AYANEO/AYANEODevice.cs            |    2 +-
 .../Devices/Ayn/AynLokiMax6600U.cs            |   24 +-
 .../Devices/Ayn/AynLokiMax6800U.cs            |   24 +-
 .../Devices/Ayn/AynLokiMiniPro.cs             |   24 +-
 HandheldCompanion/Devices/Ayn/AynLokiZero.cs  |   24 +-
 HandheldCompanion/Devices/GPD/GPDWin2.cs      |   30 +-
 HandheldCompanion/Devices/Lenovo/FanTable.cs  |  178 +-
 HandheldCompanion/Devices/Lenovo/LegionGo.cs  |   49 +-
 .../Devices/OneXPlayer/OneXPlayer2Pro.cs      |   32 +-
 .../GraphicsProcessingUnit/AMDGPU.cs          |  176 +-
 .../GraphicsProcessingUnit/GPU.cs             |    2 +
 .../GraphicsProcessingUnit/IntelGPU.cs        |   12 +-
 HandheldCompanion/Helpers/GamepadMotion.cs    |    8 +-
 .../Managers/ControllerManager.cs             |   13 +-
 HandheldCompanion/Managers/GPUManager.cs      |   16 +-
 .../Managers/MultimediaManager.cs             | 1168 ++++++------
 HandheldCompanion/Managers/SensorsManager.cs  |   27 +-
 HandheldCompanion/Misc/Dialog.cs              |  192 +-
 HandheldCompanion/Misc/PnPDetails.cs          |  414 ++---
 HandheldCompanion/Misc/PnPUtil.cs             |  276 +--
 HandheldCompanion/Misc/Profile.cs             |   10 +-
 HandheldCompanion/Platforms/Steam.cs          |    7 +-
 .../Presets/ColorPresetResources.cs           |   98 +-
 HandheldCompanion/Processors/AMD/RyzenAdj.cs  |    1 +
 HandheldCompanion/Processors/AMDProcessor.cs  |  158 +-
 .../Properties/Settings.Designer.cs           | 1058 ++++-------
 HandheldCompanion/Sensors/IMUAccelerometer.cs |  276 +--
 HandheldCompanion/Styles/NavigationView.xaml  |    9 -
 HandheldCompanion/Targets/DualShock4Target.cs |   27 +-
 HandheldCompanion/Targets/ViGEmTarget.cs      |    8 +-
 HandheldCompanion/Targets/Xbox360Target.cs    |   25 +-
 HandheldCompanion/Utils/HIDUtils.cs           |   28 +-
 HandheldCompanion/Utils/RegistryUtils.cs      |  172 +-
 HandheldCompanion/Utils/ServiceUtils.cs       |  272 +--
 HandheldCompanion/Utils/WPFUtils.cs           |  748 ++++----
 .../Layout/Mappings/AxisMappingViewModel.cs   |    2 +-
 .../Layout/Mappings/ButtonMappingViewModel.cs |    4 +-
 .../Layout/Mappings/GyroMappingViewModel.cs   |    2 +-
 .../Mappings/TriggerMappingViewModel.cs       |    2 +-
 .../ViewModels/Pages/AboutPageViewModel.cs    |   92 +-
 .../Views/Classes/GamepadWindow.cs            |  224 +--
 .../Views/Classes/OverlayWindow.cs            |  332 ++--
 .../Views/Pages/ControllerPage.xaml.cs        |    2 +-
 .../Views/Pages/ProfilesPage.xaml.cs          |   63 +-
 .../QuickPages/QuickProfilesPage.xaml.cs      |   22 +-
 .../Views/Windows/MainWindow.xaml.cs          | 1598 ++++++++---------
 HandheldCompanion/WMI.cs                      |   25 +-
 README.md                                     |    2 +-
 utils/Utils.iss                               |    4 +-
 59 files changed, 4465 insertions(+), 4860 deletions(-)

diff --git a/HandheldCompanion/App.xaml b/HandheldCompanion/App.xaml
index 82527e020..f59b99fa7 100644
--- a/HandheldCompanion/App.xaml
+++ b/HandheldCompanion/App.xaml
@@ -3,6 +3,7 @@
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:converters="clr-namespace:HandheldCompanion.Converters"
+    xmlns:local="clr-namespace:HandheldCompanion"
     xmlns:math="http://hexinnovation.com/math"
     xmlns:presets="clr-namespace:HandheldCompanion.Presets"
     xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern">
@@ -10,7 +11,7 @@
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
-                <ui:ThemeResources>
+                <ui:ThemeResources CanBeAccessedAcrossThreads="{x:Static local:App.IsMultiThreaded}">
                     <ui:ThemeResources.ThemeDictionaries>
                         <ResourceDictionary x:Key="Light" ui:ThemeDictionary.Key="Light">
                             <ResourceDictionary.MergedDictionaries>
diff --git a/HandheldCompanion/App.xaml.cs b/HandheldCompanion/App.xaml.cs
index 3e14c5c13..12e883481 100644
--- a/HandheldCompanion/App.xaml.cs
+++ b/HandheldCompanion/App.xaml.cs
@@ -16,6 +16,8 @@ namespace HandheldCompanion;
 /// </summary>
 public partial class App : Application
 {
+    public static bool IsMultiThreaded { get; } = false;
+
     /// <summary>
     ///     Initializes the singleton application object.  This is the first line of authored code
     ///     executed, and as such is the logical equivalent of main() or WinMain().
@@ -36,8 +38,10 @@ protected override void OnStartup(StartupEventArgs args)
         var CurrentAssembly = Assembly.GetExecutingAssembly();
         var fileVersionInfo = FileVersionInfo.GetVersionInfo(CurrentAssembly.Location);
 
-        // initialize log
+        // set environment variables
         Environment.SetEnvironmentVariable("APP_BASE_DIRECTORY", AppContext.BaseDirectory);
+
+        // initialize log
         LogManager.Initialize("HandheldCompanion");
         LogManager.LogInformation("{0} ({1})", CurrentAssembly.GetName(), fileVersionInfo.FileVersion);
 
diff --git a/HandheldCompanion/Controllers/DualSenseController.cs b/HandheldCompanion/Controllers/DualSenseController.cs
index 9c3dce616..34a63c15a 100644
--- a/HandheldCompanion/Controllers/DualSenseController.cs
+++ b/HandheldCompanion/Controllers/DualSenseController.cs
@@ -58,7 +58,7 @@ public override void UpdateInputs(long ticks, float delta)
             float joyShockY0 = JslGetTouchY(UserIndex);
 
             Inputs.AxisState[AxisFlags.LeftPadX] = (short)InputUtils.MapRange(joyShockX0, 0.0f, 1.0f, short.MinValue, short.MaxValue);
-            Inputs.AxisState[AxisFlags.LeftPadY] = (short)InputUtils.MapRange(joyShockY0, 0.0f, 1.0f, short.MaxValue, short.MinValue);
+            Inputs.AxisState[AxisFlags.LeftPadY] = (short)InputUtils.MapRange(joyShockY0, 0.0f, 1.1442206f, short.MaxValue, short.MinValue);
         }
         else
         {
@@ -76,7 +76,7 @@ public override void UpdateInputs(long ticks, float delta)
             float joyShockY1 = JslGetTouchY(UserIndex, true);
 
             Inputs.AxisState[AxisFlags.RightPadX] = (short)InputUtils.MapRange(joyShockX1, 0.0f, 1.0f, short.MinValue, short.MaxValue);
-            Inputs.AxisState[AxisFlags.RightPadY] = (short)InputUtils.MapRange(joyShockY1, 0.0f, 1.0f, short.MaxValue, short.MinValue);
+            Inputs.AxisState[AxisFlags.RightPadY] = (short)InputUtils.MapRange(joyShockY1, 0.0f, 1.1442206f, short.MaxValue, short.MinValue);
         }
         else
         {
diff --git a/HandheldCompanion/Controllers/IController.xaml.cs b/HandheldCompanion/Controllers/IController.xaml.cs
index 0d79258ce..67144bbd0 100644
--- a/HandheldCompanion/Controllers/IController.xaml.cs
+++ b/HandheldCompanion/Controllers/IController.xaml.cs
@@ -573,13 +573,14 @@ public virtual string GetGlyph(ButtonFlags button)
             switch (button)
             {
                 case ButtonFlags.DPadUp:
-                    return "\u219F"; // Button A
+                    return "\u219F";
                 case ButtonFlags.DPadDown:
-                    return "\u21A1"; // Button B
+                    return "\u21A1";
                 case ButtonFlags.DPadLeft:
-                    return "\u219E"; // Button X
+                    return "\u219E";
                 case ButtonFlags.DPadRight:
-                    return "\u21A0"; // Button Y
+                    return "\u21A0";
+
                 case ButtonFlags.LeftStickClick:
                     return "\u21BA";
                 case ButtonFlags.RightStickClick:
@@ -600,10 +601,39 @@ public virtual string GetGlyph(ButtonFlags button)
                     return "\u21BD";
                 case ButtonFlags.RightStickRight:
                     return "\u21C1";
+
                 case ButtonFlags.VolumeUp:
                     return "\u21fe";
                 case ButtonFlags.VolumeDown:
                     return "\u21fd";
+
+                case ButtonFlags.LeftPadTouch:
+                    return "\u2268";
+                case ButtonFlags.RightPadTouch:
+                    return "\u2269";
+
+                case ButtonFlags.LeftPadClick:
+                    return "\u2266";
+                case ButtonFlags.RightPadClick:
+                    return "\u2267";
+
+                case ButtonFlags.LeftPadClickDown:
+                    return "\u2274";
+                case ButtonFlags.LeftPadClickUp:
+                    return "\u2270";
+                case ButtonFlags.LeftPadClickRight:
+                    return "\u2272";
+                case ButtonFlags.LeftPadClickLeft:
+                    return "\u226E";
+
+                case ButtonFlags.RightPadClickDown:
+                    return "\u2275";
+                case ButtonFlags.RightPadClickUp:
+                    return "\u2271";
+                case ButtonFlags.RightPadClickRight:
+                    return "\u2273";
+                case ButtonFlags.RightPadClickLeft:
+                    return "\u226F";
             }
 
             return defaultGlyph;
@@ -621,6 +651,14 @@ public virtual string GetGlyph(AxisFlags axis)
                     return "\u21C6";
                 case AxisFlags.RightStickY:
                     return "\u21F5";
+
+                // Todo, need dedicated icons
+                case AxisFlags.LeftPadX:
+                case AxisFlags.LeftPadY:
+                    return "\u2264";
+                case AxisFlags.RightPadX:
+                case AxisFlags.RightPadY:
+                    return "\u2265";
             }
 
             return defaultGlyph;
@@ -634,8 +672,14 @@ public virtual string GetGlyph(AxisLayoutFlags axis)
                     return "\u21CB";
                 case AxisLayoutFlags.RightStick:
                     return "\u21CC";
+
                 case AxisLayoutFlags.Gyroscope:
                     return "\u2B94";
+
+                case AxisLayoutFlags.LeftPad:
+                    return "\u2264";
+                case AxisLayoutFlags.RightPad:
+                    return "\u2265";
             }
 
             return defaultGlyph;
@@ -643,26 +687,26 @@ public virtual string GetGlyph(AxisLayoutFlags axis)
 
         public GlyphIconInfo GetGlyphIconInfo(ButtonFlags button, int fontIconSize = 14)
         {
-            var glyph = GetGlyph(button);
+            string? glyph = GetGlyph(button);
             return new GlyphIconInfo
             {
                 Name = GetButtonName(button),
-                Glyph = glyph,
-                FontSize = glyph is not null ? 28 : fontIconSize,
-                FontFamily = glyph is not null ? GlyphFontFamily : null,
+                Glyph = glyph is not null ? glyph : defaultGlyph,
+                FontSize = fontIconSize,
+                FontFamily = GlyphFontFamily,
                 Foreground = GetGlyphColor(button)
             };
         }
 
         public GlyphIconInfo GetGlyphIconInfo(AxisLayoutFlags axis, int fontIconSize = 14)
         {
-            var glyph = GetGlyph(axis);
+            string? glyph = GetGlyph(axis);
             return new GlyphIconInfo
             {
                 Name = GetAxisName(axis),
-                Glyph = glyph,
-                FontSize = glyph is not null ? 28 : fontIconSize,
-                FontFamily = glyph is not null ? GlyphFontFamily : null,
+                Glyph = glyph is not null ? glyph : defaultGlyph,
+                FontSize = fontIconSize,
+                FontFamily = GlyphFontFamily,
                 Foreground = GetGlyphColor(axis)
             };
         }
@@ -678,10 +722,7 @@ public FontIcon GetFontIcon(ButtonFlags button, int FontIconSize = 14)
             };
 
             if (FontIcon.Glyph is not null)
-            {
                 FontIcon.FontFamily = GlyphFontFamily;
-                FontIcon.FontSize = 28;
-            }
 
             return FontIcon;
         }
@@ -698,10 +739,7 @@ public FontIcon GetFontIcon(AxisLayoutFlags axis, int FontIconSize = 14)
             };
 
             if (FontIcon.Glyph is not null)
-            {
                 FontIcon.FontFamily = GlyphFontFamily;
-                FontIcon.FontSize = 28;
-            }
 
             return FontIcon;
         }
diff --git a/HandheldCompanion/Controls/Hints/IHint.xaml b/HandheldCompanion/Controls/Hints/IHint.xaml
index b5a0c4f01..b93cf86f0 100644
--- a/HandheldCompanion/Controls/Hints/IHint.xaml
+++ b/HandheldCompanion/Controls/Hints/IHint.xaml
@@ -1,61 +1,61 @@
-<UserControl
-    x:Class="HandheldCompanion.Controls.Hints.IHint"
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:local="clr-namespace:HandheldCompanion.Controls.Hints"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:resx="clr-namespace:HandheldCompanion.Properties"
-    xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern"
-    d:Background="White"
-    d:DesignHeight="120"
-    d:DesignWidth="800"
-    d:Visibility="Visible"
-    Visibility="Collapsed"
-    mc:Ignorable="d">
-
-    <Expander
-        Name="HintsSteamNeptuneDeskop"
-        Padding="15,12,12,12"
-        HorizontalAlignment="Stretch">
-
-        <Expander.Header>
-            <Grid>
-                <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="8*" MinWidth="200" />
-                    <ColumnDefinition Width="2*" MinWidth="200" />
-                </Grid.ColumnDefinitions>
-
-                <DockPanel Margin="0,12,12,12">
-                    <ui:FontIcon
-                        Height="40"
-                        HorizontalAlignment="Center"
-                        FontFamily="{DynamicResource SymbolThemeFontFamily}"
-                        Glyph="&#xe7ba;" />
-
-                    <ui:SimpleStackPanel Margin="12,0,0,0" VerticalAlignment="Center">
-                        <TextBlock Name="HintTitle" Style="{StaticResource BodyTextBlockStyle}" />
-                        <TextBlock
-                            Name="HintDescription"
-                            Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
-                            Style="{StaticResource CaptionTextBlockStyle}"
-                            TextWrapping="Wrap" />
-                    </ui:SimpleStackPanel>
-                </DockPanel>
-
-                <Button
-                    Name="HintActionButton"
-                    Grid.Column="1"
-                    Width="200"
-                    HorizontalAlignment="Right"
-                    d:Visibility="Visible"
-                    Click="HintActionButton_Click"
-                    FontSize="14"
-                    Style="{StaticResource AccentButtonStyle}"
-                    Visibility="Collapsed" />
-            </Grid>
-        </Expander.Header>
-
-        <TextBlock Name="HintReadMe" TextWrapping="Wrap" />
-    </Expander>
-</UserControl>
+<UserControl
+    x:Class="HandheldCompanion.Controls.Hints.IHint"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:HandheldCompanion.Controls.Hints"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:resx="clr-namespace:HandheldCompanion.Properties"
+    xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern"
+    d:Background="White"
+    d:DesignHeight="120"
+    d:DesignWidth="800"
+    d:Visibility="Visible"
+    Visibility="Collapsed"
+    mc:Ignorable="d">
+
+    <Expander
+        Name="HintsSteamNeptuneDeskop"
+        Padding="15,12,12,12"
+        HorizontalAlignment="Stretch">
+
+        <Expander.Header>
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="8*" MinWidth="200" />
+                    <ColumnDefinition Width="2*" MinWidth="200" />
+                </Grid.ColumnDefinitions>
+
+                <DockPanel Margin="0,12,12,12">
+                    <ui:FontIcon
+                        Height="40"
+                        HorizontalAlignment="Center"
+                        FontFamily="{DynamicResource SymbolThemeFontFamily}"
+                        Glyph="&#xe7ba;" />
+
+                    <ui:SimpleStackPanel Margin="12,0,0,0" VerticalAlignment="Center">
+                        <TextBlock Name="HintTitle" Style="{StaticResource BodyTextBlockStyle}" />
+                        <TextBlock
+                            Name="HintDescription"
+                            Foreground="{DynamicResource SystemControlForegroundBaseMediumBrush}"
+                            Style="{StaticResource CaptionTextBlockStyle}"
+                            TextWrapping="Wrap" />
+                    </ui:SimpleStackPanel>
+                </DockPanel>
+
+                <Button
+                    Name="HintActionButton"
+                    Grid.Column="1"
+                    Width="200"
+                    HorizontalAlignment="Right"
+                    d:Visibility="Visible"
+                    Click="HintActionButton_Click"
+                    FontSize="14"
+                    Style="{StaticResource AccentButtonStyle}"
+                    Visibility="Collapsed" />
+            </Grid>
+        </Expander.Header>
+
+        <TextBlock Name="HintReadMe" TextWrapping="Wrap" />
+    </Expander>
+</UserControl>
diff --git a/HandheldCompanion/Controls/Hints/IHint.xaml.cs b/HandheldCompanion/Controls/Hints/IHint.xaml.cs
index b918affdd..b92cbf8a5 100644
--- a/HandheldCompanion/Controls/Hints/IHint.xaml.cs
+++ b/HandheldCompanion/Controls/Hints/IHint.xaml.cs
@@ -1,22 +1,22 @@
-using System.Windows;
-using System.Windows.Controls;
-
-namespace HandheldCompanion.Controls.Hints
-{
-    /// <summary>
-    /// Interaction logic for IHint.xaml
-    /// </summary>
-    public partial class IHint : UserControl
-    {
-        public IHint()
-        {
-            InitializeComponent();
-        }
-
-        protected virtual void HintActionButton_Click(object sender, RoutedEventArgs e)
-        { }
-
-        public virtual void Stop()
-        { }
-    }
-}
+using System.Windows;
+using System.Windows.Controls;
+
+namespace HandheldCompanion.Controls.Hints
+{
+    /// <summary>
+    /// Interaction logic for IHint.xaml
+    /// </summary>
+    public partial class IHint : UserControl
+    {
+        public IHint()
+        {
+            InitializeComponent();
+        }
+
+        protected virtual void HintActionButton_Click(object sender, RoutedEventArgs e)
+        { }
+
+        public virtual void Stop()
+        { }
+    }
+}
diff --git a/HandheldCompanion/Converters/InverseAppThemeConverter.cs b/HandheldCompanion/Converters/InverseAppThemeConverter.cs
index 4d0c85819..4b2e465f2 100644
--- a/HandheldCompanion/Converters/InverseAppThemeConverter.cs
+++ b/HandheldCompanion/Converters/InverseAppThemeConverter.cs
@@ -1,27 +1,27 @@
-using iNKORE.UI.WPF.Modern;
-using System;
-using System.Globalization;
-using System.Windows.Data;
-
-namespace HandheldCompanion.Converters;
-
-public class InverseAppThemeConverter : IValueConverter
-{
-    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
-    {
-        switch ((ApplicationTheme)value)
-        {
-            case ApplicationTheme.Light:
-                return ElementTheme.Dark;
-            case ApplicationTheme.Dark:
-                return ElementTheme.Light;
-            default:
-                throw new ArgumentOutOfRangeException(nameof(value));
-        }
-    }
-
-    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
-    {
-        throw new NotImplementedException();
-    }
+using iNKORE.UI.WPF.Modern;
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace HandheldCompanion.Converters;
+
+public class InverseAppThemeConverter : IValueConverter
+{
+    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        switch ((ApplicationTheme)value)
+        {
+            case ApplicationTheme.Light:
+                return ElementTheme.Dark;
+            case ApplicationTheme.Dark:
+                return ElementTheme.Light;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(value));
+        }
+    }
+
+    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+    {
+        throw new NotImplementedException();
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/AOKZOE/AOKZOEA1Pro.cs b/HandheldCompanion/Devices/AOKZOE/AOKZOEA1Pro.cs
index a748944ec..8ef12d4ae 100644
--- a/HandheldCompanion/Devices/AOKZOE/AOKZOEA1Pro.cs
+++ b/HandheldCompanion/Devices/AOKZOE/AOKZOEA1Pro.cs
@@ -1,17 +1,17 @@
-namespace HandheldCompanion.Devices;
-
-public class AOKZOEA1Pro : AOKZOEA1
-{
-    public AOKZOEA1Pro()
-    {
-        // device specific settings
-        ProductIllustration = "device_aokzoe_a1";
-        ProductModel = "AOKZOEA1Pro";
-
-        // https://www.amd.com/en/products/apu/amd-ryzen-7-7840u
-        nTDP = new double[] { 15, 15, 20 };
-        cTDP = new double[] { 4, 28 };
-        GfxClock = new double[] { 100, 2700 };
-        CpuClock = 5100;
-    }
+namespace HandheldCompanion.Devices;
+
+public class AOKZOEA1Pro : AOKZOEA1
+{
+    public AOKZOEA1Pro()
+    {
+        // device specific settings
+        ProductIllustration = "device_aokzoe_a1";
+        ProductModel = "AOKZOEA1Pro";
+
+        // https://www.amd.com/en/products/apu/amd-ryzen-7-7840u
+        nTDP = new double[] { 15, 15, 20 };
+        cTDP = new double[] { 4, 28 };
+        GfxClock = new double[] { 100, 2700 };
+        CpuClock = 5100;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/ASUS/AsusACPI.cs b/HandheldCompanion/Devices/ASUS/AsusACPI.cs
index 823b4269b..801fb70e5 100644
--- a/HandheldCompanion/Devices/ASUS/AsusACPI.cs
+++ b/HandheldCompanion/Devices/ASUS/AsusACPI.cs
@@ -1,511 +1,511 @@
-using HandheldCompanion.Managers;
-using System;
-using System.Management;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-public enum AsusFan
-{
-    CPU = 0,
-    GPU = 1,
-    Mid = 2,
-    XGM = 3
-}
-
-public enum AsusMode
-{
-    Performance = 0,
-    Turbo = 1,
-    Silent = 2
-}
-
-public enum AsusGPU
-{
-    Eco = 0,
-    Standard = 1,
-    Ultimate = 2
-}
-
-namespace HandheldCompanion.Devices.ASUS
-{
-    public class AsusACPI
-    {
-        const string FILE_NAME = @"\\.\\ATKACPI";
-        const uint CONTROL_CODE = 0x0022240C;
-
-        const uint DSTS = 0x53545344;
-        const uint DEVS = 0x53564544;
-        const uint INIT = 0x54494E49;
-
-        public const uint UniversalControl = 0x00100021;
-
-        public const int KB_Light_Up = 0xc4;
-        public const int KB_Light_Down = 0xc5;
-        public const int Brightness_Down = 0x10;
-        public const int Brightness_Up = 0x20;
-        public const int KB_Sleep = 0x6c;
-        public const int KB_DUO_PgUpDn = 0x4B;
-        public const int KB_DUO_SecondDisplay = 0x6A;
-
-
-        public const int Touchpad_Toggle = 0x6B;
-
-        public const int ChargerMode = 0x0012006C;
-
-        public const int ChargerUSB = 2;
-        public const int ChargerBarrel = 1;
-
-        public const uint CPU_Fan = 0x00110013;
-        public const uint GPU_Fan = 0x00110014;
-        public const uint Mid_Fan = 0x00110031;
-
-        public const uint PerformanceMode = 0x00120075; // Performance modes
-        public const uint VivoBookMode = 0x00110019; // Vivobook performance modes
-
-        public const uint GPUEco = 0x00090020;
-        public const uint GPUXGConnected = 0x00090018;
-        public const uint GPUXG = 0x00090019;
-        public const uint GPUMux = 0x00090016;
-
-        public const uint BatteryLimit = 0x00120057;
-        public const uint ScreenOverdrive = 0x00050019;
-        public const uint ScreenMiniled = 0x0005001E;
-
-        public const uint DevsCPUFan = 0x00110022;
-        public const uint DevsGPUFan = 0x00110023;
-
-        public const uint DevsCPUFanCurve = 0x00110024;
-        public const uint DevsGPUFanCurve = 0x00110025;
-        public const uint DevsMidFanCurve = 0x00110032;
-
-        public const int Temp_CPU = 0x00120094;
-        public const int Temp_GPU = 0x00120097;
-
-        public const int PPT_TotalA0 = 0x001200A0;  // SPL (Total limit for all-AMD models) / PL1
-        public const int PPT_EDCA1 = 0x001200A1;  // CPU EDC
-        public const int PPT_TDCA2 = 0x001200A2;  // CPU TDC
-        public const int PPT_APUA3 = 0x001200A3;  // sPPT (long boost limit) / PL2
-
-        public const int PPT_CPUB0 = 0x001200B0;  // CPU PPT on 2022 (PPT_LIMIT_APU)
-        public const int PPT_CPUB1 = 0x001200B1;  // Total PPT on 2022 (PPT_LIMIT_SLOW)
-
-        public const int PPT_GPUC0 = 0x001200C0;  // NVIDIA GPU Boost
-        public const int PPT_APUC1 = 0x001200C1;  // fPPT (fast boost limit)
-        public const int PPT_GPUC2 = 0x001200C2;  // NVIDIA GPU Temp Target (75.. 87 C) 
-
-        public const int TUF_KB_BRIGHTNESS = 0x00050021;
-        public const int TUF_KB = 0x00100056;
-        public const int TUF_KB_STATE = 0x00100057;
-
-        public const int MICMUTE_LED = 0x00040017;
-
-        public const int TabletState = 0x00060077;
-        public const int FnLock = 0x00100023;
-
-        public const int ScreenPadToggle = 0x00050031;
-        public const int ScreenPadBrightness = 0x00050032;
-
-        public const int Tablet_Notebook = 0;
-        public const int Tablet_Tablet = 1;
-        public const int Tablet_Tent = 2;
-        public const int Tablet_Rotated = 3;
-
-        public const int PerformanceBalanced = 0;
-        public const int PerformanceTurbo = 1;
-        public const int PerformanceSilent = 2;
-        public const int PerformanceManual = 4;
-
-        public const int GPUModeEco = 0;
-        public const int GPUModeStandard = 1;
-        public const int GPUModeUltimate = 2;
-
-        public const int MinTotal = 5;
-
-        public static int MaxTotal = 150;
-        public static int DefaultTotal = 125;
-
-        public const int MinCPU = 5;
-        public const int MaxCPU = 100;
-        public const int DefaultCPU = 80;
-
-        public const int MinGPUBoost = 5;
-        public const int MaxGPUBoost = 25;
-
-        public const int MinGPUTemp = 75;
-        public const int MaxGPUTemp = 87;
-
-
-        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-        private static extern IntPtr CreateFile(
-            string lpFileName,
-            uint dwDesiredAccess,
-            uint dwShareMode,
-            IntPtr lpSecurityAttributes,
-            uint dwCreationDisposition,
-            uint dwFlagsAndAttributes,
-            IntPtr hTemplateFile
-        );
-
-        [DllImport("kernel32.dll", SetLastError = true)]
-        private static extern bool DeviceIoControl(
-            IntPtr hDevice,
-            uint dwIoControlCode,
-            byte[] lpInBuffer,
-            uint nInBufferSize,
-            byte[] lpOutBuffer,
-            uint nOutBufferSize,
-            ref uint lpBytesReturned,
-            IntPtr lpOverlapped
-        );
-
-        [DllImport("kernel32.dll", SetLastError = true)]
-        private static extern bool CloseHandle(IntPtr hObject);
-
-        private const uint GENERIC_READ = 0x80000000;
-        private const uint GENERIC_WRITE = 0x40000000;
-        private const uint OPEN_EXISTING = 3;
-        private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
-        private const uint FILE_SHARE_READ = 1;
-        private const uint FILE_SHARE_WRITE = 2;
-
-        private const int ASUS_WMI_KEYBOARD_POWER_BOOT = 0x03 << 16;
-        private const int ASUS_WMI_KEYBOARD_POWER_AWAKE = 0x0C << 16;
-        private const int ASUS_WMI_KEYBOARD_POWER_SLEEP = 0x30 << 16;
-        private const int ASUS_WMI_KEYBOARD_POWER_SHUTDOWN = 0xC0 << 16;
-
-        private IntPtr handle;
-
-        // Event handling attempt
-
-        [DllImport("kernel32.dll", SetLastError = true)]
-        private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
-
-        [DllImport("kernel32.dll", SetLastError = true)]
-        private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
-
-        private IntPtr eventHandle;
-
-        // still works only with asus optimization service on , if someone knows how to get ACPI events from asus without that - let me know
-        public void RunListener()
-        {
-
-            eventHandle = CreateEvent(IntPtr.Zero, false, false, "ATK4001");
-
-            byte[] outBuffer = new byte[16];
-            byte[] data = new byte[8];
-            bool result;
-
-            data[0] = BitConverter.GetBytes(eventHandle.ToInt32())[0];
-            data[1] = BitConverter.GetBytes(eventHandle.ToInt32())[1];
-
-            Control(0x222400, data, outBuffer);
-
-            while (true)
-            {
-                WaitForSingleObject(eventHandle, Timeout.Infinite);
-                Control(0x222408, new byte[0], outBuffer);
-                int code = BitConverter.ToInt32(outBuffer, 0);
-            }
-        }
-
-
-        public AsusACPI()
-        {
-            handle = CreateFile(
-                FILE_NAME,
-                GENERIC_READ | GENERIC_WRITE,
-                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                IntPtr.Zero,
-                OPEN_EXISTING,
-                FILE_ATTRIBUTE_NORMAL,
-                IntPtr.Zero
-            );
-
-            if (!IsOpen())
-            {
-                LogManager.LogError("Can't connect to Asus ACPI");
-                return;
-            }
-
-            MaxTotal = 50;
-            DefaultTotal = 30;
-        }
-
-        public bool IsOpen()
-        {
-            return handle != new IntPtr(-1);
-        }
-
-        public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
-        {
-
-            uint lpBytesReturned = 0;
-            DeviceIoControl(
-                handle,
-                dwIoControlCode,
-                lpInBuffer,
-                (uint)lpInBuffer.Length,
-                lpOutBuffer,
-                (uint)lpOutBuffer.Length,
-                ref lpBytesReturned,
-                IntPtr.Zero
-            );
-        }
-
-        public void Close()
-        {
-            CloseHandle(handle);
-        }
-
-        protected byte[] CallMethod(uint MethodID, byte[] args)
-        {
-            byte[] acpiBuf = new byte[8 + args.Length];
-            byte[] outBuffer = new byte[16];
-
-            BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
-            BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
-            Array.Copy(args, 0, acpiBuf, 8, args.Length);
-
-            // if (MethodID == DEVS)  Debug.WriteLine(BitConverter.ToString(acpiBuf, 0, acpiBuf.Length));
-
-            Control(CONTROL_CODE, acpiBuf, outBuffer);
-
-            return outBuffer;
-
-        }
-
-        public byte[] DeviceInit()
-        {
-            byte[] args = new byte[8];
-            return CallMethod(INIT, args);
-        }
-
-        public int DeviceSet(uint DeviceID, int Status)
-        {
-            byte[] args = new byte[8];
-            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
-            BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
-
-            byte[] status = CallMethod(DEVS, args);
-            int result = BitConverter.ToInt32(status, 0);
-
-            return result;
-        }
-
-        public int DeviceSet(uint DeviceID, byte[] Params, string logName)
-        {
-            byte[] args = new byte[4 + Params.Length];
-            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
-            Params.CopyTo(args, 4);
-
-            byte[] status = CallMethod(DEVS, args);
-            int result = BitConverter.ToInt32(status, 0);
-
-            return BitConverter.ToInt32(status, 0);
-        }
-
-        public int DeviceGet(uint DeviceID)
-        {
-            byte[] args = new byte[8];
-            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
-            byte[] status = CallMethod(DSTS, args);
-
-            return BitConverter.ToInt32(status, 0) - 65536;
-
-        }
-
-        public byte[] DeviceGetBuffer(uint DeviceID, uint Status = 0)
-        {
-            byte[] args = new byte[8];
-            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
-            BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
-
-            return CallMethod(DSTS, args);
-        }
-
-        public int SetGPUEco(int eco)
-        {
-            int ecoFlag = DeviceGet(GPUEco);
-            if (ecoFlag < 0) return -1;
-
-            if (ecoFlag == 1 && eco == 0)
-                return DeviceSet(GPUEco, eco);
-
-            if (ecoFlag == 0 && eco == 1)
-                return DeviceSet(GPUEco, eco);
-
-            return -1;
-        }
-
-        public int SetFanRange(AsusFan device, byte[] curve)
-        {
-            byte min = (byte)(curve[8] * 255 / 100);
-            byte max = (byte)(curve[15] * 255 / 100);
-            byte[] range = { min, max };
-
-            int result;
-            switch (device)
-            {
-                case AsusFan.GPU:
-                    result = DeviceSet(DevsGPUFan, range, "FanRangeGPU");
-                    break;
-                default:
-                    result = DeviceSet(DevsCPUFan, range, "FanRangeCPU");
-                    break;
-            }
-            return result;
-        }
-
-        public int SetFanSpeed(AsusFan device, byte speed)
-        {
-            byte[] curve = new byte[] { 0x1E, 0x28, 0x32, 0x3C, 0x46, 0x50, 0x5A, 0x5A, speed, speed, speed, speed, speed, speed, speed, speed };
-            int result;
-            switch (device)
-            {
-                case AsusFan.GPU:
-                    result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
-                    break;
-                case AsusFan.Mid:
-                    result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
-                    break;
-                default:
-                    result = DeviceSet(DevsCPUFanCurve, curve, "FanCPU");
-                    break;
-            }
-            return result;
-        }
-
-        public int SetFanCurve(AsusFan device, byte[] curve)
-        {
-
-            if (curve.Length != 16) return -1;
-            // if (curve.All(singleByte => singleByte == 0)) return -1;
-
-            int result;
-            int fanScale = 100; //AppConfig.Get("fan_scale", 100);
-
-            // if (fanScale != 100 && device == AsusFan.CPU) Logger.WriteLine("Custom fan scale: " + fanScale);
-
-            // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
-
-            for (int i = 8; i < curve.Length; i++) curve[i] = (byte)(Math.Max((byte)0, Math.Min((byte)99, curve[i])) * fanScale / 100);
-
-            switch (device)
-            {
-                case AsusFan.GPU:
-                    result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
-                    break;
-                case AsusFan.Mid:
-                    result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
-                    break;
-                default:
-                    result = DeviceSet(DevsCPUFanCurve, curve, "FanCPU");
-                    break;
-            }
-
-            return result;
-        }
-
-        public byte[] GetFanCurve(AsusFan device, int mode = 0)
-        {
-            uint fan_mode;
-
-            // because it's asus, and modes are swapped here
-            switch (mode)
-            {
-                case 1: fan_mode = 2; break;
-                case 2: fan_mode = 1; break;
-                default: fan_mode = 0; break;
-            }
-
-            switch (device)
-            {
-                case AsusFan.GPU:
-                    return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
-                case AsusFan.Mid:
-                    return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
-                default:
-                    return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
-            }
-
-        }
-
-        public static bool IsInvalidCurve(byte[] curve)
-        {
-            return curve.Length != 16 || IsEmptyCurve(curve);
-        }
-
-        public static bool IsEmptyCurve(byte[] curve)
-        {
-            return false;
-        }
-
-        public static byte[] FixFanCurve(byte[] curve)
-        {
-            return curve;
-
-        }
-
-        public bool IsXGConnected()
-        {
-            //return true;
-            return DeviceGet(GPUXGConnected) == 1;
-        }
-
-        public bool IsAllAmdPPT()
-        {
-            return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
-        }
-
-        public void TUFKeyboardBrightness(int brightness)
-        {
-            int param = 0x80 | (brightness & 0x7F);
-            DeviceSet(TUF_KB_BRIGHTNESS, param);
-        }
-
-        public void TUFKeyboardRGB(int mode, System.Drawing.Color color, int speed)
-        {
-
-            byte[] setting = new byte[12];
-            setting[0] = (byte)0xB4;
-            setting[1] = (byte)mode;
-            setting[2] = color.R;
-            setting[3] = color.G;
-            setting[4] = color.B;
-            setting[5] = (byte)speed;
-
-            DeviceSet(TUF_KB, setting, "TUF RGB");
-            //Debug.WriteLine(BitConverter.ToString(setting));
-        }
-
-        public void TUFKeyboardPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
-        {
-            int state = 0xbd;
-
-            if (boot) state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
-            if (awake) state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
-            if (sleep) state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
-            if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
-
-            state = state | 0x01 << 8;
-
-            DeviceSet(TUF_KB_STATE, state);
-        }
-
-        public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)
-        {
-            try
-            {
-                ManagementEventWatcher watcher = new ManagementEventWatcher();
-                watcher.EventArrived += new EventArrivedEventHandler(EventHandler);
-                watcher.Scope = new ManagementScope("root\\wmi");
-                watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
-                watcher.Start();
-            }
-            catch
-            {
-
-            }
-        }
-    }
-}
+using HandheldCompanion.Managers;
+using System;
+using System.Management;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+public enum AsusFan
+{
+    CPU = 0,
+    GPU = 1,
+    Mid = 2,
+    XGM = 3
+}
+
+public enum AsusMode
+{
+    Performance = 0,
+    Turbo = 1,
+    Silent = 2
+}
+
+public enum AsusGPU
+{
+    Eco = 0,
+    Standard = 1,
+    Ultimate = 2
+}
+
+namespace HandheldCompanion.Devices.ASUS
+{
+    public class AsusACPI
+    {
+        const string FILE_NAME = @"\\.\\ATKACPI";
+        const uint CONTROL_CODE = 0x0022240C;
+
+        const uint DSTS = 0x53545344;
+        const uint DEVS = 0x53564544;
+        const uint INIT = 0x54494E49;
+
+        public const uint UniversalControl = 0x00100021;
+
+        public const int KB_Light_Up = 0xc4;
+        public const int KB_Light_Down = 0xc5;
+        public const int Brightness_Down = 0x10;
+        public const int Brightness_Up = 0x20;
+        public const int KB_Sleep = 0x6c;
+        public const int KB_DUO_PgUpDn = 0x4B;
+        public const int KB_DUO_SecondDisplay = 0x6A;
+
+
+        public const int Touchpad_Toggle = 0x6B;
+
+        public const int ChargerMode = 0x0012006C;
+
+        public const int ChargerUSB = 2;
+        public const int ChargerBarrel = 1;
+
+        public const uint CPU_Fan = 0x00110013;
+        public const uint GPU_Fan = 0x00110014;
+        public const uint Mid_Fan = 0x00110031;
+
+        public const uint PerformanceMode = 0x00120075; // Performance modes
+        public const uint VivoBookMode = 0x00110019; // Vivobook performance modes
+
+        public const uint GPUEco = 0x00090020;
+        public const uint GPUXGConnected = 0x00090018;
+        public const uint GPUXG = 0x00090019;
+        public const uint GPUMux = 0x00090016;
+
+        public const uint BatteryLimit = 0x00120057;
+        public const uint ScreenOverdrive = 0x00050019;
+        public const uint ScreenMiniled = 0x0005001E;
+
+        public const uint DevsCPUFan = 0x00110022;
+        public const uint DevsGPUFan = 0x00110023;
+
+        public const uint DevsCPUFanCurve = 0x00110024;
+        public const uint DevsGPUFanCurve = 0x00110025;
+        public const uint DevsMidFanCurve = 0x00110032;
+
+        public const int Temp_CPU = 0x00120094;
+        public const int Temp_GPU = 0x00120097;
+
+        public const int PPT_TotalA0 = 0x001200A0;  // SPL (Total limit for all-AMD models) / PL1
+        public const int PPT_EDCA1 = 0x001200A1;  // CPU EDC
+        public const int PPT_TDCA2 = 0x001200A2;  // CPU TDC
+        public const int PPT_APUA3 = 0x001200A3;  // sPPT (long boost limit) / PL2
+
+        public const int PPT_CPUB0 = 0x001200B0;  // CPU PPT on 2022 (PPT_LIMIT_APU)
+        public const int PPT_CPUB1 = 0x001200B1;  // Total PPT on 2022 (PPT_LIMIT_SLOW)
+
+        public const int PPT_GPUC0 = 0x001200C0;  // NVIDIA GPU Boost
+        public const int PPT_APUC1 = 0x001200C1;  // fPPT (fast boost limit)
+        public const int PPT_GPUC2 = 0x001200C2;  // NVIDIA GPU Temp Target (75.. 87 C) 
+
+        public const int TUF_KB_BRIGHTNESS = 0x00050021;
+        public const int TUF_KB = 0x00100056;
+        public const int TUF_KB_STATE = 0x00100057;
+
+        public const int MICMUTE_LED = 0x00040017;
+
+        public const int TabletState = 0x00060077;
+        public const int FnLock = 0x00100023;
+
+        public const int ScreenPadToggle = 0x00050031;
+        public const int ScreenPadBrightness = 0x00050032;
+
+        public const int Tablet_Notebook = 0;
+        public const int Tablet_Tablet = 1;
+        public const int Tablet_Tent = 2;
+        public const int Tablet_Rotated = 3;
+
+        public const int PerformanceBalanced = 0;
+        public const int PerformanceTurbo = 1;
+        public const int PerformanceSilent = 2;
+        public const int PerformanceManual = 4;
+
+        public const int GPUModeEco = 0;
+        public const int GPUModeStandard = 1;
+        public const int GPUModeUltimate = 2;
+
+        public const int MinTotal = 5;
+
+        public static int MaxTotal = 150;
+        public static int DefaultTotal = 125;
+
+        public const int MinCPU = 5;
+        public const int MaxCPU = 100;
+        public const int DefaultCPU = 80;
+
+        public const int MinGPUBoost = 5;
+        public const int MaxGPUBoost = 25;
+
+        public const int MinGPUTemp = 75;
+        public const int MaxGPUTemp = 87;
+
+
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+        private static extern IntPtr CreateFile(
+            string lpFileName,
+            uint dwDesiredAccess,
+            uint dwShareMode,
+            IntPtr lpSecurityAttributes,
+            uint dwCreationDisposition,
+            uint dwFlagsAndAttributes,
+            IntPtr hTemplateFile
+        );
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool DeviceIoControl(
+            IntPtr hDevice,
+            uint dwIoControlCode,
+            byte[] lpInBuffer,
+            uint nInBufferSize,
+            byte[] lpOutBuffer,
+            uint nOutBufferSize,
+            ref uint lpBytesReturned,
+            IntPtr lpOverlapped
+        );
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool CloseHandle(IntPtr hObject);
+
+        private const uint GENERIC_READ = 0x80000000;
+        private const uint GENERIC_WRITE = 0x40000000;
+        private const uint OPEN_EXISTING = 3;
+        private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
+        private const uint FILE_SHARE_READ = 1;
+        private const uint FILE_SHARE_WRITE = 2;
+
+        private const int ASUS_WMI_KEYBOARD_POWER_BOOT = 0x03 << 16;
+        private const int ASUS_WMI_KEYBOARD_POWER_AWAKE = 0x0C << 16;
+        private const int ASUS_WMI_KEYBOARD_POWER_SLEEP = 0x30 << 16;
+        private const int ASUS_WMI_KEYBOARD_POWER_SHUTDOWN = 0xC0 << 16;
+
+        private IntPtr handle;
+
+        // Event handling attempt
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
+
+        private IntPtr eventHandle;
+
+        // still works only with asus optimization service on , if someone knows how to get ACPI events from asus without that - let me know
+        public void RunListener()
+        {
+
+            eventHandle = CreateEvent(IntPtr.Zero, false, false, "ATK4001");
+
+            byte[] outBuffer = new byte[16];
+            byte[] data = new byte[8];
+            bool result;
+
+            data[0] = BitConverter.GetBytes(eventHandle.ToInt32())[0];
+            data[1] = BitConverter.GetBytes(eventHandle.ToInt32())[1];
+
+            Control(0x222400, data, outBuffer);
+
+            while (true)
+            {
+                WaitForSingleObject(eventHandle, Timeout.Infinite);
+                Control(0x222408, new byte[0], outBuffer);
+                int code = BitConverter.ToInt32(outBuffer, 0);
+            }
+        }
+
+
+        public AsusACPI()
+        {
+            handle = CreateFile(
+                FILE_NAME,
+                GENERIC_READ | GENERIC_WRITE,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                IntPtr.Zero,
+                OPEN_EXISTING,
+                FILE_ATTRIBUTE_NORMAL,
+                IntPtr.Zero
+            );
+
+            if (!IsOpen())
+            {
+                LogManager.LogError("Can't connect to Asus ACPI");
+                return;
+            }
+
+            MaxTotal = 50;
+            DefaultTotal = 30;
+        }
+
+        public bool IsOpen()
+        {
+            return handle != new IntPtr(-1);
+        }
+
+        public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
+        {
+
+            uint lpBytesReturned = 0;
+            DeviceIoControl(
+                handle,
+                dwIoControlCode,
+                lpInBuffer,
+                (uint)lpInBuffer.Length,
+                lpOutBuffer,
+                (uint)lpOutBuffer.Length,
+                ref lpBytesReturned,
+                IntPtr.Zero
+            );
+        }
+
+        public void Close()
+        {
+            CloseHandle(handle);
+        }
+
+        protected byte[] CallMethod(uint MethodID, byte[] args)
+        {
+            byte[] acpiBuf = new byte[8 + args.Length];
+            byte[] outBuffer = new byte[16];
+
+            BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
+            BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
+            Array.Copy(args, 0, acpiBuf, 8, args.Length);
+
+            // if (MethodID == DEVS)  Debug.WriteLine(BitConverter.ToString(acpiBuf, 0, acpiBuf.Length));
+
+            Control(CONTROL_CODE, acpiBuf, outBuffer);
+
+            return outBuffer;
+
+        }
+
+        public byte[] DeviceInit()
+        {
+            byte[] args = new byte[8];
+            return CallMethod(INIT, args);
+        }
+
+        public int DeviceSet(uint DeviceID, int Status)
+        {
+            byte[] args = new byte[8];
+            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
+            BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
+
+            byte[] status = CallMethod(DEVS, args);
+            int result = BitConverter.ToInt32(status, 0);
+
+            return result;
+        }
+
+        public int DeviceSet(uint DeviceID, byte[] Params, string logName)
+        {
+            byte[] args = new byte[4 + Params.Length];
+            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
+            Params.CopyTo(args, 4);
+
+            byte[] status = CallMethod(DEVS, args);
+            int result = BitConverter.ToInt32(status, 0);
+
+            return BitConverter.ToInt32(status, 0);
+        }
+
+        public int DeviceGet(uint DeviceID)
+        {
+            byte[] args = new byte[8];
+            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
+            byte[] status = CallMethod(DSTS, args);
+
+            return BitConverter.ToInt32(status, 0) - 65536;
+
+        }
+
+        public byte[] DeviceGetBuffer(uint DeviceID, uint Status = 0)
+        {
+            byte[] args = new byte[8];
+            BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
+            BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
+
+            return CallMethod(DSTS, args);
+        }
+
+        public int SetGPUEco(int eco)
+        {
+            int ecoFlag = DeviceGet(GPUEco);
+            if (ecoFlag < 0) return -1;
+
+            if (ecoFlag == 1 && eco == 0)
+                return DeviceSet(GPUEco, eco);
+
+            if (ecoFlag == 0 && eco == 1)
+                return DeviceSet(GPUEco, eco);
+
+            return -1;
+        }
+
+        public int SetFanRange(AsusFan device, byte[] curve)
+        {
+            byte min = (byte)(curve[8] * 255 / 100);
+            byte max = (byte)(curve[15] * 255 / 100);
+            byte[] range = { min, max };
+
+            int result;
+            switch (device)
+            {
+                case AsusFan.GPU:
+                    result = DeviceSet(DevsGPUFan, range, "FanRangeGPU");
+                    break;
+                default:
+                    result = DeviceSet(DevsCPUFan, range, "FanRangeCPU");
+                    break;
+            }
+            return result;
+        }
+
+        public int SetFanSpeed(AsusFan device, byte speed)
+        {
+            byte[] curve = new byte[] { 0x1E, 0x28, 0x32, 0x3C, 0x46, 0x50, 0x5A, 0x5A, speed, speed, speed, speed, speed, speed, speed, speed };
+            int result;
+            switch (device)
+            {
+                case AsusFan.GPU:
+                    result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
+                    break;
+                case AsusFan.Mid:
+                    result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
+                    break;
+                default:
+                    result = DeviceSet(DevsCPUFanCurve, curve, "FanCPU");
+                    break;
+            }
+            return result;
+        }
+
+        public int SetFanCurve(AsusFan device, byte[] curve)
+        {
+
+            if (curve.Length != 16) return -1;
+            // if (curve.All(singleByte => singleByte == 0)) return -1;
+
+            int result;
+            int fanScale = 100; //AppConfig.Get("fan_scale", 100);
+
+            // if (fanScale != 100 && device == AsusFan.CPU) Logger.WriteLine("Custom fan scale: " + fanScale);
+
+            // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
+
+            for (int i = 8; i < curve.Length; i++) curve[i] = (byte)(Math.Max((byte)0, Math.Min((byte)99, curve[i])) * fanScale / 100);
+
+            switch (device)
+            {
+                case AsusFan.GPU:
+                    result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
+                    break;
+                case AsusFan.Mid:
+                    result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
+                    break;
+                default:
+                    result = DeviceSet(DevsCPUFanCurve, curve, "FanCPU");
+                    break;
+            }
+
+            return result;
+        }
+
+        public byte[] GetFanCurve(AsusFan device, int mode = 0)
+        {
+            uint fan_mode;
+
+            // because it's asus, and modes are swapped here
+            switch (mode)
+            {
+                case 1: fan_mode = 2; break;
+                case 2: fan_mode = 1; break;
+                default: fan_mode = 0; break;
+            }
+
+            switch (device)
+            {
+                case AsusFan.GPU:
+                    return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
+                case AsusFan.Mid:
+                    return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
+                default:
+                    return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
+            }
+
+        }
+
+        public static bool IsInvalidCurve(byte[] curve)
+        {
+            return curve.Length != 16 || IsEmptyCurve(curve);
+        }
+
+        public static bool IsEmptyCurve(byte[] curve)
+        {
+            return false;
+        }
+
+        public static byte[] FixFanCurve(byte[] curve)
+        {
+            return curve;
+
+        }
+
+        public bool IsXGConnected()
+        {
+            //return true;
+            return DeviceGet(GPUXGConnected) == 1;
+        }
+
+        public bool IsAllAmdPPT()
+        {
+            return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
+        }
+
+        public void TUFKeyboardBrightness(int brightness)
+        {
+            int param = 0x80 | (brightness & 0x7F);
+            DeviceSet(TUF_KB_BRIGHTNESS, param);
+        }
+
+        public void TUFKeyboardRGB(int mode, System.Drawing.Color color, int speed)
+        {
+
+            byte[] setting = new byte[12];
+            setting[0] = (byte)0xB4;
+            setting[1] = (byte)mode;
+            setting[2] = color.R;
+            setting[3] = color.G;
+            setting[4] = color.B;
+            setting[5] = (byte)speed;
+
+            DeviceSet(TUF_KB, setting, "TUF RGB");
+            //Debug.WriteLine(BitConverter.ToString(setting));
+        }
+
+        public void TUFKeyboardPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
+        {
+            int state = 0xbd;
+
+            if (boot) state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
+            if (awake) state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
+            if (sleep) state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
+            if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
+
+            state = state | 0x01 << 8;
+
+            DeviceSet(TUF_KB_STATE, state);
+        }
+
+        public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)
+        {
+            try
+            {
+                ManagementEventWatcher watcher = new ManagementEventWatcher();
+                watcher.EventArrived += new EventArrivedEventHandler(EventHandler);
+                watcher.Scope = new ManagementScope("root\\wmi");
+                watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
+                watcher.Start();
+            }
+            catch
+            {
+
+            }
+        }
+    }
+}
diff --git a/HandheldCompanion/Devices/AYANEO/AYANEOAIR1S.cs b/HandheldCompanion/Devices/AYANEO/AYANEOAIR1S.cs
index b7436f291..fdd7c6862 100644
--- a/HandheldCompanion/Devices/AYANEO/AYANEOAIR1S.cs
+++ b/HandheldCompanion/Devices/AYANEO/AYANEOAIR1S.cs
@@ -19,13 +19,13 @@ public AYANEOAIR1S()
         this.OEMChords.Add(new DeviceChord("Custom Key Top Right",
             new List<KeyCode> { KeyCode.RControlKey, KeyCode.LWin, KeyCode.F16 },
             new List<KeyCode> { KeyCode.F16, KeyCode.LWin, KeyCode.RControlKey },
-            false, ButtonFlags.OEM3
+            false, ButtonFlags.OEM4
         ));
 
         this.OEMChords.Add(new DeviceChord("Custom Key Top Left",
             new List<KeyCode> { KeyCode.RControlKey, KeyCode.LWin, KeyCode.F15 },
             new List<KeyCode> { KeyCode.F15, KeyCode.LWin, KeyCode.RControlKey },
-            false, ButtonFlags.OEM4
+            false, ButtonFlags.OEM3
         ));
 
         this.OEMChords.Add(new DeviceChord("Custom Key Big",
diff --git a/HandheldCompanion/Devices/AYANEO/AYANEODevice.cs b/HandheldCompanion/Devices/AYANEO/AYANEODevice.cs
index 6658cfdd7..eb7fbafa2 100644
--- a/HandheldCompanion/Devices/AYANEO/AYANEODevice.cs
+++ b/HandheldCompanion/Devices/AYANEO/AYANEODevice.cs
@@ -36,7 +36,7 @@ public override string GetGlyph(ButtonFlags button)
                     return "\uE001";
             }
 
-            return defaultGlyph;
+            return base.GetGlyph(button);
         }
     }
 }
diff --git a/HandheldCompanion/Devices/Ayn/AynLokiMax6600U.cs b/HandheldCompanion/Devices/Ayn/AynLokiMax6600U.cs
index 6693b38a9..eea9a37fc 100644
--- a/HandheldCompanion/Devices/Ayn/AynLokiMax6600U.cs
+++ b/HandheldCompanion/Devices/Ayn/AynLokiMax6600U.cs
@@ -1,13 +1,13 @@
-namespace HandheldCompanion.Devices;
-
-public class LokiMax6600U : AynLoki
-{
-    public LokiMax6600U()
-    {
-        // https://www.amd.com/en/products/apu/amd-ryzen-5-6600u
-        nTDP = new double[] { 15, 15, 20 };
-        cTDP = new double[] { 5, 28 };
-        GfxClock = new double[] { 100, 1900 };
-        CpuClock = 4500;
-    }
+namespace HandheldCompanion.Devices;
+
+public class LokiMax6600U : AynLoki
+{
+    public LokiMax6600U()
+    {
+        // https://www.amd.com/en/products/apu/amd-ryzen-5-6600u
+        nTDP = new double[] { 15, 15, 20 };
+        cTDP = new double[] { 5, 28 };
+        GfxClock = new double[] { 100, 1900 };
+        CpuClock = 4500;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/Ayn/AynLokiMax6800U.cs b/HandheldCompanion/Devices/Ayn/AynLokiMax6800U.cs
index 6863e2979..d4f0233ca 100644
--- a/HandheldCompanion/Devices/Ayn/AynLokiMax6800U.cs
+++ b/HandheldCompanion/Devices/Ayn/AynLokiMax6800U.cs
@@ -1,13 +1,13 @@
-namespace HandheldCompanion.Devices;
-
-public class LokiMax6800U : AynLoki
-{
-    public LokiMax6800U()
-    {
-        // https://www.amd.com/en/products/apu/amd-ryzen-7-6800u
-        nTDP = new double[] { 15, 15, 20 };
-        cTDP = new double[] { 5, 28 };
-        GfxClock = new double[] { 100, 2200 };
-        CpuClock = 4700;
-    }
+namespace HandheldCompanion.Devices;
+
+public class LokiMax6800U : AynLoki
+{
+    public LokiMax6800U()
+    {
+        // https://www.amd.com/en/products/apu/amd-ryzen-7-6800u
+        nTDP = new double[] { 15, 15, 20 };
+        cTDP = new double[] { 5, 28 };
+        GfxClock = new double[] { 100, 2200 };
+        CpuClock = 4700;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/Ayn/AynLokiMiniPro.cs b/HandheldCompanion/Devices/Ayn/AynLokiMiniPro.cs
index 14a14e67b..af4c3820b 100644
--- a/HandheldCompanion/Devices/Ayn/AynLokiMiniPro.cs
+++ b/HandheldCompanion/Devices/Ayn/AynLokiMiniPro.cs
@@ -1,13 +1,13 @@
-namespace HandheldCompanion.Devices;
-
-public class LokiMiniPro : AynLoki
-{
-    public LokiMiniPro()
-    {
-        // https://www.amd.com/en/products/apu/amd-ryzen-3-7320u
-        nTDP = new double[] { 12, 12, 12 };
-        cTDP = new double[] { 5, 15 };
-        GfxClock = new double[] { 100, 1900 };
-        CpuClock = 4100;
-    }
+namespace HandheldCompanion.Devices;
+
+public class LokiMiniPro : AynLoki
+{
+    public LokiMiniPro()
+    {
+        // https://www.amd.com/en/products/apu/amd-ryzen-3-7320u
+        nTDP = new double[] { 12, 12, 12 };
+        cTDP = new double[] { 5, 15 };
+        GfxClock = new double[] { 100, 1900 };
+        CpuClock = 4100;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/Ayn/AynLokiZero.cs b/HandheldCompanion/Devices/Ayn/AynLokiZero.cs
index a1ce47daa..4a9ea29a7 100644
--- a/HandheldCompanion/Devices/Ayn/AynLokiZero.cs
+++ b/HandheldCompanion/Devices/Ayn/AynLokiZero.cs
@@ -1,13 +1,13 @@
-namespace HandheldCompanion.Devices;
-
-public class LokiZero : AynLoki
-{
-    public LokiZero()
-    {
-        // https://www.amd.com/en/products/apu/amd-athlon-silver-3050u
-        nTDP = new double[] { 10, 10, 10 };
-        cTDP = new double[] { 5, 15 };
-        GfxClock = new double[] { 100, 1100 };
-        CpuClock = 3200;
-    }
+namespace HandheldCompanion.Devices;
+
+public class LokiZero : AynLoki
+{
+    public LokiZero()
+    {
+        // https://www.amd.com/en/products/apu/amd-athlon-silver-3050u
+        nTDP = new double[] { 10, 10, 10 };
+        cTDP = new double[] { 5, 15 };
+        GfxClock = new double[] { 100, 1100 };
+        CpuClock = 3200;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/GPD/GPDWin2.cs b/HandheldCompanion/Devices/GPD/GPDWin2.cs
index 41afb38de..dc44f61c1 100644
--- a/HandheldCompanion/Devices/GPD/GPDWin2.cs
+++ b/HandheldCompanion/Devices/GPD/GPDWin2.cs
@@ -1,16 +1,16 @@
-namespace HandheldCompanion.Devices;
-
-public class GPDWin2 : IDevice
-{
-    public GPDWin2()
-    {
-        // device specific settings
-        ProductIllustration = "device_gpd_win2";
-
-        // https://www.intel.com/content/www/us/en/products/sku/185282/intel-core-m38100y-processor-4m-cache-up-to-3-40-ghz/specifications.html
-        nTDP = new double[] { 10, 10, 15 };
-        cTDP = new double[] { 5, 15 };
-        GfxClock = new double[] { 300, 900 };
-        CpuClock = 3400;
-    }
+namespace HandheldCompanion.Devices;
+
+public class GPDWin2 : IDevice
+{
+    public GPDWin2()
+    {
+        // device specific settings
+        ProductIllustration = "device_gpd_win2";
+
+        // https://www.intel.com/content/www/us/en/products/sku/185282/intel-core-m38100y-processor-4m-cache-up-to-3-40-ghz/specifications.html
+        nTDP = new double[] { 10, 10, 15 };
+        cTDP = new double[] { 5, 15 };
+        GfxClock = new double[] { 300, 900 };
+        CpuClock = 3400;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Devices/Lenovo/FanTable.cs b/HandheldCompanion/Devices/Lenovo/FanTable.cs
index d24d5f0a5..90a39c757 100644
--- a/HandheldCompanion/Devices/Lenovo/FanTable.cs
+++ b/HandheldCompanion/Devices/Lenovo/FanTable.cs
@@ -1,89 +1,89 @@
-using System;
-using System.IO;
-
-namespace HandheldCompanion.Devices.Lenovo
-{
-    public readonly struct FanTable
-    {
-        // ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
-        // ReSharper disable MemberCanBePrivate.Global
-        // ReSharper disable IdentifierTypo
-        // ReSharper disable InconsistentNaming
-
-        public byte FSTM { get; init; }
-        public byte FSID { get; init; }
-        public uint FSTL { get; init; }
-        public ushort FSS0 { get; init; }
-        public ushort FSS1 { get; init; }
-        public ushort FSS2 { get; init; }
-        public ushort FSS3 { get; init; }
-        public ushort FSS4 { get; init; }
-        public ushort FSS5 { get; init; }
-        public ushort FSS6 { get; init; }
-        public ushort FSS7 { get; init; }
-        public ushort FSS8 { get; init; }
-        public ushort FSS9 { get; init; }
-
-        // ReSharper restore AutoPropertyCanBeMadeGetOnly.Global
-        // ReSharper restore MemberCanBePrivate.Global
-        // ReSharper restore IdentifierTypo
-        // ReSharper restore InconsistentNaming
-
-        public FanTable(ushort[] fanTable)
-        {
-            if (fanTable.Length != 10)
-                // ReSharper disable once LocalizableElement
-                throw new ArgumentException("Fan table length must be 10.", nameof(fanTable));
-
-            FSTM = 1;
-            FSID = 0;
-            FSTL = 0;
-            FSS0 = fanTable[0];
-            FSS1 = fanTable[1];
-            FSS2 = fanTable[2];
-            FSS3 = fanTable[3];
-            FSS4 = fanTable[4];
-            FSS5 = fanTable[5];
-            FSS6 = fanTable[6];
-            FSS7 = fanTable[7];
-            FSS8 = fanTable[8];
-            FSS9 = fanTable[9];
-        }
-
-        public ushort[] GetTable() => new[] { FSS0, FSS1, FSS2, FSS3, FSS4, FSS5, FSS6, FSS7, FSS8, FSS9 };
-
-        public byte[] GetBytes()
-        {
-            using var ms = new MemoryStream(new byte[64]);
-            ms.WriteByte(FSTM);
-            ms.WriteByte(FSID);
-            ms.Write(BitConverter.GetBytes(FSTL));
-            ms.Write(BitConverter.GetBytes(FSS0));
-            ms.Write(BitConverter.GetBytes(FSS1));
-            ms.Write(BitConverter.GetBytes(FSS2));
-            ms.Write(BitConverter.GetBytes(FSS3));
-            ms.Write(BitConverter.GetBytes(FSS4));
-            ms.Write(BitConverter.GetBytes(FSS5));
-            ms.Write(BitConverter.GetBytes(FSS6));
-            ms.Write(BitConverter.GetBytes(FSS7));
-            ms.Write(BitConverter.GetBytes(FSS8));
-            ms.Write(BitConverter.GetBytes(FSS9));
-            return ms.ToArray();
-        }
-
-        public override string ToString() =>
-            $"{nameof(FSTM)}: {FSTM}," +
-            $" {nameof(FSID)}: {FSID}," +
-            $" {nameof(FSTL)}: {FSTL}," +
-            $" {nameof(FSS0)}: {FSS0}," +
-            $" {nameof(FSS1)}: {FSS1}," +
-            $" {nameof(FSS2)}: {FSS2}," +
-            $" {nameof(FSS3)}: {FSS3}," +
-            $" {nameof(FSS4)}: {FSS4}," +
-            $" {nameof(FSS5)}: {FSS5}," +
-            $" {nameof(FSS6)}: {FSS6}," +
-            $" {nameof(FSS7)}: {FSS7}," +
-            $" {nameof(FSS8)}: {FSS8}," +
-            $" {nameof(FSS9)}: {FSS9}";
-    }
-}
+using System;
+using System.IO;
+
+namespace HandheldCompanion.Devices.Lenovo
+{
+    public readonly struct FanTable
+    {
+        // ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+        // ReSharper disable MemberCanBePrivate.Global
+        // ReSharper disable IdentifierTypo
+        // ReSharper disable InconsistentNaming
+
+        public byte FSTM { get; init; }
+        public byte FSID { get; init; }
+        public uint FSTL { get; init; }
+        public ushort FSS0 { get; init; }
+        public ushort FSS1 { get; init; }
+        public ushort FSS2 { get; init; }
+        public ushort FSS3 { get; init; }
+        public ushort FSS4 { get; init; }
+        public ushort FSS5 { get; init; }
+        public ushort FSS6 { get; init; }
+        public ushort FSS7 { get; init; }
+        public ushort FSS8 { get; init; }
+        public ushort FSS9 { get; init; }
+
+        // ReSharper restore AutoPropertyCanBeMadeGetOnly.Global
+        // ReSharper restore MemberCanBePrivate.Global
+        // ReSharper restore IdentifierTypo
+        // ReSharper restore InconsistentNaming
+
+        public FanTable(ushort[] fanTable)
+        {
+            if (fanTable.Length != 10)
+                // ReSharper disable once LocalizableElement
+                throw new ArgumentException("Fan table length must be 10.", nameof(fanTable));
+
+            FSTM = 1;
+            FSID = 0;
+            FSTL = 0;
+            FSS0 = fanTable[0];
+            FSS1 = fanTable[1];
+            FSS2 = fanTable[2];
+            FSS3 = fanTable[3];
+            FSS4 = fanTable[4];
+            FSS5 = fanTable[5];
+            FSS6 = fanTable[6];
+            FSS7 = fanTable[7];
+            FSS8 = fanTable[8];
+            FSS9 = fanTable[9];
+        }
+
+        public ushort[] GetTable() => new[] { FSS0, FSS1, FSS2, FSS3, FSS4, FSS5, FSS6, FSS7, FSS8, FSS9 };
+
+        public byte[] GetBytes()
+        {
+            using var ms = new MemoryStream(new byte[64]);
+            ms.WriteByte(FSTM);
+            ms.WriteByte(FSID);
+            ms.Write(BitConverter.GetBytes(FSTL));
+            ms.Write(BitConverter.GetBytes(FSS0));
+            ms.Write(BitConverter.GetBytes(FSS1));
+            ms.Write(BitConverter.GetBytes(FSS2));
+            ms.Write(BitConverter.GetBytes(FSS3));
+            ms.Write(BitConverter.GetBytes(FSS4));
+            ms.Write(BitConverter.GetBytes(FSS5));
+            ms.Write(BitConverter.GetBytes(FSS6));
+            ms.Write(BitConverter.GetBytes(FSS7));
+            ms.Write(BitConverter.GetBytes(FSS8));
+            ms.Write(BitConverter.GetBytes(FSS9));
+            return ms.ToArray();
+        }
+
+        public override string ToString() =>
+            $"{nameof(FSTM)}: {FSTM}," +
+            $" {nameof(FSID)}: {FSID}," +
+            $" {nameof(FSTL)}: {FSTL}," +
+            $" {nameof(FSS0)}: {FSS0}," +
+            $" {nameof(FSS1)}: {FSS1}," +
+            $" {nameof(FSS2)}: {FSS2}," +
+            $" {nameof(FSS3)}: {FSS3}," +
+            $" {nameof(FSS4)}: {FSS4}," +
+            $" {nameof(FSS5)}: {FSS5}," +
+            $" {nameof(FSS6)}: {FSS6}," +
+            $" {nameof(FSS7)}: {FSS7}," +
+            $" {nameof(FSS8)}: {FSS8}," +
+            $" {nameof(FSS9)}: {FSS9}";
+    }
+}
diff --git a/HandheldCompanion/Devices/Lenovo/LegionGo.cs b/HandheldCompanion/Devices/Lenovo/LegionGo.cs
index 96fc8eade..a3c5f54e0 100644
--- a/HandheldCompanion/Devices/Lenovo/LegionGo.cs
+++ b/HandheldCompanion/Devices/Lenovo/LegionGo.cs
@@ -87,7 +87,7 @@ private Task SetSmartFanMode(int fanMode) => WMI.CallAsync("root\\WMI",
         "SetSmartFanMode",
         new() { { "Data", fanMode } });
 
-    private Task SetCPUPowerLimit(CapabilityID capabilityID, int limit) =>
+    public Task SetCPUPowerLimit(CapabilityID capabilityID, int limit) =>
         WMI.CallAsync("root\\WMI",
             $"SELECT * FROM LENOVO_OTHER_METHOD",
             "SetFeatureValue",
@@ -211,37 +211,14 @@ public LegionGo()
         DefaultLayout.ButtonLayout[ButtonFlags.B7] = new List<IActions>() { new MouseActions { MouseType = MouseActionsType.ScrollUp } };
         DefaultLayout.ButtonLayout[ButtonFlags.B8] = new List<IActions>() { new MouseActions { MouseType = MouseActionsType.ScrollDown } };
 
-        Init();
-
-        // make sure both left and right gyros are enabled
-        SetLeftGyroStatus(1);
-        SetRightGyroStatus(1);
-
-        // make sure both left and right gyros are reporting values
-        SetGyroModeStatus(2, 1, 1);
-        SetGyroModeStatus(2, 2, 2);
-
-        // make sure both left and right gyros are reporting raw values
-        SetGyroSensorDataOnorOff(LeftJoyconIndex, 0x02);
-        SetGyroSensorDataOnorOff(RightJoyconIndex, 0x02);
-
+        /*
         Task<bool> task = Task.Run(async () => await GetFanFullSpeedAsync());
         bool FanFullSpeed = task.Result;
+        */
     }
 
     private void PowerProfileManager_Applied(PowerProfile profile, UpdateSource source)
     {
-        // tentative: stability fix
-        if (PerformanceManager.GetProcessor() is AMDProcessor AMDProcessor)
-            AMDProcessor.SetCoall(0x100020);
-
-        if (profile.TDPOverrideEnabled && !profile.AutoTDPEnabled)
-        {
-            SetCPUPowerLimit(CapabilityID.CPUShortTermPowerLimit, (int)profile.TDPOverrideValues[0]);
-            SetCPUPowerLimit(CapabilityID.CPULongTermPowerLimit, (int)profile.TDPOverrideValues[1]);
-            SetCPUPowerLimit(CapabilityID.CPUPeakPowerLimit, (int)profile.TDPOverrideValues[2]);
-        }
-
         FanTable fanTable = new(new ushort[] { 44, 48, 55, 60, 71, 79, 87, 87, 100, 100 });
         if (profile.FanProfile.fanMode != FanMode.Hardware)
         {
@@ -269,20 +246,36 @@ public override bool Open()
         if (!success)
             return false;
 
+        // initialize SapientiaUsb
+        Init();
+
+        // make sure both left and right gyros are enabled
+        SetLeftGyroStatus(1);
+        SetRightGyroStatus(1);
+
+        // make sure both left and right gyros are reporting values
+        SetGyroModeStatus(2, 1, 1);
+        SetGyroModeStatus(2, 2, 2);
+
+        // make sure both left and right gyros are reporting raw values
+        SetGyroSensorDataOnorOff(LeftJoyconIndex, 0x02);
+        SetGyroSensorDataOnorOff(RightJoyconIndex, 0x02);
+
+        // disable QuickLightingEffect(s)
         SetQuickLightingEffect(0, 1);
         SetQuickLightingEffect(3, 1);
         SetQuickLightingEffect(4, 1);
-
         SetQuickLightingEffectEnable(0, false);
         SetQuickLightingEffectEnable(3, false);
         SetQuickLightingEffectEnable(4, false);
 
+        // get current light profile(s)
         lightProfileL = GetCurrentLightProfile(3);
         lightProfileR = GetCurrentLightProfile(4);
 
         // Legion XInput controller and other Legion devices shares the same USBHUB
         while (ControllerManager.PowerCyclers.Count > 0)
-            Thread.Sleep(500);
+            Thread.Sleep(100);
 
         return true;
     }
diff --git a/HandheldCompanion/Devices/OneXPlayer/OneXPlayer2Pro.cs b/HandheldCompanion/Devices/OneXPlayer/OneXPlayer2Pro.cs
index fdbcbf0e0..557a8a6b1 100644
--- a/HandheldCompanion/Devices/OneXPlayer/OneXPlayer2Pro.cs
+++ b/HandheldCompanion/Devices/OneXPlayer/OneXPlayer2Pro.cs
@@ -1,17 +1,17 @@
-namespace HandheldCompanion.Devices;
-
-public class OneXPlayer2Pro : OneXPlayer2
-{
-    public OneXPlayer2Pro()
-    {
-        // device specific settings
-        ProductIllustration = "device_onexplayer_2";
-        ProductModel = "ONEXPLAYER 2 7840U";
-
-        // https://www.amd.com/en/products/apu/amd-ryzen-7-7840u
-        nTDP = new double[] { 15, 15, 20 };
-        cTDP = new double[] { 4, 30 };
-        GfxClock = new double[] { 100, 2700 };
-        CpuClock = 5100;
-    }
+namespace HandheldCompanion.Devices;
+
+public class OneXPlayer2Pro : OneXPlayer2
+{
+    public OneXPlayer2Pro()
+    {
+        // device specific settings
+        ProductIllustration = "device_onexplayer_2";
+        ProductModel = "ONEXPLAYER 2 7840U";
+
+        // https://www.amd.com/en/products/apu/amd-ryzen-7-7840u
+        nTDP = new double[] { 15, 15, 20 };
+        cTDP = new double[] { 4, 30 };
+        GfxClock = new double[] { 100, 2700 };
+        CpuClock = 5100;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/GraphicsProcessingUnit/AMDGPU.cs b/HandheldCompanion/GraphicsProcessingUnit/AMDGPU.cs
index 418a298ad..96e38b765 100644
--- a/HandheldCompanion/GraphicsProcessingUnit/AMDGPU.cs
+++ b/HandheldCompanion/GraphicsProcessingUnit/AMDGPU.cs
@@ -280,9 +280,16 @@ private void TelemetryTimer_Elapsed(object? sender, ElapsedEventArgs e)
             if (halting)
                 return;
 
-            lock (telemetryLock)
+            if (Monitor.TryEnter(telemetryLock))
             {
-                TelemetryData = GetTelemetry();
+                try
+                {
+                    TelemetryData = GetTelemetry();
+                }
+                finally
+                {
+                    Monitor.Exit(telemetryLock);
+                }
             }
         }
 
@@ -304,104 +311,111 @@ private void UpdateTimer_Elapsed(object? sender, ElapsedEventArgs e)
             if (halting)
                 return;
 
-            lock (updateLock)
+            if (Monitor.TryEnter(updateLock))
             {
-                bool GPUScaling = false;
-
-                try
-                {
-                    // check for GPU Scaling support
-                    // if yes, get GPU Scaling (bool)
-                    bool GPUScalingSupport = HasGPUScalingSupport();
-                    if (GPUScalingSupport)
-                        GPUScaling = GetGPUScaling();
-
-                    // check for Scaling Mode support
-                    // if yes, get Scaling Mode (int)
-                    bool ScalingSupport = HasScalingModeSupport();
-                    int ScalingMode = 0;
-                    if (ScalingSupport)
-                        ScalingMode = GetScalingMode();
-
-                    if (GPUScalingSupport != prevGPUScalingSupport || GPUScaling != prevGPUScaling || ScalingMode != prevScalingMode)
-                    {
-                        // raise event
-                        base.OnGPUScalingChanged(GPUScalingSupport, GPUScaling, ScalingMode);
-
-                        prevGPUScaling = GPUScaling;
-                        prevScalingMode = ScalingMode;
-                        prevGPUScalingSupport = GPUScalingSupport;
-                    }
-                }
-                catch { }
-
                 try
                 {
-                    // get rsr
-                    bool RSRSupport = false;
-                    bool RSR = false;
-                    int RSRSharpness = GetRSRSharpness();
+                    bool GPUScaling = false;
 
-                    DateTime timeout = DateTime.Now.Add(TimeSpan.FromSeconds(2));
-                    while (DateTime.Now < timeout && !RSRSupport)
+                    try
                     {
-                        RSRSupport = HasRSRSupport();
-                        Thread.Sleep(250);
+                        // check for GPU Scaling support
+                        // if yes, get GPU Scaling (bool)
+                        bool GPUScalingSupport = HasGPUScalingSupport();
+                        if (GPUScalingSupport)
+                            GPUScaling = GetGPUScaling();
+
+                        // check for Scaling Mode support
+                        // if yes, get Scaling Mode (int)
+                        bool ScalingSupport = HasScalingModeSupport();
+                        int ScalingMode = 0;
+                        if (ScalingSupport)
+                            ScalingMode = GetScalingMode();
+
+                        if (GPUScalingSupport != prevGPUScalingSupport || GPUScaling != prevGPUScaling || ScalingMode != prevScalingMode)
+                        {
+                            // raise event
+                            base.OnGPUScalingChanged(GPUScalingSupport, GPUScaling, ScalingMode);
+
+                            prevGPUScaling = GPUScaling;
+                            prevScalingMode = ScalingMode;
+                            prevGPUScalingSupport = GPUScalingSupport;
+                        }
                     }
-                    RSR = GetRSR();
+                    catch { }
 
-                    if (RSRSupport != prevRSRSupport || RSR != prevRSR || RSRSharpness != prevRSRSharpness)
+                    try
                     {
-                        // raise event
-                        RSRStateChanged?.Invoke(RSRSupport, RSR, RSRSharpness);
-
-                        prevRSRSupport = RSRSupport;
-                        prevRSR = RSR;
-                        prevRSRSharpness = RSRSharpness;
+                        // get rsr
+                        bool RSRSupport = false;
+                        bool RSR = false;
+                        int RSRSharpness = GetRSRSharpness();
+
+                        DateTime timeout = DateTime.Now.Add(TimeSpan.FromSeconds(2));
+                        while (DateTime.Now < timeout && !RSRSupport)
+                        {
+                            RSRSupport = HasRSRSupport();
+                            Thread.Sleep(250);
+                        }
+                        RSR = GetRSR();
+
+                        if (RSRSupport != prevRSRSupport || RSR != prevRSR || RSRSharpness != prevRSRSharpness)
+                        {
+                            // raise event
+                            RSRStateChanged?.Invoke(RSRSupport, RSR, RSRSharpness);
+
+                            prevRSRSupport = RSRSupport;
+                            prevRSR = RSR;
+                            prevRSRSharpness = RSRSharpness;
+                        }
                     }
-                }
-                catch { }
-
-                try
-                {
-                    // get gpu scaling and scaling mode
-                    bool IntegerScalingSupport = false;
-                    bool IntegerScaling = false;
+                    catch { }
 
-                    DateTime timeout = DateTime.Now.Add(TimeSpan.FromSeconds(2));
-                    while (DateTime.Now < timeout && !IntegerScalingSupport)
+                    try
                     {
-                        IntegerScalingSupport = HasIntegerScalingSupport();
-                        Thread.Sleep(250);
+                        // get gpu scaling and scaling mode
+                        bool IntegerScalingSupport = false;
+                        bool IntegerScaling = false;
+
+                        DateTime timeout = DateTime.Now.Add(TimeSpan.FromSeconds(2));
+                        while (DateTime.Now < timeout && !IntegerScalingSupport)
+                        {
+                            IntegerScalingSupport = HasIntegerScalingSupport();
+                            Thread.Sleep(250);
+                        }
+                        IntegerScaling = GetIntegerScaling();
+
+                        if (IntegerScalingSupport != prevIntegerScalingSupport || IntegerScaling != prevIntegerScaling)
+                        {
+                            // raise event
+                            base.OnIntegerScalingChanged(IntegerScalingSupport, IntegerScaling);
+
+                            prevIntegerScalingSupport = IntegerScalingSupport;
+                            prevIntegerScaling = IntegerScaling;
+                        }
                     }
-                    IntegerScaling = GetIntegerScaling();
+                    catch { }
 
-                    if (IntegerScalingSupport != prevIntegerScalingSupport || IntegerScaling != prevIntegerScaling)
+                    try
                     {
-                        // raise event
-                        base.OnIntegerScalingChanged(IntegerScalingSupport, IntegerScaling);
+                        bool ImageSharpening = GetImageSharpening();
+                        int ImageSharpeningSharpness = GetImageSharpeningSharpness();
+
+                        if (ImageSharpening != prevImageSharpening || ImageSharpeningSharpness != prevImageSharpeningSharpness)
+                        {
+                            // raise event
+                            base.OnImageSharpeningChanged(ImageSharpening, ImageSharpeningSharpness);
 
-                        prevIntegerScalingSupport = IntegerScalingSupport;
-                        prevIntegerScaling = IntegerScaling;
+                            prevImageSharpening = ImageSharpening;
+                            prevImageSharpeningSharpness = ImageSharpeningSharpness;
+                        }
                     }
+                    catch { }
                 }
-                catch { }
-
-                try
+                finally
                 {
-                    bool ImageSharpening = GetImageSharpening();
-                    int ImageSharpeningSharpness = GetImageSharpeningSharpness();
-
-                    if (ImageSharpening != prevImageSharpening || ImageSharpeningSharpness != prevImageSharpeningSharpness)
-                    {
-                        // raise event
-                        base.OnImageSharpeningChanged(ImageSharpening, ImageSharpeningSharpness);
-
-                        prevImageSharpening = ImageSharpening;
-                        prevImageSharpeningSharpness = ImageSharpeningSharpness;
-                    }
+                    Monitor.Exit(updateLock);
                 }
-                catch { }
             }
         }
     }
diff --git a/HandheldCompanion/GraphicsProcessingUnit/GPU.cs b/HandheldCompanion/GraphicsProcessingUnit/GPU.cs
index d3a2aeba2..799cb8a94 100644
--- a/HandheldCompanion/GraphicsProcessingUnit/GPU.cs
+++ b/HandheldCompanion/GraphicsProcessingUnit/GPU.cs
@@ -58,6 +58,8 @@ protected T Execute<T>(Func<T> func, T defaultValue)
                     {
                         lock (functionLock)
                         {
+                            // make sure while we were waiting for the lock
+                            // that someone else didn't unitialize the GPU backend
                             if (!halting && GPUManager.IsInitialized)
                                 return func();
                             else
diff --git a/HandheldCompanion/GraphicsProcessingUnit/IntelGPU.cs b/HandheldCompanion/GraphicsProcessingUnit/IntelGPU.cs
index 294703a0f..54ed74c56 100644
--- a/HandheldCompanion/GraphicsProcessingUnit/IntelGPU.cs
+++ b/HandheldCompanion/GraphicsProcessingUnit/IntelGPU.cs
@@ -1,5 +1,6 @@
 using HandheldCompanion.IGCL;
 using SharpDX.Direct3D9;
+using System.Threading;
 using System.Timers;
 using static HandheldCompanion.IGCL.IGCLBackend;
 using Timer = System.Timers.Timer;
@@ -159,9 +160,16 @@ private void TelemetryTimer_Elapsed(object? sender, ElapsedEventArgs e)
             if (halting)
                 return;
 
-            lock (telemetryLock)
+            if (Monitor.TryEnter(telemetryLock))
             {
-                TelemetryData = GetTelemetry();
+                try
+                {
+                    TelemetryData = GetTelemetry();
+                }
+                finally
+                {
+                    Monitor.Exit(telemetryLock);
+                }
             }
         }
 
diff --git a/HandheldCompanion/Helpers/GamepadMotion.cs b/HandheldCompanion/Helpers/GamepadMotion.cs
index 84ced99b6..316b92ea2 100644
--- a/HandheldCompanion/Helpers/GamepadMotion.cs
+++ b/HandheldCompanion/Helpers/GamepadMotion.cs
@@ -1,4 +1,4 @@
-using HandheldCompanion.Sensors;
+using HandheldCompanion.Sensors;
 using System;
 using System.Runtime.InteropServices;
 
@@ -73,7 +73,7 @@ public IMUCalibration GetCalibration()
         }
 
         // Implement the ProcessMotion function
-        public void ProcessMotion(float gyroX, float gyroY, float gyroZ, float accelX, float accelY, float accelZ, float deltaTime)
+        public void ProcessMotion(float gyroX, float gyroY, float gyroZ, float accelX, float accelY, float accelZ, float deltaTimeSeconds)
         {
             this.gyroX = gyroX;
             this.gyroY = gyroY;
@@ -81,7 +81,7 @@ public void ProcessMotion(float gyroX, float gyroY, float gyroZ, float accelX, f
             this.accelX = accelX;
             this.accelY = accelY;
             this.accelZ = accelZ;
-            this.deltaTime = deltaTime;
+            this.deltaTime = deltaTimeSeconds;
 
             if (thresholdCalibration)
             {
@@ -100,7 +100,7 @@ public void ProcessMotion(float gyroX, float gyroY, float gyroZ, float accelX, f
                     maxAccel = accelZ;
             }
 
-            ProcessMotion(handle, gyroX, gyroY, gyroZ, accelX, accelY, accelZ, deltaTime);
+            ProcessMotion(handle, gyroX, gyroY, gyroZ, accelX, accelY, accelZ, deltaTimeSeconds);
         }
 
         public void GetRawGyro(out float x, out float y, out float z)
diff --git a/HandheldCompanion/Managers/ControllerManager.cs b/HandheldCompanion/Managers/ControllerManager.cs
index 6aac639ab..e26426a3f 100644
--- a/HandheldCompanion/Managers/ControllerManager.cs
+++ b/HandheldCompanion/Managers/ControllerManager.cs
@@ -192,8 +192,9 @@ private static void GamepadFocusManager_GotFocus(Control control)
         CheckControllerScenario();
     }
 
-    private static void ProcessManager_ForegroundChanged(ProcessEx processEx, ProcessEx backgroundEx)
+    private static void ProcessManager_ForegroundChanged(ProcessEx? processEx, ProcessEx? backgroundEx)
     {
+        // update current process
         foregroundProcess = processEx;
 
         // check applicable scenarios
@@ -272,7 +273,7 @@ private static void SettingsManager_SettingValueChanged(string name, object valu
                                     watchdogThread = null;
                                 }
 
-                                UpdateStatus(ControllerManagerStatus.Failed);
+                                UpdateStatus(ControllerManagerStatus.Pending);
                             }
                             break;
                     }
@@ -700,7 +701,7 @@ private static void watchdogThreadLoop(object? obj)
                             }
 
                             // suspend virtual controller
-                            VirtualManager.Suspend();
+                            VirtualManager.Suspend(false);
 
                             // suspend all physical controllers
                             foreach (XInputController xInputController in GetPhysicalControllers().OfType<XInputController>())
@@ -710,7 +711,7 @@ private static void watchdogThreadLoop(object? obj)
                             }
 
                             // resume virtual controller
-                            VirtualManager.Resume();
+                            VirtualManager.Resume(false);
 
                             // resume all physical controllers
                             StringCollection deviceInstanceIds = SettingsManager.GetStringCollection("SuspendedControllers");
@@ -718,8 +719,8 @@ private static void watchdogThreadLoop(object? obj)
                                 ResumeControllers();
 
                             // suspend and resume virtual controller
-                            VirtualManager.Suspend();
-                            VirtualManager.Resume();
+                            VirtualManager.Suspend(false);
+                            VirtualManager.Resume(false);
 
                             // increment attempt counter (if no wireless controller is power cycling)
                             if (!HasCyclingController)
diff --git a/HandheldCompanion/Managers/GPUManager.cs b/HandheldCompanion/Managers/GPUManager.cs
index d244b6492..2a5125671 100644
--- a/HandheldCompanion/Managers/GPUManager.cs
+++ b/HandheldCompanion/Managers/GPUManager.cs
@@ -23,9 +23,9 @@ public static class GPUManager
         public delegate void UnhookedEventHandler(GPU GPU);
         #endregion
 
-        public static bool IsInitialized;
-        public static bool IsLoaded_IGCL;
-        public static bool IsLoaded_ADLX;
+        public static bool IsInitialized = false;
+        public static bool IsLoaded_IGCL = false;
+        public static bool IsLoaded_ADLX = false;
 
         private static GPU currentGPU = null;
         private static ConcurrentDictionary<AdapterInformation, GPU> DisplayGPU = new();
@@ -205,8 +205,14 @@ public static void Start()
             if (IsInitialized)
                 return;
 
-            IsLoaded_IGCL = IGCLBackend.Initialize();
-            IsLoaded_ADLX = ADLXBackend.IntializeAdlx();
+            lock (GPU.functionLock)
+            {
+                if (!IsLoaded_IGCL)
+                    IsLoaded_IGCL = IGCLBackend.Initialize();
+
+                if (!IsLoaded_ADLX)
+                    IsLoaded_ADLX = ADLXBackend.IntializeAdlx();
+            }
 
             // todo: check if usefull on resume
             // it could be DeviceManager_DisplayAdapterArrived is called already, making this redundant
diff --git a/HandheldCompanion/Managers/MultimediaManager.cs b/HandheldCompanion/Managers/MultimediaManager.cs
index dbfc32b43..780483fbe 100644
--- a/HandheldCompanion/Managers/MultimediaManager.cs
+++ b/HandheldCompanion/Managers/MultimediaManager.cs
@@ -1,585 +1,585 @@
-using HandheldCompanion.Managers.Desktop;
-using Microsoft.Win32;
-using NAudio.CoreAudioApi;
-using NAudio.CoreAudioApi.Interfaces;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Management;
-using System.Media;
-using System.Runtime.InteropServices;
-using System.Windows.Forms;
-using WindowsDisplayAPI;
-using WindowsDisplayAPI.DisplayConfig;
-
-namespace HandheldCompanion.Managers;
-
-public static class MultimediaManager
-{
-    private static DesktopScreen desktopScreen;
-    private static ScreenRotation screenOrientation;
-
-    private static readonly MMDeviceEnumerator DevEnum;
-    private static MMDevice multimediaDevice;
-    private static readonly MMDeviceNotificationClient notificationClient;
-
-    private static readonly ManagementEventWatcher BrightnessWatcher;
-    private static readonly ManagementScope Scope;
-
-    private static bool VolumeSupport;
-    private static readonly bool BrightnessSupport;
-
-    public static bool IsInitialized;
-
-    static MultimediaManager()
-    {
-        // setup the multimedia device and get current volume value
-        notificationClient = new MMDeviceNotificationClient();
-        DevEnum = new MMDeviceEnumerator();
-        DevEnum.RegisterEndpointNotificationCallback(notificationClient);
-        SetDefaultAudioEndPoint();
-
-        // get current brightness value
-        Scope = new ManagementScope(@"\\.\root\wmi");
-        Scope.Connect();
-
-        // creating the watcher
-        BrightnessWatcher = new ManagementEventWatcher(Scope, new EventQuery("Select * From WmiMonitorBrightnessEvent"));
-        BrightnessWatcher.EventArrived += onWMIEvent;
-
-        // check if we have control over brightness
-        BrightnessSupport = GetBrightness() != -1;
-
-        // manage events
-        SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
-        SettingsManager.SettingValueChanged += SettingsManager_SettingValueChanged;
-        HotkeysManager.CommandExecuted += HotkeysManager_CommandExecuted;
-    }
-
-    private static void AudioEndpointVolume_OnVolumeNotification(AudioVolumeNotificationData data)
-    {
-        VolumeNotification?.Invoke(data.MasterVolume * 100.0f);
-    }
-
-    private static void SetDefaultAudioEndPoint()
-    {
-        try
-        {
-            if (multimediaDevice is not null && multimediaDevice.AudioEndpointVolume is not null)
-            {
-                VolumeSupport = false;
-                multimediaDevice.AudioEndpointVolume.OnVolumeNotification -= AudioEndpointVolume_OnVolumeNotification;
-            }
-
-            multimediaDevice = DevEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
-
-            if (multimediaDevice is not null && multimediaDevice.AudioEndpointVolume is not null)
-            {
-                VolumeSupport = true;
-                multimediaDevice.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
-            }
-
-            // do this even when no device found, to set to 0
-            VolumeNotification?.Invoke((float)GetVolume());
-        }
-        catch (Exception)
-        {
-            LogManager.LogError("No AudioEndpoint available");
-        }
-    }
-
-    private static void SettingsManager_SettingValueChanged(string name, object value)
-    {
-        switch (name)
-        {
-            case "NativeDisplayOrientation":
-                {
-                    ScreenRotation.Rotations nativeOrientation = (ScreenRotation.Rotations)Convert.ToInt32(value);
-
-                    if (!IsInitialized)
-                        return;
-
-                    ScreenRotation.Rotations oldOrientation = screenOrientation.rotation;
-                    screenOrientation = new ScreenRotation(screenOrientation.rotationUnnormalized, nativeOrientation);
-
-                    // Though the real orientation didn't change, raise event because the interpretation of it changed
-                    if (oldOrientation != screenOrientation.rotation)
-                        DisplayOrientationChanged?.Invoke(screenOrientation);
-                }
-                break;
-        }
-    }
-
-    private static void HotkeysManager_CommandExecuted(string listener)
-    {
-        switch (listener)
-        {
-            case "increaseBrightness":
-                {
-                    int stepRoundDn = (int)Math.Floor(GetBrightness() / 5.0d);
-                    int brightness = stepRoundDn * 5 + 5;
-                    SetBrightness(brightness);
-                }
-                break;
-            case "decreaseBrightness":
-                {
-                    int stepRoundUp = (int)Math.Ceiling(GetBrightness() / 5.0d);
-                    int brightness = stepRoundUp * 5 - 5;
-                    SetBrightness(brightness);
-                }
-                break;
-            case "increaseVolume":
-                {
-                    int stepRoundDn = (int)Math.Floor(Math.Round(GetVolume() / 5.0d, 2));
-                    int volume = stepRoundDn * 5 + 5;
-                    SetVolume(volume);
-                }
-                break;
-            case "decreaseVolume":
-                {
-                    int stepRoundUp = (int)Math.Ceiling(Math.Round(GetVolume() / 5.0d, 2));
-                    int volume = stepRoundUp * 5 - 5;
-                    SetVolume(volume);
-                }
-                break;
-        }
-    }
-
-    private static void onWMIEvent(object sender, EventArrivedEventArgs e)
-    {
-        int brightness = Convert.ToInt32(e.NewEvent.Properties["Brightness"].Value);
-        BrightnessNotification?.Invoke(brightness);
-    }
-
-    public static string GetDisplayFriendlyName(string DeviceName)
-    {
-        string friendlyName = string.Empty;
-
-        Display? PrimaryDisplay = Display.GetDisplays().Where(display => display.DisplayName.Equals(DeviceName)).FirstOrDefault();
-        if (PrimaryDisplay is not null)
-        {
-            string DevicePath = PrimaryDisplay.DevicePath;
-            PathDisplayTarget? PrimaryTarget = GetDisplayTarget(DevicePath);
-            if (PrimaryTarget is not null)
-                friendlyName = PrimaryTarget.FriendlyName;
-        }
-
-        return friendlyName;
-    }
-
-    public static string GetDisplayPath(string DeviceName)
-    {
-        string DevicePath = string.Empty;
-
-        Display? PrimaryDisplay = Display.GetDisplays().Where(display => display.DisplayName.Equals(DeviceName)).FirstOrDefault();
-        if (PrimaryDisplay is not null)
-            DevicePath = PrimaryDisplay.DevicePath;
-
-        return DevicePath;
-    }
-
-    private static PathDisplayTarget? GetDisplayTarget(string DevicePath)
-    {
-        PathDisplayTarget PrimaryTarget;
-        PrimaryTarget = PathDisplayTarget.GetDisplayTargets().Where(target => target.DevicePath.Equals(DevicePath)).FirstOrDefault();
-        return PrimaryTarget;
-    }
-
-    private static void SystemEvents_DisplaySettingsChanged(object? sender, EventArgs e)
-    {
-        // get primary screen
-        Screen PrimaryScreen = Screen.PrimaryScreen;
-
-        if (desktopScreen is null || desktopScreen.PrimaryScreen.DeviceName != PrimaryScreen.DeviceName)
-        {
-            // update current desktop screen
-            desktopScreen = new DesktopScreen(PrimaryScreen);
-            desktopScreen.devMode = GetDisplay(PrimaryScreen.DeviceName);
-            desktopScreen.FriendlyName = GetDisplayFriendlyName(PrimaryScreen.DeviceName);
-            desktopScreen.DevicePath = GetDisplayPath(PrimaryScreen.DeviceName);
-
-            // pull resolutions details
-            List<DisplayDevice> resolutions = GetResolutions(desktopScreen.PrimaryScreen.DeviceName);
-            foreach (DisplayDevice mode in resolutions)
-            {
-                ScreenResolution res = new ScreenResolution(mode.dmPelsWidth, mode.dmPelsHeight, mode.dmBitsPerPel);
-
-                List<int> frequencies = resolutions
-                    .Where(a => a.dmPelsWidth == mode.dmPelsWidth && a.dmPelsHeight == mode.dmPelsHeight)
-                    .Select(b => b.dmDisplayFrequency).Distinct().ToList();
-
-                foreach (int frequency in frequencies)
-                    res.Frequencies.Add(frequency, frequency);
-
-                if (!desktopScreen.HasResolution(res))
-                    desktopScreen.screenResolutions.Add(res);
-            }
-
-            // sort resolutions
-            desktopScreen.SortResolutions();
-
-            // raise event
-            PrimaryScreenChanged?.Invoke(desktopScreen);
-        }
-        else
-        {
-            // update current desktop resolution
-            desktopScreen.devMode = GetDisplay(desktopScreen.PrimaryScreen.DeviceName);
-        }
-
-        ScreenRotation.Rotations oldOrientation = screenOrientation.rotation;
-
-        if (!IsInitialized)
-        {
-            ScreenRotation.Rotations nativeScreenRotation = (ScreenRotation.Rotations)SettingsManager.GetInt("NativeDisplayOrientation");
-            screenOrientation = new ScreenRotation((ScreenRotation.Rotations)desktopScreen.devMode.dmDisplayOrientation, nativeScreenRotation);
-            oldOrientation = ScreenRotation.Rotations.UNSET;
-
-            if (nativeScreenRotation == ScreenRotation.Rotations.UNSET)
-                SettingsManager.SetProperty("NativeDisplayOrientation", (int)screenOrientation.rotationNativeBase, true);
-        }
-        else
-        {
-            screenOrientation = new ScreenRotation((ScreenRotation.Rotations)desktopScreen.devMode.dmDisplayOrientation, screenOrientation.rotationNativeBase);
-        }
-
-        // raise event
-        ScreenResolution screenResolution = desktopScreen.GetResolution(desktopScreen.devMode.dmPelsWidth, desktopScreen.devMode.dmPelsHeight);
-        if (screenResolution is not null)
-            DisplaySettingsChanged?.Invoke(desktopScreen, screenResolution);
-
-        // raise event
-        if (oldOrientation != screenOrientation.rotation)
-            DisplayOrientationChanged?.Invoke(screenOrientation);
-    }
-
-    public static DesktopScreen GetDesktopScreen()
-    {
-        return desktopScreen;
-    }
-
-    public static ScreenRotation GetScreenOrientation()
-    {
-        return screenOrientation;
-    }
-
-    public static void Start()
-    {
-        // start brightness watcher
-        BrightnessWatcher.Start();
-
-        // force trigger events
-        SystemEvents_DisplaySettingsChanged(null, null);
-
-        // get native resolution
-        ScreenResolution nativeResolution = desktopScreen.screenResolutions.First();
-
-        // get integer scaling dividers
-        int idx = 1;
-
-        while (true)
-        {
-            int height = nativeResolution.Height / idx;
-            ScreenResolution? dividedRes = desktopScreen.screenResolutions.FirstOrDefault(r => r.Height == height);
-            if (dividedRes is null)
-                break;
-
-            desktopScreen.screenDividers.Add(new(idx, dividedRes));
-            idx++;
-        }
-
-        IsInitialized = true;
-        Initialized?.Invoke();
-
-        LogManager.LogInformation("{0} has started", "SystemManager");
-    }
-
-    public static void Stop()
-    {
-        if (!IsInitialized)
-            return;
-
-        // stop brightness watcher
-        BrightnessWatcher.Stop();
-
-        DevEnum.UnregisterEndpointNotificationCallback(notificationClient);
-
-        IsInitialized = false;
-
-        LogManager.LogInformation("{0} has stopped", "SystemManager");
-    }
-
-    public static bool SetResolution(int width, int height, int displayFrequency)
-    {
-        if (!IsInitialized)
-            return false;
-
-        bool ret = false;
-        DisplayDevice dm = new DisplayDevice();
-        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
-        dm.dmPelsWidth = width;
-        dm.dmPelsHeight = height;
-        dm.dmDisplayFrequency = displayFrequency;
-        dm.dmFields = DisplayDevice.DM_PELSWIDTH | DisplayDevice.DM_PELSHEIGHT | DisplayDevice.DM_DISPLAYFREQUENCY;
-
-        long RetVal = ChangeDisplaySettings(ref dm, CDS_TEST);
-        if (RetVal == 0)
-        {
-            RetVal = ChangeDisplaySettings(ref dm, 0);
-            ret = true;
-        }
-
-        return ret;
-    }
-
-    public static bool SetResolution(int width, int height, int displayFrequency, int bitsPerPel)
-    {
-        if (!IsInitialized)
-            return false;
-
-        bool ret = false;
-        DisplayDevice dm = new DisplayDevice();
-        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
-        dm.dmPelsWidth = width;
-        dm.dmPelsHeight = height;
-        dm.dmDisplayFrequency = displayFrequency;
-        dm.dmBitsPerPel = bitsPerPel;
-        dm.dmFields = DisplayDevice.DM_PELSWIDTH | DisplayDevice.DM_PELSHEIGHT | DisplayDevice.DM_DISPLAYFREQUENCY;
-
-        long RetVal = ChangeDisplaySettings(ref dm, CDS_TEST);
-        if (RetVal == 0)
-        {
-            RetVal = ChangeDisplaySettings(ref dm, 0);
-            ret = true;
-        }
-
-        return ret;
-    }
-
-    public static DisplayDevice GetDisplay(string DeviceName)
-    {
-        DisplayDevice dm = new DisplayDevice();
-        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
-        EnumDisplaySettings(DeviceName, -1, ref dm);
-        return dm;
-    }
-
-    public static List<DisplayDevice> GetResolutions(string DeviceName)
-    {
-        List<DisplayDevice> allMode = new List<DisplayDevice>();
-        DisplayDevice dm = new DisplayDevice();
-        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
-        int index = 0;
-        while (EnumDisplaySettings(DeviceName, index, ref dm))
-        {
-            allMode.Add(dm);
-            index++;
-        }
-
-        return allMode;
-    }
-
-    public static void PlayWindowsMedia(string file)
-    {
-        string path = Path.Combine(@"c:\Windows\Media\", file);
-        if (File.Exists(path))
-            new SoundPlayer(path).Play();
-    }
-
-    public static bool HasVolumeSupport()
-    {
-        return VolumeSupport;
-    }
-
-    public static void SetVolume(double volume)
-    {
-        if (!VolumeSupport)
-            return;
-
-        multimediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar = (float)(volume / 100.0d);
-    }
-
-    public static double GetVolume()
-    {
-        if (!VolumeSupport)
-            return 0.0d;
-
-        return multimediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar * 100.0d;
-    }
-
-    public static bool HasBrightnessSupport()
-    {
-        return BrightnessSupport;
-    }
-
-    public static void SetBrightness(double brightness)
-    {
-        if (!BrightnessSupport)
-            return;
-
-        try
-        {
-            using (ManagementClass mclass = new ManagementClass("WmiMonitorBrightnessMethods"))
-            {
-                mclass.Scope = new ManagementScope(@"\\.\root\wmi");
-                using (ManagementObjectCollection instances = mclass.GetInstances())
-                {
-                    foreach (ManagementObject instance in instances)
-                    {
-                        object[] args = { 1, brightness };
-                        instance.InvokeMethod("WmiSetBrightness", args);
-                    }
-                }
-            }
-        }
-        catch
-        {
-        }
-    }
-
-    public static short GetBrightness()
-    {
-        try
-        {
-            using (ManagementClass mclass = new ManagementClass("WmiMonitorBrightness"))
-            {
-                mclass.Scope = new ManagementScope(@"\\.\root\wmi");
-                using (ManagementObjectCollection instances = mclass.GetInstances())
-                {
-                    foreach (ManagementObject instance in instances)
-                        return (byte)instance.GetPropertyValue("CurrentBrightness");
-                }
-            }
-
-            return 0;
-        }
-        catch
-        {
-        }
-
-        return -1;
-    }
-
-    private class MMDeviceNotificationClient : IMMNotificationClient
-    {
-        public void OnDefaultDeviceChanged(DataFlow flow, Role role, string defaultDeviceId)
-        {
-            SetDefaultAudioEndPoint();
-        }
-
-        public void OnDeviceAdded(string deviceId)
-        {
-        }
-
-        public void OnDeviceRemoved(string deviceId)
-        {
-        }
-
-        public void OnDeviceStateChanged(string deviceId, DeviceState newState)
-        {
-        }
-
-        public void OnPropertyValueChanged(string deviceId, PropertyKey key)
-        {
-        }
-    }
-
-    #region imports
-
-    public enum DMDO
-    {
-        DEFAULT = 0,
-        D90 = 1,
-        D180 = 2,
-        D270 = 3
-    }
-
-    public const int CDS_UPDATEREGISTRY = 0x01;
-    public const int CDS_TEST = 0x02;
-    public const int DISP_CHANGE_SUCCESSFUL = 0;
-    public const int DISP_CHANGE_RESTART = 1;
-    public const int DISP_CHANGE_FAILED = -1;
-
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
-    public struct DisplayDevice
-    {
-        public const int DM_DISPLAYFREQUENCY = 0x400000;
-        public const int DM_PELSWIDTH = 0x80000;
-        public const int DM_PELSHEIGHT = 0x100000;
-        private const int CCHDEVICENAME = 32;
-        private const int CCHFORMNAME = 32;
-
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHDEVICENAME)]
-        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 DMDO dmDisplayOrientation;
-        public int dmDisplayFixedOutput;
-
-        public short dmColor;
-        public short dmDuplex;
-        public short dmYResolution;
-        public short dmTTOption;
-        public short dmCollate;
-
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHFORMNAME)]
-        public string dmFormName;
-
-        public short dmLogPixels;
-        public int 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;
-
-        public override string ToString()
-        {
-            return $"{dmPelsWidth}x{dmPelsHeight}, {dmDisplayFrequency}, {dmBitsPerPel}";
-        }
-    }
-
-    [DllImport("user32.dll", CharSet = CharSet.Auto)]
-    private static extern int ChangeDisplaySettings([In] ref DisplayDevice lpDevMode, int dwFlags);
-
-    [DllImport("user32.dll", CharSet = CharSet.Auto)]
-    private static extern bool EnumDisplaySettings(string lpszDeviceName, int iModeNum, ref DisplayDevice lpDevMode);
-    #endregion
-
-    #region events
-
-    public static event DisplaySettingsChangedEventHandler DisplaySettingsChanged;
-    public delegate void DisplaySettingsChangedEventHandler(DesktopScreen screen, ScreenResolution resolution);
-
-    public static event PrimaryScreenChangedEventHandler PrimaryScreenChanged;
-    public delegate void PrimaryScreenChangedEventHandler(DesktopScreen screen);
-
-    public static event DisplayOrientationChangedEventHandler DisplayOrientationChanged;
-    public delegate void DisplayOrientationChangedEventHandler(ScreenRotation rotation);
-
-    public static event VolumeNotificationEventHandler VolumeNotification;
-    public delegate void VolumeNotificationEventHandler(float volume);
-
-    public static event BrightnessNotificationEventHandler BrightnessNotification;
-    public delegate void BrightnessNotificationEventHandler(int brightness);
-
-    public static event InitializedEventHandler Initialized;
-    public delegate void InitializedEventHandler();
-
-    #endregion
+using HandheldCompanion.Managers.Desktop;
+using Microsoft.Win32;
+using NAudio.CoreAudioApi;
+using NAudio.CoreAudioApi.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Management;
+using System.Media;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using WindowsDisplayAPI;
+using WindowsDisplayAPI.DisplayConfig;
+
+namespace HandheldCompanion.Managers;
+
+public static class MultimediaManager
+{
+    private static DesktopScreen desktopScreen;
+    private static ScreenRotation screenOrientation;
+
+    private static readonly MMDeviceEnumerator DevEnum;
+    private static MMDevice multimediaDevice;
+    private static readonly MMDeviceNotificationClient notificationClient;
+
+    private static readonly ManagementEventWatcher BrightnessWatcher;
+    private static readonly ManagementScope Scope;
+
+    private static bool VolumeSupport;
+    private static readonly bool BrightnessSupport;
+
+    public static bool IsInitialized;
+
+    static MultimediaManager()
+    {
+        // setup the multimedia device and get current volume value
+        notificationClient = new MMDeviceNotificationClient();
+        DevEnum = new MMDeviceEnumerator();
+        DevEnum.RegisterEndpointNotificationCallback(notificationClient);
+        SetDefaultAudioEndPoint();
+
+        // get current brightness value
+        Scope = new ManagementScope(@"\\.\root\wmi");
+        Scope.Connect();
+
+        // creating the watcher
+        BrightnessWatcher = new ManagementEventWatcher(Scope, new EventQuery("Select * From WmiMonitorBrightnessEvent"));
+        BrightnessWatcher.EventArrived += onWMIEvent;
+
+        // check if we have control over brightness
+        BrightnessSupport = GetBrightness() != -1;
+
+        // manage events
+        SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
+        SettingsManager.SettingValueChanged += SettingsManager_SettingValueChanged;
+        HotkeysManager.CommandExecuted += HotkeysManager_CommandExecuted;
+    }
+
+    private static void AudioEndpointVolume_OnVolumeNotification(AudioVolumeNotificationData data)
+    {
+        VolumeNotification?.Invoke(data.MasterVolume * 100.0f);
+    }
+
+    private static void SetDefaultAudioEndPoint()
+    {
+        try
+        {
+            if (multimediaDevice is not null && multimediaDevice.AudioEndpointVolume is not null)
+            {
+                VolumeSupport = false;
+                multimediaDevice.AudioEndpointVolume.OnVolumeNotification -= AudioEndpointVolume_OnVolumeNotification;
+            }
+
+            multimediaDevice = DevEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
+
+            if (multimediaDevice is not null && multimediaDevice.AudioEndpointVolume is not null)
+            {
+                VolumeSupport = true;
+                multimediaDevice.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
+            }
+
+            // do this even when no device found, to set to 0
+            VolumeNotification?.Invoke((float)GetVolume());
+        }
+        catch (Exception)
+        {
+            LogManager.LogError("No AudioEndpoint available");
+        }
+    }
+
+    private static void SettingsManager_SettingValueChanged(string name, object value)
+    {
+        switch (name)
+        {
+            case "NativeDisplayOrientation":
+                {
+                    ScreenRotation.Rotations nativeOrientation = (ScreenRotation.Rotations)Convert.ToInt32(value);
+
+                    if (!IsInitialized)
+                        return;
+
+                    ScreenRotation.Rotations oldOrientation = screenOrientation.rotation;
+                    screenOrientation = new ScreenRotation(screenOrientation.rotationUnnormalized, nativeOrientation);
+
+                    // Though the real orientation didn't change, raise event because the interpretation of it changed
+                    if (oldOrientation != screenOrientation.rotation)
+                        DisplayOrientationChanged?.Invoke(screenOrientation);
+                }
+                break;
+        }
+    }
+
+    private static void HotkeysManager_CommandExecuted(string listener)
+    {
+        switch (listener)
+        {
+            case "increaseBrightness":
+                {
+                    int stepRoundDn = (int)Math.Floor(GetBrightness() / 5.0d);
+                    int brightness = stepRoundDn * 5 + 5;
+                    SetBrightness(brightness);
+                }
+                break;
+            case "decreaseBrightness":
+                {
+                    int stepRoundUp = (int)Math.Ceiling(GetBrightness() / 5.0d);
+                    int brightness = stepRoundUp * 5 - 5;
+                    SetBrightness(brightness);
+                }
+                break;
+            case "increaseVolume":
+                {
+                    int stepRoundDn = (int)Math.Floor(Math.Round(GetVolume() / 5.0d, 2));
+                    int volume = stepRoundDn * 5 + 5;
+                    SetVolume(volume);
+                }
+                break;
+            case "decreaseVolume":
+                {
+                    int stepRoundUp = (int)Math.Ceiling(Math.Round(GetVolume() / 5.0d, 2));
+                    int volume = stepRoundUp * 5 - 5;
+                    SetVolume(volume);
+                }
+                break;
+        }
+    }
+
+    private static void onWMIEvent(object sender, EventArrivedEventArgs e)
+    {
+        int brightness = Convert.ToInt32(e.NewEvent.Properties["Brightness"].Value);
+        BrightnessNotification?.Invoke(brightness);
+    }
+
+    public static string GetDisplayFriendlyName(string DeviceName)
+    {
+        string friendlyName = string.Empty;
+
+        Display? PrimaryDisplay = Display.GetDisplays().Where(display => display.DisplayName.Equals(DeviceName)).FirstOrDefault();
+        if (PrimaryDisplay is not null)
+        {
+            string DevicePath = PrimaryDisplay.DevicePath;
+            PathDisplayTarget? PrimaryTarget = GetDisplayTarget(DevicePath);
+            if (PrimaryTarget is not null)
+                friendlyName = PrimaryTarget.FriendlyName;
+        }
+
+        return friendlyName;
+    }
+
+    public static string GetDisplayPath(string DeviceName)
+    {
+        string DevicePath = string.Empty;
+
+        Display? PrimaryDisplay = Display.GetDisplays().Where(display => display.DisplayName.Equals(DeviceName)).FirstOrDefault();
+        if (PrimaryDisplay is not null)
+            DevicePath = PrimaryDisplay.DevicePath;
+
+        return DevicePath;
+    }
+
+    private static PathDisplayTarget? GetDisplayTarget(string DevicePath)
+    {
+        PathDisplayTarget PrimaryTarget;
+        PrimaryTarget = PathDisplayTarget.GetDisplayTargets().Where(target => target.DevicePath.Equals(DevicePath)).FirstOrDefault();
+        return PrimaryTarget;
+    }
+
+    private static void SystemEvents_DisplaySettingsChanged(object? sender, EventArgs e)
+    {
+        // get primary screen
+        Screen PrimaryScreen = Screen.PrimaryScreen;
+
+        if (desktopScreen is null || desktopScreen.PrimaryScreen.DeviceName != PrimaryScreen.DeviceName)
+        {
+            // update current desktop screen
+            desktopScreen = new DesktopScreen(PrimaryScreen);
+            desktopScreen.devMode = GetDisplay(PrimaryScreen.DeviceName);
+            desktopScreen.FriendlyName = GetDisplayFriendlyName(PrimaryScreen.DeviceName);
+            desktopScreen.DevicePath = GetDisplayPath(PrimaryScreen.DeviceName);
+
+            // pull resolutions details
+            List<DisplayDevice> resolutions = GetResolutions(desktopScreen.PrimaryScreen.DeviceName);
+            foreach (DisplayDevice mode in resolutions)
+            {
+                ScreenResolution res = new ScreenResolution(mode.dmPelsWidth, mode.dmPelsHeight, mode.dmBitsPerPel);
+
+                List<int> frequencies = resolutions
+                    .Where(a => a.dmPelsWidth == mode.dmPelsWidth && a.dmPelsHeight == mode.dmPelsHeight)
+                    .Select(b => b.dmDisplayFrequency).Distinct().ToList();
+
+                foreach (int frequency in frequencies)
+                    res.Frequencies.Add(frequency, frequency);
+
+                if (!desktopScreen.HasResolution(res))
+                    desktopScreen.screenResolutions.Add(res);
+            }
+
+            // sort resolutions
+            desktopScreen.SortResolutions();
+
+            // raise event
+            PrimaryScreenChanged?.Invoke(desktopScreen);
+        }
+        else
+        {
+            // update current desktop resolution
+            desktopScreen.devMode = GetDisplay(desktopScreen.PrimaryScreen.DeviceName);
+        }
+
+        ScreenRotation.Rotations oldOrientation = screenOrientation.rotation;
+
+        if (!IsInitialized)
+        {
+            ScreenRotation.Rotations nativeScreenRotation = (ScreenRotation.Rotations)SettingsManager.GetInt("NativeDisplayOrientation");
+            screenOrientation = new ScreenRotation((ScreenRotation.Rotations)desktopScreen.devMode.dmDisplayOrientation, nativeScreenRotation);
+            oldOrientation = ScreenRotation.Rotations.UNSET;
+
+            if (nativeScreenRotation == ScreenRotation.Rotations.UNSET)
+                SettingsManager.SetProperty("NativeDisplayOrientation", (int)screenOrientation.rotationNativeBase, true);
+        }
+        else
+        {
+            screenOrientation = new ScreenRotation((ScreenRotation.Rotations)desktopScreen.devMode.dmDisplayOrientation, screenOrientation.rotationNativeBase);
+        }
+
+        // raise event
+        ScreenResolution screenResolution = desktopScreen.GetResolution(desktopScreen.devMode.dmPelsWidth, desktopScreen.devMode.dmPelsHeight);
+        if (screenResolution is not null)
+            DisplaySettingsChanged?.Invoke(desktopScreen, screenResolution);
+
+        // raise event
+        if (oldOrientation != screenOrientation.rotation)
+            DisplayOrientationChanged?.Invoke(screenOrientation);
+    }
+
+    public static DesktopScreen GetDesktopScreen()
+    {
+        return desktopScreen;
+    }
+
+    public static ScreenRotation GetScreenOrientation()
+    {
+        return screenOrientation;
+    }
+
+    public static void Start()
+    {
+        // start brightness watcher
+        BrightnessWatcher.Start();
+
+        // force trigger events
+        SystemEvents_DisplaySettingsChanged(null, null);
+
+        // get native resolution
+        ScreenResolution nativeResolution = desktopScreen.screenResolutions.First();
+
+        // get integer scaling dividers
+        int idx = 1;
+
+        while (true)
+        {
+            int height = nativeResolution.Height / idx;
+            ScreenResolution? dividedRes = desktopScreen.screenResolutions.FirstOrDefault(r => r.Height == height);
+            if (dividedRes is null)
+                break;
+
+            desktopScreen.screenDividers.Add(new(idx, dividedRes));
+            idx++;
+        }
+
+        IsInitialized = true;
+        Initialized?.Invoke();
+
+        LogManager.LogInformation("{0} has started", "SystemManager");
+    }
+
+    public static void Stop()
+    {
+        if (!IsInitialized)
+            return;
+
+        // stop brightness watcher
+        BrightnessWatcher.Stop();
+
+        DevEnum.UnregisterEndpointNotificationCallback(notificationClient);
+
+        IsInitialized = false;
+
+        LogManager.LogInformation("{0} has stopped", "SystemManager");
+    }
+
+    public static bool SetResolution(int width, int height, int displayFrequency)
+    {
+        if (!IsInitialized)
+            return false;
+
+        bool ret = false;
+        DisplayDevice dm = new DisplayDevice();
+        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
+        dm.dmPelsWidth = width;
+        dm.dmPelsHeight = height;
+        dm.dmDisplayFrequency = displayFrequency;
+        dm.dmFields = DisplayDevice.DM_PELSWIDTH | DisplayDevice.DM_PELSHEIGHT | DisplayDevice.DM_DISPLAYFREQUENCY;
+
+        long RetVal = ChangeDisplaySettings(ref dm, CDS_TEST);
+        if (RetVal == 0)
+        {
+            RetVal = ChangeDisplaySettings(ref dm, 0);
+            ret = true;
+        }
+
+        return ret;
+    }
+
+    public static bool SetResolution(int width, int height, int displayFrequency, int bitsPerPel)
+    {
+        if (!IsInitialized)
+            return false;
+
+        bool ret = false;
+        DisplayDevice dm = new DisplayDevice();
+        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
+        dm.dmPelsWidth = width;
+        dm.dmPelsHeight = height;
+        dm.dmDisplayFrequency = displayFrequency;
+        dm.dmBitsPerPel = bitsPerPel;
+        dm.dmFields = DisplayDevice.DM_PELSWIDTH | DisplayDevice.DM_PELSHEIGHT | DisplayDevice.DM_DISPLAYFREQUENCY;
+
+        long RetVal = ChangeDisplaySettings(ref dm, CDS_TEST);
+        if (RetVal == 0)
+        {
+            RetVal = ChangeDisplaySettings(ref dm, 0);
+            ret = true;
+        }
+
+        return ret;
+    }
+
+    public static DisplayDevice GetDisplay(string DeviceName)
+    {
+        DisplayDevice dm = new DisplayDevice();
+        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
+        EnumDisplaySettings(DeviceName, -1, ref dm);
+        return dm;
+    }
+
+    public static List<DisplayDevice> GetResolutions(string DeviceName)
+    {
+        List<DisplayDevice> allMode = new List<DisplayDevice>();
+        DisplayDevice dm = new DisplayDevice();
+        dm.dmSize = (short)Marshal.SizeOf(typeof(DisplayDevice));
+        int index = 0;
+        while (EnumDisplaySettings(DeviceName, index, ref dm))
+        {
+            allMode.Add(dm);
+            index++;
+        }
+
+        return allMode;
+    }
+
+    public static void PlayWindowsMedia(string file)
+    {
+        string path = Path.Combine(@"c:\Windows\Media\", file);
+        if (File.Exists(path))
+            new SoundPlayer(path).Play();
+    }
+
+    public static bool HasVolumeSupport()
+    {
+        return VolumeSupport;
+    }
+
+    public static void SetVolume(double volume)
+    {
+        if (!VolumeSupport)
+            return;
+
+        multimediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar = (float)(volume / 100.0d);
+    }
+
+    public static double GetVolume()
+    {
+        if (!VolumeSupport)
+            return 0.0d;
+
+        return multimediaDevice.AudioEndpointVolume.MasterVolumeLevelScalar * 100.0d;
+    }
+
+    public static bool HasBrightnessSupport()
+    {
+        return BrightnessSupport;
+    }
+
+    public static void SetBrightness(double brightness)
+    {
+        if (!BrightnessSupport)
+            return;
+
+        try
+        {
+            using (ManagementClass mclass = new ManagementClass("WmiMonitorBrightnessMethods"))
+            {
+                mclass.Scope = new ManagementScope(@"\\.\root\wmi");
+                using (ManagementObjectCollection instances = mclass.GetInstances())
+                {
+                    foreach (ManagementObject instance in instances)
+                    {
+                        object[] args = { 1, brightness };
+                        instance.InvokeMethod("WmiSetBrightness", args);
+                    }
+                }
+            }
+        }
+        catch
+        {
+        }
+    }
+
+    public static short GetBrightness()
+    {
+        try
+        {
+            using (ManagementClass mclass = new ManagementClass("WmiMonitorBrightness"))
+            {
+                mclass.Scope = new ManagementScope(@"\\.\root\wmi");
+                using (ManagementObjectCollection instances = mclass.GetInstances())
+                {
+                    foreach (ManagementObject instance in instances)
+                        return (byte)instance.GetPropertyValue("CurrentBrightness");
+                }
+            }
+
+            return 0;
+        }
+        catch
+        {
+        }
+
+        return -1;
+    }
+
+    private class MMDeviceNotificationClient : IMMNotificationClient
+    {
+        public void OnDefaultDeviceChanged(DataFlow flow, Role role, string defaultDeviceId)
+        {
+            SetDefaultAudioEndPoint();
+        }
+
+        public void OnDeviceAdded(string deviceId)
+        {
+        }
+
+        public void OnDeviceRemoved(string deviceId)
+        {
+        }
+
+        public void OnDeviceStateChanged(string deviceId, DeviceState newState)
+        {
+        }
+
+        public void OnPropertyValueChanged(string deviceId, PropertyKey key)
+        {
+        }
+    }
+
+    #region imports
+
+    public enum DMDO
+    {
+        DEFAULT = 0,
+        D90 = 1,
+        D180 = 2,
+        D270 = 3
+    }
+
+    public const int CDS_UPDATEREGISTRY = 0x01;
+    public const int CDS_TEST = 0x02;
+    public const int DISP_CHANGE_SUCCESSFUL = 0;
+    public const int DISP_CHANGE_RESTART = 1;
+    public const int DISP_CHANGE_FAILED = -1;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    public struct DisplayDevice
+    {
+        public const int DM_DISPLAYFREQUENCY = 0x400000;
+        public const int DM_PELSWIDTH = 0x80000;
+        public const int DM_PELSHEIGHT = 0x100000;
+        private const int CCHDEVICENAME = 32;
+        private const int CCHFORMNAME = 32;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHDEVICENAME)]
+        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 DMDO dmDisplayOrientation;
+        public int dmDisplayFixedOutput;
+
+        public short dmColor;
+        public short dmDuplex;
+        public short dmYResolution;
+        public short dmTTOption;
+        public short dmCollate;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHFORMNAME)]
+        public string dmFormName;
+
+        public short dmLogPixels;
+        public int 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;
+
+        public override string ToString()
+        {
+            return $"{dmPelsWidth}x{dmPelsHeight}, {dmDisplayFrequency}, {dmBitsPerPel}";
+        }
+    }
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    private static extern int ChangeDisplaySettings([In] ref DisplayDevice lpDevMode, int dwFlags);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    private static extern bool EnumDisplaySettings(string lpszDeviceName, int iModeNum, ref DisplayDevice lpDevMode);
+    #endregion
+
+    #region events
+
+    public static event DisplaySettingsChangedEventHandler DisplaySettingsChanged;
+    public delegate void DisplaySettingsChangedEventHandler(DesktopScreen screen, ScreenResolution resolution);
+
+    public static event PrimaryScreenChangedEventHandler PrimaryScreenChanged;
+    public delegate void PrimaryScreenChangedEventHandler(DesktopScreen screen);
+
+    public static event DisplayOrientationChangedEventHandler DisplayOrientationChanged;
+    public delegate void DisplayOrientationChangedEventHandler(ScreenRotation rotation);
+
+    public static event VolumeNotificationEventHandler VolumeNotification;
+    public delegate void VolumeNotificationEventHandler(float volume);
+
+    public static event BrightnessNotificationEventHandler BrightnessNotification;
+    public delegate void BrightnessNotificationEventHandler(int brightness);
+
+    public static event InitializedEventHandler Initialized;
+    public delegate void InitializedEventHandler();
+
+    #endregion
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Managers/SensorsManager.cs b/HandheldCompanion/Managers/SensorsManager.cs
index c4e7083fa..26d9ae42b 100644
--- a/HandheldCompanion/Managers/SensorsManager.cs
+++ b/HandheldCompanion/Managers/SensorsManager.cs
@@ -193,7 +193,7 @@ public static void Stop()
             LogManager.LogInformation("{0} has stopped", "SensorsManager");
         }
 
-        public static void Resume(bool update)
+        public static void Resume(bool OS)
         {
             Gyrometer?.UpdateSensor();
             Accelerometer?.UpdateSensor();
@@ -211,13 +211,20 @@ public static void UpdateReport(ControllerState controllerState, GamepadMotion g
             Vector3 accel = Accelerometer is not null ? Accelerometer.GetCurrentReading().reading : Vector3.Zero;
             Vector3 gyro = Gyrometer is not null ? Gyrometer.GetCurrentReading().reading : Vector3.Zero;
 
-            // todo: create an IMU class
-            double TotalMilliseconds = Gyrometer is not null ? Gyrometer.GetCurrentReading().timestamp : 0.0d;
-            double DeltaSeconds = (TotalMilliseconds - prevTimestamp) / 1000.0d;
-            prevTimestamp = TotalMilliseconds;
+            /*
+            double timestamp = Gyrometer is not null ? Gyrometer.GetCurrentReading().timestamp : 0.0d;
+            if (timestamp != prevTimestamp)
+            {
+                double TotalMilliseconds = Gyrometer is not null ? timestamp : 0.0d;
+                double DeltaSeconds = (TotalMilliseconds - prevTimestamp) / 1000.0d;
+
+                // replace delta with sensor value
+                delta = (float)DeltaSeconds;
 
-            // replace delta with delta from sensor
-            delta = (float)DeltaSeconds;
+                // update previous timestamp
+                prevTimestamp = TotalMilliseconds;
+            }
+            */
 
             // store motion
             controllerState.GyroState.SetGyroscope(gyro.X, gyro.Y, gyro.Z);
@@ -276,9 +283,9 @@ public static async void Calibrate(GamepadMotion gamepadMotion)
 
                 // display message
                 if (x == 0 && y == 0 && z == 0)
-                    dialog.UpdateContent("Calibration failed: gyroscope is silent.");
+                    dialog.UpdateContent("Calibration failed: device is silent.");
                 else
-                    dialog.UpdateContent("Calibration failed: device is too shaky.");
+                    dialog.UpdateContent("Calibration failed: device is silent or unsteady.");
 
                 goto Close;
             }
@@ -301,6 +308,7 @@ public static async void Calibrate(GamepadMotion gamepadMotion)
             gamepadMotion.GetCalibrationOffset(out float xOffset, out float yOffset, out float zOffset);
             gamepadMotion.SetCalibrationOffset(xOffset, yOffset, zOffset, (int)(confidence * 10.0f));
 
+            /*
             dialog.UpdateTitle("Please take back the controller in hands and get ready to shake it.");
 
             for (int i = 4; i > 0; i--)
@@ -324,6 +332,7 @@ public static async void Calibrate(GamepadMotion gamepadMotion)
 
             // get calibration offsets
             gamepadMotion.SetCalibrationThreshold(gamepadMotion.maxGyro, gamepadMotion.maxAccel);
+            */
 
             // store calibration offsets
             IMUCalibration.StoreCalibration(gamepadMotion.deviceInstanceId, gamepadMotion.GetCalibration());
diff --git a/HandheldCompanion/Misc/Dialog.cs b/HandheldCompanion/Misc/Dialog.cs
index f614576ce..b3fe511e0 100644
--- a/HandheldCompanion/Misc/Dialog.cs
+++ b/HandheldCompanion/Misc/Dialog.cs
@@ -1,97 +1,97 @@
-using HandheldCompanion.Views;
-using HandheldCompanion.Views.Windows;
-using iNKORE.UI.WPF.Modern.Controls;
-using System.Threading.Tasks;
-using System.Windows;
-namespace HandheldCompanion.Misc;
-
-public class Dialog
-{
-    private Window owner;
-    private ContentDialog dialog;
-
-    public string Title;
-    public string Content;
-    public ContentDialogButton DefaultButton = ContentDialogButton.Primary;
-    public string PrimaryButtonText = string.Empty;
-    public string SecondaryButtonText = string.Empty;
-    public string CloseButtonText = string.Empty;
-
-    public bool CanClose = true;
-
-    public Dialog(Window owner)
-    {
-        this.owner = owner;
-
-        // not my proudest code
-        switch (owner.Tag)
-        {
-            default:
-            case "MainWindow":
-                dialog = MainWindow.GetCurrent().ContentDialog;
-                break;
-            case "QuickTools":
-                dialog = OverlayQuickTools.GetCurrent().ContentDialog;
-                break;
-        }
-
-        if (dialog is not null)
-            dialog.Closing += Dialog_Closing;
-    }
-
-    public async Task<ContentDialogResult> ShowAsync()
-    {
-        try
-        {
-            dialog.Title = this.Title;
-            dialog.Content = this.Content;
-            dialog.CloseButtonText = this.CloseButtonText;
-            dialog.PrimaryButtonText = this.PrimaryButtonText;
-            dialog.SecondaryButtonText = this.SecondaryButtonText;
-            dialog.DefaultButton = this.DefaultButton;
-
-            ContentDialogResult result = await dialog.ShowAsync(owner);
-            return result;
-        }
-        catch { }
-
-        return ContentDialogResult.None;
-    }
-
-    public void Show()
-    {
-        try
-        {
-            dialog.Title = this.Title;
-            dialog.Content = this.Content;
-            dialog.CloseButtonText = this.CloseButtonText;
-            dialog.PrimaryButtonText = this.PrimaryButtonText;
-            dialog.SecondaryButtonText = this.SecondaryButtonText;
-            dialog.DefaultButton = this.DefaultButton;
-
-            dialog.ShowAsync(owner);
-        }
-        catch { }
-    }
-
-    public void Hide()
-    {
-        CanClose = true;
-        dialog.Hide();
-    }
-
-    private void Dialog_Closing(ContentDialog sender, ContentDialogClosingEventArgs args)
-    {
-        args.Cancel = !CanClose;
-    }
-
-    public void UpdateTitle(string Title)
-    {
-        dialog.Title = this.Title = Title;
-    }
-
-    public void UpdateContent(string Content)
-    {
-        dialog.Content = this.Content = Content;
-    }
+using HandheldCompanion.Views;
+using HandheldCompanion.Views.Windows;
+using iNKORE.UI.WPF.Modern.Controls;
+using System.Threading.Tasks;
+using System.Windows;
+namespace HandheldCompanion.Misc;
+
+public class Dialog
+{
+    private Window owner;
+    private ContentDialog dialog;
+
+    public string Title;
+    public string Content;
+    public ContentDialogButton DefaultButton = ContentDialogButton.Primary;
+    public string PrimaryButtonText = string.Empty;
+    public string SecondaryButtonText = string.Empty;
+    public string CloseButtonText = string.Empty;
+
+    public bool CanClose = true;
+
+    public Dialog(Window owner)
+    {
+        this.owner = owner;
+
+        // not my proudest code
+        switch (owner.Tag)
+        {
+            default:
+            case "MainWindow":
+                dialog = MainWindow.GetCurrent().ContentDialog;
+                break;
+            case "QuickTools":
+                dialog = OverlayQuickTools.GetCurrent().ContentDialog;
+                break;
+        }
+
+        if (dialog is not null)
+            dialog.Closing += Dialog_Closing;
+    }
+
+    public async Task<ContentDialogResult> ShowAsync()
+    {
+        try
+        {
+            dialog.Title = this.Title;
+            dialog.Content = this.Content;
+            dialog.CloseButtonText = this.CloseButtonText;
+            dialog.PrimaryButtonText = this.PrimaryButtonText;
+            dialog.SecondaryButtonText = this.SecondaryButtonText;
+            dialog.DefaultButton = this.DefaultButton;
+
+            ContentDialogResult result = await dialog.ShowAsync(owner);
+            return result;
+        }
+        catch { }
+
+        return ContentDialogResult.None;
+    }
+
+    public void Show()
+    {
+        try
+        {
+            dialog.Title = this.Title;
+            dialog.Content = this.Content;
+            dialog.CloseButtonText = this.CloseButtonText;
+            dialog.PrimaryButtonText = this.PrimaryButtonText;
+            dialog.SecondaryButtonText = this.SecondaryButtonText;
+            dialog.DefaultButton = this.DefaultButton;
+
+            dialog.ShowAsync(owner);
+        }
+        catch { }
+    }
+
+    public void Hide()
+    {
+        CanClose = true;
+        dialog.Hide();
+    }
+
+    private void Dialog_Closing(ContentDialog sender, ContentDialogClosingEventArgs args)
+    {
+        args.Cancel = !CanClose;
+    }
+
+    public void UpdateTitle(string Title)
+    {
+        dialog.Title = this.Title = Title;
+    }
+
+    public void UpdateContent(string Content)
+    {
+        dialog.Content = this.Content = Content;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Misc/PnPDetails.cs b/HandheldCompanion/Misc/PnPDetails.cs
index 56c50c54a..2d117382f 100644
--- a/HandheldCompanion/Misc/PnPDetails.cs
+++ b/HandheldCompanion/Misc/PnPDetails.cs
@@ -1,208 +1,208 @@
-using Nefarius.Utilities.DeviceManagement.Extensions;
-using Nefarius.Utilities.DeviceManagement.PnP;
-using System;
-using System.Runtime.InteropServices;
-
-namespace HandheldCompanion;
-
-[StructLayout(LayoutKind.Sequential)]
-public class PnPDetails
-{
-    public string deviceInstanceId;
-    public string baseContainerDeviceInstanceId;
-
-    public bool isGaming;
-    public bool isHooked;
-    public bool isExternal;
-    public bool isInternal => !isExternal;
-
-    public bool isVirtual;
-    public bool isPhysical => !isVirtual;
-    public bool isBluetooth => EnumeratorName.Equals("BTHENUM");
-    public bool isUSB => EnumeratorName.Equals("USB");
-
-    public string devicePath;
-    public string baseContainerDevicePath;
-
-    public string Name;
-    public string SymLink;
-    public string EnumeratorName;
-    public DateTimeOffset FirstInstallDate;
-
-    public ushort ProductID;
-    public ushort VendorID;
-
-    // XInput
-    public bool isXInput;
-    public byte XInputUserIndex = byte.MaxValue;
-    public int XInputDeviceIdx;
-
-    public string GetProductID()
-    {
-        return "0x" + ProductID.ToString("X4");
-    }
-
-    public string GetVendorID()
-    {
-        return "0x" + VendorID.ToString("X4");
-    }
-
-    public short GetMI()
-    {
-        string low = SymLink.ToLower();
-        int index = low.IndexOf("mi_");
-        if (index == -1)
-            return -1;
-        string mi = low.Substring(index + 3, 2);
-
-        if (short.TryParse(mi, out short number))
-            return number;
-
-        return -1;
-    }
-
-    public string GetEnumerator()
-    {
-        return EnumeratorName;
-    }
-
-    public UsbPnPDevice GetUsbPnPDevice()
-    {
-        PnPDevice device = GetBasePnPDevice();
-        if (device is null)
-            return null;
-
-        // skip if bluetooth
-        if (isBluetooth)
-            return null;
-
-        return device.ToUsbPnPDevice();
-    }
-
-    public PnPDevice GetPnPDevice()
-    {
-        try
-        {
-            return PnPDevice.GetDeviceByInstanceId(deviceInstanceId);
-        }
-        catch { }
-
-        return null;
-    }
-
-    public PnPDevice GetBasePnPDevice()
-    {
-        try
-        {
-            return PnPDevice.GetDeviceByInstanceId(baseContainerDeviceInstanceId);
-        }
-        catch { }
-
-        return null;
-    }
-
-    public bool CyclePort()
-    {
-        UsbPnPDevice device = GetUsbPnPDevice();
-
-        try
-        {
-            if (device is not null)
-            {
-                device.CyclePort();
-                return true;
-            }
-        }
-        catch { }
-
-        return false;
-    }
-
-    public bool InstallNullDrivers(bool basedevice = true)
-    {
-        PnPDevice device;
-
-        switch (basedevice)
-        {
-            case true:
-                device = GetBasePnPDevice();
-                break;
-            case false:
-                device = GetPnPDevice();
-                break;
-        }
-
-        try
-        {
-            if (device is not null)
-            {
-                device.InstallNullDriver();
-                return true;
-            }
-        }
-        catch { }
-
-        return false;
-    }
-
-    public bool InstallCustomDriver(string driverName, bool basedevice = true)
-    {
-        PnPDevice device;
-
-        switch (basedevice)
-        {
-            case true:
-                device = GetBasePnPDevice();
-                break;
-            case false:
-                device = GetPnPDevice();
-                break;
-        }
-
-        try
-        {
-            if (device is not null)
-            {
-                device.InstallCustomDriver(driverName);
-                return true;
-            }
-        }
-        catch { }
-
-        return false;
-    }
-
-    public bool Uninstall(bool basedevice = true, bool parent = false)
-    {
-        PnPDevice device;
-
-        switch (basedevice)
-        {
-            case true:
-                device = GetBasePnPDevice();
-
-                if (parent)
-                {
-                    var parentId = device.GetProperty<string>(DevicePropertyKey.Device_Parent);
-                    device = PnPDevice.GetDeviceByInstanceId(parentId);
-                }
-
-                break;
-            case false:
-                device = GetPnPDevice();
-                break;
-        }
-
-        try
-        {
-            if (device is not null)
-            {
-                device.Uninstall();
-                return true;
-            }
-        }
-        catch { }
-
-        return false;
-    }
+using Nefarius.Utilities.DeviceManagement.Extensions;
+using Nefarius.Utilities.DeviceManagement.PnP;
+using System;
+using System.Runtime.InteropServices;
+
+namespace HandheldCompanion;
+
+[StructLayout(LayoutKind.Sequential)]
+public class PnPDetails
+{
+    public string deviceInstanceId;
+    public string baseContainerDeviceInstanceId;
+
+    public bool isGaming;
+    public bool isHooked;
+    public bool isExternal;
+    public bool isInternal => !isExternal;
+
+    public bool isVirtual;
+    public bool isPhysical => !isVirtual;
+    public bool isBluetooth => EnumeratorName.Equals("BTHENUM");
+    public bool isUSB => EnumeratorName.Equals("USB");
+
+    public string devicePath;
+    public string baseContainerDevicePath;
+
+    public string Name;
+    public string SymLink;
+    public string EnumeratorName;
+    public DateTimeOffset FirstInstallDate;
+
+    public ushort ProductID;
+    public ushort VendorID;
+
+    // XInput
+    public bool isXInput;
+    public byte XInputUserIndex = byte.MaxValue;
+    public int XInputDeviceIdx;
+
+    public string GetProductID()
+    {
+        return "0x" + ProductID.ToString("X4");
+    }
+
+    public string GetVendorID()
+    {
+        return "0x" + VendorID.ToString("X4");
+    }
+
+    public short GetMI()
+    {
+        string low = SymLink.ToLower();
+        int index = low.IndexOf("mi_");
+        if (index == -1)
+            return -1;
+        string mi = low.Substring(index + 3, 2);
+
+        if (short.TryParse(mi, out short number))
+            return number;
+
+        return -1;
+    }
+
+    public string GetEnumerator()
+    {
+        return EnumeratorName;
+    }
+
+    public UsbPnPDevice GetUsbPnPDevice()
+    {
+        PnPDevice device = GetBasePnPDevice();
+        if (device is null)
+            return null;
+
+        // skip if bluetooth
+        if (isBluetooth)
+            return null;
+
+        return device.ToUsbPnPDevice();
+    }
+
+    public PnPDevice GetPnPDevice()
+    {
+        try
+        {
+            return PnPDevice.GetDeviceByInstanceId(deviceInstanceId);
+        }
+        catch { }
+
+        return null;
+    }
+
+    public PnPDevice GetBasePnPDevice()
+    {
+        try
+        {
+            return PnPDevice.GetDeviceByInstanceId(baseContainerDeviceInstanceId);
+        }
+        catch { }
+
+        return null;
+    }
+
+    public bool CyclePort()
+    {
+        UsbPnPDevice device = GetUsbPnPDevice();
+
+        try
+        {
+            if (device is not null)
+            {
+                device.CyclePort();
+                return true;
+            }
+        }
+        catch { }
+
+        return false;
+    }
+
+    public bool InstallNullDrivers(bool basedevice = true)
+    {
+        PnPDevice device;
+
+        switch (basedevice)
+        {
+            case true:
+                device = GetBasePnPDevice();
+                break;
+            case false:
+                device = GetPnPDevice();
+                break;
+        }
+
+        try
+        {
+            if (device is not null)
+            {
+                device.InstallNullDriver();
+                return true;
+            }
+        }
+        catch { }
+
+        return false;
+    }
+
+    public bool InstallCustomDriver(string driverName, bool basedevice = true)
+    {
+        PnPDevice device;
+
+        switch (basedevice)
+        {
+            case true:
+                device = GetBasePnPDevice();
+                break;
+            case false:
+                device = GetPnPDevice();
+                break;
+        }
+
+        try
+        {
+            if (device is not null)
+            {
+                device.InstallCustomDriver(driverName);
+                return true;
+            }
+        }
+        catch { }
+
+        return false;
+    }
+
+    public bool Uninstall(bool basedevice = true, bool parent = false)
+    {
+        PnPDevice device;
+
+        switch (basedevice)
+        {
+            case true:
+                device = GetBasePnPDevice();
+
+                if (parent)
+                {
+                    var parentId = device.GetProperty<string>(DevicePropertyKey.Device_Parent);
+                    device = PnPDevice.GetDeviceByInstanceId(parentId);
+                }
+
+                break;
+            case false:
+                device = GetPnPDevice();
+                break;
+        }
+
+        try
+        {
+            if (device is not null)
+            {
+                device.Uninstall();
+                return true;
+            }
+        }
+        catch { }
+
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Misc/PnPUtil.cs b/HandheldCompanion/Misc/PnPUtil.cs
index 3443aa3ce..d4427d0df 100644
--- a/HandheldCompanion/Misc/PnPUtil.cs
+++ b/HandheldCompanion/Misc/PnPUtil.cs
@@ -1,138 +1,138 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text.RegularExpressions;
-
-namespace HandheldCompanion
-{
-    // https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/pnputil-return-values
-    public class PnPUtilResult
-    {
-        public int ExitCode;
-        public string StandardOutput;
-
-        public PnPUtilResult(int exitCode, string output)
-        {
-            ExitCode = exitCode;
-            StandardOutput = output;
-        }
-    }
-
-    public static class PnPUtil
-    {
-        private const int ERROR_SUCCESS = 0;
-        private const int ERROR_NO_MORE_ITEMS = 259;
-        private const int ERROR_SUCCESS_REBOOT_REQUIRED = 3010;
-        private const int ERROR_SUCCESS_REBOOT_INITIATED = 1641;
-
-        public static bool RestartDevice(string InstanceId)
-        {
-            var pnpResult = GetPnPUtilResult($"/restart-device \"{InstanceId}\"");
-            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
-        }
-
-        public static bool EnableDevice(string InstanceId)
-        {
-            var pnpResult = GetPnPUtilResult($"/enable-device \"{InstanceId}\"");
-            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
-        }
-
-        public static bool DisableDevice(string InstanceId)
-        {
-            var pnpResult = GetPnPUtilResult($"/disable-device \"{InstanceId}\"");
-            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
-        }
-
-        public static bool EnableDevices(string Class)
-        {
-            var pnpResult = GetPnPUtilResult($"/enable-device /class \"{Class}\"");
-            return pnpResult.ExitCode == ERROR_SUCCESS;
-        }
-
-        public static List<string> GetDevices(string className, string status = "/connected")
-        {
-            // A list of string to store the Instance ID values
-            List<string> instanceIDs = new List<string>();
-
-            // A regular expression to match the Instance ID pattern
-            Regex regex = new Regex(@"Instance ID:\s+(.*)");
-
-            // Loop through each line of the input string
-            string input = GetPnPUtilOutput($"/enum-devices {status} /class {className}");
-            foreach (string line in input.Split('\r'))
-            {
-                // Try to match the line with the regular expression
-                Match match = regex.Match(line);
-
-                // If there is a match, add the Instance ID value to the list
-                if (match.Success)
-                {
-                    instanceIDs.Add(match.Groups[1].Value);
-                }
-            }
-
-            // Print the list of Instance ID values
-            Debug.WriteLine("The Instance ID values are:");
-            foreach (string id in instanceIDs)
-            {
-                Debug.WriteLine(id);
-            }
-
-            return instanceIDs;
-        }
-
-        public static Process StartPnPUtil(string arguments)
-        {
-            Process process = new();
-
-            process.StartInfo.FileName = "pnputil.exe";
-            process.StartInfo.Arguments = arguments;
-
-            process.StartInfo.UseShellExecute = false;
-            process.StartInfo.RedirectStandardOutput = true;
-            process.StartInfo.RedirectStandardError = true;
-            process.StartInfo.CreateNoWindow = true;
-
-            process.Start();
-
-            return process;
-        }
-
-        private static string GetPnPUtilOutput(string arguments)
-        {
-            Process process = StartPnPUtil(arguments);
-            var output = process.StandardOutput.ReadToEnd();
-
-            return output;
-        }
-
-        private static PnPUtilResult GetPnPUtilResult(string arguments)
-        {
-            Process process = StartPnPUtil(arguments);
-            var output = process.StandardOutput.ReadToEnd();
-            var exitCode = process.ExitCode;
-
-            return new PnPUtilResult(exitCode, output);
-        }
-
-        // this function validates the results for /enable-device, /disable-device and /restart-device.
-        private static bool ValidateChangeDeviceStatusResult(string instanceId, PnPUtilResult pnpResult)
-        {
-            string[] output = pnpResult.StandardOutput.Split("\r\n");
-            var exitCode = pnpResult.ExitCode;
-
-            switch (exitCode)
-            {
-                case ERROR_SUCCESS:
-                    if (output[2].Contains(instanceId))
-                        // we assume the operation was successful if the instance id was found
-                        return true;
-                    break;
-                default:
-                    // operation was not successful or requires a reboot.
-                    return false;
-            }
-
-            return true;
-        }
-    }
-}
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+
+namespace HandheldCompanion
+{
+    // https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/pnputil-return-values
+    public class PnPUtilResult
+    {
+        public int ExitCode;
+        public string StandardOutput;
+
+        public PnPUtilResult(int exitCode, string output)
+        {
+            ExitCode = exitCode;
+            StandardOutput = output;
+        }
+    }
+
+    public static class PnPUtil
+    {
+        private const int ERROR_SUCCESS = 0;
+        private const int ERROR_NO_MORE_ITEMS = 259;
+        private const int ERROR_SUCCESS_REBOOT_REQUIRED = 3010;
+        private const int ERROR_SUCCESS_REBOOT_INITIATED = 1641;
+
+        public static bool RestartDevice(string InstanceId)
+        {
+            var pnpResult = GetPnPUtilResult($"/restart-device \"{InstanceId}\"");
+            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
+        }
+
+        public static bool EnableDevice(string InstanceId)
+        {
+            var pnpResult = GetPnPUtilResult($"/enable-device \"{InstanceId}\"");
+            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
+        }
+
+        public static bool DisableDevice(string InstanceId)
+        {
+            var pnpResult = GetPnPUtilResult($"/disable-device \"{InstanceId}\"");
+            return ValidateChangeDeviceStatusResult(InstanceId, pnpResult);
+        }
+
+        public static bool EnableDevices(string Class)
+        {
+            var pnpResult = GetPnPUtilResult($"/enable-device /class \"{Class}\"");
+            return pnpResult.ExitCode == ERROR_SUCCESS;
+        }
+
+        public static List<string> GetDevices(string className, string status = "/connected")
+        {
+            // A list of string to store the Instance ID values
+            List<string> instanceIDs = new List<string>();
+
+            // A regular expression to match the Instance ID pattern
+            Regex regex = new Regex(@"Instance ID:\s+(.*)");
+
+            // Loop through each line of the input string
+            string input = GetPnPUtilOutput($"/enum-devices {status} /class {className}");
+            foreach (string line in input.Split('\r'))
+            {
+                // Try to match the line with the regular expression
+                Match match = regex.Match(line);
+
+                // If there is a match, add the Instance ID value to the list
+                if (match.Success)
+                {
+                    instanceIDs.Add(match.Groups[1].Value);
+                }
+            }
+
+            // Print the list of Instance ID values
+            Debug.WriteLine("The Instance ID values are:");
+            foreach (string id in instanceIDs)
+            {
+                Debug.WriteLine(id);
+            }
+
+            return instanceIDs;
+        }
+
+        public static Process StartPnPUtil(string arguments)
+        {
+            Process process = new();
+
+            process.StartInfo.FileName = "pnputil.exe";
+            process.StartInfo.Arguments = arguments;
+
+            process.StartInfo.UseShellExecute = false;
+            process.StartInfo.RedirectStandardOutput = true;
+            process.StartInfo.RedirectStandardError = true;
+            process.StartInfo.CreateNoWindow = true;
+
+            process.Start();
+
+            return process;
+        }
+
+        private static string GetPnPUtilOutput(string arguments)
+        {
+            Process process = StartPnPUtil(arguments);
+            var output = process.StandardOutput.ReadToEnd();
+
+            return output;
+        }
+
+        private static PnPUtilResult GetPnPUtilResult(string arguments)
+        {
+            Process process = StartPnPUtil(arguments);
+            var output = process.StandardOutput.ReadToEnd();
+            var exitCode = process.ExitCode;
+
+            return new PnPUtilResult(exitCode, output);
+        }
+
+        // this function validates the results for /enable-device, /disable-device and /restart-device.
+        private static bool ValidateChangeDeviceStatusResult(string instanceId, PnPUtilResult pnpResult)
+        {
+            string[] output = pnpResult.StandardOutput.Split("\r\n");
+            var exitCode = pnpResult.ExitCode;
+
+            switch (exitCode)
+            {
+                case ERROR_SUCCESS:
+                    if (output[2].Contains(instanceId))
+                        // we assume the operation was successful if the instance id was found
+                        return true;
+                    break;
+                default:
+                    // operation was not successful or requires a reboot.
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/HandheldCompanion/Misc/Profile.cs b/HandheldCompanion/Misc/Profile.cs
index e27a36acc..eeaf77cdf 100644
--- a/HandheldCompanion/Misc/Profile.cs
+++ b/HandheldCompanion/Misc/Profile.cs
@@ -4,6 +4,7 @@
 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using static HandheldCompanion.Utils.XInputPlusUtils;
 
 namespace HandheldCompanion;
@@ -126,15 +127,14 @@ public Profile(string path) : this()
     {
         if (!string.IsNullOrEmpty(path))
         {
+            Dictionary<string, string> AppProperties = ProcessUtils.GetAppProperties(path);
 
-            var AppProperties = ProcessUtils.GetAppProperties(path);
-
-            var ProductName = AppProperties.TryGetValue("FileDescription", out var property) ? property : AppProperties["ItemFolderNameDisplay"];
+            string ProductName = AppProperties.TryGetValue("FileDescription", out var property) ? property : AppProperties["ItemFolderNameDisplay"];
             // string Version = AppProperties.ContainsKey("FileVersion") ? AppProperties["FileVersion"] : "1.0.0.0";
             // string Company = AppProperties.ContainsKey("Company") ? AppProperties["Company"] : AppProperties.ContainsKey("Copyright") ? AppProperties["Copyright"] : "Unknown";
 
-            Executable = AppProperties["FileName"];
-            Name = ProductName;
+            Executable = System.IO.Path.GetFileName(path);
+            Name = string.IsNullOrEmpty(ProductName) ? Executable : ProductName;
             Path = path;
         }
 
diff --git a/HandheldCompanion/Platforms/Steam.cs b/HandheldCompanion/Platforms/Steam.cs
index 2b2fb6c1b..cb68aca70 100644
--- a/HandheldCompanion/Platforms/Steam.cs
+++ b/HandheldCompanion/Platforms/Steam.cs
@@ -107,6 +107,11 @@ public bool HasDesktopProfileApplied()
         if (!File.Exists(configPath))
             return false;
 
+        // check if file is being used
+        // todo: improve me
+        if (FileUtils.IsFileUsed(configPath))
+            return true;
+
         string configText = File.ReadAllText(configPath);
         string fileText = Encoding.UTF8.GetString(Resources.empty_neptune, 0, Resources.empty_neptune.Length);
 
@@ -138,7 +143,7 @@ private async void ProcessManager_ProcessStarted(ProcessEx processEx, bool OnSta
             ReplaceFiles();
 
             // hook into current process
-            if (!Process.HasExited)
+            if (Process is not null && !Process.HasExited)
                 Process.Exited += Process_Exited;
         }
     }
diff --git a/HandheldCompanion/Presets/ColorPresetResources.cs b/HandheldCompanion/Presets/ColorPresetResources.cs
index fe52a5af1..d45ca3946 100644
--- a/HandheldCompanion/Presets/ColorPresetResources.cs
+++ b/HandheldCompanion/Presets/ColorPresetResources.cs
@@ -1,50 +1,50 @@
-using iNKORE.UI.WPF.Modern;
-using System;
-using System.Windows;
-
-namespace HandheldCompanion.Presets;
-
-public class ColorPresetResources : ResourceDictionary
-{
-    private ApplicationTheme _targetTheme;
-
-    public ColorPresetResources()
-    {
-        WeakEventManager<PresetManager, EventArgs>.AddHandler(
-            PresetManager.Current,
-            nameof(PresetManager.ColorPresetChanged),
-            OnCurrentPresetChanged);
-
-        ApplyCurrentPreset();
-    }
-
-    public ApplicationTheme TargetTheme
-    {
-        get => _targetTheme;
-        set
-        {
-            if (_targetTheme != value)
-            {
-                _targetTheme = value;
-                ApplyCurrentPreset();
-            }
-        }
-    }
-
-    private void OnCurrentPresetChanged(object sender, EventArgs e)
-    {
-        ApplyCurrentPreset();
-    }
-
-    private void ApplyCurrentPreset()
-    {
-        if (MergedDictionaries.Count > 0) MergedDictionaries.Clear();
-
-        var assemblyName = GetType().Assembly.GetName().Name;
-        var currentPreset = PresetManager.Current.ColorPreset;
-        var source =
-            new Uri($"pack://application:,,,/{assemblyName};component/Presets/{currentPreset}/{TargetTheme}.xaml");
-        var rd = new ResourceDictionary { Source = source };
-        MergedDictionaries.Add(rd);
-    }
+using iNKORE.UI.WPF.Modern;
+using System;
+using System.Windows;
+
+namespace HandheldCompanion.Presets;
+
+public class ColorPresetResources : ResourceDictionary
+{
+    private ApplicationTheme _targetTheme;
+
+    public ColorPresetResources()
+    {
+        WeakEventManager<PresetManager, EventArgs>.AddHandler(
+            PresetManager.Current,
+            nameof(PresetManager.ColorPresetChanged),
+            OnCurrentPresetChanged);
+
+        ApplyCurrentPreset();
+    }
+
+    public ApplicationTheme TargetTheme
+    {
+        get => _targetTheme;
+        set
+        {
+            if (_targetTheme != value)
+            {
+                _targetTheme = value;
+                ApplyCurrentPreset();
+            }
+        }
+    }
+
+    private void OnCurrentPresetChanged(object sender, EventArgs e)
+    {
+        ApplyCurrentPreset();
+    }
+
+    private void ApplyCurrentPreset()
+    {
+        if (MergedDictionaries.Count > 0) MergedDictionaries.Clear();
+
+        var assemblyName = GetType().Assembly.GetName().Name;
+        var currentPreset = PresetManager.Current.ColorPreset;
+        var source =
+            new Uri($"pack://application:,,,/{assemblyName};component/Presets/{currentPreset}/{TargetTheme}.xaml");
+        var rd = new ResourceDictionary { Source = source };
+        MergedDictionaries.Add(rd);
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Processors/AMD/RyzenAdj.cs b/HandheldCompanion/Processors/AMD/RyzenAdj.cs
index c3d45e019..7187350b5 100644
--- a/HandheldCompanion/Processors/AMD/RyzenAdj.cs
+++ b/HandheldCompanion/Processors/AMD/RyzenAdj.cs
@@ -17,6 +17,7 @@ public enum RyzenFamily
     FAM_REMBRANDT = 7,
     FAM_MENDOCINO = 8,
     FAM_PHEONIX = 9,
+    FAM_HAWKPOINT = 10,
     FAM_END
 }
 
diff --git a/HandheldCompanion/Processors/AMDProcessor.cs b/HandheldCompanion/Processors/AMDProcessor.cs
index a55f3a2b6..c3971507f 100644
--- a/HandheldCompanion/Processors/AMDProcessor.cs
+++ b/HandheldCompanion/Processors/AMDProcessor.cs
@@ -1,9 +1,8 @@
-using HandheldCompanion.Devices;
+using HandheldCompanion.Devices;
 using HandheldCompanion.Helpers;
 using HandheldCompanion.Processors.AMD;
 using System;
-using System.Threading;
-using System.Timers;
+using static HandheldCompanion.Devices.LegionGo;
 
 namespace HandheldCompanion.Processors;
 
@@ -36,6 +35,7 @@ public AMDProcessor()
                 case RyzenFamily.FAM_REMBRANDT:
                 case RyzenFamily.FAM_MENDOCINO:
                 case RyzenFamily.FAM_PHEONIX:
+                case RyzenFamily.FAM_HAWKPOINT:
                     CanChangeGPU = true;
                     break;
                 case RyzenFamily.FAM_VANGOGH:
@@ -59,83 +59,13 @@ public AMDProcessor()
                 case RyzenFamily.FAM_REMBRANDT:
                 case RyzenFamily.FAM_MENDOCINO:
                 case RyzenFamily.FAM_PHEONIX:
+                case RyzenFamily.FAM_HAWKPOINT:
                     CanChangeTDP = true;
                     break;
             }
 
             IsInitialized = true;
         }
-
-        foreach (var type in (PowerType[])Enum.GetValues(typeof(PowerType)))
-        {
-            // write default limits
-            m_Limits[type] = 0;
-            m_PrevLimits[type] = 0;
-
-            /*
-            // write default values
-            m_Values[type] = 0;
-            m_PrevValues[type] = 0;
-            */
-        }
-    }
-
-    public override void Initialize()
-    {
-        updateTimer.Elapsed += UpdateTimer_Elapsed;
-        base.Initialize();
-    }
-
-    public override void Stop()
-    {
-        updateTimer.Elapsed -= UpdateTimer_Elapsed;
-        base.Stop();
-    }
-
-    protected override void UpdateTimer_Elapsed(object sender, ElapsedEventArgs e)
-    {
-        if (Monitor.TryEnter(IsBusy))
-        {
-            RyzenAdj.get_table_values(ry);
-            RyzenAdj.refresh_table(ry);
-
-            // read limit(s)
-            var limit_fast = (int)RyzenAdj.get_fast_limit(ry);
-            var limit_slow = (int)RyzenAdj.get_slow_limit(ry);
-            var limit_stapm = (int)RyzenAdj.get_stapm_limit(ry);
-
-            if (limit_fast != 0)
-                m_Limits[PowerType.Fast] = limit_fast;
-            if (limit_slow != 0)
-                m_Limits[PowerType.Slow] = limit_slow;
-            if (limit_stapm != 0)
-                m_Limits[PowerType.Stapm] = limit_stapm;
-
-            // read value(s)
-            var value_fast = (int)RyzenAdj.get_fast_value(ry);
-            var value_slow = (int)RyzenAdj.get_slow_value(ry);
-            var value_stapm = (int)RyzenAdj.get_stapm_value(ry);
-
-            while (value_fast == 0)
-                value_fast = (int)RyzenAdj.get_fast_value(ry);
-            while (value_slow == 0)
-                value_slow = (int)RyzenAdj.get_slow_value(ry);
-            while (value_stapm == 0)
-                value_stapm = (int)RyzenAdj.get_stapm_value(ry);
-
-            m_Values[PowerType.Fast] = value_fast;
-            m_Values[PowerType.Slow] = value_slow;
-            m_Values[PowerType.Stapm] = value_stapm;
-
-            // read gfx_clk
-            var gfx_clk = (int)RyzenAdj.get_gfx_clk(ry);
-            if (gfx_clk != 0)
-                m_Misc["gfx_clk"] = gfx_clk;
-
-            base.UpdateTimer_Elapsed(sender, e);
-
-            Monitor.Exit(IsBusy);
-        }
     }
 
     public override void SetTDPLimit(PowerType type, double limit, bool immediate, int result)
@@ -143,47 +73,59 @@ public override void SetTDPLimit(PowerType type, double limit, bool immediate, i
         if (ry == IntPtr.Zero)
             return;
 
-        if (Monitor.TryEnter(IsBusy))
+        lock (updateLock)
         {
-            // 15W : 15000
-            limit *= 1000;
-
-            var error = 0;
-
-            switch (type)
+            // device specific: Lenovo Legion Go
+            if (IDevice.GetCurrent() is LegionGo legion)
             {
-                case PowerType.Fast:
-                    error = RyzenAdj.set_fast_limit(ry, (uint)limit);
-                    break;
-                case PowerType.Slow:
-                    error = RyzenAdj.set_slow_limit(ry, (uint)limit);
-                    break;
-                case PowerType.Stapm:
-                    error = RyzenAdj.set_stapm_limit(ry, (uint)limit);
-                    break;
+                switch(type)
+                {
+                    case PowerType.Fast:
+                        legion.SetCPUPowerLimit(CapabilityID.CPUShortTermPowerLimit, (int)limit);
+                        legion.SetCPUPowerLimit(CapabilityID.CPUPeakPowerLimit, (int)limit);
+                        break;
+                    case PowerType.Slow:
+                        legion.SetCPUPowerLimit(CapabilityID.CPULongTermPowerLimit, (int)limit);
+                        break;
+                }
+            }
+            else
+            {
+                // 15W : 15000
+                limit *= 1000;
+
+                var error = 0;
+
+                switch (type)
+                {
+                    case PowerType.Fast:
+                        error = RyzenAdj.set_fast_limit(ry, (uint)limit);
+                        break;
+                    case PowerType.Slow:
+                        error = RyzenAdj.set_slow_limit(ry, (uint)limit);
+                        break;
+                    case PowerType.Stapm:
+                        error = RyzenAdj.set_stapm_limit(ry, (uint)limit);
+                        break;
+                }
+
+                base.SetTDPLimit(type, limit, immediate, error);
             }
-
-            base.SetTDPLimit(type, limit, immediate, error);
-
-            Monitor.Exit(IsBusy);
         }
     }
 
     public override void SetGPUClock(double clock, int result)
     {
-        if (Monitor.TryEnter(IsBusy))
+        lock (updateLock)
         {
             switch (family)
             {
                 case RyzenFamily.FAM_VANGOGH:
                     {
-                        using (var sd = VangoghGPU.Open())
+                        using (VangoghGPU? sd = VangoghGPU.Open())
                         {
                             if (sd is null)
-                            {
-                                base.SetGPUClock(clock, 1);
                                 return;
-                            }
 
                             if (clock == 12750)
                             {
@@ -195,8 +137,6 @@ public override void SetGPUClock(double clock, int result)
                                 sd.HardMinGfxClock = (uint)clock; //hardMin
                                 sd.SoftMaxGfxClock = (uint)clock; //softMax
                             }
-
-                            base.SetGPUClock(clock, 0);
                         }
                     }
                     break;
@@ -208,26 +148,10 @@ public override void SetGPUClock(double clock, int result)
                             return;
 
                         int error = RyzenAdj.set_gfx_clk(ry, (uint)clock);
-
-                        /*
-                        if (clock == 12750)
-                        {
-                            error2 = RyzenAdj.set_min_gfxclk_freq(ry, (uint)IDevice.GetCurrent().GfxClock[0]);
-                            error3 = RyzenAdj.set_max_gfxclk_freq(ry, (uint)IDevice.GetCurrent().GfxClock[1]);
-                        }
-                        else
-                        {
-                            error2 = RyzenAdj.set_min_gfxclk_freq(ry, (uint)clock);
-                            error3 = RyzenAdj.set_max_gfxclk_freq(ry, (uint)clock);
-                        }
-                        */
-
                         base.SetGPUClock(clock, error);
                     }
                     break;
             }
-
-            Monitor.Exit(IsBusy);
         }
     }
 
diff --git a/HandheldCompanion/Properties/Settings.Designer.cs b/HandheldCompanion/Properties/Settings.Designer.cs
index 0fedae925..558e82dda 100644
--- a/HandheldCompanion/Properties/Settings.Designer.cs
+++ b/HandheldCompanion/Properties/Settings.Designer.cs
@@ -29,1377 +29,969 @@ public static Settings Default
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool ToastEnable
-        {
-            get
-            {
+        public bool ToastEnable {
+            get {
                 return ((bool)(this["ToastEnable"]));
             }
-            set
-            {
+            set {
                 this["ToastEnable"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool RunAtStartup
-        {
-            get
-            {
+        public bool RunAtStartup {
+            get {
                 return ((bool)(this["RunAtStartup"]));
             }
-            set
-            {
+            set {
                 this["RunAtStartup"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool StartMinimized
-        {
-            get
-            {
+        public bool StartMinimized {
+            get {
                 return ((bool)(this["StartMinimized"]));
             }
-            set
-            {
+            set {
                 this["StartMinimized"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool CloseMinimises
-        {
-            get
-            {
+        public bool CloseMinimises {
+            get {
                 return ((bool)(this["CloseMinimises"]));
             }
-            set
-            {
+            set {
                 this["CloseMinimises"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("720")]
-        public double MainWindowHeight
-        {
-            get
-            {
+        public double MainWindowHeight {
+            get {
                 return ((double)(this["MainWindowHeight"]));
             }
-            set
-            {
+            set {
                 this["MainWindowHeight"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1280")]
-        public double MainWindowWidth
-        {
-            get
-            {
+        public double MainWindowWidth {
+            get {
                 return ((double)(this["MainWindowWidth"]));
             }
-            set
-            {
+            set {
                 this["MainWindowWidth"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double MainWindowLeft
-        {
-            get
-            {
+        public double MainWindowLeft {
+            get {
                 return ((double)(this["MainWindowLeft"]));
             }
-            set
-            {
+            set {
                 this["MainWindowLeft"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double MainWindowTop
-        {
-            get
-            {
+        public double MainWindowTop {
+            get {
                 return ((double)(this["MainWindowTop"]));
             }
-            set
-            {
+            set {
                 this["MainWindowTop"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int MainWindowState
-        {
-            get
-            {
+        public int MainWindowState {
+            get {
                 return ((int)(this["MainWindowState"]));
             }
-            set
-            {
+            set {
                 this["MainWindowState"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int MainWindowTheme
-        {
-            get
-            {
+        public int MainWindowTheme {
+            get {
                 return ((int)(this["MainWindowTheme"]));
             }
-            set
-            {
+            set {
                 this["MainWindowTheme"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1989-12-20")]
-        public global::System.DateTime UpdateLastChecked
-        {
-            get
-            {
+        public global::System.DateTime UpdateLastChecked {
+            get {
                 return ((global::System.DateTime)(this["UpdateLastChecked"]));
             }
-            set
-            {
+            set {
                 this["UpdateLastChecked"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int OverlayModel
-        {
-            get
-            {
+        public int OverlayModel {
+            get {
                 return ((int)(this["OverlayModel"]));
             }
-            set
-            {
+            set {
                 this["OverlayModel"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("7")]
-        public int OverlayControllerAlignment
-        {
-            get
-            {
+        public int OverlayControllerAlignment {
+            get {
                 return ((int)(this["OverlayControllerAlignment"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerAlignment"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("300")]
-        public double OverlayControllerSize
-        {
-            get
-            {
+        public double OverlayControllerSize {
+            get {
                 return ((double)(this["OverlayControllerSize"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerSize"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1")]
-        public int OverlayTrackpadsAlignment
-        {
-            get
-            {
+        public int OverlayTrackpadsAlignment {
+            get {
                 return ((int)(this["OverlayTrackpadsAlignment"]));
             }
-            set
-            {
+            set {
                 this["OverlayTrackpadsAlignment"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0.25")]
-        public double OverlayTrackpadsOpacity
-        {
-            get
-            {
+        public double OverlayTrackpadsOpacity {
+            get {
                 return ((double)(this["OverlayTrackpadsOpacity"]));
             }
-            set
-            {
+            set {
                 this["OverlayTrackpadsOpacity"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("250")]
-        public double OverlayTrackpadsSize
-        {
-            get
-            {
+        public double OverlayTrackpadsSize {
+            get {
                 return ((double)(this["OverlayTrackpadsSize"]));
             }
-            set
-            {
+            set {
                 this["OverlayTrackpadsSize"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("en-US")]
-        public string CurrentCulture
-        {
-            get
-            {
+        public string CurrentCulture {
+            get {
                 return ((string)(this["CurrentCulture"]));
             }
-            set
-            {
+            set {
                 this["CurrentCulture"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double OverlayControllerRestingPitch
-        {
-            get
-            {
+        public double OverlayControllerRestingPitch {
+            get {
                 return ((double)(this["OverlayControllerRestingPitch"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerRestingPitch"] = value;
             }
         }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double OverlayControllerRestingYaw
-        {
-            get
-            {
-                return ((double)(this["OverlayControllerRestingYaw"]));
-            }
-            set
-            {
-                this["OverlayControllerRestingYaw"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double OverlayControllerRestingRoll
-        {
-            get
-            {
-                return ((double)(this["OverlayControllerRestingRoll"]));
-            }
-            set
-            {
-                this["OverlayControllerRestingRoll"] = value;
-            }
-        }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool SensorPlacementUpsideDown
-        {
-            get
-            {
+        public bool SensorPlacementUpsideDown {
+            get {
                 return ((bool)(this["SensorPlacementUpsideDown"]));
             }
-            set
-            {
+            set {
                 this["SensorPlacementUpsideDown"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("-1")]
-        public int SensorSelection
-        {
-            get
-            {
+        public int SensorSelection {
+            get {
                 return ((int)(this["SensorSelection"]));
             }
-            set
-            {
+            set {
                 this["SensorSelection"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int SensorPlacement
-        {
-            get
-            {
+        public int SensorPlacement {
+            get {
                 return ((int)(this["SensorPlacement"]));
             }
-            set
-            {
+            set {
                 this["SensorPlacement"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("30")]
-        public double OverlayRenderInterval
-        {
-            get
-            {
+        public double OverlayRenderInterval {
+            get {
                 return ((double)(this["OverlayRenderInterval"]));
             }
-            set
-            {
+            set {
                 this["OverlayRenderInterval"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool OverlayRenderAntialiasing
-        {
-            get
-            {
+        [global::System.Configuration.DefaultSettingValueAttribute("True")]
+        public bool OverlayRenderAntialiasing {
+            get {
                 return ((bool)(this["OverlayRenderAntialiasing"]));
             }
-            set
-            {
+            set {
                 this["OverlayRenderAntialiasing"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool OverlayFaceCamera
-        {
-            get
-            {
+        public bool OverlayFaceCamera {
+            get {
                 return ((bool)(this["OverlayFaceCamera"]));
             }
-            set
-            {
+            set {
                 this["OverlayFaceCamera"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("720")]
-        public double QuickToolsHeight
-        {
-            get
-            {
+        public double QuickToolsHeight {
+            get {
                 return ((double)(this["QuickToolsHeight"]));
             }
-            set
-            {
+            set {
                 this["QuickToolsHeight"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool ConfigurableTDPOverride
-        {
-            get
-            {
+        public bool ConfigurableTDPOverride {
+            get {
                 return ((bool)(this["ConfigurableTDPOverride"]));
             }
-            set
-            {
+            set {
                 this["ConfigurableTDPOverride"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double ConfigurableTDPOverrideUp
-        {
-            get
-            {
+        public double ConfigurableTDPOverrideUp {
+            get {
                 return ((double)(this["ConfigurableTDPOverrideUp"]));
             }
-            set
-            {
+            set {
                 this["ConfigurableTDPOverrideUp"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public double ConfigurableTDPOverrideDown
-        {
-            get
-            {
+        public double ConfigurableTDPOverrideDown {
+            get {
                 return ((double)(this["ConfigurableTDPOverrideDown"]));
             }
-            set
-            {
+            set {
                 this["ConfigurableTDPOverrideDown"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1")]
-        public double OverlayControllerOpacity
-        {
-            get
-            {
+        public double OverlayControllerOpacity {
+            get {
                 return ((double)(this["OverlayControllerOpacity"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerOpacity"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("#00000000")]
-        public string OverlayControllerBackgroundColor
-        {
-            get
-            {
+        public string OverlayControllerBackgroundColor {
+            get {
                 return ((string)(this["OverlayControllerBackgroundColor"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerBackgroundColor"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int MainWindowPrevState
-        {
-            get
-            {
+        public int MainWindowPrevState {
+            get {
                 return ((int)(this["MainWindowPrevState"]));
             }
-            set
-            {
+            set {
                 this["MainWindowPrevState"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool FirstStart
-        {
-            get
-            {
+        public bool FirstStart {
+            get {
                 return ((bool)(this["FirstStart"]));
             }
-            set
-            {
+            set {
                 this["FirstStart"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1")]
-        public int MainWindowBackdrop
-        {
-            get
-            {
+        public int MainWindowBackdrop {
+            get {
                 return ((int)(this["MainWindowBackdrop"]));
             }
-            set
-            {
+            set {
                 this["MainWindowBackdrop"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool UseEnergyStar
-        {
-            get
-            {
+        public bool UseEnergyStar {
+            get {
                 return ((bool)(this["UseEnergyStar"]));
             }
-            set
-            {
+            set {
                 this["UseEnergyStar"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("https://api.github.com/repos/Valkirie/HandheldCompanion")]
-        public string UpdateUrl
-        {
-            get
-            {
+        public string UpdateUrl {
+            get {
                 return ((string)(this["UpdateUrl"]));
             }
-            set
-            {
+            set {
                 this["UpdateUrl"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool OverlayControllerAlwaysOnTop
-        {
-            get
-            {
+        public bool OverlayControllerAlwaysOnTop {
+            get {
                 return ((bool)(this["OverlayControllerAlwaysOnTop"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerAlwaysOnTop"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool HIDuncloakonclose
-        {
-            get
-            {
+        public bool HIDuncloakonclose {
+            get {
                 return ((bool)(this["HIDuncloakonclose"]));
             }
-            set
-            {
+            set {
                 this["HIDuncloakonclose"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("100")]
-        public double VibrationStrength
-        {
-            get
-            {
+        public double VibrationStrength {
+            get {
                 return ((double)(this["VibrationStrength"]));
             }
-            set
-            {
+            set {
                 this["VibrationStrength"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("")]
-        public string HIDInstancePath
-        {
-            get
-            {
+        public string HIDInstancePath {
+            get {
                 return ((string)(this["HIDInstancePath"]));
             }
-            set
-            {
+            set {
                 this["HIDInstancePath"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool OverlayControllerMotion
-        {
-            get
-            {
+        public bool OverlayControllerMotion {
+            get {
                 return ((bool)(this["OverlayControllerMotion"]));
             }
-            set
-            {
+            set {
                 this["OverlayControllerMotion"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool SteamControllerMute
-        {
-            get
-            {
+        public bool SteamControllerMute {
+            get {
                 return ((bool)(this["SteamControllerMute"]));
             }
-            set
-            {
+            set {
                 this["SteamControllerMute"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool HIDcloakonconnect
-        {
-            get
-            {
+        public bool HIDcloakonconnect {
+            get {
                 return ((bool)(this["HIDcloakonconnect"]));
             }
-            set
-            {
+            set {
                 this["HIDcloakonconnect"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool HIDvibrateonconnect
-        {
-            get
-            {
+        public bool HIDvibrateonconnect {
+            get {
                 return ((bool)(this["HIDvibrateonconnect"]));
             }
-            set
-            {
+            set {
                 this["HIDvibrateonconnect"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool QuickToolsIsPaneOpen
-        {
-            get
-            {
+        public bool QuickToolsIsPaneOpen {
+            get {
                 return ((bool)(this["QuickToolsIsPaneOpen"]));
             }
-            set
-            {
+            set {
                 this["QuickToolsIsPaneOpen"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool LayoutFilterOnDevice
-        {
-            get
-            {
+        public bool LayoutFilterOnDevice {
+            get {
                 return ((bool)(this["LayoutFilterOnDevice"]));
             }
-            set
-            {
+            set {
                 this["LayoutFilterOnDevice"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("40")]
-        public double QuietModeDuty
-        {
-            get
-            {
+        public double QuietModeDuty {
+            get {
                 return ((double)(this["QuietModeDuty"]));
             }
-            set
-            {
+            set {
                 this["QuietModeDuty"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool QuietModeToggled
-        {
-            get
-            {
+        public bool QuietModeToggled {
+            get {
                 return ((bool)(this["QuietModeToggled"]));
             }
-            set
-            {
+            set {
                 this["QuietModeToggled"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool QuietModeEnabled
-        {
-            get
-            {
+        public bool QuietModeEnabled {
+            get {
                 return ((bool)(this["QuietModeEnabled"]));
             }
-            set
-            {
+            set {
                 this["QuietModeEnabled"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool MainWindowIsPaneOpen
-        {
-            get
-            {
+        public bool MainWindowIsPaneOpen {
+            get {
                 return ((bool)(this["MainWindowIsPaneOpen"]));
             }
-            set
-            {
+            set {
                 this["MainWindowIsPaneOpen"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool DesktopProfileOnStart
-        {
-            get
-            {
+        public bool DesktopProfileOnStart {
+            get {
                 return ((bool)(this["DesktopProfileOnStart"]));
             }
-            set
-            {
+            set {
                 this["DesktopProfileOnStart"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool QuietModeDisclosure
-        {
-            get
-            {
+        public bool QuietModeDisclosure {
+            get {
                 return ((bool)(this["QuietModeDisclosure"]));
             }
-            set
-            {
+            set {
                 this["QuietModeDisclosure"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int OnScreenDisplayLevel
-        {
-            get
-            {
+        public int OnScreenDisplayLevel {
+            get {
                 return ((int)(this["OnScreenDisplayLevel"]));
             }
-            set
-            {
+            set {
                 this["OnScreenDisplayLevel"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1000")]
-        public double OnScreenDisplayRefreshRate
-        {
-            get
-            {
+        public double OnScreenDisplayRefreshRate {
+            get {
                 return ((double)(this["OnScreenDisplayRefreshRate"]));
             }
-            set
-            {
+            set {
                 this["OnScreenDisplayRefreshRate"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("-1")]
-        public int NativeDisplayOrientation
-        {
-            get
-            {
+        public int NativeDisplayOrientation {
+            get {
                 return ((int)(this["NativeDisplayOrientation"]));
             }
-            set
-            {
+            set {
                 this["NativeDisplayOrientation"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool PlatformRTSSEnabled
-        {
-            get
-            {
+        public bool PlatformRTSSEnabled {
+            get {
                 return ((bool)(this["PlatformRTSSEnabled"]));
             }
-            set
-            {
+            set {
                 this["PlatformRTSSEnabled"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("3")]
-        public int QuickToolsLocation
-        {
-            get
-            {
+        [global::System.Configuration.DefaultSettingValueAttribute("1")]
+        public int QuickToolsLocation {
+            get {
                 return ((int)(this["QuickToolsLocation"]));
             }
-            set
-            {
+            set {
                 this["QuickToolsLocation"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1")]
-        public int QuicktoolsBackdrop
-        {
-            get
-            {
+        public int QuicktoolsBackdrop {
+            get {
                 return ((int)(this["QuicktoolsBackdrop"]));
             }
-            set
-            {
+            set {
                 this["QuicktoolsBackdrop"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool QuickToolsAutoHide
-        {
-            get
-            {
+        public bool QuickToolsAutoHide {
+            get {
                 return ((bool)(this["QuickToolsAutoHide"]));
             }
-            set
-            {
+            set {
                 this["QuickToolsAutoHide"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool ControllerManagement
-        {
-            get
-            {
+        public bool ControllerManagement {
+            get {
                 return ((bool)(this["ControllerManagement"]));
             }
-            set
-            {
+            set {
                 this["ControllerManagement"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        public global::System.Collections.Specialized.StringCollection SuspendedControllers
-        {
-            get
-            {
+        public global::System.Collections.Specialized.StringCollection SuspendedControllers {
+            get {
                 return ((global::System.Collections.Specialized.StringCollection)(this["SuspendedControllers"]));
             }
-            set
-            {
+            set {
                 this["SuspendedControllers"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool HidModeDoNotShowAgain
-        {
-            get
-            {
+        public bool HidModeDoNotShowAgain {
+            get {
                 return ((bool)(this["HidModeDoNotShowAgain"]));
             }
-            set
-            {
+            set {
                 this["HidModeDoNotShowAgain"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int HIDmode
-        {
-            get
-            {
+        public int HIDmode {
+            get {
                 return ((int)(this["HIDmode"]));
             }
-            set
-            {
+            set {
                 this["HIDmode"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("1")]
-        public int HIDstatus
-        {
-            get
-            {
+        public int HIDstatus {
+            get {
                 return ((int)(this["HIDstatus"]));
             }
-            set
-            {
+            set {
                 this["HIDstatus"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool DSUEnabled
-        {
-            get
-            {
+        public bool DSUEnabled {
+            get {
                 return ((bool)(this["DSUEnabled"]));
             }
-            set
-            {
+            set {
                 this["DSUEnabled"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("26760")]
-        public int DSUport
-        {
-            get
-            {
+        public int DSUport {
+            get {
                 return ((int)(this["DSUport"]));
             }
-            set
-            {
+            set {
                 this["DSUport"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("127.0.0.1")]
-        public string DSUip
-        {
-            get
-            {
+        public string DSUip {
+            get {
                 return ((string)(this["DSUip"]));
             }
-            set
-            {
+            set {
                 this["DSUip"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("50")]
-        public double LEDBrightness
-        {
-            get
-            {
+        public double LEDBrightness {
+            get {
                 return ((double)(this["LEDBrightness"]));
             }
-            set
-            {
+            set {
                 this["LEDBrightness"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("#FFFFFF00")]
-        public string LEDMainColor
-        {
-            get
-            {
+        public string LEDMainColor {
+            get {
                 return ((string)(this["LEDMainColor"]));
             }
-            set
-            {
+            set {
                 this["LEDMainColor"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool LEDAmbilightVerticalBlackBarDetection
-        {
-            get
-            {
+        public bool LEDAmbilightVerticalBlackBarDetection {
+            get {
                 return ((bool)(this["LEDAmbilightVerticalBlackBarDetection"]));
             }
-            set
-            {
+            set {
                 this["LEDAmbilightVerticalBlackBarDetection"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool LEDUseSecondColor
-        {
-            get
-            {
+        public bool LEDUseSecondColor {
+            get {
                 return ((bool)(this["LEDUseSecondColor"]));
             }
-            set
-            {
+            set {
                 this["LEDUseSecondColor"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("0")]
-        public int LEDSettingsLevel
-        {
-            get
-            {
+        public int LEDSettingsLevel {
+            get {
                 return ((int)(this["LEDSettingsLevel"]));
             }
-            set
-            {
+            set {
                 this["LEDSettingsLevel"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
-        public bool LEDSettingsEnabled
-        {
-            get
-            {
+        public bool LEDSettingsEnabled {
+            get {
                 return ((bool)(this["LEDSettingsEnabled"]));
             }
-            set
-            {
+            set {
                 this["LEDSettingsEnabled"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("#FFFFFF00")]
-        public string LEDSecondColor
-        {
-            get
-            {
+        public string LEDSecondColor {
+            get {
                 return ((string)(this["LEDSecondColor"]));
             }
-            set
-            {
+            set {
                 this["LEDSecondColor"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool LEDSettingsUseAccentColor
-        {
-            get
-            {
+        public bool LEDSettingsUseAccentColor {
+            get {
                 return ((bool)(this["LEDSettingsUseAccentColor"]));
             }
-            set
-            {
+            set {
                 this["LEDSettingsUseAccentColor"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("50")]
-        public double LEDSpeed
-        {
-            get
-            {
+        public double LEDSpeed {
+            get {
                 return ((double)(this["LEDSpeed"]));
             }
-            set
-            {
+            set {
                 this["LEDSpeed"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        public global::System.Collections.Specialized.StringCollection SuspendedDevices
-        {
-            get
-            {
+        public global::System.Collections.Specialized.StringCollection SuspendedDevices {
+            get {
                 return ((global::System.Collections.Specialized.StringCollection)(this["SuspendedDevices"]));
             }
-            set
-            {
+            set {
                 this["SuspendedDevices"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool LegionControllerPassthrough
-        {
-            get
-            {
+        public bool LegionControllerPassthrough {
+            get {
                 return ((bool)(this["LegionControllerPassthrough"]));
             }
-            set
-            {
+            set {
                 this["LegionControllerPassthrough"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool OnScreenDisplayToggle
-        {
-            get
-            {
+        public bool OnScreenDisplayToggle {
+            get {
                 return ((bool)(this["OnScreenDisplayToggle"]));
             }
-            set
-            {
+            set {
                 this["OnScreenDisplayToggle"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int LastOnScreenDisplayLevel
-        {
-            get
-            {
+        public int LastOnScreenDisplayLevel {
+            get {
                 return ((int)(this["LastOnScreenDisplayLevel"]));
             }
-            set
-            {
+            set {
                 this["LastOnScreenDisplayLevel"] = value;
             }
         }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayTimeLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayTimeLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayTimeLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayCPULevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayCPULevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayCPULevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayRAMLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayRAMLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayRAMLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayGPULevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayGPULevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayGPULevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayVRAMLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayVRAMLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayVRAMLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayBatteryLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayBatteryLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayBatteryLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayFPSLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayFPSLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayFPSLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("2")]
-        public int OnScreenDisplayBATTLevel
-        {
-            get
-            {
-                return ((int)(this["OnScreenDisplayBATTLevel"]));
-            }
-            set
-            {
-                this["OnScreenDisplayBATTLevel"] = value;
-            }
-        }
-
-        [global::System.Configuration.UserScopedSettingAttribute()]
-        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-        [global::System.Configuration.DefaultSettingValueAttribute("Time,GPU,CPU,VRAM,RAM,BATT,FPS")]
-        public string OnScreenDisplayOrder
-        {
-            get
-            {
-                return ((string)(this["OnScreenDisplayOrder"]));
-            }
-            set
-            {
-                this["OnScreenDisplayOrder"] = value;
-            }
-        }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
-        public bool UISounds
-        {
-            get
-            {
+        public bool UISounds {
+            get {
                 return ((bool)(this["UISounds"]));
             }
-            set
-            {
+            set {
                 this["UISounds"] = value;
             }
         }
diff --git a/HandheldCompanion/Sensors/IMUAccelerometer.cs b/HandheldCompanion/Sensors/IMUAccelerometer.cs
index 849892fd4..cb9de06c0 100644
--- a/HandheldCompanion/Sensors/IMUAccelerometer.cs
+++ b/HandheldCompanion/Sensors/IMUAccelerometer.cs
@@ -1,139 +1,139 @@
-using HandheldCompanion.Devices;
-using HandheldCompanion.Managers;
-using System;
-using System.Numerics;
-using Windows.Devices.Sensors;
-using static HandheldCompanion.Utils.DeviceUtils;
-
-namespace HandheldCompanion.Sensors;
-
-public class IMUAccelerometer : IMUSensor
-{
-    public IMUAccelerometer(SensorFamily sensorFamily, int updateInterval)
-    {
-        this.sensorFamily = sensorFamily;
-        this.updateInterval = updateInterval;
-
-        UpdateSensor();
-    }
-
-    public void UpdateSensor()
-    {
-        switch (sensorFamily)
-        {
-            case SensorFamily.Windows:
-                sensor = Accelerometer.GetDefault();
-                break;
-            case SensorFamily.SerialUSBIMU:
-                sensor = SerialUSBIMU.GetCurrent();
-                break;
-            case SensorFamily.Controller:
-                sensor = new object();
-                break;
-        }
-
-        if (sensor is null)
-        {
-            LogManager.LogWarning("{0} not initialised as a {1}", ToString(), sensorFamily.ToString());
-            return;
-        }
-
-        switch (sensorFamily)
-        {
-            case SensorFamily.Windows:
-                ((Accelerometer)sensor).ReportInterval = Math.Max(((Accelerometer)sensor).MinimumReportInterval, (uint)updateInterval);
-                LogManager.LogInformation("{0} initialised as a {1}. Report interval set to {2}ms", ToString(),
-                    sensorFamily.ToString(), updateInterval);
-                break;
-            case SensorFamily.SerialUSBIMU:
-                LogManager.LogInformation("{0} initialised as a {1}. Baud rate set to {2}", ToString(),
-                    sensorFamily.ToString(), ((SerialUSBIMU)sensor).GetInterval());
-                break;
-            case SensorFamily.Controller:
-                LogManager.LogInformation("{0} initialised as a {1}", ToString(), sensorFamily.ToString());
-                break;
-        }
-
-        StartListening();
-    }
-
-    public override void StartListening()
-    {
-        switch (sensorFamily)
-        {
-            case SensorFamily.Windows:
-                ((Accelerometer)sensor).ReadingChanged += ReadingChanged;
-                break;
-            case SensorFamily.SerialUSBIMU:
-                ((SerialUSBIMU)sensor).ReadingChanged += ReadingChanged;
-                break;
-        }
-    }
-
-    public override void StopListening()
-    {
-        if (sensor is null)
-            return;
-
-        switch (sensorFamily)
-        {
-            case SensorFamily.Windows:
-                ((Accelerometer)sensor).ReadingChanged -= ReadingChanged;
-                break;
-            case SensorFamily.SerialUSBIMU:
-                ((SerialUSBIMU)sensor).ReadingChanged -= ReadingChanged;
-                break;
-        }
-
-        sensor = null;
-
-        base.StopListening();
-    }
-
-    private void ReadingChanged(Vector3 AccelerationG, Vector3 AngularVelocityDeg, double timestamp)
-    {
-        reading.reading.X = AccelerationG.X;
-        reading.reading.Y = AccelerationG.Y;
-        reading.reading.Z = AccelerationG.Z;
-        reading.timestamp = timestamp;
-
-        base.ReadingChanged();
-    }
-
-    private void ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
-    {
-        foreach (char axis in reading_axis.Keys)
-        {
-            switch (IDevice.GetCurrent().AccelerometerAxisSwap[axis])
-            {
-                default:
-                case 'X':
-                    reading_axis[axis] = args.Reading.AccelerationX;
-                    break;
-                case 'Y':
-                    reading_axis[axis] = args.Reading.AccelerationY;
-                    break;
-                case 'Z':
-                    reading_axis[axis] = args.Reading.AccelerationZ;
-                    break;
-            }
-        }
-
-        reading.reading.X = (float)reading_axis['X'] * IDevice.GetCurrent().AccelerometerAxis.X;
-        reading.reading.Y = (float)reading_axis['Y'] * IDevice.GetCurrent().AccelerometerAxis.Y;
-        reading.reading.Z = (float)reading_axis['Z'] * IDevice.GetCurrent().AccelerometerAxis.Z;
-        reading.timestamp = args.Reading.Timestamp.DateTime.TimeOfDay.TotalMilliseconds;
-
-        base.ReadingChanged();
-    }
-
-    private void Shaken(Accelerometer sender, AccelerometerShakenEventArgs args)
-    {
-        // throw new NotImplementedException();
-    }
-
-    public new SensorReading GetCurrentReading(bool center = false, bool ratio = false)
-    {
-        return this.reading;
-    }
+using HandheldCompanion.Devices;
+using HandheldCompanion.Managers;
+using System;
+using System.Numerics;
+using Windows.Devices.Sensors;
+using static HandheldCompanion.Utils.DeviceUtils;
+
+namespace HandheldCompanion.Sensors;
+
+public class IMUAccelerometer : IMUSensor
+{
+    public IMUAccelerometer(SensorFamily sensorFamily, int updateInterval)
+    {
+        this.sensorFamily = sensorFamily;
+        this.updateInterval = updateInterval;
+
+        UpdateSensor();
+    }
+
+    public void UpdateSensor()
+    {
+        switch (sensorFamily)
+        {
+            case SensorFamily.Windows:
+                sensor = Accelerometer.GetDefault();
+                break;
+            case SensorFamily.SerialUSBIMU:
+                sensor = SerialUSBIMU.GetCurrent();
+                break;
+            case SensorFamily.Controller:
+                sensor = new object();
+                break;
+        }
+
+        if (sensor is null)
+        {
+            LogManager.LogWarning("{0} not initialised as a {1}", ToString(), sensorFamily.ToString());
+            return;
+        }
+
+        switch (sensorFamily)
+        {
+            case SensorFamily.Windows:
+                ((Accelerometer)sensor).ReportInterval = Math.Max(((Accelerometer)sensor).MinimumReportInterval, (uint)updateInterval);
+                LogManager.LogInformation("{0} initialised as a {1}. Report interval set to {2}ms", ToString(),
+                    sensorFamily.ToString(), updateInterval);
+                break;
+            case SensorFamily.SerialUSBIMU:
+                LogManager.LogInformation("{0} initialised as a {1}. Baud rate set to {2}", ToString(),
+                    sensorFamily.ToString(), ((SerialUSBIMU)sensor).GetInterval());
+                break;
+            case SensorFamily.Controller:
+                LogManager.LogInformation("{0} initialised as a {1}", ToString(), sensorFamily.ToString());
+                break;
+        }
+
+        StartListening();
+    }
+
+    public override void StartListening()
+    {
+        switch (sensorFamily)
+        {
+            case SensorFamily.Windows:
+                ((Accelerometer)sensor).ReadingChanged += ReadingChanged;
+                break;
+            case SensorFamily.SerialUSBIMU:
+                ((SerialUSBIMU)sensor).ReadingChanged += ReadingChanged;
+                break;
+        }
+    }
+
+    public override void StopListening()
+    {
+        if (sensor is null)
+            return;
+
+        switch (sensorFamily)
+        {
+            case SensorFamily.Windows:
+                ((Accelerometer)sensor).ReadingChanged -= ReadingChanged;
+                break;
+            case SensorFamily.SerialUSBIMU:
+                ((SerialUSBIMU)sensor).ReadingChanged -= ReadingChanged;
+                break;
+        }
+
+        sensor = null;
+
+        base.StopListening();
+    }
+
+    private void ReadingChanged(Vector3 AccelerationG, Vector3 AngularVelocityDeg, double timestamp)
+    {
+        reading.reading.X = AccelerationG.X;
+        reading.reading.Y = AccelerationG.Y;
+        reading.reading.Z = AccelerationG.Z;
+        reading.timestamp = timestamp;
+
+        base.ReadingChanged();
+    }
+
+    private void ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
+    {
+        foreach (char axis in reading_axis.Keys)
+        {
+            switch (IDevice.GetCurrent().AccelerometerAxisSwap[axis])
+            {
+                default:
+                case 'X':
+                    reading_axis[axis] = args.Reading.AccelerationX;
+                    break;
+                case 'Y':
+                    reading_axis[axis] = args.Reading.AccelerationY;
+                    break;
+                case 'Z':
+                    reading_axis[axis] = args.Reading.AccelerationZ;
+                    break;
+            }
+        }
+
+        reading.reading.X = (float)reading_axis['X'] * IDevice.GetCurrent().AccelerometerAxis.X;
+        reading.reading.Y = (float)reading_axis['Y'] * IDevice.GetCurrent().AccelerometerAxis.Y;
+        reading.reading.Z = (float)reading_axis['Z'] * IDevice.GetCurrent().AccelerometerAxis.Z;
+        reading.timestamp = args.Reading.Timestamp.DateTime.TimeOfDay.TotalMilliseconds;
+
+        base.ReadingChanged();
+    }
+
+    private void Shaken(Accelerometer sender, AccelerometerShakenEventArgs args)
+    {
+        // throw new NotImplementedException();
+    }
+
+    public new SensorReading GetCurrentReading(bool center = false, bool ratio = false)
+    {
+        return this.reading;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Styles/NavigationView.xaml b/HandheldCompanion/Styles/NavigationView.xaml
index f4127fb4b..f837c1586 100644
--- a/HandheldCompanion/Styles/NavigationView.xaml
+++ b/HandheldCompanion/Styles/NavigationView.xaml
@@ -5,15 +5,6 @@
     xmlns:local="http://schemas.inkore.net/lib/ui/wpf/modern"
     xmlns:primitives="http://schemas.inkore.net/lib/ui/wpf/modern"
     xmlns:ui="http://schemas.inkore.net/lib/ui/wpf/modern">
-    <ResourceDictionary.MergedDictionaries>
-        <ResourceDictionary Source="/iNKORE.UI.WPF.Modern;component/Themes/Styles/Button.xaml" />
-        <ResourceDictionary>
-            <ui:BindingProxy x:Key="OverlayCornerRadiusProxy" Value="{DynamicResource OverlayCornerRadius}" />
-            <ui:CornerRadiusFilterConverter x:Key="RightCornerRadiusFilterConverter" Filter="Right" />
-            <ui:CornerRadiusFilterConverter x:Key="TopLeftCornerRadiusDoubleValueConverter" Filter="TopLeftValue" />
-            <ui:CornerRadiusFilterConverter x:Key="BottomRightCornerRadiusDoubleValueConverter" Filter="BottomRightValue" />
-        </ResourceDictionary>
-    </ResourceDictionary.MergedDictionaries>
 
     <Style x:Key="DefaultContentControlStyle" TargetType="ContentControl">
         <Setter Property="HorizontalContentAlignment" Value="Left" />
diff --git a/HandheldCompanion/Targets/DualShock4Target.cs b/HandheldCompanion/Targets/DualShock4Target.cs
index 442603ea2..1d519353f 100644
--- a/HandheldCompanion/Targets/DualShock4Target.cs
+++ b/HandheldCompanion/Targets/DualShock4Target.cs
@@ -29,34 +29,39 @@ public DualShock4Target() : base()
             LogManager.LogInformation("{0} initialized, {1}", ToString(), virtualController);
         }
 
-        public override void Connect()
+        public override bool Connect()
         {
             if (IsConnected)
-                return;
+                return true;
 
             try
             {
                 virtualController.Connect();
-
-                base.Connect();
+                return base.Connect();
             }
-            catch (Exception ex)
+            catch(Exception ex)
             {
                 virtualController?.Disconnect();
                 LogManager.LogWarning("Failed to connect {0}. {1}", this.ToString(), ex.Message);
+                return false;
             }
         }
 
-        public override void Disconnect()
+        public override bool Disconnect()
         {
+            if (!IsConnected)
+                return true;
+
             try
             {
-                if (virtualController != null)
-                    virtualController.Disconnect();
-
-                base.Disconnect();
+                virtualController?.Disconnect();
+                return base.Disconnect();
+            }
+            catch (Exception ex)
+            {
+                LogManager.LogWarning("Failed to disconnect {0}. {1}", this.ToString(), ex.Message);
+                return false;
             }
-            catch { }
         }
 
         public void FeedbackReceived(object sender, DualShock4FeedbackReceivedEventArgs e)
diff --git a/HandheldCompanion/Targets/ViGEmTarget.cs b/HandheldCompanion/Targets/ViGEmTarget.cs
index 4d515f7a0..130ad1712 100644
--- a/HandheldCompanion/Targets/ViGEmTarget.cs
+++ b/HandheldCompanion/Targets/ViGEmTarget.cs
@@ -38,18 +38,22 @@ protected virtual void SendVibrate(byte LargeMotor, byte SmallMotor)
             Vibrated?.Invoke(LargeMotor, SmallMotor);
         }
 
-        public virtual void Connect()
+        public virtual bool Connect()
         {
             IsConnected = true;
             Connected?.Invoke(this);
             LogManager.LogInformation("{0} connected", ToString());
+
+            return true;
         }
 
-        public virtual void Disconnect()
+        public virtual bool Disconnect()
         {
             IsConnected = false;
             Disconnected?.Invoke(this);
             LogManager.LogInformation("{0} disconnected", ToString());
+
+            return true;
         }
 
         public virtual void UpdateInputs(ControllerState inputs, GamepadMotion gamepadMotion)
diff --git a/HandheldCompanion/Targets/Xbox360Target.cs b/HandheldCompanion/Targets/Xbox360Target.cs
index 865263d65..6faec360f 100644
--- a/HandheldCompanion/Targets/Xbox360Target.cs
+++ b/HandheldCompanion/Targets/Xbox360Target.cs
@@ -26,34 +26,39 @@ public Xbox360Target(ushort vendorId, ushort productId) : base()
             LogManager.LogInformation("{0} initialized, {1}", ToString(), virtualController);
         }
 
-        public override void Connect()
+        public override bool Connect()
         {
             if (IsConnected)
-                return;
+                return true;
 
             try
             {
                 virtualController.Connect();
-
-                base.Connect();
+                return base.Connect();
             }
             catch (Exception ex)
             {
                 virtualController?.Disconnect();
                 LogManager.LogWarning("Failed to connect {0}. {1}", this.ToString(), ex.Message);
+                return false;
             }
         }
 
-        public override void Disconnect()
+        public override bool Disconnect()
         {
+            if (!IsConnected)
+                return true;
+
             try
             {
-                if (virtualController != null)
-                    virtualController.Disconnect();
-
-                base.Disconnect();
+                virtualController?.Disconnect();
+                return base.Disconnect();
+            }
+            catch (Exception ex)
+            {
+                LogManager.LogWarning("Failed to disconnect {0}. {1}", this.ToString(), ex.Message);
+                return false;
             }
-            catch { }
         }
 
         public void FeedbackReceived(object sender, Xbox360FeedbackReceivedEventArgs e)
diff --git a/HandheldCompanion/Utils/HIDUtils.cs b/HandheldCompanion/Utils/HIDUtils.cs
index 4999d921c..64b9566c4 100644
--- a/HandheldCompanion/Utils/HIDUtils.cs
+++ b/HandheldCompanion/Utils/HIDUtils.cs
@@ -1,15 +1,15 @@
-namespace HandheldCompanion.Utils;
-
-public enum HIDmode
-{
-    NotSelected = -1,
-    Xbox360Controller = 0,
-    DualShock4Controller = 1,
-    NoController = 2
-}
-
-public enum HIDstatus
-{
-    Disconnected = 0,
-    Connected = 1
+namespace HandheldCompanion.Utils;
+
+public enum HIDmode
+{
+    NotSelected = -1,
+    Xbox360Controller = 0,
+    DualShock4Controller = 1,
+    NoController = 2
+}
+
+public enum HIDstatus
+{
+    Disconnected = 0,
+    Connected = 1
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Utils/RegistryUtils.cs b/HandheldCompanion/Utils/RegistryUtils.cs
index 5d835d512..2734457ba 100644
--- a/HandheldCompanion/Utils/RegistryUtils.cs
+++ b/HandheldCompanion/Utils/RegistryUtils.cs
@@ -1,87 +1,87 @@
-using Microsoft.Win32;
-using System;
-
-namespace HandheldCompanion.Utils;
-
-public static class RegistryUtils
-{
-    private const string HKLM = @"HKEY_LOCAL_MACHINE";
-
-    private static object GetValue(string key, string valueName)
-    {
-        var keyName = HKLM + "\\" + key;
-        return Registry.GetValue(keyName, valueName, null);
-    }
-
-    public static void SetValue(string key, string valueName, object value)
-    {
-        var keyName = HKLM + "\\" + key;
-        Registry.SetValue(keyName, valueName, value);
-    }
-
-    public static bool KeyExists(string key, string valueName)
-    {
-        var keyName = HKLM + "\\" + key;
-        return Registry.GetValue(keyName, valueName, null) != null;
-    }
-
-    public static string GetString(string key, string valueName)
-    {
-        return Convert.ToString(GetValue(key, valueName));
-    }
-
-    public static int GetInt(string key, string valueName)
-    {
-        try
-        {
-            return Convert.ToInt32(GetValue(key, valueName));
-        }
-        catch { }
-
-        return 0;
-    }
-
-    public static bool GetBoolean(string key, string valueName)
-    {
-        try
-        {
-            return Convert.ToBoolean(GetValue(key, valueName));
-        }
-        catch { }
-
-        return false;
-    }
-
-    public static bool SearchForKeyValue(string key, string valueName, string value)
-    {
-        // Open the root registry key for reading
-        RegistryKey root = Registry.LocalMachine.OpenSubKey(key);
-
-        // Check if the root key exists
-        if (root != null)
-        {
-            // Get the names of the subkeys under the root key
-            string[] subkeys = root.GetSubKeyNames();
-
-            // Loop through each subkey
-            foreach (string subkey in subkeys)
-            {
-                // Open the subkey for reading
-                RegistryKey subKey = root.OpenSubKey(subkey);
-
-                // Check if the subkey exists and has a value named DeviceDesc
-                if (subKey != null && subKey.GetValue(valueName) != null)
-                {
-                    // Get the value of DeviceDesc as a string
-                    string subKeyDesc = subKey.GetValue(valueName).ToString();
-
-                    // Check if the value contains the target strings
-                    if (subKeyDesc.Contains(value, StringComparison.InvariantCultureIgnoreCase))
-                        return true;
-                }
-            }
-        }
-
-        return false;
-    }
+using Microsoft.Win32;
+using System;
+
+namespace HandheldCompanion.Utils;
+
+public static class RegistryUtils
+{
+    private const string HKLM = @"HKEY_LOCAL_MACHINE";
+
+    private static object GetValue(string key, string valueName)
+    {
+        var keyName = HKLM + "\\" + key;
+        return Registry.GetValue(keyName, valueName, null);
+    }
+
+    public static void SetValue(string key, string valueName, object value)
+    {
+        var keyName = HKLM + "\\" + key;
+        Registry.SetValue(keyName, valueName, value);
+    }
+
+    public static bool KeyExists(string key, string valueName)
+    {
+        var keyName = HKLM + "\\" + key;
+        return Registry.GetValue(keyName, valueName, null) != null;
+    }
+
+    public static string GetString(string key, string valueName)
+    {
+        return Convert.ToString(GetValue(key, valueName));
+    }
+
+    public static int GetInt(string key, string valueName)
+    {
+        try
+        {
+            return Convert.ToInt32(GetValue(key, valueName));
+        }
+        catch { }
+
+        return 0;
+    }
+
+    public static bool GetBoolean(string key, string valueName)
+    {
+        try
+        {
+            return Convert.ToBoolean(GetValue(key, valueName));
+        }
+        catch { }
+
+        return false;
+    }
+
+    public static bool SearchForKeyValue(string key, string valueName, string value)
+    {
+        // Open the root registry key for reading
+        RegistryKey root = Registry.LocalMachine.OpenSubKey(key);
+
+        // Check if the root key exists
+        if (root != null)
+        {
+            // Get the names of the subkeys under the root key
+            string[] subkeys = root.GetSubKeyNames();
+
+            // Loop through each subkey
+            foreach (string subkey in subkeys)
+            {
+                // Open the subkey for reading
+                RegistryKey subKey = root.OpenSubKey(subkey);
+
+                // Check if the subkey exists and has a value named DeviceDesc
+                if (subKey != null && subKey.GetValue(valueName) != null)
+                {
+                    // Get the value of DeviceDesc as a string
+                    string subKeyDesc = subKey.GetValue(valueName).ToString();
+
+                    // Check if the value contains the target strings
+                    if (subKeyDesc.Contains(value, StringComparison.InvariantCultureIgnoreCase))
+                        return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Utils/ServiceUtils.cs b/HandheldCompanion/Utils/ServiceUtils.cs
index c1845f98d..063b9210b 100644
--- a/HandheldCompanion/Utils/ServiceUtils.cs
+++ b/HandheldCompanion/Utils/ServiceUtils.cs
@@ -1,136 +1,136 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.InteropServices;
-using System.ServiceProcess;
-
-namespace HandheldCompanion.Utils
-{
-    [SuppressMessage("ReSharper", "InconsistentNaming")]
-    [SuppressMessage("ReSharper", "UnusedMember.Local")]
-    [SuppressMessage("ReSharper", "FieldCanBeMadeReadOnly.Local")]
-    static class ServiceUtils
-    {
-        private const uint SERVICE_NO_CHANGE = 0xFFFFFFFF;
-        private const uint SERVICE_QUERY_CONFIG = 0x00000001;
-        private const uint SERVICE_CHANGE_CONFIG = 0x00000002;
-
-
-        [StructLayout(LayoutKind.Sequential)]
-        private sealed class SERVICE_STATUS_PROCESS
-        {
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwServiceType;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwCurrentState;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwControlsAccepted;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwWin32ExitCode;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwServiceSpecificExitCode;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwCheckPoint;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwWaitHint;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwProcessId;
-            [MarshalAs(UnmanagedType.U4)]
-            private uint dwServiceFlags;
-        }
-
-        private const uint SC_MANAGER_ALL_ACCESS = 0x000F003F;
-        private const int ERROR_INSUFFICIENT_BUFFER = 0x7a;
-        private const int SC_STATUS_PROCESS_INFO = 0;
-        private const uint SC_MANAGER_CONNECT = 0x0001;
-        private const uint SC_MANAGER_ENUMERATE_SERVICE = 0x0004;
-
-
-        [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
-        private static extern bool ChangeServiceConfig(
-            IntPtr hService,
-            uint nServiceType,
-            uint nStartType,
-            uint nErrorControl,
-            string lpBinaryPathName,
-            string lpLoadOrderGroup,
-            IntPtr lpdwTagId,
-            [In] char[] lpDependencies,
-            string lpServiceStartName,
-            string lpPassword,
-            string lpDisplayName);
-
-        [StructLayout(LayoutKind.Sequential)]
-        private struct SERVICE_FAILURE_ACTIONS
-        {
-            private int dwResetPeriod;
-            [MarshalAs(UnmanagedType.LPTStr)]
-            private string lpRebootMsg;
-            [MarshalAs(UnmanagedType.LPTStr)]
-            private string lpCommand;
-            private int cActions;
-            private IntPtr lpsaActions;
-        }
-
-        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
-        private static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);
-
-        [DllImport("advapi32.dll", EntryPoint = "OpenSCManagerW", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true)]
-        private static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);
-
-        [DllImport("advapi32.dll", EntryPoint = "CloseServiceHandle")]
-        private static extern int CloseServiceHandle(IntPtr hSCObject);
-
-        [DllImport("advapi32.dll", SetLastError = true)]
-        private static extern bool QueryServiceStatusEx(SafeHandle hService, int infoLevel, IntPtr lpBuffer, uint cbBufSize, out uint pcbBytesNeeded);
-
-        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static extern bool ChangeServiceConfig2(
-            IntPtr hService,
-            int dwInfoLevel,
-            IntPtr lpInfo);
-
-        /// <summary>
-        /// Change the startup mode for the provided service
-        /// </summary>
-        /// <param name="svc"></param>
-        /// <param name="mode"></param>
-        /// <param name="error"></param>
-        /// <returns></returns>
-        public static bool ChangeStartMode(ServiceController svc, ServiceStartMode mode, out string error)
-        {
-            error = "";
-
-            var hManager = IntPtr.Zero;
-            var hService = IntPtr.Zero;
-
-            try
-            {
-                // open the service manager
-                hManager = OpenSCManager(null, null, SC_MANAGER_CONNECT + SC_MANAGER_ENUMERATE_SERVICE);
-                if (hManager == IntPtr.Zero)
-                    return false;
-
-                // open the service
-                hService = OpenService(hManager, svc.ServiceName, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG);
-                if (hService == IntPtr.Zero)
-                    return false;
-
-                // set the new startup config
-                bool result = ChangeServiceConfig(hService, SERVICE_NO_CHANGE, (uint)mode, SERVICE_NO_CHANGE, null, null,
-                    IntPtr.Zero, null, null, null, null);
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return false;
-            }
-            finally
-            {
-                if (hService != IntPtr.Zero) CloseServiceHandle(hService);
-                if (hManager != IntPtr.Zero) CloseServiceHandle(hManager);
-            }
-        }
-    }
-}
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.ServiceProcess;
+
+namespace HandheldCompanion.Utils
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    [SuppressMessage("ReSharper", "UnusedMember.Local")]
+    [SuppressMessage("ReSharper", "FieldCanBeMadeReadOnly.Local")]
+    static class ServiceUtils
+    {
+        private const uint SERVICE_NO_CHANGE = 0xFFFFFFFF;
+        private const uint SERVICE_QUERY_CONFIG = 0x00000001;
+        private const uint SERVICE_CHANGE_CONFIG = 0x00000002;
+
+
+        [StructLayout(LayoutKind.Sequential)]
+        private sealed class SERVICE_STATUS_PROCESS
+        {
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwServiceType;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwCurrentState;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwControlsAccepted;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwWin32ExitCode;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwServiceSpecificExitCode;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwCheckPoint;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwWaitHint;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwProcessId;
+            [MarshalAs(UnmanagedType.U4)]
+            private uint dwServiceFlags;
+        }
+
+        private const uint SC_MANAGER_ALL_ACCESS = 0x000F003F;
+        private const int ERROR_INSUFFICIENT_BUFFER = 0x7a;
+        private const int SC_STATUS_PROCESS_INFO = 0;
+        private const uint SC_MANAGER_CONNECT = 0x0001;
+        private const uint SC_MANAGER_ENUMERATE_SERVICE = 0x0004;
+
+
+        [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern bool ChangeServiceConfig(
+            IntPtr hService,
+            uint nServiceType,
+            uint nStartType,
+            uint nErrorControl,
+            string lpBinaryPathName,
+            string lpLoadOrderGroup,
+            IntPtr lpdwTagId,
+            [In] char[] lpDependencies,
+            string lpServiceStartName,
+            string lpPassword,
+            string lpDisplayName);
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct SERVICE_FAILURE_ACTIONS
+        {
+            private int dwResetPeriod;
+            [MarshalAs(UnmanagedType.LPTStr)]
+            private string lpRebootMsg;
+            [MarshalAs(UnmanagedType.LPTStr)]
+            private string lpCommand;
+            private int cActions;
+            private IntPtr lpsaActions;
+        }
+
+        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        private static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);
+
+        [DllImport("advapi32.dll", EntryPoint = "OpenSCManagerW", ExactSpelling = true, CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);
+
+        [DllImport("advapi32.dll", EntryPoint = "CloseServiceHandle")]
+        private static extern int CloseServiceHandle(IntPtr hSCObject);
+
+        [DllImport("advapi32.dll", SetLastError = true)]
+        private static extern bool QueryServiceStatusEx(SafeHandle hService, int infoLevel, IntPtr lpBuffer, uint cbBufSize, out uint pcbBytesNeeded);
+
+        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool ChangeServiceConfig2(
+            IntPtr hService,
+            int dwInfoLevel,
+            IntPtr lpInfo);
+
+        /// <summary>
+        /// Change the startup mode for the provided service
+        /// </summary>
+        /// <param name="svc"></param>
+        /// <param name="mode"></param>
+        /// <param name="error"></param>
+        /// <returns></returns>
+        public static bool ChangeStartMode(ServiceController svc, ServiceStartMode mode, out string error)
+        {
+            error = "";
+
+            var hManager = IntPtr.Zero;
+            var hService = IntPtr.Zero;
+
+            try
+            {
+                // open the service manager
+                hManager = OpenSCManager(null, null, SC_MANAGER_CONNECT + SC_MANAGER_ENUMERATE_SERVICE);
+                if (hManager == IntPtr.Zero)
+                    return false;
+
+                // open the service
+                hService = OpenService(hManager, svc.ServiceName, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG);
+                if (hService == IntPtr.Zero)
+                    return false;
+
+                // set the new startup config
+                bool result = ChangeServiceConfig(hService, SERVICE_NO_CHANGE, (uint)mode, SERVICE_NO_CHANGE, null, null,
+                    IntPtr.Zero, null, null, null, null);
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                return false;
+            }
+            finally
+            {
+                if (hService != IntPtr.Zero) CloseServiceHandle(hService);
+                if (hManager != IntPtr.Zero) CloseServiceHandle(hManager);
+            }
+        }
+    }
+}
diff --git a/HandheldCompanion/Utils/WPFUtils.cs b/HandheldCompanion/Utils/WPFUtils.cs
index 322c0665c..e3ba97ae6 100644
--- a/HandheldCompanion/Utils/WPFUtils.cs
+++ b/HandheldCompanion/Utils/WPFUtils.cs
@@ -1,375 +1,375 @@
-using iNKORE.UI.WPF.Modern.Controls;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
-using System.Windows.Interop;
-using System.Windows.Media;
-using Control = System.Windows.Controls.Control;
-
-namespace HandheldCompanion.Utils;
-
-public static class WPFUtils
-{
-    public const int WM_KEYDOWN = 0x0100;
-    public const int WM_CHANGEUISTATE = 0x0127;
-    public const int UIS_SET = 1;
-    public const int UIS_CLEAR = 2;
-    public const int UISF_HIDEFOCUS = 0x1;
-
-    [DllImport("user32.dll")]
-    public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
-
-    public static HwndSource GetControlHandle(Control control)
-    {
-        return PresentationSource.FromVisual(control) as HwndSource;
-    }
-
-    public static void MakeFocusVisible(Control c)
-    {
-        IntPtr hWnd = GetControlHandle(c).Handle;
-        // SendMessage(hWnd, WM_CHANGEUISTATE, (IntPtr)MakeLong((int)UIS_CLEAR, (int)UISF_HIDEFOCUS), IntPtr.Zero);
-        SendMessage(hWnd, 257, (IntPtr)0x0000000000000009, (IntPtr)0x00000000c00f0001);
-    }
-
-    public static void MakeFocusInvisible(Control c)
-    {
-        IntPtr hWnd = GetControlHandle(c).Handle;
-        SendMessage(hWnd, WM_CHANGEUISTATE, (IntPtr)MakeLong((int)UIS_SET, (int)UISF_HIDEFOCUS), IntPtr.Zero);
-    }
-
-    public static int MakeLong(int wLow, int wHigh)
-    {
-        int low = (int)IntLoWord(wLow);
-        short high = IntLoWord(wHigh);
-        int product = 0x10000 * (int)high;
-        int mkLong = (int)(low | product);
-        return mkLong;
-    }
-
-    private static short IntLoWord(int word)
-    {
-        return (short)(word & short.MaxValue);
-    }
-
-    // A function that takes a list of controls and returns the top-left control
-    public static Control GetTopLeftControl<T>(List<Control> controls) where T : Control
-    {
-        // filter list
-        controls = controls.Where(c => c is T).ToList();
-
-        // If no controls are found, return null
-        if (controls == null || controls.Count == 0)
-        {
-            return null;
-        }
-
-        // Initialize the top left control with the first element of the list
-        Control topLeft = controls[0];
-
-        // Browse other list items
-        for (int i = 1; i < controls.Count; i++)
-        {
-            // Get current control
-            Control current = controls[i];
-
-            // Compare the Canvas.Top and Canvas.Left properties of the current control with those of the top-left control
-            // If the current control is farther up or to the left, replace it with the farthest control to the left
-            if (Canvas.GetTop(current) < Canvas.GetTop(topLeft) || (Canvas.GetTop(current) == Canvas.GetTop(topLeft) && Canvas.GetLeft(current) < Canvas.GetLeft(topLeft)))
-            {
-                topLeft = current;
-            }
-        }
-
-        // Return the top left control
-        return topLeft;
-    }
-
-    public enum Direction { None, Left, Right, Up, Down }
-
-    public static Control GetClosestControl<T>(Control source, List<Control> controls, Direction direction, List<Type> typesToIgnore = null) where T : Control
-    {
-        // Filter list based on requested type
-        controls = controls.Where(c => c is T).ToList();
-
-        // Filter based on exclusion type list
-        if (typesToIgnore is not null)
-            controls = controls.Where(c => !typesToIgnore.Contains(c.GetType())).ToList();
-
-        // Filter out the controls that are not in the given direction
-        controls = controls.Where(c => c != source && IsInDirection(source, c, direction)).ToList();
-
-        // If no controls are found, return source
-        if (controls.Count == 0) return source;
-
-        // Find the control with the same parent and the minimum distance to the source
-        // If no control has the same parent, find the control with the minimum distance to the source
-        controls = controls.OrderBy(c => GetDistanceV2(source, c, direction)).ToList();
-
-        return controls.First();
-    }
-
-    // Helper method to check if a control is in a given direction from another control
-    private static bool IsInDirection(Control source, Control target, Direction direction)
-    {
-        // Get the position of the target on the canvas
-        var p = target.TranslatePoint(new Point(0, 0), source);
-        double x = Math.Round(p.X);
-        double y = Math.Round(p.Y);
-
-        switch (direction)
-        {
-            case Direction.Left:
-                return x + (target.ActualWidth / 2) <= 0;
-            case Direction.Right:
-                return x >= (source.ActualWidth / 2);
-            case Direction.Up:
-                return y + (target.ActualHeight / 2) <= 0;
-            case Direction.Down:
-                return y >= (source.ActualHeight / 2);
-            default:
-                return false;
-        }
-    }
-
-    // Helper method to calculate the distance between the centers of two controls
-    private static double GetDistance(Control source, Control target, Direction direction)
-    {
-        try
-        {
-            // Get the relative position of the target with respect to the source
-            var transform = target.TransformToVisual(source);
-            var position = transform.Transform(new Point(0, 0));
-
-            double dx = source.ActualWidth / 2 - (position.X + target.ActualWidth / 2);
-            double dy = source.ActualHeight / 2 - (position.Y + target.ActualHeight / 2);
-
-            switch (direction)
-            {
-                case Direction.Up:
-                case Direction.Down:
-                    return Math.Sqrt(dy * dy);
-
-                case Direction.Left:
-                case Direction.Right:
-                    return Math.Sqrt(dx * dx);
-            }
-
-            return Math.Sqrt(dx * dx + dy * dy);
-        }
-        catch { }
-
-        return 9999.0d;
-    }
-
-    public static double GetDistanceV2(Control c1, Control c2, Direction direction)
-    {
-        try
-        {
-            // We retrieve the control's bounding box
-            Rect r1 = c1.TransformToVisual(c1).TransformBounds(new Rect(c1.RenderSize));
-            Rect r2 = c2.TransformToVisual(c1).TransformBounds(new Rect(c2.RenderSize));
-
-            // Calculate the horizontal and vertical distances between the edges of the rectangles
-            double dx = Math.Max(0, Math.Max(r1.Left, r2.Left) - Math.Min(r1.Right, r2.Right));
-            double dy = Math.Max(0, Math.Max(r1.Top, r2.Top) - Math.Min(r1.Bottom, r2.Bottom));
-
-            // Return the Euclidean distance between the nearest edges
-            return Math.Sqrt(dx * dx + dy * dy);
-        }
-        catch { }
-
-        return 9999.0d;
-    }
-
-    // This function takes two controls and returns their distance in pixels
-    private static double GetDistanceV3(Control c1, Control c2, Direction direction)
-    {
-        try
-        {
-            // Get the position of each control relative to the screen
-            Point p1 = c1.PointToScreen(new Point(0, 0));
-            Point p2 = c2.PointToScreen(new Point(0, 0));
-
-            // Convert the points to vectors
-            Vector3 v1 = new Vector3((float)p1.X, (float)p1.Y, 0f);
-            Vector3 v2 = new Vector3((float)p2.X, (float)p2.Y, 0f);
-
-            switch (direction)
-            {
-                case Direction.Up:
-                case Direction.Down:
-                    v1 = new Vector3(0f, (float)p1.Y, 0f);
-                    v2 = new Vector3(0f, (float)p2.Y, 0f);
-                    break;
-
-                case Direction.Left:
-                case Direction.Right:
-                    v1 = new Vector3((float)p1.X, 0f, 0f);
-                    v2 = new Vector3((float)p2.X, 0f, 0f);
-                    break;
-            }
-
-            // Calculate and return the distance between the vectors
-            return Vector3.Distance(v1, v2);
-        }
-        catch { }
-
-        return 9999.0d;
-    }
-
-    public static List<FrameworkElement> FindChildren(DependencyObject startNode)
-    {
-        int count = VisualTreeHelper.GetChildrenCount(startNode);
-        List<FrameworkElement> childs = new();
-
-        for (int i = 0; i < count; i++)
-        {
-            DependencyObject current = VisualTreeHelper.GetChild(startNode, i);
-
-            string currentType = current.GetType().Name;
-            switch (currentType)
-            {
-                case "TextBox":
-                    {
-                        TextBox textBox = (TextBox)current;
-                        if (!textBox.IsReadOnly)
-                            goto case "Slider";
-                    }
-                    break;
-
-                case "RepeatButton":
-                    {
-                        RepeatButton repeatButton = (RepeatButton)current;
-                        if (!repeatButton.Name.StartsWith("PART_"))
-                        {
-                            // skip if repeat button is part of scrollbar
-                            goto case "Slider";
-                        }
-                    }
-                    break;
-
-                case "Button":
-                    {
-                        Button button = (Button)current;
-                        if (button.Name.Equals("NavigationViewBackButton"))
-                            break;
-                        else if (button.Name.Equals("TogglePaneButton"))
-                            break;
-                        else
-                            goto case "Slider";
-                    }
-                    break;
-
-                case "Slider":
-                case "ToggleSwitch":
-                case "NavigationViewItem":
-                case "ComboBox":
-                case "ComboBoxItem":
-                case "AppBarButton":
-                case "ToggleButton":
-                case "CheckBox":
-                case "RadioButton":
-                    {
-                        FrameworkElement asType = (FrameworkElement)current;
-                        if (asType.IsEnabled && asType.Focusable && asType.IsVisible)
-                            childs.Add(asType);
-                    }
-                    break;
-            }
-
-            foreach (var item in FindChildren(current))
-            {
-                childs.Add(item);
-            }
-        }
-
-        return childs;
-    }
-
-    public static T FindParent<T>(DependencyObject child) where T : DependencyObject
-    {
-        T parent = null;
-        if (child is null)
-        {
-            return parent;
-        }
-        DependencyObject CurrentParent = VisualTreeHelper.GetParent(child);
-        while (CurrentParent is not null)
-        {
-            if (CurrentParent is T)
-            {
-                parent = (T)CurrentParent;
-                break;
-            }
-            CurrentParent = VisualTreeHelper.GetParent(CurrentParent);
-        }
-        return parent;
-    }
-
-    // Helper method to find all visual children of a given type
-    public static IEnumerable<T> FindVisualChildren<T>(DependencyObject parent) where T : DependencyObject
-    {
-        if (parent != null)
-        {
-            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
-            {
-                var child = VisualTreeHelper.GetChild(parent, i);
-
-                if (child is T)
-                {
-                    yield return (T)child;
-                }
-
-                foreach (var childOfChild in FindVisualChildren<T>(child))
-                {
-                    yield return childOfChild;
-                }
-            }
-        }
-    }
-
-    // Returns all FrameworkElement of specified type from a list, where their parent or parents of their parent is oftype() Popup
-    public static List<T> GetElementsFromPopup<T>(List<FrameworkElement> elements) where T : FrameworkElement
-    {
-        // Create an empty list to store the result
-        List<T> result = new List<T>();
-
-        // Loop through each element in the input list
-        foreach (FrameworkElement element in elements)
-        {
-            // Check if the element is of the specified type
-            if (element is T)
-            {
-                // Get the parent of the element
-                FrameworkElement parent = element.Parent as FrameworkElement;
-
-                // Loop until the parent is null or a Popup
-                while (parent != null && (!(parent is Popup) && !(parent is ContentDialog)))
-                {
-                    // Get the parent of the parent
-                    parent = parent.Parent as FrameworkElement;
-                }
-
-                // Check if the parent is a Popup
-                if (parent is Popup || parent is ContentDialog)
-                {
-                    // Add the element to the result list
-                    result.Add(element as T);
-                }
-            }
-        }
-
-        // Return the result list
-        return result;
-    }
-
-    public static void SendKeyToControl(Control control, int keyCode)
-    {
-        SendMessage(GetControlHandle(control).Handle.ToInt32(), WM_KEYDOWN, keyCode, IntPtr.Zero);
-    }
+using iNKORE.UI.WPF.Modern.Controls;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Interop;
+using System.Windows.Media;
+using Control = System.Windows.Controls.Control;
+
+namespace HandheldCompanion.Utils;
+
+public static class WPFUtils
+{
+    public const int WM_KEYDOWN = 0x0100;
+    public const int WM_CHANGEUISTATE = 0x0127;
+    public const int UIS_SET = 1;
+    public const int UIS_CLEAR = 2;
+    public const int UISF_HIDEFOCUS = 0x1;
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
+
+    public static HwndSource GetControlHandle(Control control)
+    {
+        return PresentationSource.FromVisual(control) as HwndSource;
+    }
+
+    public static void MakeFocusVisible(Control c)
+    {
+        IntPtr hWnd = GetControlHandle(c).Handle;
+        // SendMessage(hWnd, WM_CHANGEUISTATE, (IntPtr)MakeLong((int)UIS_CLEAR, (int)UISF_HIDEFOCUS), IntPtr.Zero);
+        SendMessage(hWnd, 257, (IntPtr)0x0000000000000009, (IntPtr)0x00000000c00f0001);
+    }
+
+    public static void MakeFocusInvisible(Control c)
+    {
+        IntPtr hWnd = GetControlHandle(c).Handle;
+        SendMessage(hWnd, WM_CHANGEUISTATE, (IntPtr)MakeLong((int)UIS_SET, (int)UISF_HIDEFOCUS), IntPtr.Zero);
+    }
+
+    public static int MakeLong(int wLow, int wHigh)
+    {
+        int low = (int)IntLoWord(wLow);
+        short high = IntLoWord(wHigh);
+        int product = 0x10000 * (int)high;
+        int mkLong = (int)(low | product);
+        return mkLong;
+    }
+
+    private static short IntLoWord(int word)
+    {
+        return (short)(word & short.MaxValue);
+    }
+
+    // A function that takes a list of controls and returns the top-left control
+    public static Control GetTopLeftControl<T>(List<Control> controls) where T : Control
+    {
+        // filter list
+        controls = controls.Where(c => c is T).ToList();
+
+        // If no controls are found, return null
+        if (controls == null || controls.Count == 0)
+        {
+            return null;
+        }
+
+        // Initialize the top left control with the first element of the list
+        Control topLeft = controls[0];
+
+        // Browse other list items
+        for (int i = 1; i < controls.Count; i++)
+        {
+            // Get current control
+            Control current = controls[i];
+
+            // Compare the Canvas.Top and Canvas.Left properties of the current control with those of the top-left control
+            // If the current control is farther up or to the left, replace it with the farthest control to the left
+            if (Canvas.GetTop(current) < Canvas.GetTop(topLeft) || (Canvas.GetTop(current) == Canvas.GetTop(topLeft) && Canvas.GetLeft(current) < Canvas.GetLeft(topLeft)))
+            {
+                topLeft = current;
+            }
+        }
+
+        // Return the top left control
+        return topLeft;
+    }
+
+    public enum Direction { None, Left, Right, Up, Down }
+
+    public static Control GetClosestControl<T>(Control source, List<Control> controls, Direction direction, List<Type> typesToIgnore = null) where T : Control
+    {
+        // Filter list based on requested type
+        controls = controls.Where(c => c is T).ToList();
+
+        // Filter based on exclusion type list
+        if (typesToIgnore is not null)
+            controls = controls.Where(c => !typesToIgnore.Contains(c.GetType())).ToList();
+
+        // Filter out the controls that are not in the given direction
+        controls = controls.Where(c => c != source && IsInDirection(source, c, direction)).ToList();
+
+        // If no controls are found, return source
+        if (controls.Count == 0) return source;
+
+        // Find the control with the same parent and the minimum distance to the source
+        // If no control has the same parent, find the control with the minimum distance to the source
+        controls = controls.OrderBy(c => GetDistanceV2(source, c, direction)).ToList();
+
+        return controls.First();
+    }
+
+    // Helper method to check if a control is in a given direction from another control
+    private static bool IsInDirection(Control source, Control target, Direction direction)
+    {
+        // Get the position of the target on the canvas
+        var p = target.TranslatePoint(new Point(0, 0), source);
+        double x = Math.Round(p.X);
+        double y = Math.Round(p.Y);
+
+        switch (direction)
+        {
+            case Direction.Left:
+                return x + (target.ActualWidth / 2) <= 0;
+            case Direction.Right:
+                return x >= (source.ActualWidth / 2);
+            case Direction.Up:
+                return y + (target.ActualHeight / 2) <= 0;
+            case Direction.Down:
+                return y >= (source.ActualHeight / 2);
+            default:
+                return false;
+        }
+    }
+
+    // Helper method to calculate the distance between the centers of two controls
+    private static double GetDistance(Control source, Control target, Direction direction)
+    {
+        try
+        {
+            // Get the relative position of the target with respect to the source
+            var transform = target.TransformToVisual(source);
+            var position = transform.Transform(new Point(0, 0));
+
+            double dx = source.ActualWidth / 2 - (position.X + target.ActualWidth / 2);
+            double dy = source.ActualHeight / 2 - (position.Y + target.ActualHeight / 2);
+
+            switch (direction)
+            {
+                case Direction.Up:
+                case Direction.Down:
+                    return Math.Sqrt(dy * dy);
+
+                case Direction.Left:
+                case Direction.Right:
+                    return Math.Sqrt(dx * dx);
+            }
+
+            return Math.Sqrt(dx * dx + dy * dy);
+        }
+        catch { }
+
+        return 9999.0d;
+    }
+
+    public static double GetDistanceV2(Control c1, Control c2, Direction direction)
+    {
+        try
+        {
+            // We retrieve the control's bounding box
+            Rect r1 = c1.TransformToVisual(c1).TransformBounds(new Rect(c1.RenderSize));
+            Rect r2 = c2.TransformToVisual(c1).TransformBounds(new Rect(c2.RenderSize));
+
+            // Calculate the horizontal and vertical distances between the edges of the rectangles
+            double dx = Math.Max(0, Math.Max(r1.Left, r2.Left) - Math.Min(r1.Right, r2.Right));
+            double dy = Math.Max(0, Math.Max(r1.Top, r2.Top) - Math.Min(r1.Bottom, r2.Bottom));
+
+            // Return the Euclidean distance between the nearest edges
+            return Math.Sqrt(dx * dx + dy * dy);
+        }
+        catch { }
+
+        return 9999.0d;
+    }
+
+    // This function takes two controls and returns their distance in pixels
+    private static double GetDistanceV3(Control c1, Control c2, Direction direction)
+    {
+        try
+        {
+            // Get the position of each control relative to the screen
+            Point p1 = c1.PointToScreen(new Point(0, 0));
+            Point p2 = c2.PointToScreen(new Point(0, 0));
+
+            // Convert the points to vectors
+            Vector3 v1 = new Vector3((float)p1.X, (float)p1.Y, 0f);
+            Vector3 v2 = new Vector3((float)p2.X, (float)p2.Y, 0f);
+
+            switch (direction)
+            {
+                case Direction.Up:
+                case Direction.Down:
+                    v1 = new Vector3(0f, (float)p1.Y, 0f);
+                    v2 = new Vector3(0f, (float)p2.Y, 0f);
+                    break;
+
+                case Direction.Left:
+                case Direction.Right:
+                    v1 = new Vector3((float)p1.X, 0f, 0f);
+                    v2 = new Vector3((float)p2.X, 0f, 0f);
+                    break;
+            }
+
+            // Calculate and return the distance between the vectors
+            return Vector3.Distance(v1, v2);
+        }
+        catch { }
+
+        return 9999.0d;
+    }
+
+    public static List<FrameworkElement> FindChildren(DependencyObject startNode)
+    {
+        int count = VisualTreeHelper.GetChildrenCount(startNode);
+        List<FrameworkElement> childs = new();
+
+        for (int i = 0; i < count; i++)
+        {
+            DependencyObject current = VisualTreeHelper.GetChild(startNode, i);
+
+            string currentType = current.GetType().Name;
+            switch (currentType)
+            {
+                case "TextBox":
+                    {
+                        TextBox textBox = (TextBox)current;
+                        if (!textBox.IsReadOnly)
+                            goto case "Slider";
+                    }
+                    break;
+
+                case "RepeatButton":
+                    {
+                        RepeatButton repeatButton = (RepeatButton)current;
+                        if (!repeatButton.Name.StartsWith("PART_"))
+                        {
+                            // skip if repeat button is part of scrollbar
+                            goto case "Slider";
+                        }
+                    }
+                    break;
+
+                case "Button":
+                    {
+                        Button button = (Button)current;
+                        if (button.Name.Equals("NavigationViewBackButton"))
+                            break;
+                        else if (button.Name.Equals("TogglePaneButton"))
+                            break;
+                        else
+                            goto case "Slider";
+                    }
+                    break;
+
+                case "Slider":
+                case "ToggleSwitch":
+                case "NavigationViewItem":
+                case "ComboBox":
+                case "ComboBoxItem":
+                case "AppBarButton":
+                case "ToggleButton":
+                case "CheckBox":
+                case "RadioButton":
+                    {
+                        FrameworkElement asType = (FrameworkElement)current;
+                        if (asType.IsEnabled && asType.Focusable && asType.IsVisible)
+                            childs.Add(asType);
+                    }
+                    break;
+            }
+
+            foreach (var item in FindChildren(current))
+            {
+                childs.Add(item);
+            }
+        }
+
+        return childs;
+    }
+
+    public static T FindParent<T>(DependencyObject child) where T : DependencyObject
+    {
+        T parent = null;
+        if (child is null)
+        {
+            return parent;
+        }
+        DependencyObject CurrentParent = VisualTreeHelper.GetParent(child);
+        while (CurrentParent is not null)
+        {
+            if (CurrentParent is T)
+            {
+                parent = (T)CurrentParent;
+                break;
+            }
+            CurrentParent = VisualTreeHelper.GetParent(CurrentParent);
+        }
+        return parent;
+    }
+
+    // Helper method to find all visual children of a given type
+    public static IEnumerable<T> FindVisualChildren<T>(DependencyObject parent) where T : DependencyObject
+    {
+        if (parent != null)
+        {
+            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
+            {
+                var child = VisualTreeHelper.GetChild(parent, i);
+
+                if (child is T)
+                {
+                    yield return (T)child;
+                }
+
+                foreach (var childOfChild in FindVisualChildren<T>(child))
+                {
+                    yield return childOfChild;
+                }
+            }
+        }
+    }
+
+    // Returns all FrameworkElement of specified type from a list, where their parent or parents of their parent is oftype() Popup
+    public static List<T> GetElementsFromPopup<T>(List<FrameworkElement> elements) where T : FrameworkElement
+    {
+        // Create an empty list to store the result
+        List<T> result = new List<T>();
+
+        // Loop through each element in the input list
+        foreach (FrameworkElement element in elements)
+        {
+            // Check if the element is of the specified type
+            if (element is T)
+            {
+                // Get the parent of the element
+                FrameworkElement parent = element.Parent as FrameworkElement;
+
+                // Loop until the parent is null or a Popup
+                while (parent != null && (!(parent is Popup) && !(parent is ContentDialog)))
+                {
+                    // Get the parent of the parent
+                    parent = parent.Parent as FrameworkElement;
+                }
+
+                // Check if the parent is a Popup
+                if (parent is Popup || parent is ContentDialog)
+                {
+                    // Add the element to the result list
+                    result.Add(element as T);
+                }
+            }
+        }
+
+        // Return the result list
+        return result;
+    }
+
+    public static void SendKeyToControl(Control control, int keyCode)
+    {
+        SendMessage(GetControlHandle(control).Handle.ToInt32(), WM_KEYDOWN, keyCode, IntPtr.Zero);
+    }
 }
\ No newline at end of file
diff --git a/HandheldCompanion/ViewModels/Layout/Mappings/AxisMappingViewModel.cs b/HandheldCompanion/ViewModels/Layout/Mappings/AxisMappingViewModel.cs
index e8f9d585b..37dee05a4 100644
--- a/HandheldCompanion/ViewModels/Layout/Mappings/AxisMappingViewModel.cs
+++ b/HandheldCompanion/ViewModels/Layout/Mappings/AxisMappingViewModel.cs
@@ -229,7 +229,7 @@ protected override void UpdateController(IController controller)
 
             if (IsSupported)
             {
-                UpdateIcon(controller.GetGlyphIconInfo(flag));
+                UpdateIcon(controller.GetGlyphIconInfo(flag, 28));
             }
         }
 
diff --git a/HandheldCompanion/ViewModels/Layout/Mappings/ButtonMappingViewModel.cs b/HandheldCompanion/ViewModels/Layout/Mappings/ButtonMappingViewModel.cs
index 6e320efc0..d39932d8b 100644
--- a/HandheldCompanion/ViewModels/Layout/Mappings/ButtonMappingViewModel.cs
+++ b/HandheldCompanion/ViewModels/Layout/Mappings/ButtonMappingViewModel.cs
@@ -207,7 +207,7 @@ public ButtonMappingViewModel(ButtonStackViewModel parentStack, ButtonFlags butt
 
             if (OEM.Contains(button))
             {
-                UpdateIcon(IDevice.GetCurrent().GetGlyphIconInfo(button));
+                UpdateIcon(IDevice.GetCurrent().GetGlyphIconInfo(button, 28));
             }
         }
 
@@ -217,7 +217,7 @@ protected override void UpdateController(IController controller)
             if (OEM.Contains(flag))
                 return;
 
-            UpdateIcon(controller.GetGlyphIconInfo(flag));
+            UpdateIcon(controller.GetGlyphIconInfo(flag, 28));
         }
 
         protected override void ActionTypeChanged(ActionType? newActionType = null)
diff --git a/HandheldCompanion/ViewModels/Layout/Mappings/GyroMappingViewModel.cs b/HandheldCompanion/ViewModels/Layout/Mappings/GyroMappingViewModel.cs
index 5977b32c7..d22c64018 100644
--- a/HandheldCompanion/ViewModels/Layout/Mappings/GyroMappingViewModel.cs
+++ b/HandheldCompanion/ViewModels/Layout/Mappings/GyroMappingViewModel.cs
@@ -286,7 +286,7 @@ protected override void UpdateController(IController controller)
 
             if (IsSupported)
             {
-                UpdateIcon(controller.GetGlyphIconInfo(flag));
+                UpdateIcon(controller.GetGlyphIconInfo(flag, 28));
             }
         }
 
diff --git a/HandheldCompanion/ViewModels/Layout/Mappings/TriggerMappingViewModel.cs b/HandheldCompanion/ViewModels/Layout/Mappings/TriggerMappingViewModel.cs
index d317304c3..963b4c3f8 100644
--- a/HandheldCompanion/ViewModels/Layout/Mappings/TriggerMappingViewModel.cs
+++ b/HandheldCompanion/ViewModels/Layout/Mappings/TriggerMappingViewModel.cs
@@ -62,7 +62,7 @@ protected override void UpdateController(IController controller)
 
             if (IsSupported)
             {
-                UpdateIcon(controller.GetGlyphIconInfo(flag));
+                UpdateIcon(controller.GetGlyphIconInfo(flag, 28));
             }
         }
 
diff --git a/HandheldCompanion/ViewModels/Pages/AboutPageViewModel.cs b/HandheldCompanion/ViewModels/Pages/AboutPageViewModel.cs
index ad36007dc..06a2778c8 100644
--- a/HandheldCompanion/ViewModels/Pages/AboutPageViewModel.cs
+++ b/HandheldCompanion/ViewModels/Pages/AboutPageViewModel.cs
@@ -1,46 +1,46 @@
-using HandheldCompanion.Devices;
-using HandheldCompanion.Managers;
-using HandheldCompanion.Views;
-using Nefarius.Utilities.DeviceManagement.PnP;
-using System;
-using System.Windows.Media.Imaging;
-
-namespace HandheldCompanion.ViewModels
-{
-    public class AboutPageViewModel : BaseViewModel
-    {
-        public string Manufacturer => IDevice.GetCurrent().ManufacturerName;
-        public string ProductName => IDevice.GetCurrent().ProductName;
-        public string Version => MainWindow.fileVersionInfo.FileVersion!;
-
-        public string InternalSensor => IDevice.GetCurrent().Capabilities.HasFlag(DeviceCapabilities.InternalSensor)
-                ? IDevice.GetCurrent().InternalSensorName
-                : "N/A";
-        public string ExternalSensor => IDevice.GetCurrent().Capabilities.HasFlag(DeviceCapabilities.ExternalSensor)
-                ? IDevice.GetCurrent().ExternalSensorName
-                : "N/A";
-
-        public bool IsUnsupportedDevice => IDevice.GetCurrent() is DefaultDevice;
-
-        public BitmapImage DeviceImage => new(new Uri($"pack://application:,,,/Resources/{IDevice.GetCurrent().ProductIllustration}.png"));
-
-        public AboutPageViewModel()
-        {
-            DeviceManager.UsbDeviceArrived += GenericDeviceUpdated;
-            DeviceManager.UsbDeviceRemoved += GenericDeviceUpdated;
-        }
-
-        public override void Dispose()
-        {
-            DeviceManager.UsbDeviceArrived -= GenericDeviceUpdated;
-            DeviceManager.UsbDeviceRemoved -= GenericDeviceUpdated;
-            base.Dispose();
-        }
-
-        private void GenericDeviceUpdated(PnPDevice device, DeviceEventArgs obj)
-        {
-            // Update all bindings
-            OnPropertyChanged(string.Empty);
-        }
-    }
-}
+using HandheldCompanion.Devices;
+using HandheldCompanion.Managers;
+using HandheldCompanion.Views;
+using Nefarius.Utilities.DeviceManagement.PnP;
+using System;
+using System.Windows.Media.Imaging;
+
+namespace HandheldCompanion.ViewModels
+{
+    public class AboutPageViewModel : BaseViewModel
+    {
+        public string Manufacturer => IDevice.GetCurrent().ManufacturerName;
+        public string ProductName => IDevice.GetCurrent().ProductName;
+        public string Version => MainWindow.fileVersionInfo.FileVersion!;
+
+        public string InternalSensor => IDevice.GetCurrent().Capabilities.HasFlag(DeviceCapabilities.InternalSensor)
+                ? IDevice.GetCurrent().InternalSensorName
+                : "N/A";
+        public string ExternalSensor => IDevice.GetCurrent().Capabilities.HasFlag(DeviceCapabilities.ExternalSensor)
+                ? IDevice.GetCurrent().ExternalSensorName
+                : "N/A";
+
+        public bool IsUnsupportedDevice => IDevice.GetCurrent() is DefaultDevice;
+
+        public BitmapImage DeviceImage => new(new Uri($"pack://application:,,,/Resources/{IDevice.GetCurrent().ProductIllustration}.png"));
+
+        public AboutPageViewModel()
+        {
+            DeviceManager.UsbDeviceArrived += GenericDeviceUpdated;
+            DeviceManager.UsbDeviceRemoved += GenericDeviceUpdated;
+        }
+
+        public override void Dispose()
+        {
+            DeviceManager.UsbDeviceArrived -= GenericDeviceUpdated;
+            DeviceManager.UsbDeviceRemoved -= GenericDeviceUpdated;
+            base.Dispose();
+        }
+
+        private void GenericDeviceUpdated(PnPDevice device, DeviceEventArgs obj)
+        {
+            // Update all bindings
+            OnPropertyChanged(string.Empty);
+        }
+    }
+}
diff --git a/HandheldCompanion/Views/Classes/GamepadWindow.cs b/HandheldCompanion/Views/Classes/GamepadWindow.cs
index c6f8e2b5a..880ea342e 100644
--- a/HandheldCompanion/Views/Classes/GamepadWindow.cs
+++ b/HandheldCompanion/Views/Classes/GamepadWindow.cs
@@ -1,112 +1,112 @@
-using HandheldCompanion.Managers;
-using HandheldCompanion.Utils;
-using iNKORE.UI.WPF.Modern.Controls;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Media;
-
-namespace HandheldCompanion.Views.Classes
-{
-    public class GamepadWindow : Window
-    {
-        public List<Control> controlElements = new();
-        public List<FrameworkElement> frameworkElements = new();
-
-        public ContentDialog currentDialog;
-        protected UIGamepad gamepadFocusManager;
-
-        public GamepadWindow()
-        {
-            LayoutUpdated += OnLayoutUpdated;
-        }
-
-        protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved)
-        {
-            // Track when objects are added and removed
-            if (visualAdded != null && visualAdded is Control)
-                controlElements.Add((Control)visualAdded);
-
-            if (visualRemoved != null && visualRemoved is Control)
-                controlElements.Remove((Control)visualRemoved);
-
-            base.OnVisualChildrenChanged(visualAdded, visualRemoved);
-        }
-
-        public ScrollViewer GetScrollViewer(DependencyObject depObj)
-        {
-            if (depObj is ScrollViewer) { return depObj as ScrollViewer; }
-
-            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
-            {
-                var child = VisualTreeHelper.GetChild(depObj, i);
-                var result = GetScrollViewer(child);
-                if (result != null && result.Name.Equals("scrollViewer"))
-                    return result;
-            }
-            return null;
-        }
-
-        private void OnLayoutUpdated(object? sender, EventArgs e)
-        {
-            if (!this.IsActive || this.Visibility != Visibility.Visible)
-                return;
-
-            // get all FrameworkElement(s)
-            frameworkElements = WPFUtils.FindChildren(this);
-
-            // do we have a popup ?
-            ContentDialog dialog = ContentDialog.GetOpenDialog(this);
-            if (dialog is not null)
-            {
-                if (currentDialog is null)
-                {
-                    currentDialog = dialog;
-
-                    frameworkElements = WPFUtils.FindChildren(this);
-
-                    // get all Control(s)
-                    controlElements = WPFUtils.GetElementsFromPopup<Control>(frameworkElements);
-
-                    ContentDialogOpened?.Invoke();
-                }
-            }
-            else if (dialog is null)
-            {
-                // get all Control(s)
-                controlElements = frameworkElements.OfType<Control>().ToList();
-
-                if (currentDialog is not null)
-                {
-                    currentDialog = null;
-                }
-            }
-        }
-
-        protected void InvokeGotGamepadWindowFocus()
-        {
-            GotGamepadWindowFocus?.Invoke();
-        }
-
-        protected void InvokeLostGamepadWindowFocus()
-        {
-            LostGamepadWindowFocus?.Invoke();
-        }
-
-        #region events
-        public event GotGamepadWindowFocusEventHandler GotGamepadWindowFocus;
-        public delegate void GotGamepadWindowFocusEventHandler();
-
-        public event LostGamepadWindowFocusEventHandler LostGamepadWindowFocus;
-        public delegate void LostGamepadWindowFocusEventHandler();
-
-        public event ContentDialogOpenedEventHandler ContentDialogOpened;
-        public delegate void ContentDialogOpenedEventHandler();
-
-        public event ContentDialogClosedEventHandler ContentDialogClosed;
-        public delegate void ContentDialogClosedEventHandler();
-        #endregion
-    }
-}
+using HandheldCompanion.Managers;
+using HandheldCompanion.Utils;
+using iNKORE.UI.WPF.Modern.Controls;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace HandheldCompanion.Views.Classes
+{
+    public class GamepadWindow : Window
+    {
+        public List<Control> controlElements = new();
+        public List<FrameworkElement> frameworkElements = new();
+
+        public ContentDialog currentDialog;
+        protected UIGamepad gamepadFocusManager;
+
+        public GamepadWindow()
+        {
+            LayoutUpdated += OnLayoutUpdated;
+        }
+
+        protected override void OnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved)
+        {
+            // Track when objects are added and removed
+            if (visualAdded != null && visualAdded is Control)
+                controlElements.Add((Control)visualAdded);
+
+            if (visualRemoved != null && visualRemoved is Control)
+                controlElements.Remove((Control)visualRemoved);
+
+            base.OnVisualChildrenChanged(visualAdded, visualRemoved);
+        }
+
+        public ScrollViewer GetScrollViewer(DependencyObject depObj)
+        {
+            if (depObj is ScrollViewer) { return depObj as ScrollViewer; }
+
+            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
+            {
+                var child = VisualTreeHelper.GetChild(depObj, i);
+                var result = GetScrollViewer(child);
+                if (result != null && result.Name.Equals("scrollViewer"))
+                    return result;
+            }
+            return null;
+        }
+
+        private void OnLayoutUpdated(object? sender, EventArgs e)
+        {
+            if (!this.IsActive || this.Visibility != Visibility.Visible)
+                return;
+
+            // get all FrameworkElement(s)
+            frameworkElements = WPFUtils.FindChildren(this);
+
+            // do we have a popup ?
+            ContentDialog dialog = ContentDialog.GetOpenDialog(this);
+            if (dialog is not null)
+            {
+                if (currentDialog is null)
+                {
+                    currentDialog = dialog;
+
+                    frameworkElements = WPFUtils.FindChildren(this);
+
+                    // get all Control(s)
+                    controlElements = WPFUtils.GetElementsFromPopup<Control>(frameworkElements);
+
+                    ContentDialogOpened?.Invoke();
+                }
+            }
+            else if (dialog is null)
+            {
+                // get all Control(s)
+                controlElements = frameworkElements.OfType<Control>().ToList();
+
+                if (currentDialog is not null)
+                {
+                    currentDialog = null;
+                }
+            }
+        }
+
+        protected void InvokeGotGamepadWindowFocus()
+        {
+            GotGamepadWindowFocus?.Invoke();
+        }
+
+        protected void InvokeLostGamepadWindowFocus()
+        {
+            LostGamepadWindowFocus?.Invoke();
+        }
+
+        #region events
+        public event GotGamepadWindowFocusEventHandler GotGamepadWindowFocus;
+        public delegate void GotGamepadWindowFocusEventHandler();
+
+        public event LostGamepadWindowFocusEventHandler LostGamepadWindowFocus;
+        public delegate void LostGamepadWindowFocusEventHandler();
+
+        public event ContentDialogOpenedEventHandler ContentDialogOpened;
+        public delegate void ContentDialogOpenedEventHandler();
+
+        public event ContentDialogClosedEventHandler ContentDialogClosed;
+        public delegate void ContentDialogClosedEventHandler();
+        #endregion
+    }
+}
diff --git a/HandheldCompanion/Views/Classes/OverlayWindow.cs b/HandheldCompanion/Views/Classes/OverlayWindow.cs
index ef4fc96d8..d7c7e2145 100644
--- a/HandheldCompanion/Views/Classes/OverlayWindow.cs
+++ b/HandheldCompanion/Views/Classes/OverlayWindow.cs
@@ -1,167 +1,167 @@
-using HandheldCompanion.Managers;
-using System;
-using System.Runtime.InteropServices;
-using System.Windows;
-using System.Windows.Input;
-using System.Windows.Interop;
-using System.Windows.Media;
-
-namespace HandheldCompanion.Views.Classes;
-
-public class OverlayWindow : Window
-{
-    public HorizontalAlignment _HorizontalAlignment;
-    public VerticalAlignment _VerticalAlignment;
-    protected ushort _hotkeyId;
-
-    private const int WM_MOUSEACTIVATE = 0x0021;
-    private const int MA_NOACTIVATE = 0x0003;
-
-    public OverlayWindow()
-    {
-        // overlay specific settings
-        WindowStyle = WindowStyle.None;
-        AllowsTransparency = true;
-        Background = Brushes.Transparent;
-        ShowInTaskbar = false;
-        Topmost = true;
-        Focusable = false;
-        ResizeMode = ResizeMode.NoResize;
-        ShowActivated = false;
-        FocusManager.SetIsFocusScope(this, false);
-
-        SizeChanged += (o, e) => { UpdatePosition(); };
-
-        Loaded += OverlayWindow_Loaded;
-        IsVisibleChanged += OverlayWindow_IsVisibleChanged;
-    }
-
-    private void OverlayWindow_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
-    {
-        if (_hotkeyId == 0)
-            return;
-
-        if (HotkeysManager.Hotkeys.TryGetValue(_hotkeyId, out Hotkey hotkey))
-            hotkey.SetToggle(this.Visibility == Visibility.Visible ? true : false);
-    }
-
-    public new HorizontalAlignment HorizontalAlignment
-    {
-        get => _HorizontalAlignment;
-
-        set
-        {
-            _HorizontalAlignment = value;
-            UpdatePosition();
-        }
-    }
-
-    public new VerticalAlignment VerticalAlignment
-    {
-        get => _VerticalAlignment;
-
-        set
-        {
-            _VerticalAlignment = value;
-            UpdatePosition();
-        }
-    }
-
-    private void OverlayWindow_Loaded(object sender, RoutedEventArgs e)
-    {
-        var source = PresentationSource.FromVisual(this) as HwndSource;
-        source.AddHook(WndProc);
-
-        //Set the window style to noactivate.
-        var helper = new WindowInteropHelper(this);
-        SetWindowLong(helper.Handle, GWL_EXSTYLE, GetWindowLong(helper.Handle, GWL_EXSTYLE) | WS_EX_NOACTIVATE);
-    }
-
-    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
-    {
-        if (msg == WM_MOUSEACTIVATE)
-        {
-            handled = true;
-            return new IntPtr(MA_NOACTIVATE);
-        }
-        else return IntPtr.Zero;
-    }
-
-    private void UpdatePosition()
-    {
-        var r = SystemParameters.WorkArea;
-
-        switch (HorizontalAlignment)
-        {
-            case HorizontalAlignment.Left:
-                Left = 0;
-                break;
-
-            default:
-            case HorizontalAlignment.Center:
-                Left = r.Width / 2 - Width / 2;
-                break;
-
-            case HorizontalAlignment.Right:
-                Left = r.Right - Width;
-                break;
-
-            case HorizontalAlignment.Stretch:
-                Left = 0;
-                Width = SystemParameters.PrimaryScreenWidth;
-                break;
-        }
-
-        switch (VerticalAlignment)
-        {
-            case VerticalAlignment.Top:
-                Top = 0;
-                break;
-
-            default:
-            case VerticalAlignment.Center:
-                Top = r.Height / 2 - Height / 2;
-                break;
-
-            case VerticalAlignment.Bottom:
-                Top = r.Height - Height;
-                break;
-
-            case VerticalAlignment.Stretch:
-                Top = 0;
-                Height = SystemParameters.PrimaryScreenHeight;
-                break;
-        }
-    }
-
-    public virtual void ToggleVisibility()
-    {
-        // UI thread
-        Application.Current.Dispatcher.Invoke(() =>
-        {
-            switch (Visibility)
-            {
-                case Visibility.Visible:
-                    Hide();
-                    break;
-                case Visibility.Collapsed:
-                case Visibility.Hidden:
-                    Show();
-                    break;
-            }
-        });
-    }
-
-    #region import
-
-    private const int GWL_EXSTYLE = -20;
-    private const int WS_EX_NOACTIVATE = 0x08000000;
-
-    [DllImport("user32.dll")]
-    public static extern IntPtr SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
-
-    [DllImport("user32.dll")]
-    public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
-
-    #endregion
+using HandheldCompanion.Managers;
+using System;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Media;
+
+namespace HandheldCompanion.Views.Classes;
+
+public class OverlayWindow : Window
+{
+    public HorizontalAlignment _HorizontalAlignment;
+    public VerticalAlignment _VerticalAlignment;
+    protected ushort _hotkeyId;
+
+    private const int WM_MOUSEACTIVATE = 0x0021;
+    private const int MA_NOACTIVATE = 0x0003;
+
+    public OverlayWindow()
+    {
+        // overlay specific settings
+        WindowStyle = WindowStyle.None;
+        AllowsTransparency = true;
+        Background = Brushes.Transparent;
+        ShowInTaskbar = false;
+        Topmost = true;
+        Focusable = false;
+        ResizeMode = ResizeMode.NoResize;
+        ShowActivated = false;
+        FocusManager.SetIsFocusScope(this, false);
+
+        SizeChanged += (o, e) => { UpdatePosition(); };
+
+        Loaded += OverlayWindow_Loaded;
+        IsVisibleChanged += OverlayWindow_IsVisibleChanged;
+    }
+
+    private void OverlayWindow_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
+    {
+        if (_hotkeyId == 0)
+            return;
+
+        if (HotkeysManager.Hotkeys.TryGetValue(_hotkeyId, out Hotkey hotkey))
+            hotkey.SetToggle(this.Visibility == Visibility.Visible ? true : false);
+    }
+
+    public new HorizontalAlignment HorizontalAlignment
+    {
+        get => _HorizontalAlignment;
+
+        set
+        {
+            _HorizontalAlignment = value;
+            UpdatePosition();
+        }
+    }
+
+    public new VerticalAlignment VerticalAlignment
+    {
+        get => _VerticalAlignment;
+
+        set
+        {
+            _VerticalAlignment = value;
+            UpdatePosition();
+        }
+    }
+
+    private void OverlayWindow_Loaded(object sender, RoutedEventArgs e)
+    {
+        var source = PresentationSource.FromVisual(this) as HwndSource;
+        source.AddHook(WndProc);
+
+        //Set the window style to noactivate.
+        var helper = new WindowInteropHelper(this);
+        SetWindowLong(helper.Handle, GWL_EXSTYLE, GetWindowLong(helper.Handle, GWL_EXSTYLE) | WS_EX_NOACTIVATE);
+    }
+
+    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    {
+        if (msg == WM_MOUSEACTIVATE)
+        {
+            handled = true;
+            return new IntPtr(MA_NOACTIVATE);
+        }
+        else return IntPtr.Zero;
+    }
+
+    private void UpdatePosition()
+    {
+        var r = SystemParameters.WorkArea;
+
+        switch (HorizontalAlignment)
+        {
+            case HorizontalAlignment.Left:
+                Left = 0;
+                break;
+
+            default:
+            case HorizontalAlignment.Center:
+                Left = r.Width / 2 - Width / 2;
+                break;
+
+            case HorizontalAlignment.Right:
+                Left = r.Right - Width;
+                break;
+
+            case HorizontalAlignment.Stretch:
+                Left = 0;
+                Width = SystemParameters.PrimaryScreenWidth;
+                break;
+        }
+
+        switch (VerticalAlignment)
+        {
+            case VerticalAlignment.Top:
+                Top = 0;
+                break;
+
+            default:
+            case VerticalAlignment.Center:
+                Top = r.Height / 2 - Height / 2;
+                break;
+
+            case VerticalAlignment.Bottom:
+                Top = r.Height - Height;
+                break;
+
+            case VerticalAlignment.Stretch:
+                Top = 0;
+                Height = SystemParameters.PrimaryScreenHeight;
+                break;
+        }
+    }
+
+    public virtual void ToggleVisibility()
+    {
+        // UI thread
+        Application.Current.Dispatcher.Invoke(() =>
+        {
+            switch (Visibility)
+            {
+                case Visibility.Visible:
+                    Hide();
+                    break;
+                case Visibility.Collapsed:
+                case Visibility.Hidden:
+                    Show();
+                    break;
+            }
+        });
+    }
+
+    #region import
+
+    private const int GWL_EXSTYLE = -20;
+    private const int WS_EX_NOACTIVATE = 0x08000000;
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+
+    [DllImport("user32.dll")]
+    public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+
+    #endregion
 }
\ No newline at end of file
diff --git a/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs b/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
index 0e0713ae5..f37a1b231 100644
--- a/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
+++ b/HandheldCompanion/Views/Pages/ControllerPage.xaml.cs
@@ -212,7 +212,7 @@ private void ControllerManager_Working(ControllerManagerStatus status, int attem
                 case ControllerManagerStatus.Failed:
                     {
                         // set dialog settings
-                        dialog.CanClose = false;
+                        dialog.CanClose = true;
                         dialog.DefaultButton = ContentDialogButton.Close;
                         dialog.CloseButtonText = Properties.Resources.ControllerPage_Close;
                         dialog.PrimaryButtonText = Properties.Resources.ControllerPage_TryAgain;
diff --git a/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs b/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
index 14c30a9c6..2e61e2cb6 100644
--- a/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
+++ b/HandheldCompanion/Views/Pages/ProfilesPage.xaml.cs
@@ -668,30 +668,40 @@ private void UpdateSubProfiles()
         if (selectedMainProfile is null)
             return;
 
-        var ind = 0; // default or main profile itself
-
-        // add main profile as first subprofile
-        cb_SubProfilePicker.Items.Clear();
-        cb_SubProfilePicker.Items.Add(selectedMainProfile);
-
-        // if main profile is not default, occupy sub profiles dropdown list
-        if (!selectedMainProfile.Default)
+        if (profileLock.TryEnter())
         {
-            foreach (Profile subprofile in ProfileManager.GetSubProfilesFromPath(selectedMainProfile.Path, false))
+            try
             {
-                cb_SubProfilePicker.Items.Add(subprofile);
+                int idx = 0; // default or main profile itself
 
-                // select sub profile if it's favorite for main profile
-                if (subprofile.IsFavoriteSubProfile)
-                    ind = cb_SubProfilePicker.Items.IndexOf(subprofile);
-            }
-        }
+                // add main profile as first subprofile
+                cb_SubProfilePicker.Items.Clear();
+                cb_SubProfilePicker.Items.Add(selectedMainProfile);
+
+                // if main profile is not default, occupy sub profiles dropdown list
+                if (!selectedMainProfile.Default)
+                {
+                    foreach (Profile subprofile in ProfileManager.GetSubProfilesFromPath(selectedMainProfile.Path, false))
+                    {
+                        cb_SubProfilePicker.Items.Add(subprofile);
 
-        // refresh sub profiles dropdown
-        cb_SubProfilePicker.Items.Refresh();
+                        // select sub profile if it's favorite for main profile
+                        if (subprofile.IsFavoriteSubProfile)
+                            idx = cb_SubProfilePicker.Items.IndexOf(subprofile);
+                    }
+                }
 
-        // set subprofile to be applied
-        cb_SubProfilePicker.SelectedIndex = ind;
+                // refresh sub profiles dropdown
+                cb_SubProfilePicker.Items.Refresh();
+
+                // set subprofile to be applied
+                cb_SubProfilePicker.SelectedIndex = idx;
+            }
+            finally
+            {
+                profileLock.Exit();
+            }
+        }
 
         // update UI elements
         UpdateUI();
@@ -1021,8 +1031,6 @@ public void SubmitProfile(UpdateSource source = UpdateSource.ProfilesPage)
         if (selectedProfile is null)
             return;
 
-        LogManager.LogInformation($"Submitting profile in ProfilesPage: {selectedProfile} - is Sub Profile? {selectedProfile.IsSubProfile}");
-
         switch (source)
         {
             case UpdateSource.ProfilesPageUpdateOnly: // when renaming main profile, update main profile only but don't apply it
@@ -1185,21 +1193,18 @@ private void cb_SubProfilePicker_SelectionChanged(object sender, SelectionChange
     {
         if (cb_SubProfilePicker.SelectedIndex == -1)
             return;
-        
+
+        // update selected profile
+        selectedProfile = (Profile)cb_SubProfilePicker.SelectedItem;
+        UpdateUI();
+
         // prevent update loop
         if (profileLock.IsEntered())
             return;
 
-        LogManager.LogInformation($"Subprofile changed in ProfilesPage - ind: {cb_SubProfilePicker.SelectedIndex} - {cb_SubProfilePicker.SelectedItem}");
-
         // selected sub profile
         if (selectedProfile != cb_SubProfilePicker.SelectedItem)
-        {
-            selectedProfile = (Profile)cb_SubProfilePicker.SelectedItem;
             UpdateProfile();
-        }
-
-        UpdateUI();
     }
 
     private void b_SubProfileCreate_Click(object sender, RoutedEventArgs e)
diff --git a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
index d26bdf72e..eaea33493 100644
--- a/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
+++ b/HandheldCompanion/Views/QuickPages/QuickProfilesPage.xaml.cs
@@ -533,14 +533,7 @@ private void ProfileManager_Deleted(Profile profile)
             ProcessManager_ForegroundChanged(currentProcess, null);
     }
 
-    private void ProfileManager_Deleted(Profile profile)
-    {
-        // this shouldn't happen, someone removed the currently applied profile
-        if (selectedProfile == profile)
-            ProcessManager_ForegroundChanged(currentProcess, null);
-    }
-
-    private void ProcessManager_ForegroundChanged(ProcessEx processEx, ProcessEx backgroundEx)
+    private void ProcessManager_ForegroundChanged(ProcessEx? processEx, ProcessEx? backgroundEx)
     {
         if (foregroundLock.TryEnter())
         {
@@ -549,16 +542,21 @@ private void ProcessManager_ForegroundChanged(ProcessEx processEx, ProcessEx bac
                 // update current process
                 currentProcess = processEx;
 
+                // get path
+                string path = currentProcess != null ? currentProcess.Path : string.Empty;
+                ImageSource imageSource = currentProcess != null ? currentProcess.ProcessIcon : null;
+                nint handle = currentProcess != null ? currentProcess.MainWindowHandle : IntPtr.Zero;
+
                 // update real profile
-                realProfile = ProfileManager.GetProfileFromPath(processEx.Path, true);
+                realProfile = ProfileManager.GetProfileFromPath(path, true);
 
                 // UI thread
                 Application.Current.Dispatcher.Invoke(() =>
                 {
                     ProfileToggle.IsOn = !realProfile.Default && realProfile.Enabled;
-                    ProfileIcon.Source = processEx.ProcessIcon;
+                    ProfileIcon.Source = imageSource;
 
-                    if (processEx.MainWindowHandle != IntPtr.Zero)
+                    if (handle != IntPtr.Zero)
                     {
                         // string MainWindowTitle = ProcessUtils.GetWindowTitle(processEx.MainWindowHandle);
 
@@ -615,7 +613,7 @@ private void ProfileToggle_Toggled(object sender, RoutedEventArgs e)
 
     private void CreateProfile()
     {
-        if (currentProcess is null)
+        if (currentProcess is null || currentProcess == ProcessManager.Empty)
             return;
 
         // create profile
diff --git a/HandheldCompanion/Views/Windows/MainWindow.xaml.cs b/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
index 14b97abd9..d2c436772 100644
--- a/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
+++ b/HandheldCompanion/Views/Windows/MainWindow.xaml.cs
@@ -1,239 +1,237 @@
-using HandheldCompanion.Controllers;
-using HandheldCompanion.Devices;
-using HandheldCompanion.Inputs;
-using HandheldCompanion.Managers;
-using HandheldCompanion.Utils;
-using HandheldCompanion.Views.Classes;
-using HandheldCompanion.Views.Pages;
-using HandheldCompanion.Views.Windows;
-using iNKORE.UI.WPF.Modern.Controls;
-using Nefarius.Utilities.DeviceManagement.PnP;
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Forms;
-using System.Windows.Input;
-using System.Windows.Interop;
-using System.Windows.Navigation;
-using Windows.UI.ViewManagement;
-using static HandheldCompanion.Managers.InputsHotkey;
-using Application = System.Windows.Application;
-using Control = System.Windows.Controls.Control;
-using Page = System.Windows.Controls.Page;
-using RadioButton = System.Windows.Controls.RadioButton;
-
-namespace HandheldCompanion.Views;
-
-/// <summary>
-///     Interaction logic for MainWindow.xaml
-/// </summary>
-public partial class MainWindow : GamepadWindow
-{
-    // devices vars
-    public static IDevice CurrentDevice;
-
-    // page vars
-    private static readonly Dictionary<string, Page> _pages = new();
-
-    public static ControllerPage controllerPage;
-    public static DevicePage devicePage;
-    public static PerformancePage performancePage;
-    public static ProfilesPage profilesPage;
-    public static SettingsPage settingsPage;
-    public static AboutPage aboutPage;
-    public static OverlayPage overlayPage;
-    public static HotkeysPage hotkeysPage;
-    public static LayoutPage layoutPage;
-    public static NotificationsPage notificationsPage;
-
-    // overlay(s) vars
-    public static OverlayModel overlayModel;
-    public static OverlayTrackpad overlayTrackpad;
-    public static OverlayQuickTools overlayquickTools;
-
-    public static string CurrentExe, CurrentPath;
-
-    private static MainWindow CurrentWindow;
-    public static FileVersionInfo fileVersionInfo;
-
-    public static string InstallPath = string.Empty;
-    public static string SettingsPath = string.Empty;
-    public static string CurrentPageName = string.Empty;
-
-    private bool appClosing;
-    private bool IsReady;
-    private readonly NotifyIcon notifyIcon;
-    private bool NotifyInTaskbar;
-    private string preNavItemTag;
-
-    private WindowState prevWindowState;
-    private SplashScreen splashScreen;
-
-    public static UISettings uiSettings;
-
-    private const int WM_QUERYENDSESSION = 0x0011;
-
-    public MainWindow(FileVersionInfo _fileVersionInfo, Assembly CurrentAssembly)
-    {
-        InitializeComponent();
-
-        fileVersionInfo = _fileVersionInfo;
-        CurrentWindow = this;
-
-        // used by system manager, controller manager
-        uiSettings = new UISettings();
-
-        // used by gamepad navigation
-        Tag = "MainWindow";
-
-        // get process
-        var process = Process.GetCurrentProcess();
-
-        // fix touch support
-        TabletDeviceCollection tabletDevices = Tablet.TabletDevices;
-        /*if (tabletDevices.Count > 0)
-        {
-            // Get the Type of InputManager.  
-            Type inputManagerType = typeof(System.Windows.Input.InputManager);
-
-            // Call the StylusLogic method on the InputManager.Current instance.  
-            object stylusLogic = inputManagerType.InvokeMember("StylusLogic",
-                        BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic,
-                        null, InputManager.Current, null);
-
-            if (stylusLogic != null)
-            {
-                //  Get the type of the stylusLogic returned from the call to StylusLogic.  
-                Type stylusLogicType = stylusLogic.GetType();
-
-                // Loop until there are no more devices to remove.  
-                while (tabletDevices.Count > 0)
-                {
-                    // Remove the first tablet device in the devices collection.  
-                    stylusLogicType.InvokeMember("OnTabletRemoved",
-                            BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.NonPublic,
-                            null, stylusLogic, new object[] { (uint)0 });
-                }
-            }
-        }*/
+using HandheldCompanion.Controllers;
+using HandheldCompanion.Devices;
+using HandheldCompanion.Inputs;
+using HandheldCompanion.Managers;
+using HandheldCompanion.UI;
+using HandheldCompanion.Utils;
+using HandheldCompanion.Views.Classes;
+using HandheldCompanion.Views.Pages;
+using HandheldCompanion.Views.Windows;
+using iNKORE.UI.WPF.Modern.Controls;
+using Nefarius.Utilities.DeviceManagement.PnP;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Forms;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Navigation;
+using System.Windows.Threading;
+using Windows.UI.ViewManagement;
+using static HandheldCompanion.Managers.InputsHotkey;
+using Application = System.Windows.Application;
+using Control = System.Windows.Controls.Control;
+using Page = System.Windows.Controls.Page;
+using RadioButton = System.Windows.Controls.RadioButton;
+
+namespace HandheldCompanion.Views;
+
+/// <summary>
+///     Interaction logic for MainWindow.xaml
+/// </summary>
+public partial class MainWindow : GamepadWindow
+{
+    // devices vars
+    private static IDevice CurrentDevice;
+
+    // page vars
+    private static readonly Dictionary<string, Page> _pages = new();
+
+    public static ControllerPage controllerPage;
+    public static DevicePage devicePage;
+    public static PerformancePage performancePage;
+    public static ProfilesPage profilesPage;
+    public static SettingsPage settingsPage;
+    public static AboutPage aboutPage;
+    public static OverlayPage overlayPage;
+    public static HotkeysPage hotkeysPage;
+    public static LayoutPage layoutPage;
+    public static NotificationsPage notificationsPage;
+
+    // overlay(s) vars
+    public static OverlayModel overlayModel;
+    public static OverlayTrackpad overlayTrackpad;
+    public static OverlayQuickTools overlayquickTools;
+
+    public static string CurrentExe, CurrentPath;
+
+    private static MainWindow CurrentWindow;
+    public static FileVersionInfo fileVersionInfo;
+
+    public static string InstallPath = string.Empty;
+    public static string SettingsPath = string.Empty;
+    public static string CurrentPageName = string.Empty;
+
+    private bool appClosing;
+    private readonly NotifyIcon notifyIcon;
+    private bool NotifyInTaskbar;
+    private string preNavItemTag;
+
+    private WindowState prevWindowState;
+    public static SplashScreen SplashScreen;
+
+    public static UISettings uiSettings;
+
+    private const int WM_QUERYENDSESSION = 0x0011;
+    private const int WM_DISPLAYCHANGE = 0x007e;
+    private const int WM_DEVICECHANGE = 0x0219;
+
+    public MainWindow(FileVersionInfo _fileVersionInfo, Assembly CurrentAssembly)
+    {
+        // initialize splash screen
+        SplashScreen = new SplashScreen();
 
         // get first start
-        bool FirstStart = SettingsManager.GetBoolean("FirstStart");
-
-        // define current directory
-        InstallPath = AppDomain.CurrentDomain.BaseDirectory;
-        SettingsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
-            "HandheldCompanion");
-
-        // initialiaze path
-        if (!Directory.Exists(SettingsPath))
-            Directory.CreateDirectory(SettingsPath);
-
-        Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
-
-        // initialize XInputWrapper
-        XInputPlus.ExtractXInputPlusLibraries();
-
-        // initialize notifyIcon
-        notifyIcon = new NotifyIcon
+        bool FirstStart = SettingsManager.GetBoolean("FirstStart");
+
+        if (FirstStart)
         {
-            Text = Title,
-            Icon = System.Drawing.Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location),
-            Visible = false,
-            ContextMenuStrip = new ContextMenuStrip()
-        };
-
-        notifyIcon.DoubleClick += (sender, e) => { SwapWindowState(); };
-
-        AddNotifyIconItem(Properties.Resources.MainWindow_MainWindow);
+#if !DEBUG
+            SplashScreen.Show();
+#endif
+        }
+
+        SplashScreen.LoadingSequence.Text = "Preparing UI...";
+
+        InitializeComponent();
+        this.Tag = "MainWindow";
+
+        fileVersionInfo = _fileVersionInfo;
+        CurrentWindow = this;
+
+        // used by system manager, controller manager
+        uiSettings = new UISettings();
+
+        // fix touch support
+        TabletDeviceCollection tabletDevices = Tablet.TabletDevices;
+
+        // define current directory
+        InstallPath = AppDomain.CurrentDomain.BaseDirectory;
+        SettingsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
+            "HandheldCompanion");
+
+        // initialiaze path
+        if (!Directory.Exists(SettingsPath))
+            Directory.CreateDirectory(SettingsPath);
+
+        Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
+
+        // initialize XInputWrapper
+        XInputPlus.ExtractXInputPlusLibraries();
+
+        // initialize notifyIcon
+        notifyIcon = new NotifyIcon
+        {
+            Text = Title,
+            Icon = System.Drawing.Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location),
+            Visible = false,
+            ContextMenuStrip = new ContextMenuStrip()
+        };
+
+        notifyIcon.DoubleClick += (sender, e) => { SwapWindowState(); };
+
+        AddNotifyIconItem(Properties.Resources.MainWindow_MainWindow);
         AddNotifyIconItem(Properties.Resources.MainWindow_QuickTools);
-        
-        AddNotifyIconSeparator();
 
-        AddNotifyIconItem(Properties.Resources.MainWindow_Exit);
-
-        // paths
-        CurrentExe = process.MainModule.FileName;
-        CurrentPath = AppDomain.CurrentDomain.BaseDirectory;
-
-        // initialize HidHide
+        AddNotifyIconSeparator();
+
+        AddNotifyIconItem(Properties.Resources.MainWindow_Exit);
+
+        // paths
+        Process process = Process.GetCurrentProcess();
+        CurrentExe = process.MainModule.FileName;
+        CurrentPath = AppDomain.CurrentDomain.BaseDirectory;
+
+        // initialize HidHide
         HidHide.RegisterApplication(CurrentExe);
 
-        // initialize title
-        Title += $" ({fileVersionInfo.FileVersion})";
-
-        // initialize device
-        CurrentDevice = IDevice.GetDefault();
+        // collect details from MotherboardInfo
+        MotherboardInfo.Collect();
+
+        // initialize title
+        Title += $" ({fileVersionInfo.FileVersion})";
+
+        // initialize device
+        SplashScreen.LoadingSequence.Text = "Initializing device...";
+        CurrentDevice = IDevice.GetCurrent();
         CurrentDevice.PullSensors();
 
-        // workaround for Bosch BMI320/BMI323 (as of 06/20/2023)
-        // todo: check if still needed with Bosch G-sensor Driver V1.0.1.7
-        // https://dlcdnets.asus.com/pub/ASUS/IOTHMD/Image/Driver/Chipset/34644/BoschG-sensor_ROG_Bosch_Z_V1.0.1.7_34644.exe?model=ROG%20Ally%20(2023)
-
-        string currentDeviceType = CurrentDevice.GetType().Name;
-        switch (currentDeviceType)
+        string currentDeviceType = CurrentDevice.GetType().Name;
+        switch (currentDeviceType)
         {
-            case "AYANEOAIRPlus":
-            case "ROGAlly":
-                {
-                    LogManager.LogInformation("Restarting: {0}", CurrentDevice.InternalSensorName);
+            /*
+             * workaround for Bosch BMI320/BMI323 (as of 06/20/2023)
+             * todo: check if still needed with Bosch G-sensor Driver V1.0.1.7
+             * https://dlcdnets.asus.com/pub/ASUS/IOTHMD/Image/Driver/Chipset/34644/BoschG-sensor_ROG_Bosch_Z_V1.0.1.7_34644.exe?model=ROG%20Ally%20(2023)
 
-                    if (CurrentDevice.RestartSensor())
+                case "AYANEOAIRPlus":
+                case "ROGAlly":
                     {
-                        // give the device some breathing space once restarted
-                        Thread.Sleep(500);
-
-                        LogManager.LogInformation("Successfully restarted: {0}", CurrentDevice.InternalSensorName);
-                    }
-                    else
-                        LogManager.LogError("Failed to restart: {0}", CurrentDevice.InternalSensorName);
-                }
-                break;
+                        LogManager.LogInformation("Restarting: {0}", CurrentDevice.InternalSensorName);
 
-            case "SteamDeck":
-                {
-                    // prevent Steam Deck controller from being hidden by default
-                    if (FirstStart)
-                        SettingsManager.SetProperty("HIDcloakonconnect", false);
-                }
-                break;
-        }
-
-        // initialize splash screen on first start only
-        if (FirstStart)
-        {
-            splashScreen = new SplashScreen();
-            splashScreen.Show();
-
-            SettingsManager.SetProperty("FirstStart", false);
-        }
-
-        // load window(s)
-        loadWindows();
-
-        // load page(s)
-        loadPages();
-
-        // manage events
-        InputsManager.TriggerRaised += InputsManager_TriggerRaised;
-        PowerManager.SystemStatusChanged += OnSystemStatusChanged;
-        DeviceManager.UsbDeviceArrived += GenericDeviceUpdated;
-        DeviceManager.UsbDeviceRemoved += GenericDeviceUpdated;
-        ControllerManager.ControllerSelected += ControllerManager_ControllerSelected;
-        VirtualManager.ControllerSelected += VirtualManager_ControllerSelected;
-
-        ToastManager.Start();
-        ToastManager.IsEnabled = SettingsManager.GetBoolean("ToastEnable");
+                        if (CurrentDevice.RestartSensor())
+                        {
+                            // give the device some breathing space once restarted
+                            Thread.Sleep(500);
 
-        // start static managers in sequence
+                            LogManager.LogInformation("Successfully restarted: {0}", CurrentDevice.InternalSensorName);
+                        }
+                        else
+                            LogManager.LogError("Failed to restart: {0}", CurrentDevice.InternalSensorName);
+                    }
+                    break;
+            */
+
+            case "SteamDeck":
+                {
+                    // prevent Steam Deck controller from being hidden by default
+                    if (FirstStart)
+                        SettingsManager.SetProperty("HIDcloakonconnect", false);
+                }
+                break;
+        }
+
+        // initialize splash screen on first start only
+        SettingsManager.SetProperty("FirstStart", false);
+
+        // initialize UI sounds board
+        UISounds uiSounds = new UISounds();
+
+        // load window(s)
+        SplashScreen.LoadingSequence.Text = "Drawing windows...";
+        Dispatcher.Invoke(new Action(() =>
+        {
+            loadWindows();
+        }), DispatcherPriority.Background); // Lower priority
+
+        // load page(s)
+        SplashScreen.LoadingSequence.Text = "Drawing pages...";
+        Dispatcher.Invoke(new Action(() =>
+        {
+            loadPages();
+        }), DispatcherPriority.Background); // Lower priority
+
+        // manage events
+        InputsManager.TriggerRaised += InputsManager_TriggerRaised;
+        SystemManager.SystemStatusChanged += OnSystemStatusChanged;
+        DeviceManager.UsbDeviceArrived += GenericDeviceUpdated;
+        DeviceManager.UsbDeviceRemoved += GenericDeviceUpdated;
+        ControllerManager.ControllerSelected += ControllerManager_ControllerSelected;
+
+        ToastManager.Start();
+        ToastManager.IsEnabled = SettingsManager.GetBoolean("ToastEnable");
+
+        // start static managers in sequence
+        SplashScreen.LoadingSequence.Text = "Initializing managers...";
+        GPUManager.Start();
         PowerProfileManager.Start();
         ProfileManager.Start();
         ControllerManager.Start();
@@ -241,600 +239,586 @@ public MainWindow(FileVersionInfo _fileVersionInfo, Assembly CurrentAssembly)
         DeviceManager.Start();
         OSDManager.Start();
         LayoutManager.Start();
-        PowerManager.Start();
-        DynamicLightingManager.Start();
         SystemManager.Start();
+        DynamicLightingManager.Start();
+        MultimediaManager.Start();
         VirtualManager.Start();
         InputsManager.Start();
         SensorsManager.Start();
-        TimerManager.Start();
-
-        // todo: improve overall threading logic
-        new Thread(() => { PlatformManager.Start(); }).Start();
-        new Thread(() => { ProcessManager.Start(); }).Start();
+        TimerManager.Start();
+
+        // todo: improve overall threading logic
+        new Thread(() => { PlatformManager.Start(); }).Start();
+        new Thread(() => { ProcessManager.Start(); }).Start();
         new Thread(() => { TaskManager.Start(CurrentExe); }).Start();
-        new Thread(() => { PerformanceManager.Start(); }).Start();
-        new Thread(() => { UpdateManager.Start(); }).Start();
-
-        // start setting last
-        SettingsManager.SettingValueChanged += SettingsManager_SettingValueChanged;
-        SettingsManager.Start();
-
-        // update Position and Size
-        Height = (int)Math.Max(MinHeight, SettingsManager.GetDouble("MainWindowHeight"));
-        Width = (int)Math.Max(MinWidth, SettingsManager.GetDouble("MainWindowWidth"));
-        Left = Math.Min(SystemParameters.PrimaryScreenWidth - MinWidth, SettingsManager.GetDouble("MainWindowLeft"));
-        Top = Math.Min(SystemParameters.PrimaryScreenHeight - MinHeight, SettingsManager.GetDouble("MainWindowTop"));
-        navView.IsPaneOpen = SettingsManager.GetBoolean("MainWindowIsPaneOpen");
-    }
-
-    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
-    {
-        // windows shutting down event
-        if (msg == WM_QUERYENDSESSION)
-        {
-            // do something
-        }
-
-        return IntPtr.Zero;
-    }
-
-    private void ControllerManager_ControllerSelected(IController Controller)
-    {
-        // UI thread (async)
-        Application.Current.Dispatcher.BeginInvoke(() =>
-        {
-            GamepadUISelectIcon.Glyph = Controller.GetGlyph(ButtonFlags.B1);
-            GamepadUISelectIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B1);
-
-            GamepadUIBackIcon.Glyph = Controller.GetGlyph(ButtonFlags.B2);
-            GamepadUIBackIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B2);
-
-            GamepadUIToggleIcon.Glyph = Controller.GetGlyph(ButtonFlags.B4);
-            GamepadUIToggleIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B4);
-        });
-    }
-
-    private void GamepadFocusManagerOnFocused(Control control)
-    {
-        // UI thread (async)
-        Application.Current.Dispatcher.BeginInvoke(() =>
-        {
-            // todo : localize me
-            string controlType = control.GetType().Name;
-            switch (controlType)
-            {
-                default:
-                    {
-                        GamepadUISelect.Visibility = Visibility.Visible;
-                        GamepadUIBack.Visibility = Visibility.Visible;
-                        GamepadUIToggle.Visibility = Visibility.Collapsed;
-
-                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Select;
-                        GamepadUIBackDesc.Text = Properties.Resources.MainWindow_Back;
-                    }
-                    break;
-
-                case "Button":
-                    {
-                        GamepadUISelect.Visibility = Visibility.Visible;
-                        GamepadUIBack.Visibility = Visibility.Visible;
-
-                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Select;
-                        GamepadUIBackDesc.Text = Properties.Resources.MainWindow_Back;
-
-                        // To get the first RadioButton in the list, if any
-                        RadioButton firstRadioButton = WPFUtils.FindChildren(control).FirstOrDefault(c => c is RadioButton) as RadioButton;
-                        if (firstRadioButton is not null)
-                        {
-                            GamepadUIToggle.Visibility = Visibility.Visible;
-                            GamepadUIToggleDesc.Text = Properties.Resources.MainWindow_Toggle;
-                        }
-                    }
-                    break;
-
-                case "Slider":
-                    {
-                        GamepadUISelect.Visibility = Visibility.Collapsed;
-                        GamepadUIBack.Visibility = Visibility.Visible;
-                        GamepadUIToggle.Visibility = Visibility.Collapsed;
-                    }
-                    break;
-
-                case "NavigationViewItem":
-                    {
-                        GamepadUISelect.Visibility = Visibility.Visible;
-                        GamepadUIBack.Visibility = Visibility.Collapsed;
-                        GamepadUIToggle.Visibility = Visibility.Collapsed;
-
-                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Navigate;
-                    }
-                    break;
-            }
-        });
-    }
-
-    private void AddNotifyIconItem(string name, object tag = null)
-    {
-        tag ??= string.Concat(name.Where(c => !char.IsWhiteSpace(c)));
-
-        var menuItemMainWindow = new ToolStripMenuItem(name);
-        menuItemMainWindow.Tag = tag;
-        menuItemMainWindow.Click += MenuItem_Click;
-        notifyIcon.ContextMenuStrip.Items.Add(menuItemMainWindow);
-    }
-
-    private void AddNotifyIconSeparator()
-    {
-        var separator = new ToolStripSeparator();
-        notifyIcon.ContextMenuStrip.Items.Add(separator);
-    }
-
-    private void SettingsManager_SettingValueChanged(string name, object value)
-    {
-        switch (name)
-        {
-            case "ToastEnable":
-                ToastManager.IsEnabled = Convert.ToBoolean(value);
-                break;
-            case "DesktopProfileOnStart":
-                if (SettingsManager.IsInitialized)
-                    break;
-
-                var DesktopLayout = Convert.ToBoolean(value);
-                SettingsManager.SetProperty("DesktopLayoutEnabled", DesktopLayout, false, true);
-                break;
-        }
-    }
-
-    public void SwapWindowState()
-    {
-        // UI thread
-        Application.Current.Dispatcher.Invoke(() =>
-        {
-            switch (WindowState)
-            {
-                case WindowState.Normal:
-                case WindowState.Maximized:
-                    WindowState = WindowState.Minimized;
-                    break;
-                case WindowState.Minimized:
-                    WindowState = prevWindowState;
-                    break;
-            }
-        });
-    }
-
-    public static MainWindow GetCurrent()
-    {
-        return CurrentWindow;
-    }
-
-    private void loadPages()
-    {
-        // initialize pages
-        controllerPage = new ControllerPage("controller");
-        controllerPage.Loaded += ControllerPage_Loaded;
-
-        devicePage = new DevicePage("device");
-        performancePage = new PerformancePage("performance");
-        profilesPage = new ProfilesPage("profiles");
+        new Thread(() => { PerformanceManager.Start(); }).Start();
+        new Thread(() => { UpdateManager.Start(); }).Start();
+
+        // start setting last
+        SettingsManager.SettingValueChanged += SettingsManager_SettingValueChanged;
+        SettingsManager.Start();
+
+        // Load MVVM pages after the Models / data have been created.
+        overlayquickTools.LoadPages_MVVM();
+        LoadPages_MVVM();
+
+        // update Position and Size
+        Height = (int)Math.Max(MinHeight, SettingsManager.GetDouble("MainWindowHeight"));
+        Width = (int)Math.Max(MinWidth, SettingsManager.GetDouble("MainWindowWidth"));
+        Left = Math.Min(SystemParameters.PrimaryScreenWidth - MinWidth, SettingsManager.GetDouble("MainWindowLeft"));
+        Top = Math.Min(SystemParameters.PrimaryScreenHeight - MinHeight, SettingsManager.GetDouble("MainWindowTop"));
+        navView.IsPaneOpen = SettingsManager.GetBoolean("MainWindowIsPaneOpen");
+    }
+
+    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    {
+        switch (msg)
+        {
+            case WM_DISPLAYCHANGE:
+            case WM_DEVICECHANGE:
+                DeviceManager.RefreshDisplayAdapters();
+                break;
+            case WM_QUERYENDSESSION:
+                break;
+        }
+
+        return IntPtr.Zero;
+    }
+
+    private void ControllerManager_ControllerSelected(IController Controller)
+    {
+        // UI thread (async)
+        Application.Current.Dispatcher.Invoke(() =>
+        {
+            GamepadUISelectIcon.Glyph = Controller.GetGlyph(ButtonFlags.B1);
+            GamepadUISelectIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B1);
+
+            GamepadUIBackIcon.Glyph = Controller.GetGlyph(ButtonFlags.B2);
+            GamepadUIBackIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B2);
+
+            GamepadUIToggleIcon.Glyph = Controller.GetGlyph(ButtonFlags.B4);
+            GamepadUIToggleIcon.Foreground = Controller.GetGlyphColor(ButtonFlags.B4);
+        });
+    }
+
+    private void GamepadFocusManagerOnFocused(Control control)
+    {
+        // UI thread (async)
+        Application.Current.Dispatcher.Invoke(() =>
+        {
+            // todo : localize me
+            string controlType = control.GetType().Name;
+            switch (controlType)
+            {
+                default:
+                    {
+                        GamepadUISelect.Visibility = Visibility.Visible;
+                        GamepadUIBack.Visibility = Visibility.Visible;
+                        GamepadUIToggle.Visibility = Visibility.Collapsed;
+
+                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Select;
+                        GamepadUIBackDesc.Text = Properties.Resources.MainWindow_Back;
+                    }
+                    break;
+
+                case "Button":
+                    {
+                        GamepadUISelect.Visibility = Visibility.Visible;
+                        GamepadUIBack.Visibility = Visibility.Visible;
+
+                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Select;
+                        GamepadUIBackDesc.Text = Properties.Resources.MainWindow_Back;
+
+                        // To get the first RadioButton in the list, if any
+                        RadioButton firstRadioButton = WPFUtils.FindChildren(control).FirstOrDefault(c => c is RadioButton) as RadioButton;
+                        if (firstRadioButton is not null)
+                        {
+                            GamepadUIToggle.Visibility = Visibility.Visible;
+                            GamepadUIToggleDesc.Text = Properties.Resources.MainWindow_Toggle;
+                        }
+                    }
+                    break;
+
+                case "Slider":
+                    {
+                        GamepadUISelect.Visibility = Visibility.Collapsed;
+                        GamepadUIBack.Visibility = Visibility.Visible;
+                        GamepadUIToggle.Visibility = Visibility.Collapsed;
+                    }
+                    break;
+
+                case "NavigationViewItem":
+                    {
+                        GamepadUISelect.Visibility = Visibility.Visible;
+                        GamepadUIBack.Visibility = Visibility.Collapsed;
+                        GamepadUIToggle.Visibility = Visibility.Collapsed;
+
+                        GamepadUISelectDesc.Text = Properties.Resources.MainWindow_Navigate;
+                    }
+                    break;
+            }
+        });
+    }
+
+    private void AddNotifyIconItem(string name, object tag = null)
+    {
+        tag ??= string.Concat(name.Where(c => !char.IsWhiteSpace(c)));
+
+        var menuItemMainWindow = new ToolStripMenuItem(name);
+        menuItemMainWindow.Tag = tag;
+        menuItemMainWindow.Click += MenuItem_Click;
+        notifyIcon.ContextMenuStrip.Items.Add(menuItemMainWindow);
+    }
+
+    private void AddNotifyIconSeparator()
+    {
+        var separator = new ToolStripSeparator();
+        notifyIcon.ContextMenuStrip.Items.Add(separator);
+    }
+
+    private void SettingsManager_SettingValueChanged(string name, object value)
+    {
+        switch (name)
+        {
+            case "ToastEnable":
+                ToastManager.IsEnabled = Convert.ToBoolean(value);
+                break;
+            case "DesktopProfileOnStart":
+                if (SettingsManager.IsInitialized)
+                    break;
+
+                var DesktopLayout = Convert.ToBoolean(value);
+                SettingsManager.SetProperty("DesktopLayoutEnabled", DesktopLayout, false, true);
+                break;
+        }
+    }
+
+    public void SwapWindowState()
+    {
+        // UI thread
+        Application.Current.Dispatcher.Invoke(() =>
+        {
+            switch (WindowState)
+            {
+                case WindowState.Normal:
+                case WindowState.Maximized:
+                    WindowState = WindowState.Minimized;
+                    break;
+                case WindowState.Minimized:
+                    WindowState = prevWindowState;
+                    break;
+            }
+        });
+    }
+
+    public static MainWindow GetCurrent()
+    {
+        return CurrentWindow;
+    }
+
+    private void loadPages()
+    {
+        // initialize pages
+        controllerPage = new ControllerPage("controller");
+        controllerPage.Loaded += ControllerPage_Loaded;
+
+        devicePage = new DevicePage("device");
+        profilesPage = new ProfilesPage("profiles");
         settingsPage = new SettingsPage("settings");
-        aboutPage = new AboutPage("about");
-        overlayPage = new OverlayPage("overlay");
+
+        overlayPage = new OverlayPage("overlay");
         hotkeysPage = new HotkeysPage("hotkeys");
-        layoutPage = new LayoutPage("layout", navView);
-        notificationsPage = new NotificationsPage("notifications");
-        notificationsPage.StatusChanged += NotificationsPage_LayoutUpdated;
 
-        // store pages
-        _pages.Add("ControllerPage", controllerPage);
+        notificationsPage = new NotificationsPage("notifications");
+        notificationsPage.StatusChanged += NotificationsPage_LayoutUpdated;
+
+        // store pages
+        _pages.Add("ControllerPage", controllerPage);
         _pages.Add("DevicePage", devicePage);
-        _pages.Add("PerformancePage", performancePage);
-        _pages.Add("ProfilesPage", profilesPage);
-        _pages.Add("AboutPage", aboutPage);
-        _pages.Add("OverlayPage", overlayPage);
-        _pages.Add("SettingsPage", settingsPage);
-        _pages.Add("HotkeysPage", hotkeysPage);
-        _pages.Add("LayoutPage", layoutPage);
-        _pages.Add("NotificationsPage", notificationsPage);
-    }
-
-    private void loadWindows()
-    {
-        // initialize overlay
-        overlayModel = new OverlayModel();
-        overlayTrackpad = new OverlayTrackpad();
-        overlayquickTools = new OverlayQuickTools();
-    }
-
-    private void GenericDeviceUpdated(PnPDevice device, DeviceEventArgs obj)
-    {
-        // todo: improve me
-        CurrentDevice.PullSensors();
-
-        aboutPage.UpdateDevice(device);
-        settingsPage.UpdateDevice(device);
-    }
-
-    private void InputsManager_TriggerRaised(string listener, InputsChord input, InputsHotkeyType type, bool IsKeyDown,
-        bool IsKeyUp)
-    {
-        switch (listener)
-        {
-            case "quickTools":
-                overlayquickTools.ToggleVisibility();
-                break;
-            case "overlayGamepad":
-                overlayModel.ToggleVisibility();
-                break;
-            case "overlayTrackpads":
-                overlayTrackpad.ToggleVisibility();
-                break;
-            case "shortcutMainwindow":
-                SwapWindowState();
-                break;
-        }
-    }
-
-    private void MenuItem_Click(object? sender, EventArgs e)
-    {
-        switch (((ToolStripMenuItem)sender).Tag)
-        {
-            case "MainWindow":
-                SwapWindowState();
-                break;
-            case "QuickTools":
-                overlayquickTools.ToggleVisibility();
-                break;
-            case "Exit":
-                appClosing = true;
-                Close();
-                break;
-        }
-    }
-
-    private void Window_Loaded(object sender, RoutedEventArgs e)
-    {
-        // load gamepad navigation maanger
-        gamepadFocusManager = new(this, ContentFrame);
-
-        HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
-        source.AddHook(WndProc); // Hook into the window's message loop
-    }
-
-    private void ControllerPage_Loaded(object sender, RoutedEventArgs e)
-    {
-        if (IsReady)
-            return;
-
-        // hide splashscreen
-        if (splashScreen is not null)
-            splashScreen.Close();
-
-        // home page has loaded, display main window
-        WindowState = SettingsManager.GetBoolean("StartMinimized")
-            ? WindowState.Minimized
-            : (WindowState)SettingsManager.GetInt("MainWindowState");
-        prevWindowState = (WindowState)SettingsManager.GetInt("MainWindowPrevState");
-
-        IsReady = true;
-    }
-
-    private void NotificationsPage_LayoutUpdated(int status)
-    {
-        bool hasNotification = Convert.ToBoolean(status);
-
-        // UI thread (async)
-        Application.Current.Dispatcher.BeginInvoke(() =>
-        {
-            HasNotifications.Visibility = hasNotification ? Visibility.Visible : Visibility.Collapsed;
-        });
-    }
-
-    private void VirtualManager_ControllerSelected(HIDmode HIDmode)
-    {
-        Application.Current.Dispatcher.BeginInvoke(() =>
-        {
-            overlayModel.UpdateHIDMode(HIDmode);
-        });
-        CurrentDevice.SetKeyPressDelay(HIDmode);
-    }
-
-    public void UpdateSettings(Dictionary<string, string> args)
-    {
-        foreach (var pair in args)
-        {
-            var name = pair.Key;
-            var property = pair.Value;
-
-            switch (name)
-            {
-                case "DSUEnabled":
-                    break;
-                case "DSUip":
-                    break;
-                case "DSUport":
-                    break;
-            }
-        }
-    }
-
-    // no code from the cases inside this function will be called on program start
-    private async void OnSystemStatusChanged(PowerManager.SystemStatus status, PowerManager.SystemStatus prevStatus)
-    {
-        if (status == prevStatus)
-            return;
-
-        switch (status)
-        {
-            case PowerManager.SystemStatus.SystemReady:
-                {
-                    // resume from sleep
-                    if (prevStatus == PowerManager.SystemStatus.SystemPending)
-                    {
-                        // use device-specific delay
-                        await Task.Delay(CurrentDevice.ResumeDelay);
-
-                        // restore inputs manager
-                        InputsManager.Start();
-
-                        // start timer manager
-                        TimerManager.Start();
-
-                        // resume the virtual controller last
-                        VirtualManager.Resume();
-
-                        // restart IMU
-                        SensorsManager.Resume(true);
-                    }
-
-                    // open device, when ready
-                    new Thread(() =>
-                    {
-                        // wait for all HIDs to be ready
-                        while (!CurrentDevice.IsReady())
-                            Thread.Sleep(500);
-
-                        // open current device (threaded to avoid device to hang)
-                        CurrentDevice.Open();
-                    }).Start();
-                }
-                break;
-
-            case PowerManager.SystemStatus.SystemPending:
-                // sleep
-                {
-                    // stop the virtual controller
-                    VirtualManager.Suspend();
-
-                    // stop timer manager
-                    TimerManager.Stop();
-
-                    // stop sensors
-                    SensorsManager.Stop();
 
-                    // pause inputs manager
-                    InputsManager.Stop();
-
-                    // close current device
-                    CurrentDevice.Close();
-                }
-                break;
-        }
-    }
-
-    #region UI
-
-    private void navView_ItemInvoked(NavigationView sender, NavigationViewItemInvokedEventArgs args)
-    {
-        if (args.InvokedItemContainer is not null)
-        {
-            var navItem = (NavigationViewItem)args.InvokedItemContainer;
-            var navItemTag = (string)navItem.Tag;
-
-            switch (navItemTag)
-            {
-                default:
-                    preNavItemTag = navItemTag;
-                    break;
-            }
-
-            NavView_Navigate(preNavItemTag);
-        }
-    }
-
-    public void NavView_Navigate(string navItemTag)
-    {
-        var item = _pages.FirstOrDefault(p => p.Key.Equals(navItemTag));
-        var _page = item.Value;
-
-        // Get the page type before navigation so you can prevent duplicate
-        // entries in the backstack.
-        var preNavPageType = ContentFrame.CurrentSourcePageType;
-
-        // Only navigate if the selected page isn't currently loaded.
-        if (!(_page is null) && !Equals(preNavPageType, _page)) NavView_Navigate(_page);
-    }
-
-    public static void NavView_Navigate(Page _page)
-    {
-        CurrentWindow.ContentFrame.Navigate(_page);
-        CurrentWindow.scrollViewer.ScrollToTop();
-    }
-
-    private void navView_BackRequested(NavigationView sender, NavigationViewBackRequestedEventArgs args)
-    {
-        TryGoBack();
-    }
-
-    private void Window_Closed(object sender, EventArgs e)
-    {
-        CurrentDevice.Close();
-
-        notifyIcon.Visible = false;
-        notifyIcon.Dispose();
-
-        overlayModel.Close();
-        overlayTrackpad.Close();
-        overlayquickTools.Close(true);
-
-        VirtualManager.Stop();
-        SystemManager.Stop();
-        MotionManager.Stop();
-        SensorsManager.Stop();
-        ControllerManager.Stop();
-        InputsManager.Stop();
-        DeviceManager.Stop();
-        PlatformManager.Stop();
-        OSDManager.Stop();
-        PowerProfileManager.Stop();
-        ProfileManager.Stop();
-        LayoutManager.Stop();
-        PowerManager.Stop();
-        ProcessManager.Stop();
-        ToastManager.Stop();
-        TaskManager.Stop();
-        PerformanceManager.Stop();
-        UpdateManager.Stop();
-
-        // closing page(s)
-        controllerPage.Page_Closed();
-        profilesPage.Page_Closed();
-        settingsPage.Page_Closed();
-        overlayPage.Page_Closed();
-        hotkeysPage.Page_Closed();
-        layoutPage.Page_Closed();
-        notificationsPage.Page_Closed();
-
-        // force kill application
-        Environment.Exit(0);
-    }
-
-    private async void Window_Closing(object sender, CancelEventArgs e)
-    {
-        // position and size settings
-        switch (WindowState)
-        {
-            case WindowState.Normal:
-                SettingsManager.SetProperty("MainWindowLeft", Left);
-                SettingsManager.SetProperty("MainWindowTop", Top);
-                SettingsManager.SetProperty("MainWindowWidth", ActualWidth);
-                SettingsManager.SetProperty("MainWindowHeight", ActualHeight);
-                break;
-            case WindowState.Maximized:
-                SettingsManager.SetProperty("MainWindowLeft", 0);
-                SettingsManager.SetProperty("MainWindowTop", 0);
-                SettingsManager.SetProperty("MainWindowWidth", SystemParameters.MaximizedPrimaryScreenWidth);
-                SettingsManager.SetProperty("MainWindowHeight", SystemParameters.MaximizedPrimaryScreenHeight);
-
-                break;
-        }
-
-        SettingsManager.SetProperty("MainWindowState", (int)WindowState);
-        SettingsManager.SetProperty("MainWindowPrevState", (int)prevWindowState);
-
-        SettingsManager.SetProperty("MainWindowIsPaneOpen", navView.IsPaneOpen);
-
-        if (SettingsManager.GetBoolean("CloseMinimises") && !appClosing)
-        {
-            e.Cancel = true;
-            WindowState = WindowState.Minimized;
-            return;
-        }
-    }
-
-    private void Window_StateChanged(object sender, EventArgs e)
-    {
-        switch (WindowState)
-        {
-            case WindowState.Minimized:
-                notifyIcon.Visible = true;
-                ShowInTaskbar = false;
-
-                if (!NotifyInTaskbar)
-                {
-                    ToastManager.SendToast(Title, "is running in the background");
-                    NotifyInTaskbar = true;
-                }
-
-                break;
-            case WindowState.Normal:
-            case WindowState.Maximized:
-                notifyIcon.Visible = false;
-                ShowInTaskbar = true;
-
-                Activate();
-                Topmost = true;  // important
-                Topmost = false; // important
-                Focus();
-
-                prevWindowState = WindowState;
-                break;
-        }
-    }
-
-    private void navView_Loaded(object sender, RoutedEventArgs e)
-    {
-        // Add handler for ContentFrame navigation.
-        ContentFrame.Navigated += On_Navigated;
-
-        // NavView doesn't load any page by default, so load home page.
-        navView.SelectedItem = navView.MenuItems[0];
-
-        // If navigation occurs on SelectionChanged, this isn't needed.
-        // Because we use ItemInvoked to navigate, we need to call Navigate
-        // here to load the home page.
-        preNavItemTag = "ControllerPage";
-        NavView_Navigate(preNavItemTag);
-    }
-
-    private void GamepadWindow_PreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
-    {
-        if (!e.NewFocus.GetType().IsSubclassOf(typeof(Control)))
-            return;
-
-        GamepadFocusManagerOnFocused((Control)e.NewFocus);
-    }
-
-    private void GamepadWindow_PreviewLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
-    {
-        // do something
-    }
-
-    private bool TryGoBack()
-    {
-        if (!ContentFrame.CanGoBack)
-            return false;
-
-        // Don't go back if the nav pane is overlayed.
-        if (navView.IsPaneOpen &&
-            (navView.DisplayMode == NavigationViewDisplayMode.Compact ||
-             navView.DisplayMode == NavigationViewDisplayMode.Minimal))
-            return false;
-
-        ContentFrame.GoBack();
-        return true;
-    }
-
-    private void On_Navigated(object sender, NavigationEventArgs e)
-    {
-        navView.IsBackEnabled = ContentFrame.CanGoBack;
-
-        if (ContentFrame.SourcePageType is not null)
-        {
-            CurrentPageName = ContentFrame.CurrentSourcePageType.Name;
-
-            var NavViewItem = navView.MenuItems
-                .OfType<NavigationViewItem>()
-                .Where(n => n.Tag.Equals(CurrentPageName)).FirstOrDefault();
-
-            if (!(NavViewItem is null))
-                navView.SelectedItem = NavViewItem;
+        _pages.Add("ProfilesPage", profilesPage);
 
-            navView.Header = new TextBlock() { Text = (string)((Page)e.Content).Title };
-        }
-    }
+        _pages.Add("OverlayPage", overlayPage);
+        _pages.Add("SettingsPage", settingsPage);
+        _pages.Add("HotkeysPage", hotkeysPage);
 
-    #endregion
-}
+        _pages.Add("NotificationsPage", notificationsPage);
+    }
+
+    private void LoadPages_MVVM()
+    {
+        layoutPage = new LayoutPage("layout", navView);
+        layoutPage.Initialize();
+
+        performancePage = new PerformancePage();
+        aboutPage = new AboutPage();
+
+        _pages.Add("LayoutPage", layoutPage);
+        _pages.Add("PerformancePage", performancePage);
+        _pages.Add("AboutPage", aboutPage);
+    }
+
+    private void loadWindows()
+    {
+        // initialize overlay
+        overlayModel = new OverlayModel();
+        overlayTrackpad = new OverlayTrackpad();
+        overlayquickTools = new OverlayQuickTools();
+    }
+
+    private void GenericDeviceUpdated(PnPDevice device, DeviceEventArgs obj)
+    {
+        // todo: improve me
+        CurrentDevice.PullSensors();
+    }
+
+    private void InputsManager_TriggerRaised(string listener, InputsChord input, InputsHotkeyType type, bool IsKeyDown,
+        bool IsKeyUp)
+    {
+        switch (listener)
+        {
+            case "quickTools":
+                overlayquickTools.ToggleVisibility();
+                break;
+            case "overlayGamepad":
+                overlayModel.ToggleVisibility();
+                break;
+            case "overlayTrackpads":
+                overlayTrackpad.ToggleVisibility();
+                break;
+            case "shortcutMainwindow":
+                SwapWindowState();
+                break;
+        }
+    }
+
+    private void MenuItem_Click(object? sender, EventArgs e)
+    {
+        switch (((ToolStripMenuItem)sender).Tag)
+        {
+            case "MainWindow":
+                SwapWindowState();
+                break;
+            case "QuickTools":
+                overlayquickTools.ToggleVisibility();
+                break;
+            case "Exit":
+                appClosing = true;
+                Close();
+                break;
+        }
+    }
+
+    private void Window_Loaded(object sender, RoutedEventArgs e)
+    {
+        // load gamepad navigation maanger
+        gamepadFocusManager = new(this, ContentFrame);
+
+        HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
+        source.AddHook(WndProc); // Hook into the window's message loop
+
+        // restore window state
+        WindowState = SettingsManager.GetBoolean("StartMinimized") ? WindowState.Minimized : (WindowState)SettingsManager.GetInt("MainWindowState");
+        prevWindowState = (WindowState)SettingsManager.GetInt("MainWindowPrevState");
+    }
+
+    private void ControllerPage_Loaded(object sender, RoutedEventArgs e)
+    {
+        // hide splashscreen
+        if (SplashScreen is not null)
+            SplashScreen.Close();
+
+        // home page is ready, display main window
+        this.Visibility = Visibility.Visible;
+    }
+
+    private void NotificationsPage_LayoutUpdated(int status)
+    {
+        bool hasNotification = Convert.ToBoolean(status);
+
+        // UI thread (async)
+        Application.Current.Dispatcher.Invoke(() =>
+        {
+            HasNotifications.Visibility = hasNotification ? Visibility.Visible : Visibility.Collapsed;
+        });
+    }
+
+    // no code from the cases inside this function will be called on program start
+    private async void OnSystemStatusChanged(SystemManager.SystemStatus status, SystemManager.SystemStatus prevStatus)
+    {
+        if (status == prevStatus)
+            return;
+
+        switch (status)
+        {
+            case SystemManager.SystemStatus.SystemReady:
+                {
+                    if (prevStatus == SystemManager.SystemStatus.SystemPending)
+                    {
+                        // when device resumes from sleep
+                        // use device-specific delay
+                        await Task.Delay(CurrentDevice.ResumeDelay);
+
+                        // resume manager(s)
+                        InputsManager.Start();
+                        TimerManager.Start();
+                        VirtualManager.Resume(true);
+                        SensorsManager.Resume(true);
+                        GPUManager.Start();
+
+                        // resume platform(s)
+                        PlatformManager.LibreHardwareMonitor.Start();
+                    }
+
+                    // open device, when ready
+                    new Thread(() =>
+                    {
+                        // wait for all HIDs to be ready
+                        while (!CurrentDevice.IsReady())
+                            Thread.Sleep(100);
+
+                        // open current device (threaded to avoid device to hang)
+                        CurrentDevice.Open();
+                    }).Start();
+                }
+                break;
+
+            case SystemManager.SystemStatus.SystemPending:
+                {
+                    // when device goes to sleep
+                    // suspend manager(s)
+                    VirtualManager.Suspend(true);
+                    TimerManager.Stop();
+                    SensorsManager.Stop();
+                    InputsManager.Stop();
+                    GPUManager.Stop();
+
+                    // suspend platform(s)
+                    PlatformManager.LibreHardwareMonitor.Stop();
+
+                    // close current device
+                    CurrentDevice.Close();
+
+                    // Allow system to sleep
+                    SystemManager.SetThreadExecutionState(SystemManager.ES_CONTINUOUS);
+                    LogManager.LogDebug("Tasks completed. System can now suspend if needed.");
+                }
+                break;
+        }
+    }
+
+    #region UI
+
+    private void navView_ItemInvoked(NavigationView sender, NavigationViewItemInvokedEventArgs args)
+    {
+        if (args.InvokedItemContainer is not null)
+        {
+            var navItem = (NavigationViewItem)args.InvokedItemContainer;
+            var navItemTag = (string)navItem.Tag;
+
+            switch (navItemTag)
+            {
+                default:
+                    preNavItemTag = navItemTag;
+                    break;
+            }
+
+            NavView_Navigate(preNavItemTag);
+        }
+    }
+
+    public void NavView_Navigate(string navItemTag)
+    {
+        var item = _pages.FirstOrDefault(p => p.Key.Equals(navItemTag));
+        var _page = item.Value;
+
+        // Get the page type before navigation so you can prevent duplicate
+        // entries in the backstack.
+        var preNavPageType = ContentFrame.CurrentSourcePageType;
+
+        // Only navigate if the selected page isn't currently loaded.
+        if (!(_page is null) && !Equals(preNavPageType, _page)) NavView_Navigate(_page);
+    }
+
+    public static void NavView_Navigate(Page _page)
+    {
+        CurrentWindow.ContentFrame.Navigate(_page);
+        CurrentWindow.scrollViewer.ScrollToTop();
+    }
+
+    private void navView_BackRequested(NavigationView sender, NavigationViewBackRequestedEventArgs args)
+    {
+        TryGoBack();
+    }
+
+    private void Window_Closed(object sender, EventArgs e)
+    {
+        CurrentDevice.Close();
+
+        notifyIcon.Visible = false;
+        notifyIcon.Dispose();
+
+        overlayModel.Close();
+        overlayTrackpad.Close();
+        overlayquickTools.Close(true);
+
+        VirtualManager.Stop();
+        MultimediaManager.Stop();
+        GPUManager.Stop();
+        MotionManager.Stop();
+        SensorsManager.Stop();
+        ControllerManager.Stop();
+        InputsManager.Stop();
+        DeviceManager.Stop();
+        PlatformManager.Stop();
+        OSDManager.Stop();
+        PowerProfileManager.Stop();
+        ProfileManager.Stop();
+        LayoutManager.Stop();
+        SystemManager.Stop();
+        ProcessManager.Stop();
+        ToastManager.Stop();
+        TaskManager.Stop();
+        PerformanceManager.Stop();
+        UpdateManager.Stop();
+
+        // closing page(s)
+        controllerPage.Page_Closed();
+        profilesPage.Page_Closed();
+        settingsPage.Page_Closed();
+        overlayPage.Page_Closed();
+        hotkeysPage.Page_Closed();
+        layoutPage.Page_Closed();
+        notificationsPage.Page_Closed();
+
+        // force kill application
+        Environment.Exit(0);
+    }
+
+    private async void Window_Closing(object sender, CancelEventArgs e)
+    {
+        // position and size settings
+        switch (WindowState)
+        {
+            case WindowState.Normal:
+                SettingsManager.SetProperty("MainWindowLeft", Left);
+                SettingsManager.SetProperty("MainWindowTop", Top);
+                SettingsManager.SetProperty("MainWindowWidth", ActualWidth);
+                SettingsManager.SetProperty("MainWindowHeight", ActualHeight);
+                break;
+            case WindowState.Maximized:
+                SettingsManager.SetProperty("MainWindowLeft", 0);
+                SettingsManager.SetProperty("MainWindowTop", 0);
+                SettingsManager.SetProperty("MainWindowWidth", SystemParameters.MaximizedPrimaryScreenWidth);
+                SettingsManager.SetProperty("MainWindowHeight", SystemParameters.MaximizedPrimaryScreenHeight);
+
+                break;
+        }
+
+        SettingsManager.SetProperty("MainWindowState", (int)WindowState);
+        SettingsManager.SetProperty("MainWindowPrevState", (int)prevWindowState);
+
+        SettingsManager.SetProperty("MainWindowIsPaneOpen", navView.IsPaneOpen);
+
+        if (SettingsManager.GetBoolean("CloseMinimises") && !appClosing)
+        {
+            e.Cancel = true;
+            WindowState = WindowState.Minimized;
+            return;
+        }
+    }
+
+    private void Window_StateChanged(object sender, EventArgs e)
+    {
+        switch (WindowState)
+        {
+            case WindowState.Minimized:
+                notifyIcon.Visible = true;
+                ShowInTaskbar = false;
+
+                if (!NotifyInTaskbar)
+                {
+                    ToastManager.SendToast(Title, "is running in the background");
+                    NotifyInTaskbar = true;
+                }
+
+                break;
+            case WindowState.Normal:
+            case WindowState.Maximized:
+                notifyIcon.Visible = false;
+                ShowInTaskbar = true;
+
+                Activate();
+                Topmost = true;  // important
+                Topmost = false; // important
+                Focus();
+
+                prevWindowState = WindowState;
+                break;
+        }
+    }
+
+    private void navView_Loaded(object sender, RoutedEventArgs e)
+    {
+        // Add handler for ContentFrame navigation.
+        ContentFrame.Navigated += On_Navigated;
+
+        // NavView doesn't load any page by default, so load home page.
+        navView.SelectedItem = navView.MenuItems[0];
+
+        // If navigation occurs on SelectionChanged, this isn't needed.
+        // Because we use ItemInvoked to navigate, we need to call Navigate
+        // here to load the home page.
+        preNavItemTag = "ControllerPage";
+        NavView_Navigate(preNavItemTag);
+    }
+
+    private void GamepadWindow_PreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+    {
+        if (!e.NewFocus.GetType().IsSubclassOf(typeof(Control)))
+            return;
+
+        GamepadFocusManagerOnFocused((Control)e.NewFocus);
+    }
+
+    private void GamepadWindow_PreviewLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+    {
+        // do something
+    }
+
+    private bool TryGoBack()
+    {
+        if (!ContentFrame.CanGoBack)
+            return false;
+
+        // Don't go back if the nav pane is overlayed.
+        if (navView.IsPaneOpen &&
+            (navView.DisplayMode == NavigationViewDisplayMode.Compact ||
+             navView.DisplayMode == NavigationViewDisplayMode.Minimal))
+            return false;
+
+        ContentFrame.GoBack();
+        return true;
+    }
+
+    private void On_Navigated(object sender, NavigationEventArgs e)
+    {
+        navView.IsBackEnabled = ContentFrame.CanGoBack;
+
+        if (ContentFrame.SourcePageType is not null)
+        {
+            CurrentPageName = ContentFrame.CurrentSourcePageType.Name;
+
+            var NavViewItem = navView.MenuItems
+                .OfType<NavigationViewItem>()
+                .Where(n => n.Tag.Equals(CurrentPageName)).FirstOrDefault();
+
+            if (!(NavViewItem is null))
+                navView.SelectedItem = NavViewItem;
+
+            navView.Header = new TextBlock() { Text = (string)((Page)e.Content).Title };
+        }
+    }
+
+    #endregion
+}
diff --git a/HandheldCompanion/WMI.cs b/HandheldCompanion/WMI.cs
index af49c8525..c80017378 100644
--- a/HandheldCompanion/WMI.cs
+++ b/HandheldCompanion/WMI.cs
@@ -1,4 +1,5 @@
 using HandheldCompanion.Extensions;
+using HandheldCompanion.Managers;
 using HandheldCompanion.Utils;
 using System;
 using System.Collections.Generic;
@@ -51,7 +52,8 @@ public static async Task<IEnumerable<T>> ReadAsync<T>(string scope, FormattableS
             }
             catch (ManagementException ex)
             {
-                throw new ManagementException($"Read failed: {ex.Message}. [scope={scope}, query={query}]", ex);
+                LogManager.LogError($"Read failed: {ex.Message}. [scope={scope}, query={query}]", ex);
+                return Enumerable.Empty<T>();
             }
         }
 
@@ -62,7 +64,11 @@ public static async Task CallAsync(string scope, FormattableString query, string
                 var queryFormatted = query.ToString(WMIPropertyValueFormatter.Instance);
                 var mos = new ManagementObjectSearcher(scope, queryFormatted);
                 var managementObjects = await mos.GetAsync().ConfigureAwait(false);
-                var managementObject = managementObjects.FirstOrDefault() ?? throw new InvalidOperationException("No results in query");
+                var managementObject = managementObjects.FirstOrDefault();
+
+                // Check if managementObject is null and return the default value
+                if (managementObject == null)
+                    return;
 
                 var mo = (ManagementObject)managementObject;
                 var methodParamsObject = mo.GetMethodParameters(methodName);
@@ -73,19 +79,26 @@ public static async Task CallAsync(string scope, FormattableString query, string
             }
             catch (ManagementException ex)
             {
-                throw new ManagementException($"Call failed: {ex.Message}. [scope={scope}, query={query}, methodName={methodName}]", ex);
+                LogManager.LogError($"Call failed: {ex.Message}. [scope={scope}, query={query}, methodName={methodName}]", ex);
             }
         }
 
         public static async Task<T> CallAsync<T>(string scope, FormattableString query, string methodName, Dictionary<string, object> methodParams, Func<PropertyDataCollection, T> converter)
         {
+            // Define a default value for the type T
+            T defaultValue = default(T);
+
             try
             {
                 var queryFormatted = query.ToString(WMIPropertyValueFormatter.Instance);
 
                 var mos = new ManagementObjectSearcher(scope, queryFormatted);
                 var managementObjects = await mos.GetAsync().ConfigureAwait(false);
-                var managementObject = managementObjects.FirstOrDefault() ?? throw new InvalidOperationException("No results in query");
+                var managementObject = managementObjects.FirstOrDefault();
+
+                // Check if managementObject is null and return the default value
+                if (managementObject == null)
+                    return defaultValue;
 
                 var mo = (ManagementObject)managementObject;
                 var methodParamsObject = mo.GetMethodParameters(methodName);
@@ -98,7 +111,9 @@ public static async Task<T> CallAsync<T>(string scope, FormattableString query,
             }
             catch (ManagementException ex)
             {
-                throw new ManagementException($"Call failed: {ex.Message}. [scope={scope}, query={query}, methodName={methodName}]", ex);
+                // Log the exception details and return the default value
+                LogManager.LogError($"Call failed: {ex.Message}. [scope={scope}, query={query}, methodName={methodName}]");
+                return defaultValue;
             }
         }
 
diff --git a/README.md b/README.md
index db7a2b50b..155b1e7e3 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ A few examples of the most common use cases are:
 - You want to add universal motion controls (UMC) to any game.
 - You want to add high-precision motion controls to your Windows game library through [Steam](https://store.steampowered.com/controller/update/dec15).
 - You want to play your Sony Playstation 4 library through [PlayStation Now](https://www.playstation.com/en-us/ps-now/) or [PS4 Remote Play](<https://remoteplay.dl.playstation.net/remoteplay/>).
-- You want to enjoy all your [Wii](https://dolphin-emu.org/), [WiiU](https://cemu.info/) and [Switch](https://yuzu-emu.org/) games with full motion controls through UDP motion control protocol.
+- You want to enjoy all your [Wii](https://dolphin-emu.org/), [WiiU](https://cemu.info/) and [Switch](https://ryujinx.org/) games with full motion controls through UDP motion control protocol.
 
 [Youtube Channel](https://www.youtube.com/channel/UCFLra6QVYJYeaWp2mGaq3Og)
 
diff --git a/utils/Utils.iss b/utils/Utils.iss
index 1ace4e7bb..3c839b6dc 100644
--- a/utils/Utils.iss
+++ b/utils/Utils.iss
@@ -29,7 +29,7 @@ end;
 function isHidHideInstalled():boolean;
 begin
   result:= false;
-  if(FileExists(ExpandConstant('{commonpf}') + '\Nefarius Software Solutions\HidHide\HidHide_Updater.exe')) then
+  if(FileExists(ExpandConstant('{commonpf}') + '\Nefarius Software Solutions\HidHide\x64\HidHideClient.exe')) then
   begin
     log('HidHide is already installed.');
     result:= true; 
@@ -42,7 +42,7 @@ var
   versionNumber, filePath:string;
 begin
   result:= '';
-  filePath:= ExpandConstant('{commonpf}') + '\Nefarius Software Solutions\HidHide\HidHide_Updater.exe';
+  filePath:= ExpandConstant('{commonpf}') + '\Nefarius Software Solutions\HidHide\x64\HidHideClient.exe';
 
   if(FileExists(filePath)) then
   begin