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

New Crowdin updates

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Publish
       run: |
         dotnet publish app/GHelper.sln --configuration Release --runtime win-x64 -p:PublishSingleFile=true --no-self-contained
-        powershell Compress-Archive app/bin/x64/Release/net7.0-windows8.0/win-x64/publish/* GHelper.zip
+        powershell Compress-Archive app/bin/x64/Release/net7.0-windows/win-x64/publish/* GHelper.zip
     - name: Upload
       env:
         GH_TOKEN: ${{ github.token }}

app/AnimeMatrix/AniMatrixControl.cs

@@ -70,6 +70,7 @@ namespace GHelper.AnimeMatrix
             if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
             {
                 mat.SetDisplayState(false);
+                mat.SetDisplayState(false); // some devices are dumb
                 Logger.WriteLine("Matrix Off");
             }
             else

app/AnimeMatrix/Communication/Device.cs

@@ -6,11 +6,17 @@ namespace GHelper.AnimeMatrix.Communication
 {
     public abstract class Device : IDisposable
     {
-        private static UsbProvider _usbProvider;
+        protected UsbProvider? _usbProvider;
 
-        private static ushort _vendorId;
-        private static ushort _productId;
-        private static int _maxFeatureReportLength;
+        protected ushort _vendorId;
+        protected ushort _productId;
+        protected int _maxFeatureReportLength;
+
+        protected Device(ushort vendorId, ushort productId)
+        {
+            _vendorId = vendorId;
+            _productId = productId;
+        }
 
         protected Device(ushort vendorId, ushort productId, int maxFeatureReportLength)
         {
@@ -20,7 +26,17 @@ namespace GHelper.AnimeMatrix.Communication
             SetProvider();
         }
 
-        public void SetProvider()
+        public ushort VendorID()
+        {
+            return _vendorId;
+        }
+
+        public ushort ProductID()
+        {
+            return _productId;
+        }
+
+        public virtual void SetProvider()
         {
             _usbProvider = new WindowsUsbProvider(_vendorId, _productId, _maxFeatureReportLength);
         }
@@ -36,7 +52,12 @@ namespace GHelper.AnimeMatrix.Communication
         public byte[] Get(Packet packet)
             => _usbProvider?.Get(packet.Data);
 
-        public void Dispose()
+        public void Read(byte[] data)
+            => _usbProvider?.Read(data);
+        public void Write(byte[] data)
+            => _usbProvider?.Write(data);
+
+        public virtual void Dispose()
         {
             _usbProvider?.Dispose();
         }

app/AnimeMatrix/Communication/Platform/UsbProvider.cs

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

app/AnimeMatrix/Communication/Platform/WindowsUsbProvider.cs

@@ -8,6 +8,27 @@ namespace GHelper.AnimeMatrix.Communication.Platform
         protected HidDevice HidDevice { get; }
         protected HidStream HidStream { get; }
 
+        public WindowsUsbProvider(ushort vendorId, ushort productId, string path, int timeout = 500) : base(vendorId, productId)
+        {
+            try
+            {
+                HidDevice = DeviceList.Local.GetHidDevices(vendorId, productId)
+                   .First(x => x.DevicePath.Contains(path));
+            }
+            catch
+            {
+                throw new IOException("HID device was not found on your machine.");
+            }
+
+            var config = new OpenConfiguration();
+            config.SetOption(OpenOption.Interruptible, true);
+            config.SetOption(OpenOption.Exclusive, false);
+            config.SetOption(OpenOption.Priority, 10);
+            HidStream = HidDevice.Open(config);
+            HidStream.ReadTimeout = timeout;
+            HidStream.WriteTimeout = timeout;
+        }
+
         public WindowsUsbProvider(ushort vendorId, ushort productId, int maxFeatureReportLength)
             : base(vendorId, productId)
         {
@@ -53,6 +74,23 @@ namespace GHelper.AnimeMatrix.Communication.Platform
             return data;
         }
 
+        public override void Read(byte[] data)
+        {
+            WrapException(() =>
+            {
+                HidStream.Read(data);
+            });
+        }
+
+        public override void Write(byte[] data)
+        {
+            WrapException(() =>
+            {
+                HidStream.Write(data);
+                HidStream.Flush();
+            });
+        }
+
         public override void Dispose()
         {
             HidStream.Dispose();

app/AppConfig.cs

@@ -96,8 +96,15 @@ public static class AppConfig
     public static int Get(string name, int empty = -1)
     {
         if (config.ContainsKey(name))
+        {
+            //Debug.WriteLine(name);
             return int.Parse(config[name].ToString());
-        else return empty;
+        }
+        else
+        {
+            //Debug.WriteLine(name + "E");
+            return empty;
+        }
     }
 
     public static bool Is(string name)

app/AsusACPI.cs

@@ -92,6 +92,9 @@ public class AsusACPI
     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;
@@ -326,9 +329,13 @@ public class AsusACPI
         if (curve.All(singleByte => singleByte == 0)) return -1;
 
         int result;
+        int fanScale = AppConfig.Get("fan_scale", 100);
 
-        for (int i = 8; i < curve.Length; i++)
-            curve[i] = Math.Max((byte)0, Math.Min((byte)99, curve[i])); // it seems to be a bug, when some old model's bios can go nuts if fan is set to 100% 
+        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)
         {

app/AsusMouseSettings.cs

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

app/AsusMouseSettings.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!--
+    Microsoft ResX Schema 
+
+    Version 2.0
+
+    The primary goals of this format is to allow a simple XML format
+    that is mostly human readable. The generation and parsing of the
+    various data types are done through the TypeConverter classes
+    associated with the data types.
+
+    Example:
+
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+
+    There are any number of "resheader" rows that contain simple
+    name/value pairs.
+
+    Each data row contains a name, and value. The row also contains a
+    type or mimetype. Type corresponds to a .NET class that support
+    text/value conversion through the TypeConverter architecture.
+    Classes that don't support this are serialized and stored with the
+    mimetype set.
+
+    The mimetype is used for serialized objects, and tells the
+    ResXResourceReader how to depersist the object. This is currently not
+    extensible. For a given mimetype the value must be set accordingly:
+
+    Note - application/x-microsoft.net.object.binary.base64 is the format
+    that the ResXResourceWriter will generate, however the reader can
+    read any of the formats listed below.
+
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

app/AsusUSB.cs

@@ -1,56 +1,43 @@
-using HidLibrary;
+using GHelper.Helpers;
+using HidLibrary;
+using System.Diagnostics;
 using System.Text;
 
 namespace GHelper
 {
 
-    [Flags]
-    public enum AuraDev19b6 : uint
+
+    public class AuraPower
     {
-        BootLogo = 1,
-        BootKeyb = 1 << 1,
-        AwakeLogo = 1 << 2,
-        AwakeKeyb = 1 << 3,
-        SleepLogo = 1 << 4,
-        SleepKeyb = 1 << 5,
-        ShutdownLogo = 1 << 6,
-        ShutdownKeyb = 1 << 7,
-        BootBar = 1u << (7 + 2),
-        AwakeBar = 1u << (7 + 3),
-        SleepBar = 1u << (7 + 4),
-        ShutdownBar = 1u << (7 + 5),
-        BootLid = 1u << (15 + 1),
-        AwakeLid = 1u << (15 + 2),
-        SleepLid = 1u << (15 + 3),
-        ShutdownLid = 1u << (15 + 4)
-    }
+        public bool BootLogo;
+        public bool BootKeyb;
+        public bool AwakeLogo;
+        public bool AwakeKeyb;
+        public bool SleepLogo;
+        public bool SleepKeyb;
+        public bool ShutdownLogo;
+        public bool ShutdownKeyb;
 
-    public static class AuraDev19b6Extensions
-    {
-        public static byte[] ToBytes(this AuraDev19b6[] controls)
-        {
-            uint a = 0;
-            foreach (var n in controls)
-            {
-                a |= (uint)n;
-            }
-            return new byte[] { 0x5d, 0xbd, 0x01, (byte)(a & 0xff), (byte)((a & 0xff00) >> 8), (byte)((a & 0xff0000) >> 16) };
-        }
+        public bool BootBar;
+        public bool AwakeBar;
+        public bool SleepBar;
+        public bool ShutdownBar;
 
-        public static ushort BitOr(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self | rhs);
-        }
+        public bool BootLid;
+        public bool AwakeLid;
+        public bool SleepLid;
+        public bool ShutdownLid;
 
-        public static ushort BitAnd(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self & rhs);
-        }
+        public bool BootRear;
+        public bool AwakeRear;
+        public bool SleepRear;
+        public bool ShutdownRear;
     }
 
 
     public static class AsusUSB
     {
+        public const int HEATMAP = 20;
 
         public const int ASUS_ID = 0x0b05;
 
@@ -59,12 +46,12 @@ namespace GHelper
 
         public static readonly byte[] LED_INIT1 = new byte[] { AURA_HID_ID, 0xb9 };
         public static readonly byte[] LED_INIT2 = Encoding.ASCII.GetBytes("]ASUS Tech.Inc.");
-        public static readonly byte[] LED_INIT3 = new byte[] { AURA_HID_ID, 0x05, 0x20, 0x31, 0, 0x08 };
+        public static readonly byte[] LED_INIT3 = new byte[] { AURA_HID_ID, 0x05, 0x20, 0x31, 0, 0x1a };
         public static readonly byte[] LED_INIT4 = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
-        public static readonly byte[] LED_INIT5 = new byte[] { 0x5e, 0x05, 0x20, 0x31, 0, 0x08 };
+        public static readonly byte[] LED_INIT5 = new byte[] { 0x5e, 0x05, 0x20, 0x31, 0, 0x1a };
 
-        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
         static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
+        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
 
         static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6, 0x1abe };
 
@@ -73,6 +60,81 @@ namespace GHelper
         public static Color Color1 = Color.White;
         public static Color Color2 = Color.Black;
 
+        static bool isTuf = AppConfig.ContainsModel("Tuf");
+        static bool isStrix = AppConfig.ContainsModel("Strix");
+
+
+        static System.Timers.Timer timer = new System.Timers.Timer(2000);
+        static HidDevice? auraDevice = null;
+
+        static bool Manual = false;
+
+        static byte[] AuraPowerMessage(AuraPower flags)
+        {
+            byte keyb = 0, bar = 0, lid = 0, rear = 0;
+
+            if (flags.BootLogo) keyb |= 1 << 0;
+            if (flags.BootKeyb) keyb |= 1 << 1;
+            if (flags.AwakeLogo) keyb |= 1 << 2;
+            if (flags.AwakeKeyb) keyb |= 1 << 3;
+            if (flags.SleepLogo) keyb |= 1 << 4;
+            if (flags.SleepKeyb) keyb |= 1 << 5;
+            if (flags.ShutdownLogo) keyb |= 1 << 6;
+            if (flags.ShutdownKeyb) keyb |= 1 << 7;
+
+            if (flags.BootBar) bar |= 1 << 1;
+            if (flags.AwakeBar) bar |= 1 << 2;
+            if (flags.SleepBar) bar |= 1 << 3;
+            if (flags.ShutdownBar) bar |= 1 << 4;
+
+            if (flags.BootLid) lid |= 1 << 0;
+            if (flags.AwakeLid) lid |= 1 << 1;
+            if (flags.SleepLid) lid |= 1 << 2;
+            if (flags.ShutdownLid) lid |= 1 << 3;
+
+            if (flags.BootLid) lid |= 1 << 4;
+            if (flags.AwakeLid) lid |= 1 << 5;
+            if (flags.SleepLid) lid |= 1 << 6;
+            if (flags.ShutdownLid) lid |= 1 << 7;
+
+            if (flags.BootRear) rear |= 1 << 0;
+            if (flags.AwakeRear) rear |= 1 << 1;
+            if (flags.SleepRear) rear |= 1 << 2;
+            if (flags.ShutdownRear) rear |= 1 << 3;
+
+            if (flags.BootRear) rear |= 1 << 4;
+            if (flags.AwakeRear) rear |= 1 << 5;
+            if (flags.SleepRear) rear |= 1 << 6;
+            if (flags.ShutdownRear) rear |= 1 << 7;
+
+            return new byte[] { 0x5d, 0xbd, 0x01, keyb, bar, lid, rear, 0xFF };
+        }
+
+        static AsusUSB()
+        {
+            timer.Elapsed += Timer_Elapsed;
+        }
+
+        private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            SetHeatmap();
+        }
+
+        static void SetHeatmap(bool init = false)
+        {
+            float cpuTemp = (float)HardwareControl.GetCPUTemp();
+            int freeze = 20, cold = 40, warm = 65, hot = 90;
+            Color color;
+
+            //Debug.WriteLine(cpuTemp);
+
+            if (cpuTemp < cold) color = ColorUtilities.GetWeightedAverage(Color.Blue, Color.Green, ((float)cpuTemp - freeze) / (cold - freeze));
+            else if (cpuTemp < warm) color = ColorUtilities.GetWeightedAverage(Color.Green, Color.Yellow, ((float)cpuTemp - cold) / (warm - cold));
+            else if (cpuTemp < hot) color = ColorUtilities.GetWeightedAverage(Color.Yellow, Color.Red, ((float)cpuTemp - warm) / (hot - warm));
+            else color = Color.Red;
+
+            ApplyColor(color, init);
+        }
 
         public static Dictionary<int, string> GetSpeeds()
         {
@@ -92,6 +154,7 @@ namespace GHelper
                 { 2, Properties.Strings.AuraColorCycle },
                 { 3, Properties.Strings.AuraRainbow },
                 { 10, Properties.Strings.AuraStrobe },
+                { HEATMAP, "Heatmap"}
             };
 
         static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
@@ -108,12 +171,13 @@ namespace GHelper
                 { 10, Properties.Strings.AuraStrobe},
                 { 11, "Comet" },
                 { 12, "Flash" },
+                { HEATMAP, "Heatmap"}
             };
 
 
         public static Dictionary<int, string> GetModes()
         {
-            if (AppConfig.ContainsModel("TUF"))
+            if (isTuf)
             {
                 _modes.Remove(3);
             }
@@ -157,7 +221,7 @@ namespace GHelper
 
         public static bool HasSecondColor()
         {
-            return (mode == 1 && !AppConfig.ContainsModel("TUF"));
+            return (mode == 1 && !isTuf);
         }
 
         public static int Speed
@@ -184,6 +248,7 @@ namespace GHelper
         }
 
 
+
         private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minFeatures = 1)
         {
             HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
@@ -228,6 +293,7 @@ namespace GHelper
             msg[6] = (byte)(color.B); // B
             msg[7] = (byte)speed; // aura.speed as u8;
             msg[8] = 0; // aura.direction as u8;
+            msg[9] = (mode == 1) ? (byte)1 : (byte)0;
             msg[10] = (byte)(color2.R); // R
             msg[11] = (byte)(color2.G); // G
             msg[12] = (byte)(color2.B); // B
@@ -256,13 +322,12 @@ namespace GHelper
         public static void ApplyBrightness(int brightness, string log = "Backlight")
         {
 
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardBrightness(brightness);
-
 
             Task.Run(async () =>
             {
 
+                if (isTuf) Program.acpi.TUFKeyboardBrightness(brightness);
+
                 byte[] msg = { AURA_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
                 byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
 
@@ -311,55 +376,153 @@ namespace GHelper
         public static void ApplyAuraPower()
         {
 
-            List<AuraDev19b6> flags = new();
+            Task.Run(async () =>
+            {
 
-            // Keyboard
-            if (AppConfig.IsNotFalse("keyboard_awake")) flags.Add(AuraDev19b6.AwakeKeyb);
-            if (AppConfig.IsNotFalse("keyboard_boot")) flags.Add(AuraDev19b6.BootKeyb);
-            if (AppConfig.IsNotFalse("keyboard_sleep")) flags.Add(AuraDev19b6.SleepKeyb);
-            if (AppConfig.IsNotFalse("keyboard_shutdown")) flags.Add(AuraDev19b6.ShutdownKeyb);
+                AuraPower flags = new();
 
-            // Lightbar
-            if (AppConfig.IsNotFalse("keyboard_awake_bar")) flags.Add(AuraDev19b6.AwakeBar);
-            if (AppConfig.IsNotFalse("keyboard_boot_bar")) flags.Add(AuraDev19b6.BootBar);
-            if (AppConfig.IsNotFalse("keyboard_sleep_bar")) flags.Add(AuraDev19b6.SleepBar);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_bar")) flags.Add(AuraDev19b6.ShutdownBar);
+                // Keyboard
+                flags.AwakeKeyb = AppConfig.IsNotFalse("keyboard_awake");
+                flags.BootKeyb = AppConfig.IsNotFalse("keyboard_boot");
+                flags.SleepKeyb = AppConfig.IsNotFalse("keyboard_sleep");
+                flags.ShutdownKeyb = AppConfig.IsNotFalse("keyboard_shutdown");
 
-            // Lid
-            if (AppConfig.IsNotFalse("keyboard_awake_lid")) flags.Add(AuraDev19b6.AwakeLid);
-            if (AppConfig.IsNotFalse("keyboard_boot_lid")) flags.Add(AuraDev19b6.BootLid);
-            if (AppConfig.IsNotFalse("keyboard_sleep_lid")) flags.Add(AuraDev19b6.SleepLid);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_lid")) flags.Add(AuraDev19b6.ShutdownLid);
+                // Logo
+                flags.AwakeLogo = AppConfig.IsNotFalse("keyboard_awake_logo");
+                flags.BootLogo = AppConfig.IsNotFalse("keyboard_boot_logo");
+                flags.SleepLogo = AppConfig.IsNotFalse("keyboard_sleep_logo");
+                flags.ShutdownLogo = AppConfig.IsNotFalse("keyboard_shutdown_logo");
 
-            // Logo
-            if (AppConfig.IsNotFalse("keyboard_awake_logo")) flags.Add(AuraDev19b6.AwakeLogo);
-            if (AppConfig.IsNotFalse("keyboard_boot_logo")) flags.Add(AuraDev19b6.BootLogo);
-            if (AppConfig.IsNotFalse("keyboard_sleep_logo")) flags.Add(AuraDev19b6.SleepLogo);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_logo")) flags.Add(AuraDev19b6.ShutdownLogo);
-
-
-            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
+                // Lightbar
+                flags.AwakeBar = AppConfig.IsNotFalse("keyboard_awake_bar");
+                flags.BootBar = AppConfig.IsNotFalse("keyboard_boot_bar");
+                flags.SleepBar = AppConfig.IsNotFalse("keyboard_sleep_bar");
+                flags.ShutdownBar = AppConfig.IsNotFalse("keyboard_shutdown_bar");
+
+                // Lid
+                flags.AwakeLid = AppConfig.IsNotFalse("keyboard_awake_lid");
+                flags.BootLid = AppConfig.IsNotFalse("keyboard_boot_lid");
+                flags.SleepLid = AppConfig.IsNotFalse("keyboard_sleep_lid");
+                flags.ShutdownLid = AppConfig.IsNotFalse("keyboard_shutdown_lid");
+
+                // Rear Bar
+                flags.AwakeRear = AppConfig.IsNotFalse("keyboard_awake_lid");
+                flags.BootRear = AppConfig.IsNotFalse("keyboard_boot_lid");
+                flags.SleepRear = AppConfig.IsNotFalse("keyboard_sleep_lid");
+                flags.ShutdownRear = AppConfig.IsNotFalse("keyboard_shutdown_lid");
+
+                var devices = GetHidDevices(deviceIds);
+                byte[] msg = AuraPowerMessage(flags);
+
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+                    if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                    {
+                        device.WriteFeatureData(msg);
+                        Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                    }
+                    device.CloseDevice();
+                }
+
+                if (isTuf)
+                    Program.acpi.TUFKeyboardPower(
+                        flags.AwakeKeyb,
+                        flags.BootKeyb,
+                        flags.SleepKeyb,
+                        flags.ShutdownKeyb);
+
+            });
+
+        }
 
 
+        static void GetAuraDevice()
+        {
             var devices = GetHidDevices(deviceIds);
-
             foreach (HidDevice device in devices)
             {
                 device.OpenDevice();
                 if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
                 {
-                    device.WriteFeatureData(msg);
-                    Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
+                    Logger.WriteLine("Aura Device:" + device.DevicePath);
+                    auraDevice = device;
+                    return;
                 }
-                device.CloseDevice();
+                else
+                {
+                    device.CloseDevice();
+                }
+            }
+        }
+
+        public static void ApplyColor(Color color, bool init = false)
+        {
+
+            if (isTuf)
+            {
+                Program.acpi.TUFKeyboardRGB(0, color, 0);
+                return;
             }
 
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardPower(
-                    flags.Contains(AuraDev19b6.AwakeKeyb),
-                    flags.Contains(AuraDev19b6.BootKeyb),
-                    flags.Contains(AuraDev19b6.SleepKeyb),
-                    flags.Contains(AuraDev19b6.ShutdownKeyb));
+            if (auraDevice is null || !auraDevice.IsConnected) GetAuraDevice();
+            if (auraDevice is null || !auraDevice.IsConnected) return;
+
+            if (isStrix)
+            {
+                byte[] msg = new byte[0x40];
+                
+                byte start = 9;
+                byte maxLeds = 0x93;
+
+                msg[0] = AURA_HID_ID;
+                msg[1] = 0xbc;
+                msg[2] = 0;
+                msg[3] = 1;
+                msg[4] = 1;
+                msg[5] = 1;
+                msg[6] = 0;
+                msg[7] = 0x10;
+
+                for (byte i = 0; i < 0x12; i++)
+                {
+                    msg[start + i * 3] = color.R; // R
+                    msg[start + 1 + i * 3] = color.G; // G
+                    msg[start + 2 + i * 3] = color.B; // B
+                }
+
+
+                if (init)
+                {
+                    auraDevice.Write(LED_INIT1);
+                    auraDevice.Write(LED_INIT2);
+                    auraDevice.Write(LED_INIT3);
+                    auraDevice.Write(LED_INIT4);
+                    auraDevice.Write(LED_INIT5);
+                    auraDevice.Write(new byte[] { AURA_HID_ID, 0xbc});
+                }
+
+                for (byte b = 0; b < maxLeds; b += 0x10)
+                {
+                    msg[6] = b;
+                    auraDevice.Write(msg);
+                }
+
+                msg[6] = maxLeds;
+                auraDevice.Write(msg);
+
+                msg[4] = 4;
+                msg[5] = 0;
+                msg[6] = 0;
+                msg[7] = 0;
+                auraDevice.Write(msg);
+            }
+
+            else
+            {
+                auraDevice.Write(AuraMessage(0, color, color, 0));
+                auraDevice.Write(MESSAGE_SET);
+            }
 
         }
 
@@ -367,39 +530,60 @@ namespace GHelper
         public static void ApplyAura()
         {
 
-            int _speed;
+            Mode = AppConfig.Get("aura_mode");
+            Speed = AppConfig.Get("aura_speed");
+            SetColor(AppConfig.Get("aura_color"));
+            SetColor2(AppConfig.Get("aura_color2"));
 
-            switch (Speed)
+            if (Mode == HEATMAP)
             {
-                case 1:
-                    _speed = 0xeb;
-                    break;
-                case 2:
-                    _speed = 0xf5;
-                    break;
-                default:
-                    _speed = 0xe1;
-                    break;
+                SetHeatmap(true);
+                timer.Enabled = true;
+                return;
+            }
+            else
+            {
+                timer.Enabled = false;
             }
 
-            byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
-            var devices = GetHidDevices(deviceIds);
-
-            foreach (HidDevice device in devices)
+            Task.Run(async () =>
             {
-                device.OpenDevice();
-                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+
+
+                int _speed;
+
+                switch (Speed)
                 {
-                    device.WriteFeatureData(msg);
-                    device.WriteFeatureData(MESSAGE_SET);
-                    device.WriteFeatureData(MESSAGE_APPLY);
-                    Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+                    case 1:
+                        _speed = 0xeb;
+                        break;
+                    case 2:
+                        _speed = 0xf5;
+                        break;
+                    default:
+                        _speed = 0xe1;
+                        break;
                 }
-                device.CloseDevice();
-            }
 
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardRGB(Mode, Color1, _speed);
+                byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
+                var devices = GetHidDevices(deviceIds);
+
+                foreach (HidDevice device in devices)
+                {
+                    device.OpenDevice();
+                    if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
+                    {
+                        device.WriteFeatureData(msg);
+                        device.WriteFeatureData(MESSAGE_APPLY);
+                        device.WriteFeatureData(MESSAGE_SET);
+                        Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
+                    }
+                    device.CloseDevice();
+                }
+
+                if (AppConfig.ContainsModel("TUF"))
+                    Program.acpi.TUFKeyboardRGB(Mode, Color1, _speed);
+            });
 
         }
 
@@ -425,6 +609,15 @@ namespace GHelper
             return 0;
         }
 
+        public static void InitXGM()
+        {
+            SetXGM(LED_INIT1);
+            SetXGM(LED_INIT2);
+            SetXGM(LED_INIT3);
+            SetXGM(LED_INIT4);
+            SetXGM(LED_INIT5);
+        }
+
         public static void ApplyXGMLight(bool status)
         {
             SetXGM(new byte[] { 0x5e, 0xc5, status ? (byte)0x50 : (byte)0 });
@@ -441,6 +634,8 @@ namespace GHelper
 
             if (AsusACPI.IsInvalidCurve(curve)) return -1;
 
+            //InitXGM();
+
             byte[] msg = new byte[19];
             Array.Copy(new byte[] { 0x5e, 0xd1, 0x01 }, msg, 3);
             Array.Copy(curve, 0, msg, 3, curve.Length);

app/AutoUpdate/AutoUpdateControl.cs

@@ -16,7 +16,8 @@ namespace GHelper.AutoUpdate
         public AutoUpdateControl(SettingsForm settingsForm)
         {
             settings = settingsForm;
-            settings.SetVersionLabel(Properties.Strings.VersionLabel + ": " + Assembly.GetExecutingAssembly().GetName().Version);
+            var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+            settings.SetVersionLabel(Properties.Strings.VersionLabel + $": {appVersion.Major}.{appVersion.Minor}.{appVersion.Build}");
         }
 
         public void CheckForUpdates()
@@ -40,6 +41,8 @@ namespace GHelper.AutoUpdate
         async void CheckForUpdatesAsync()
         {
 
+            if (AppConfig.Is("skip_updates")) return;
+
             try
             {
 

app/Battery/BatteryControl.cs

@@ -1,7 +1,4 @@
-using GHelper.Helpers;
-using System.Diagnostics;
-
-namespace GHelper.Battery
+namespace GHelper.Battery
 {
     internal class BatteryControl
     {
@@ -13,18 +10,8 @@ namespace GHelper.Battery
             if (limit < 40 || limit > 100) return;
 
             Program.settingsForm.VisualiseBattery(limit);
-
             Program.acpi.DeviceSet(AsusACPI.BatteryLimit, limit, "BatteryLimit");
 
-            try
-            {
-                OptimizationService.SetChargeLimit(limit);
-            }
-            catch (Exception ex)
-            {
-                Debug.WriteLine(ex);
-            }
-
             AppConfig.Set("charge_limit", limit);
 
         }

app/Display/ScreenBrightness.cs

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

app/Display/ScreenControl.cs

@@ -24,8 +24,8 @@ namespace GHelper.Display
 
         public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
         {
-
             var laptopScreen = ScreenNative.FindLaptopScreen(true);
+
             if (laptopScreen is null) return;
 
             if (ScreenNative.GetRefreshRate(laptopScreen) < 0) return;
@@ -66,7 +66,6 @@ namespace GHelper.Display
 
         public void InitScreen()
         {
-
             var laptopScreen = ScreenNative.FindLaptopScreen();
 
             int frequency = ScreenNative.GetRefreshRate(laptopScreen);

app/Display/ScreenNative.cs

@@ -118,14 +118,36 @@ namespace GHelper.Display
         public const int ENUM_CURRENT_SETTINGS = -1;
         public const string defaultDevice = @"\\.\DISPLAY1";
 
+        static bool? _ultimate = null;
+
+        static bool isUltimate
+        {
+            get
+            {
+                if (_ultimate is null) _ultimate = (Program.acpi.DeviceGet(AsusACPI.GPUMux) == 0);
+                return (bool)_ultimate;
+            }
+        }
+
         public static string? FindLaptopScreen(bool log = false)
         {
             string? laptopScreen = null;
+            var screens = Screen.AllScreens;
+
+            /*
+            if (!isUltimate)
+            {
+                foreach (var screen in screens )
+                {
+                    if (log) Logger.WriteLine(screen.DeviceName);
+                    if (screen.DeviceName == defaultDevice) return defaultDevice;
+                }
+            }
+            */
 
             try
             {
                 var devices = GetAllDevices().ToArray();
-                var screens = Screen.AllScreens;
 
                 int count = 0, displayNum = -1;
 
@@ -147,11 +169,7 @@ namespace GHelper.Display
                 count = 0;
                 foreach (var screen in screens)
                 {
-                    if (count == displayNum)
-                    {
-                        laptopScreen = screen.DeviceName;
-                    }
-                    //if (log) Logger.WriteLine(screen.DeviceName);
+                    if (count == displayNum) laptopScreen = screen.DeviceName;
                     count++;
                 }
 
@@ -220,7 +238,7 @@ namespace GHelper.Display
                 //Fallback scenario
                 if (iRet != 0)
                 {
-                    Thread.Sleep(300);
+                    Thread.Sleep(500);
                     iRet = ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
                     Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
                 }

app/Extra.Designer.cs

@@ -41,8 +41,11 @@ namespace GHelper
             labelBindings = new Label();
             panelBindings = new Panel();
             tableBindings = new TableLayoutPanel();
-            label1 = new Label();
-            textBox1 = new TextBox();
+            labelFNE = new Label();
+            comboFNE = new RComboBox();
+            textFNE = new TextBox();
+            labelFNC = new Label();
+            textM2 = new TextBox();
             textM1 = new TextBox();
             comboM1 = new RComboBox();
             labelM1 = new Label();
@@ -60,8 +63,6 @@ namespace GHelper
             comboFNC = new RComboBox();
             textFNC = new TextBox();
             tableKeys = new TableLayoutPanel();
-            labelFNC = new Label();
-            textM2 = new TextBox();
             panelBacklightHeader = new Panel();
             sliderBrightness = new Slider();
             pictureBacklight = new PictureBox();
@@ -101,6 +102,7 @@ namespace GHelper
             pictureSettings = new PictureBox();
             labelSettings = new Label();
             panelSettings = new Panel();
+            checkAutoToggleClamshellMode = new CheckBox();
             checkAutoApplyWindowsPowerMode = new CheckBox();
             checkTopmost = new CheckBox();
             checkNoOverdrive = new CheckBox();
@@ -115,7 +117,6 @@ namespace GHelper
             ((System.ComponentModel.ISupportInitialize)pictureHelp).BeginInit();
             panelBindings.SuspendLayout();
             tableBindings.SuspendLayout();
-            tableKeys.SuspendLayout();
             panelBacklightHeader.SuspendLayout();
             ((System.ComponentModel.ISupportInitialize)pictureBacklight).BeginInit();
             panelBacklight.SuspendLayout();
@@ -136,7 +137,7 @@ namespace GHelper
             panelServices.Controls.Add(labelServices);
             panelServices.Controls.Add(buttonServices);
             panelServices.Dock = DockStyle.Top;
-            panelServices.Location = new Point(15, 1196);
+            panelServices.Location = new Point(15, 1267);
             panelServices.Name = "panelServices";
             panelServices.Size = new Size(983, 75);
             panelServices.TabIndex = 3;
@@ -155,7 +156,7 @@ namespace GHelper
             // 
             labelServices.AutoSize = true;
             labelServices.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-            labelServices.Location = new Point(57, 18);
+            labelServices.Location = new Point(57, 19);
             labelServices.Name = "labelServices";
             labelServices.Size = new Size(273, 32);
             labelServices.TabIndex = 20;
@@ -188,15 +189,15 @@ namespace GHelper
             panelBindingsHeader.Dock = DockStyle.Top;
             panelBindingsHeader.Location = new Point(15, 15);
             panelBindingsHeader.Name = "panelBindingsHeader";
-            panelBindingsHeader.Padding = new Padding(10, 5, 10, 5);
-            panelBindingsHeader.Size = new Size(983, 50);
+            panelBindingsHeader.Padding = new Padding(11, 5, 11, 5);
+            panelBindingsHeader.Size = new Size(983, 51);
             panelBindingsHeader.TabIndex = 4;
             // 
             // pictureBindings
             // 
             pictureBindings.BackgroundImage = Resources.icons8_keyboard_32;
             pictureBindings.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureBindings.Location = new Point(20, 10);
+            pictureBindings.Location = new Point(20, 11);
             pictureBindings.Name = "pictureBindings";
             pictureBindings.Size = new Size(32, 32);
             pictureBindings.TabIndex = 1;
@@ -208,7 +209,7 @@ namespace GHelper
             pictureHelp.BackgroundImage = Resources.icons8_help_32;
             pictureHelp.BackgroundImageLayout = ImageLayout.Zoom;
             pictureHelp.Cursor = Cursors.Hand;
-            pictureHelp.Location = new Point(930, 10);
+            pictureHelp.Location = new Point(931, 11);
             pictureHelp.Margin = new Padding(4, 3, 4, 3);
             pictureHelp.Name = "pictureHelp";
             pictureHelp.Size = new Size(32, 32);
@@ -231,20 +232,25 @@ namespace GHelper
             panelBindings.AutoSizeMode = AutoSizeMode.GrowAndShrink;
             panelBindings.Controls.Add(tableBindings);
             panelBindings.Dock = DockStyle.Top;
-            panelBindings.Location = new Point(15, 65);
+            panelBindings.Location = new Point(15, 66);
             panelBindings.Name = "panelBindings";
-            panelBindings.Padding = new Padding(0, 0, 10, 5);
-            panelBindings.Size = new Size(983, 325);
+            panelBindings.Padding = new Padding(0, 0, 11, 5);
+            panelBindings.Size = new Size(983, 351);
             panelBindings.TabIndex = 5;
             // 
             // tableBindings
             // 
+            tableBindings.AutoSize = true;
+            tableBindings.AutoSizeMode = AutoSizeMode.GrowAndShrink;
             tableBindings.ColumnCount = 3;
-            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 15.4649944F));
-            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40.97453F));
-            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 43.6323357F));
-            tableBindings.Controls.Add(label1, 0, 5);
-            tableBindings.Controls.Add(textBox1, 2, 1);
+            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 20F));
+            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40F));
+            tableBindings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40F));
+            tableBindings.Controls.Add(labelFNE, 0, 6);
+            tableBindings.Controls.Add(comboFNE, 0, 6);
+            tableBindings.Controls.Add(textFNE, 0, 6);
+            tableBindings.Controls.Add(labelFNC, 0, 5);
+            tableBindings.Controls.Add(textM2, 2, 1);
             tableBindings.Controls.Add(textM1, 2, 0);
             tableBindings.Controls.Add(comboM1, 1, 0);
             tableBindings.Controls.Add(labelM1, 0, 0);
@@ -266,45 +272,80 @@ namespace GHelper
             tableBindings.Margin = new Padding(0, 3, 4, 3);
             tableBindings.Name = "tableBindings";
             tableBindings.Padding = new Padding(16, 12, 0, 12);
-            tableBindings.RowCount = 6;
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 51F));
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 51F));
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 51F));
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 51F));
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 49F));
-            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 21F));
-            tableBindings.Size = new Size(973, 320);
+            tableBindings.RowCount = 7;
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle());
+            tableBindings.RowStyles.Add(new RowStyle(SizeType.Absolute, 20F));
+            tableBindings.Size = new Size(972, 346);
             tableBindings.TabIndex = 12;
             // 
-            // label1
+            // labelFNE
             // 
-            label1.AutoSize = true;
-            label1.Location = new Point(16, 265);
-            label1.Margin = new Padding(0);
-            label1.Name = "label1";
-            label1.Padding = new Padding(5, 10, 0, 0);
-            label1.Size = new Size(85, 42);
-            label1.TabIndex = 15;
-            label1.Text = "FN+C:";
+            labelFNE.AutoSize = true;
+            labelFNE.Location = new Point(16, 288);
+            labelFNE.Margin = new Padding(0);
+            labelFNE.Name = "labelFNE";
+            labelFNE.Padding = new Padding(5, 11, 0, 0);
+            labelFNE.Size = new Size(143, 43);
+            labelFNE.TabIndex = 20;
+            labelFNE.Text = "FN+NmEnt:";
             // 
-            // textBox1
+            // comboFNE
             // 
-            textBox1.Dock = DockStyle.Top;
-            textBox1.Location = new Point(558, 66);
-            textBox1.Margin = new Padding(4, 3, 4, 3);
-            textBox1.Name = "textBox1";
-            textBox1.PlaceholderText = "action";
-            textBox1.Size = new Size(411, 39);
-            textBox1.TabIndex = 14;
+            comboFNE.BorderColor = Color.White;
+            comboFNE.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboFNE.Dock = DockStyle.Top;
+            comboFNE.FormattingEnabled = true;
+            comboFNE.Location = new Point(211, 291);
+            comboFNE.Margin = new Padding(4, 3, 4, 3);
+            comboFNE.Name = "comboFNE";
+            comboFNE.Size = new Size(374, 40);
+            comboFNE.TabIndex = 19;
+            // 
+            // textFNE
+            // 
+            textFNE.Dock = DockStyle.Top;
+            textFNE.Location = new Point(593, 291);
+            textFNE.Margin = new Padding(4, 3, 4, 3);
+            textFNE.Name = "textFNE";
+            textFNE.PlaceholderText = "action";
+            textFNE.Size = new Size(375, 39);
+            textFNE.TabIndex = 18;
+            // 
+            // labelFNC
+            // 
+            labelFNC.AutoSize = true;
+            labelFNC.Location = new Point(16, 242);
+            labelFNC.Margin = new Padding(0);
+            labelFNC.Name = "labelFNC";
+            labelFNC.Padding = new Padding(5, 11, 0, 0);
+            labelFNC.Size = new Size(85, 43);
+            labelFNC.TabIndex = 15;
+            labelFNC.Text = "FN+C:";
+            // 
+            // textM2
+            // 
+            textM2.Dock = DockStyle.Top;
+            textM2.Location = new Point(594, 61);
+            textM2.Margin = new Padding(5, 3, 5, 3);
+            textM2.Name = "textM2";
+            textM2.PlaceholderText = "action";
+            textM2.Size = new Size(373, 39);
+            textM2.TabIndex = 14;
             // 
             // textM1
             // 
             textM1.Dock = DockStyle.Top;
-            textM1.Location = new Point(558, 15);
+            textM1.Location = new Point(593, 15);
             textM1.Margin = new Padding(4, 3, 4, 3);
             textM1.Name = "textM1";
             textM1.PlaceholderText = "action";
-            textM1.Size = new Size(411, 39);
+            textM1.Size = new Size(375, 39);
             textM1.TabIndex = 13;
             // 
             // comboM1
@@ -314,10 +355,10 @@ namespace GHelper
             comboM1.Dock = DockStyle.Top;
             comboM1.FormattingEnabled = true;
             comboM1.Items.AddRange(new object[] { Strings.Default, Strings.VolumeMute, Strings.PlayPause, Strings.PrintScreen, Strings.ToggleAura, Strings.Custom });
-            comboM1.Location = new Point(167, 15);
+            comboM1.Location = new Point(211, 15);
             comboM1.Margin = new Padding(4, 3, 4, 3);
             comboM1.Name = "comboM1";
-            comboM1.Size = new Size(383, 40);
+            comboM1.Size = new Size(374, 40);
             comboM1.TabIndex = 11;
             // 
             // labelM1
@@ -326,8 +367,8 @@ namespace GHelper
             labelM1.Location = new Point(16, 12);
             labelM1.Margin = new Padding(0);
             labelM1.Name = "labelM1";
-            labelM1.Padding = new Padding(5, 10, 0, 0);
-            labelM1.Size = new Size(59, 42);
+            labelM1.Padding = new Padding(5, 11, 0, 0);
+            labelM1.Size = new Size(59, 43);
             labelM1.TabIndex = 9;
             labelM1.Text = "M1:";
             // 
@@ -338,10 +379,10 @@ namespace GHelper
             comboM4.Dock = DockStyle.Top;
             comboM4.FormattingEnabled = true;
             comboM4.Items.AddRange(new object[] { Strings.PerformanceMode, Strings.OpenGHelper, Strings.Custom });
-            comboM4.Location = new Point(167, 168);
+            comboM4.Location = new Point(211, 153);
             comboM4.Margin = new Padding(4, 3, 4, 3);
             comboM4.Name = "comboM4";
-            comboM4.Size = new Size(383, 40);
+            comboM4.Size = new Size(374, 40);
             comboM4.TabIndex = 3;
             // 
             // comboM3
@@ -351,62 +392,62 @@ namespace GHelper
             comboM3.Dock = DockStyle.Top;
             comboM3.FormattingEnabled = true;
             comboM3.Items.AddRange(new object[] { Strings.Default, Strings.VolumeMute, Strings.PlayPause, Strings.PrintScreen, Strings.ToggleAura, Strings.Custom });
-            comboM3.Location = new Point(167, 117);
+            comboM3.Location = new Point(211, 107);
             comboM3.Margin = new Padding(4, 3, 4, 3);
             comboM3.Name = "comboM3";
-            comboM3.Size = new Size(383, 40);
+            comboM3.Size = new Size(374, 40);
             comboM3.TabIndex = 1;
             // 
             // textM4
             // 
             textM4.Dock = DockStyle.Top;
-            textM4.Location = new Point(558, 168);
+            textM4.Location = new Point(593, 153);
             textM4.Margin = new Padding(4, 3, 4, 3);
             textM4.Name = "textM4";
             textM4.PlaceholderText = "action";
-            textM4.Size = new Size(411, 39);
+            textM4.Size = new Size(375, 39);
             textM4.TabIndex = 5;
             // 
             // textM3
             // 
             textM3.Dock = DockStyle.Top;
-            textM3.Location = new Point(558, 117);
+            textM3.Location = new Point(593, 107);
             textM3.Margin = new Padding(4, 3, 4, 3);
             textM3.Name = "textM3";
             textM3.PlaceholderText = "action";
-            textM3.Size = new Size(411, 39);
+            textM3.Size = new Size(375, 39);
             textM3.TabIndex = 4;
             // 
             // labelM4
             // 
             labelM4.AutoSize = true;
-            labelM4.Location = new Point(16, 165);
+            labelM4.Location = new Point(16, 150);
             labelM4.Margin = new Padding(0);
             labelM4.Name = "labelM4";
-            labelM4.Padding = new Padding(5, 10, 0, 0);
-            labelM4.Size = new Size(116, 42);
+            labelM4.Padding = new Padding(5, 11, 0, 0);
+            labelM4.Size = new Size(116, 43);
             labelM4.TabIndex = 2;
             labelM4.Text = "M4/ROG:";
             // 
             // labelM3
             // 
             labelM3.AutoSize = true;
-            labelM3.Location = new Point(16, 114);
+            labelM3.Location = new Point(16, 104);
             labelM3.Margin = new Padding(0);
             labelM3.Name = "labelM3";
-            labelM3.Padding = new Padding(5, 10, 0, 0);
-            labelM3.Size = new Size(59, 42);
+            labelM3.Padding = new Padding(5, 11, 0, 0);
+            labelM3.Size = new Size(59, 43);
             labelM3.TabIndex = 0;
             labelM3.Text = "M3:";
             // 
             // labelM2
             // 
             labelM2.AutoSize = true;
-            labelM2.Location = new Point(16, 63);
+            labelM2.Location = new Point(16, 58);
             labelM2.Margin = new Padding(0);
             labelM2.Name = "labelM2";
-            labelM2.Padding = new Padding(5, 10, 0, 0);
-            labelM2.Size = new Size(59, 42);
+            labelM2.Padding = new Padding(5, 11, 0, 0);
+            labelM2.Size = new Size(59, 43);
             labelM2.TabIndex = 10;
             labelM2.Text = "M2:";
             // 
@@ -417,20 +458,20 @@ namespace GHelper
             comboM2.Dock = DockStyle.Top;
             comboM2.FormattingEnabled = true;
             comboM2.Items.AddRange(new object[] { Strings.Default, Strings.VolumeMute, Strings.PlayPause, Strings.PrintScreen, Strings.ToggleAura, Strings.Custom });
-            comboM2.Location = new Point(167, 66);
+            comboM2.Location = new Point(211, 61);
             comboM2.Margin = new Padding(4, 3, 4, 3);
             comboM2.Name = "comboM2";
-            comboM2.Size = new Size(383, 40);
+            comboM2.Size = new Size(374, 40);
             comboM2.TabIndex = 12;
             // 
             // labelFNF4
             // 
             labelFNF4.AutoSize = true;
-            labelFNF4.Location = new Point(16, 216);
+            labelFNF4.Location = new Point(16, 196);
             labelFNF4.Margin = new Padding(0);
             labelFNF4.Name = "labelFNF4";
-            labelFNF4.Padding = new Padding(5, 10, 0, 0);
-            labelFNF4.Size = new Size(95, 42);
+            labelFNF4.Padding = new Padding(5, 11, 0, 0);
+            labelFNF4.Size = new Size(95, 43);
             labelFNF4.TabIndex = 6;
             labelFNF4.Text = "FN+F4:";
             // 
@@ -440,20 +481,20 @@ namespace GHelper
             comboFNF4.ButtonColor = Color.FromArgb(255, 255, 255);
             comboFNF4.Dock = DockStyle.Top;
             comboFNF4.FormattingEnabled = true;
-            comboFNF4.Location = new Point(167, 219);
+            comboFNF4.Location = new Point(211, 199);
             comboFNF4.Margin = new Padding(4, 3, 4, 3);
             comboFNF4.Name = "comboFNF4";
-            comboFNF4.Size = new Size(383, 40);
+            comboFNF4.Size = new Size(374, 40);
             comboFNF4.TabIndex = 7;
             // 
             // textFNF4
             // 
             textFNF4.Dock = DockStyle.Top;
-            textFNF4.Location = new Point(558, 219);
+            textFNF4.Location = new Point(593, 199);
             textFNF4.Margin = new Padding(4, 3, 4, 3);
             textFNF4.Name = "textFNF4";
             textFNF4.PlaceholderText = "action";
-            textFNF4.Size = new Size(411, 39);
+            textFNF4.Size = new Size(375, 39);
             textFNF4.TabIndex = 8;
             // 
             // comboFNC
@@ -462,20 +503,20 @@ namespace GHelper
             comboFNC.ButtonColor = Color.FromArgb(255, 255, 255);
             comboFNC.Dock = DockStyle.Top;
             comboFNC.FormattingEnabled = true;
-            comboFNC.Location = new Point(167, 268);
+            comboFNC.Location = new Point(211, 245);
             comboFNC.Margin = new Padding(4, 3, 4, 3);
             comboFNC.Name = "comboFNC";
-            comboFNC.Size = new Size(383, 40);
+            comboFNC.Size = new Size(374, 40);
             comboFNC.TabIndex = 16;
             // 
             // textFNC
             // 
             textFNC.Dock = DockStyle.Top;
-            textFNC.Location = new Point(558, 268);
+            textFNC.Location = new Point(593, 245);
             textFNC.Margin = new Padding(4, 3, 4, 3);
             textFNC.Name = "textFNC";
             textFNC.PlaceholderText = "action";
-            textFNC.Size = new Size(411, 39);
+            textFNC.Size = new Size(375, 39);
             textFNC.TabIndex = 17;
             // 
             // tableKeys
@@ -484,7 +525,6 @@ namespace GHelper
             tableKeys.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 20F));
             tableKeys.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40F));
             tableKeys.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 40F));
-            tableKeys.Controls.Add(labelFNC, 0, 5);
             tableKeys.Location = new Point(0, 0);
             tableKeys.Name = "tableKeys";
             tableKeys.RowCount = 6;
@@ -497,26 +537,6 @@ namespace GHelper
             tableKeys.Size = new Size(200, 100);
             tableKeys.TabIndex = 0;
             // 
-            // labelFNC
-            // 
-            labelFNC.AutoSize = true;
-            labelFNC.Location = new Point(4, 100);
-            labelFNC.Margin = new Padding(4, 0, 4, 0);
-            labelFNC.Name = "labelFNC";
-            labelFNC.Size = new Size(32, 20);
-            labelFNC.TabIndex = 15;
-            labelFNC.Text = "FN+C:";
-            // 
-            // textM2
-            // 
-            textM2.Dock = DockStyle.Top;
-            textM2.Location = new Point(124, 2);
-            textM2.Margin = new Padding(4, 2, 4, 2);
-            textM2.Name = "textM2";
-            textM2.PlaceholderText = "action";
-            textM2.Size = new Size(72, 39);
-            textM2.TabIndex = 14;
-            // 
             // panelBacklightHeader
             // 
             panelBacklightHeader.AutoSize = true;
@@ -525,20 +545,21 @@ namespace GHelper
             panelBacklightHeader.Controls.Add(pictureBacklight);
             panelBacklightHeader.Controls.Add(labelBacklightTitle);
             panelBacklightHeader.Dock = DockStyle.Top;
-            panelBacklightHeader.Location = new Point(15, 390);
+            panelBacklightHeader.Location = new Point(15, 417);
             panelBacklightHeader.Name = "panelBacklightHeader";
-            panelBacklightHeader.Padding = new Padding(10, 5, 10, 5);
-            panelBacklightHeader.Size = new Size(983, 50);
+            panelBacklightHeader.Padding = new Padding(11, 5, 11, 5);
+            panelBacklightHeader.Size = new Size(983, 51);
             panelBacklightHeader.TabIndex = 44;
             // 
             // sliderBrightness
             // 
             sliderBrightness.Anchor = AnchorStyles.Top | AnchorStyles.Right;
-            sliderBrightness.Location = new Point(546, 6);
+            sliderBrightness.Location = new Point(467, 5);
+            sliderBrightness.Margin = new Padding(0);
             sliderBrightness.Max = 3;
             sliderBrightness.Min = 0;
             sliderBrightness.Name = "sliderBrightness";
-            sliderBrightness.Size = new Size(419, 36);
+            sliderBrightness.Size = new Size(500, 40);
             sliderBrightness.Step = 1;
             sliderBrightness.TabIndex = 50;
             sliderBrightness.Text = "sliderBrightness";
@@ -548,7 +569,7 @@ namespace GHelper
             // 
             pictureBacklight.BackgroundImage = Resources.backlight;
             pictureBacklight.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureBacklight.Location = new Point(20, 10);
+            pictureBacklight.Location = new Point(20, 11);
             pictureBacklight.Name = "pictureBacklight";
             pictureBacklight.Size = new Size(32, 32);
             pictureBacklight.TabIndex = 3;
@@ -571,7 +592,7 @@ namespace GHelper
             panelBacklight.Controls.Add(panelXMG);
             panelBacklight.Controls.Add(tableBacklight);
             panelBacklight.Dock = DockStyle.Top;
-            panelBacklight.Location = new Point(15, 440);
+            panelBacklight.Location = new Point(15, 468);
             panelBacklight.Name = "panelBacklight";
             panelBacklight.Padding = new Padding(0, 5, 0, 5);
             panelBacklight.Size = new Size(983, 402);
@@ -619,7 +640,7 @@ namespace GHelper
             labelBacklightTimeout.Location = new Point(16, 63);
             labelBacklightTimeout.Margin = new Padding(4, 0, 4, 0);
             labelBacklightTimeout.Name = "labelBacklightTimeout";
-            labelBacklightTimeout.Size = new Size(646, 47);
+            labelBacklightTimeout.Size = new Size(612, 47);
             labelBacklightTimeout.TabIndex = 46;
             labelBacklightTimeout.Text = "Timeout when plugged / on battery";
             // 
@@ -628,7 +649,7 @@ namespace GHelper
             labelSpeed.Location = new Point(16, 16);
             labelSpeed.Margin = new Padding(4, 0, 4, 0);
             labelSpeed.Name = "labelSpeed";
-            labelSpeed.Size = new Size(646, 43);
+            labelSpeed.Size = new Size(612, 43);
             labelSpeed.TabIndex = 44;
             labelSpeed.Text = "Animation Speed";
             // 
@@ -662,7 +683,7 @@ namespace GHelper
             // checkXMG
             // 
             checkXMG.AutoSize = true;
-            checkXMG.Location = new Point(4, 10);
+            checkXMG.Location = new Point(4, 11);
             checkXMG.Margin = new Padding(4, 3, 4, 3);
             checkXMG.Name = "checkXMG";
             checkXMG.Padding = new Padding(16, 3, 7, 3);
@@ -960,10 +981,10 @@ namespace GHelper
             panelSettingsHeader.Controls.Add(pictureSettings);
             panelSettingsHeader.Controls.Add(labelSettings);
             panelSettingsHeader.Dock = DockStyle.Top;
-            panelSettingsHeader.Location = new Point(15, 842);
+            panelSettingsHeader.Location = new Point(15, 870);
             panelSettingsHeader.Name = "panelSettingsHeader";
-            panelSettingsHeader.Padding = new Padding(10, 5, 10, 5);
-            panelSettingsHeader.Size = new Size(983, 50);
+            panelSettingsHeader.Padding = new Padding(11, 5, 11, 5);
+            panelSettingsHeader.Size = new Size(983, 51);
             panelSettingsHeader.TabIndex = 45;
             // 
             // pictureLog
@@ -972,7 +993,7 @@ namespace GHelper
             pictureLog.BackgroundImage = Resources.icons8_log_32;
             pictureLog.BackgroundImageLayout = ImageLayout.Zoom;
             pictureLog.Cursor = Cursors.Hand;
-            pictureLog.Location = new Point(930, 10);
+            pictureLog.Location = new Point(931, 11);
             pictureLog.Margin = new Padding(4, 3, 4, 3);
             pictureLog.Name = "pictureLog";
             pictureLog.Size = new Size(32, 32);
@@ -983,7 +1004,7 @@ namespace GHelper
             // 
             pictureSettings.BackgroundImage = Resources.icons8_settings_32;
             pictureSettings.BackgroundImageLayout = ImageLayout.Zoom;
-            pictureSettings.Location = new Point(20, 10);
+            pictureSettings.Location = new Point(20, 11);
             pictureSettings.Name = "pictureSettings";
             pictureSettings.Size = new Size(32, 32);
             pictureSettings.TabIndex = 1;
@@ -1003,6 +1024,7 @@ namespace GHelper
             // 
             panelSettings.AutoSize = true;
             panelSettings.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+            panelSettings.Controls.Add(checkAutoToggleClamshellMode);
             panelSettings.Controls.Add(checkAutoApplyWindowsPowerMode);
             panelSettings.Controls.Add(checkTopmost);
             panelSettings.Controls.Add(checkNoOverdrive);
@@ -1011,12 +1033,24 @@ namespace GHelper
             panelSettings.Controls.Add(checkGpuApps);
             panelSettings.Controls.Add(checkFnLock);
             panelSettings.Dock = DockStyle.Top;
-            panelSettings.Location = new Point(15, 892);
+            panelSettings.Location = new Point(15, 921);
             panelSettings.Name = "panelSettings";
-            panelSettings.Padding = new Padding(20, 5, 10, 5);
-            panelSettings.Size = new Size(983, 304);
+            panelSettings.Padding = new Padding(20, 5, 11, 5);
+            panelSettings.Size = new Size(983, 346);
             panelSettings.TabIndex = 46;
             // 
+            // checkAutoToggleClamshellMode
+            // 
+            checkAutoToggleClamshellMode.AutoSize = true;
+            checkAutoToggleClamshellMode.Dock = DockStyle.Top;
+            checkAutoToggleClamshellMode.Location = new Point(20, 299);
+            checkAutoToggleClamshellMode.Name = "checkAutoToggleClamshellMode";
+            checkAutoToggleClamshellMode.Padding = new Padding(3);
+            checkAutoToggleClamshellMode.Size = new Size(952, 42);
+            checkAutoToggleClamshellMode.TabIndex = 58;
+            checkAutoToggleClamshellMode.Text = "Auto Toggle Clamshell Mode";
+            checkAutoToggleClamshellMode.UseVisualStyleBackColor = true;
+            // 
             // checkAutoApplyWindowsPowerMode
             // 
             checkAutoApplyWindowsPowerMode.AutoSize = true;
@@ -1025,7 +1059,7 @@ namespace GHelper
             checkAutoApplyWindowsPowerMode.Margin = new Padding(4, 3, 4, 3);
             checkAutoApplyWindowsPowerMode.Name = "checkAutoApplyWindowsPowerMode";
             checkAutoApplyWindowsPowerMode.Padding = new Padding(3);
-            checkAutoApplyWindowsPowerMode.Size = new Size(953, 42);
+            checkAutoApplyWindowsPowerMode.Size = new Size(952, 42);
             checkAutoApplyWindowsPowerMode.TabIndex = 54;
             checkAutoApplyWindowsPowerMode.Text = "Auto Adjust Windows Power Mode";
             checkAutoApplyWindowsPowerMode.UseVisualStyleBackColor = true;
@@ -1038,7 +1072,7 @@ namespace GHelper
             checkTopmost.Margin = new Padding(4, 3, 4, 3);
             checkTopmost.Name = "checkTopmost";
             checkTopmost.Padding = new Padding(3);
-            checkTopmost.Size = new Size(953, 42);
+            checkTopmost.Size = new Size(952, 42);
             checkTopmost.TabIndex = 51;
             checkTopmost.Text = Strings.WindowTop;
             checkTopmost.UseVisualStyleBackColor = true;
@@ -1051,7 +1085,7 @@ namespace GHelper
             checkNoOverdrive.Margin = new Padding(4, 3, 4, 3);
             checkNoOverdrive.Name = "checkNoOverdrive";
             checkNoOverdrive.Padding = new Padding(3);
-            checkNoOverdrive.Size = new Size(953, 42);
+            checkNoOverdrive.Size = new Size(952, 42);
             checkNoOverdrive.TabIndex = 52;
             checkNoOverdrive.Text = Strings.DisableOverdrive;
             checkNoOverdrive.UseVisualStyleBackColor = true;
@@ -1064,7 +1098,7 @@ namespace GHelper
             checkUSBC.Margin = new Padding(4, 3, 4, 3);
             checkUSBC.Name = "checkUSBC";
             checkUSBC.Padding = new Padding(3);
-            checkUSBC.Size = new Size(953, 42);
+            checkUSBC.Size = new Size(952, 42);
             checkUSBC.TabIndex = 53;
             checkUSBC.Text = "Keep GPU disabled on USB-C charger in Optimized mode";
             checkUSBC.UseVisualStyleBackColor = true;
@@ -1077,7 +1111,7 @@ namespace GHelper
             checkVariBright.Margin = new Padding(4, 3, 4, 3);
             checkVariBright.Name = "checkVariBright";
             checkVariBright.Padding = new Padding(3);
-            checkVariBright.Size = new Size(953, 42);
+            checkVariBright.Size = new Size(952, 42);
             checkVariBright.TabIndex = 57;
             checkVariBright.Text = "AMD Display VariBright";
             checkVariBright.UseVisualStyleBackColor = true;
@@ -1090,7 +1124,7 @@ namespace GHelper
             checkGpuApps.Margin = new Padding(4, 3, 4, 3);
             checkGpuApps.Name = "checkGpuApps";
             checkGpuApps.Padding = new Padding(3);
-            checkGpuApps.Size = new Size(953, 42);
+            checkGpuApps.Size = new Size(952, 42);
             checkGpuApps.TabIndex = 55;
             checkGpuApps.Text = "Stop all apps using GPU when switching to Eco";
             checkGpuApps.UseVisualStyleBackColor = true;
@@ -1116,7 +1150,7 @@ namespace GHelper
             AutoScroll = true;
             AutoSize = true;
             AutoSizeMode = AutoSizeMode.GrowAndShrink;
-            ClientSize = new Size(1013, 1355);
+            ClientSize = new Size(1013, 1431);
             Controls.Add(panelServices);
             Controls.Add(panelSettings);
             Controls.Add(panelSettingsHeader);
@@ -1129,7 +1163,7 @@ namespace GHelper
             MaximizeBox = false;
             MdiChildrenMinimizedAnchorBottom = false;
             MinimizeBox = false;
-            MinimumSize = new Size(1034, 71);
+            MinimumSize = new Size(1033, 71);
             Name = "Extra";
             Padding = new Padding(15);
             ShowIcon = false;
@@ -1143,10 +1177,9 @@ namespace GHelper
             ((System.ComponentModel.ISupportInitialize)pictureBindings).EndInit();
             ((System.ComponentModel.ISupportInitialize)pictureHelp).EndInit();
             panelBindings.ResumeLayout(false);
+            panelBindings.PerformLayout();
             tableBindings.ResumeLayout(false);
             tableBindings.PerformLayout();
-            tableKeys.ResumeLayout(false);
-            tableKeys.PerformLayout();
             panelBacklightHeader.ResumeLayout(false);
             panelBacklightHeader.PerformLayout();
             ((System.ComponentModel.ISupportInitialize)pictureBacklight).EndInit();
@@ -1175,8 +1208,8 @@ namespace GHelper
         private Panel panelBindingsHeader;
         private Panel panelBindings;
         private TableLayoutPanel tableBindings;
-        private Label label1;
-        private TextBox textBox1;
+        private Label labelFNC;
+        private TextBox textM2;
         private TextBox textM1;
         private RComboBox comboM1;
         private Label labelM1;
@@ -1195,8 +1228,6 @@ namespace GHelper
         private TextBox textFNC;
         private PictureBox pictureHelp;
         private TableLayoutPanel tableKeys;
-        private Label labelFNC;
-        private TextBox textM2;
         private PictureBox pictureBindings;
         private Label labelBindings;
         private Panel panelBacklightHeader;
@@ -1246,5 +1277,10 @@ namespace GHelper
         private PictureBox pictureService;
         private Slider sliderBrightness;
         private PictureBox pictureLog;
+        private CheckBox checkAutoToggleClamshellMode;
+        private Label labelFNE;
+        private RComboBox comboFNE;
+        private TextBox textFNE;
+        private Slider slider1;
     }
 }

app/Extra.cs

@@ -11,6 +11,7 @@ namespace GHelper
     {
 
         ScreenControl screenControl = new ScreenControl();
+        ClamshellModeControl clamshellControl = new ClamshellModeControl();
 
         Dictionary<string, string> customActions = new Dictionary<string, string>
         {
@@ -53,6 +54,10 @@ namespace GHelper
                     customActions[""] = Properties.Strings.ToggleFnLock;
                     customActions.Remove("fnlock");
                     break;
+                case "fne":
+                    customActions[""] = "Calculator";
+                    customActions["ghelper"] = Properties.Strings.OpenGHelper;
+                    break;
             }
 
             combo.DropDownStyle = ComboBoxStyle.DropDownList;
@@ -86,6 +91,31 @@ namespace GHelper
         {
             InitializeComponent();
 
+            // Change text and hide irrelevant options on the ROG Ally,
+            // which is a bit of a special case piece of hardware.
+            if (AppConfig.ContainsModel("RC71"))
+            {
+                // The back paddles both seem to issue the same code;
+                // so we'll replace "M1/M2" with one field, for now.
+                // (Eventually, we should learn how Asus' software tells the difference.)
+                labelM1.Text = "Back Paddles";
+                labelM2.Visible = false;
+                comboM2.Visible = false;
+                textM2.Visible = false;
+
+                // Re-label M3 and M4 to match the front labels.
+                labelM3.Text = "Ctrl Center";
+                labelM4.Text = "ROG";
+
+                // Hide all of the FN options, as the Ally has no special keyboard FN key.
+                labelFNC.Visible = false;
+                comboFNC.Visible = false;
+                textFNC.Visible = false;
+                labelFNF4.Visible = false;
+                comboFNF4.Visible = false;
+                textFNF4.Visible = false;
+            }
+
             labelBindings.Text = Properties.Strings.KeyBindings;
             labelBacklightTitle.Text = Properties.Strings.LaptopBacklight;
             labelSettings.Text = Properties.Strings.Other;
@@ -106,6 +136,7 @@ namespace GHelper
             checkUSBC.Text = Properties.Strings.OptimizedUSBC;
             checkAutoApplyWindowsPowerMode.Text = Properties.Strings.ApplyWindowsPowerPlan;
             checkFnLock.Text = Properties.Strings.FnLock;
+            checkAutoToggleClamshellMode.Text = Properties.Strings.ToggleClamshellMode;
 
             labelBacklightKeyboard.Text = Properties.Strings.Keyboard;
             labelBacklightBar.Text = Properties.Strings.Lightbar;
@@ -116,6 +147,32 @@ namespace GHelper
 
             Text = Properties.Strings.ExtraSettings;
 
+            if (AppConfig.ContainsModel("Duo"))
+            {
+                customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
+                customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
+            }
+
+            if (InputDispatcher.NoMKeys())
+            {
+                labelM1.Text = "FN+F2";
+                labelM2.Text = "FN+F3";
+                labelM3.Text = "FN+F4";
+                labelM4.Visible = comboM4.Visible = textM4.Visible = false;
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (!AppConfig.ContainsModel("TUF"))
+            {
+                labelFNE.Visible = comboFNE.Visible = textFNE.Visible = false;
+            }
+
+            if (Program.acpi.DeviceGet(AsusACPI.GPUEco) < 0)
+            {
+                checkGpuApps.Visible = false;
+                checkUSBC.Visible = false;
+            }
+
             InitTheme();
 
             SetKeyCombo(comboM1, textM1, "m1");
@@ -124,6 +181,7 @@ namespace GHelper
             SetKeyCombo(comboM4, textM4, "m4");
             SetKeyCombo(comboFNF4, textFNF4, "fnf4");
             SetKeyCombo(comboFNC, textFNC, "fnc");
+            SetKeyCombo(comboFNE, textFNE, "fne");
 
             Shown += Keyboard_Shown;
 
@@ -204,6 +262,10 @@ namespace GHelper
                 }
             }
 
+            //checkAutoToggleClamshellMode.Visible = clamshellControl.IsExternalDisplayConnected();
+            checkAutoToggleClamshellMode.Checked = AppConfig.Is("toggle_clamshell_mode");
+            checkAutoToggleClamshellMode.CheckedChanged += checkAutoToggleClamshellMode_CheckedChanged;
+
             checkTopmost.Checked = AppConfig.Is("topmost");
             checkTopmost.CheckedChanged += CheckTopmost_CheckedChanged; ;
 
@@ -438,7 +500,7 @@ namespace GHelper
         private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
-            Program.settingsForm.SetAura();
+            AsusUSB.ApplyAura();
         }
 
 
@@ -460,5 +522,20 @@ namespace GHelper
         {
             AppConfig.Set("auto_apply_power_plan", checkAutoApplyWindowsPowerMode.Checked ? 1 : 0);
         }
+
+        private void checkAutoToggleClamshellMode_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("toggle_clamshell_mode", checkAutoToggleClamshellMode.Checked ? 1 : 0);
+
+            if (checkAutoToggleClamshellMode.Checked)
+            {
+                clamshellControl.ToggleLidAction();
+            }
+            else
+            {
+                ClamshellModeControl.DisableClamshellMode();
+            }
+
+        }
     }
 }

app/Fans.cs

@@ -59,7 +59,7 @@ namespace GHelper
             InitTheme(true);
 
             MinRPM = 18;
-            MaxRPM = HardwareControl.GetFanMax();
+            MaxRPM = HardwareControl.fanMax;
             labelTip.Visible = false;
             labelTip.BackColor = Color.Transparent;
 
@@ -75,16 +75,16 @@ namespace GHelper
             seriesMid.Color = colorEco;
             seriesXGM.Color = Color.Orange;
 
-            chartCPU.MouseMove += ChartCPU_MouseMove;
+            chartCPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.CPU);
             chartCPU.MouseUp += ChartCPU_MouseUp;
 
-            chartGPU.MouseMove += ChartCPU_MouseMove;
+            chartGPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.GPU);
             chartGPU.MouseUp += ChartCPU_MouseUp;
 
-            chartMid.MouseMove += ChartCPU_MouseMove;
+            chartMid.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.Mid);
             chartMid.MouseUp += ChartCPU_MouseUp;
 
-            chartXGM.MouseMove += ChartCPU_MouseMove;
+            chartXGM.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.XGM);
             chartXGM.MouseUp += ChartCPU_MouseUp;
 
             buttonReset.Click += ButtonReset_Click;
@@ -285,6 +285,19 @@ namespace GHelper
 
         private void VisualiseAdvanced()
         {
+            if (!RyzenControl.IsSupportedUV())
+            {
+                panelTitleAdvanced.Visible = false;
+                labelRisky.Visible = false;
+                panelUV.Visible = false;
+                panelUViGPU.Visible = false;
+            }
+
+            if (!RyzenControl.IsSupportedUV())
+            {
+                panelUViGPU.Visible = false;
+            }
+
             labelUV.Text = trackUV.Value.ToString();
             labelUViGPU.Text = trackUViGPU.Value.ToString();
             labelTemp.Text = (trackTemp.Value < RyzenControl.MaxTemp) ? trackTemp.Value.ToString() + "°C" : "Default";
@@ -398,7 +411,7 @@ namespace GHelper
                 return;
             }
 
-            if (HardwareControl.GpuControl is null) HardwareControl.RecreateGpuControl();
+            if (HardwareControl.GpuControl is null || !HardwareControl.GpuControl.IsValid) HardwareControl.RecreateGpuControl();
 
             if (HardwareControl.GpuControl is not null && HardwareControl.GpuControl.IsNvidia)
             {
@@ -494,11 +507,14 @@ namespace GHelper
             VisualiseGPUSettings();
         }
 
-        static string ChartPercToRPM(int percentage, string unit = "")
+        static string ChartPercToRPM(int percentage, AsusFan device, string unit = "")
         {
             if (percentage == 0) return "OFF";
 
-            return (200 * Math.Round((float)(MinRPM * 100 + (MaxRPM - MinRPM) * percentage) / 200)).ToString() + unit;
+            int Max = MaxRPM;
+            if (device == AsusFan.XGM ) Max = 72;
+
+            return (200 * Math.Round((float)(MinRPM * 100 + (Max - MinRPM) * percentage) / 200)).ToString() + unit;
         }
 
         void SetChart(Chart chart, AsusFan device)
@@ -539,7 +555,7 @@ namespace GHelper
             chart.ChartAreas[0].AxisY.LineColor = chartGrid;
 
             for (int i = 0; i <= fansMax - 10; i += 10)
-                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartPercToRPM(i));
+                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartPercToRPM(i, device));
 
             chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax - 2, fansMax + 2, Properties.Strings.RPM);
 
@@ -655,7 +671,11 @@ namespace GHelper
             }
             else
             {
-                labelLeftA0.Text = "CPU Slow (SPL + sPPT)";
+                if (RyzenControl.IsAMD())
+                    labelLeftA0.Text = "CPU Slow (SPL + sPPT)";
+                else
+                    labelLeftA0.Text = "CPU (PL1 + PL2)";
+
                 labelLeftC1.Text = "CPU Fast (fPPT)";
                 panelC1.Visible = modeC1;
             }
@@ -752,7 +772,7 @@ namespace GHelper
             try
             {
                 if (chartCount > 2)
-                    Size = MinimumSize = new Size(0, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100)));
+                    Size = MinimumSize = new Size(Size.Width, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100)));
             }
             catch (Exception ex)
             {
@@ -894,7 +914,7 @@ namespace GHelper
 
         }
 
-        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e)
+        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e, AsusFan device)
         {
 
             if (sender is null) return;
@@ -955,7 +975,7 @@ namespace GHelper
                         tip = true;
                     }
 
-                    labelTip.Text = Math.Round(curPoint.XValue) + "C, " + ChartPercToRPM((int)curPoint.YValues[0], " " + Properties.Strings.RPM);
+                    labelTip.Text = Math.Round(curPoint.XValue) + "C, " + ChartPercToRPM((int)curPoint.YValues[0], device, " " + Properties.Strings.RPM);
                     labelTip.Top = e.Y + ((Control)sender).Top;
                     labelTip.Left = e.X - 50;
 

app/GHelper.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows8.0</TargetFramework>
+    <TargetFramework>net7.0-windows</TargetFramework>
     <Nullable>enable</Nullable>
     <UseWindowsForms>True</UseWindowsForms>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -11,12 +11,11 @@
     <StartupObject>GHelper.Program</StartupObject>
     <ApplicationIcon>favicon.ico</ApplicationIcon>
     <Platforms>AnyCPU;x64</Platforms>
-    <SupportedOSPlatformVersion>8.0</SupportedOSPlatformVersion>
     <AssemblyName>GHelper</AssemblyName>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.97</AssemblyVersion>
+    <AssemblyVersion>0.105</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

app/Gpu/GPUModeControl.cs

@@ -36,7 +36,7 @@ namespace GHelper.Gpu
                 else
                     GpuMode = AsusACPI.GPUModeStandard;
 
-                // Ultimate mode not suported
+                // Ultimate mode not supported
                 if (mux != 1) settings.HideUltimateMode();
                 // GPU mode not supported
                 if (eco < 0 && mux < 0) settings.HideGPUModes();
@@ -49,11 +49,16 @@ namespace GHelper.Gpu
         }
 
 
-        public void SetGPUMode(int GPUMode)
+        bool NoAutoUltimate()
+        {
+            return AppConfig.ContainsModel("G614") || AppConfig.ContainsModel("M16");
+        }
+
+        public void SetGPUMode(int GPUMode, int auto = 0)
         {
 
             int CurrentGPU = AppConfig.Get("gpu_mode");
-            AppConfig.Set("gpu_auto", 0);
+            AppConfig.Set("gpu_auto", auto);
 
             if (CurrentGPU == GPUMode)
             {
@@ -79,6 +84,11 @@ namespace GHelper.Gpu
                 DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
                 if (dialogResult == DialogResult.Yes)
                 {
+                    if (NoAutoUltimate())
+                    {
+                        Program.acpi.SetGPUEco(0);
+                        Thread.Sleep(100);
+                    }
                     Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
                     restart = true;
                     changed = true;
@@ -154,7 +164,7 @@ namespace GHelper.Gpu
 
                 if (eco == 0)
                 {
-                    await Task.Delay(TimeSpan.FromMilliseconds(5000));
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
                     HardwareControl.RecreateGpuControl();
                     Program.modeControl.SetGPUClocks(false);
                 }
@@ -177,7 +187,7 @@ namespace GHelper.Gpu
         {
 
             bool GpuAuto = AppConfig.Is("gpu_auto");
-            bool ForceGPU = AppConfig.ContainsModel("503");
+            bool ForceGPU = AppConfig.ContainsModel("503") || AppConfig.Is("gpu_fix");
 
             int GpuMode = AppConfig.Get("gpu_mode");
 
@@ -188,14 +198,12 @@ namespace GHelper.Gpu
 
             if (mux == 0)
             {
-                if (optimized) SetGPUMode(AsusACPI.GPUModeStandard);
+                if (optimized) SetGPUMode(AsusACPI.GPUModeStandard, 1);
                 return false;
             }
             else
             {
 
-                if (ReEnableGPU()) return true;
-
                 if (eco == 1)
                     if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
                     {
@@ -256,21 +264,6 @@ namespace GHelper.Gpu
         }
 
 
-        public bool ReEnableGPU()
-        {
-
-            if (AppConfig.Get("gpu_reenable") != 1) return false;
-            if (Screen.AllScreens.Length <= 1) return false;
-
-            Logger.WriteLine("Re-enabling gpu for 503 model");
-
-            Thread.Sleep(1000);
-            SetGPUEco(1);
-            Thread.Sleep(1000);
-            SetGPUEco(0);
-            return true;
-        }
-
         public void InitXGM()
         {
             bool connected = Program.acpi.IsXGConnected();
@@ -304,6 +297,9 @@ namespace GHelper.Gpu
 
                     if (AppConfig.IsMode("auto_apply"))
                         AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+
+                    HardwareControl.RecreateGpuControl();
+
                 }
 
                 settings.Invoke(delegate
@@ -321,5 +317,16 @@ namespace GHelper.Gpu
             }
         }
 
+        // Manually forcing standard mode on shutdown/hibernate for some exotic cases
+        // https://github.com/seerge/g-helper/pull/855 
+        public void StandardModeFix()
+        {
+            if (!AppConfig.Is("gpu_fix")) return; // No config entry
+            if (Program.acpi.DeviceGet(AsusACPI.GPUMux) == 0) return; // Ultimate mode
+
+            Logger.WriteLine("Forcing Standard Mode on shutdown / hibernation");
+            Program.acpi.SetGPUEco(0);
+        }
+
     }
 }

app/HardwareControl.cs

@@ -5,13 +5,26 @@ using GHelper.Gpu.AMD;
 
 using GHelper.Helpers;
 using System.Diagnostics;
+using System.Management;
 
 public static class HardwareControl
 {
+
+    const int DEFAULT_FAN_MAX = 58;
+    const int INADEQUATE_MAX = 80;
+
     public static IGpuControl? GpuControl;
 
     public static float? cpuTemp = -1;
-    public static float? batteryDischarge = -1;
+    public static decimal? batteryRate = 0;
+    public static decimal batteryHealth = -1;
+    public static decimal batteryCapacity = -1;
+
+    public static decimal? designCapacity;
+    public static decimal? fullCapacity;
+    public static decimal? chargeCapacity;
+
+
     public static int? gpuTemp = null;
 
     public static string? cpuFan;
@@ -20,21 +33,50 @@ public static class HardwareControl
 
     public static int? gpuUse;
 
-    public static int GetFanMax()
-    {
-        int max = 58;
-        int configMax = AppConfig.Get("fan_max");
-        if (configMax > 80) configMax = 0; // skipping inadvequate settings
+    static long lastUpdate;
 
-        if (AppConfig.ContainsModel("401")) max = 72;
-        else if (AppConfig.ContainsModel("503")) max = 68;
-        return Math.Max(max, configMax);
+    static int _fanMax = DEFAULT_FAN_MAX;
+    static bool _fanRpm = false;
+
+    public static int fanMax
+    {
+        get
+        {
+            return _fanMax;
+        }
+        set
+        {
+            AppConfig.Set("fan_max", value);
+            _fanMax = value;
+        }
     }
 
-    public static void SetFanMax(int fan)
+    public static bool fanRpm
     {
-        AppConfig.Set("fan_max", fan);
+        get
+        {
+            return _fanRpm;
+        }
+        set
+        {
+            AppConfig.Set("fan_rpm", value ? 1 : 0);
+            _fanRpm = value;
+        }
     }
+
+    static HardwareControl()
+    {
+        _fanMax = AppConfig.Get("fan_max");
+        if (_fanMax > INADEQUATE_MAX) _fanMax = -1; // skipping inadvequate settings
+
+        if (_fanMax < 0 && AppConfig.ContainsModel("401")) _fanMax = 72;
+        if (_fanMax < 0 && AppConfig.ContainsModel("503")) _fanMax = 68;
+        if (_fanMax < 0) _fanMax = DEFAULT_FAN_MAX;
+
+        _fanRpm = AppConfig.Is("fan_rpm");
+
+    }
+
     public static string FormatFan(int fan)
     {
         // fix for old models 
@@ -44,10 +86,9 @@ public static class HardwareControl
             if (fan <= 0 || fan > 100) return null; //nothing reasonable
         }
 
-        int fanMax = GetFanMax();
-        if (fan > fanMax && fan < 80) SetFanMax(fan);
+        if (fan > fanMax && fan <= INADEQUATE_MAX) fanMax = fan;
 
-        if (AppConfig.Is("fan_rpm"))
+        if (fanRpm)
             return GHelper.Properties.Strings.FanSpeed + ": " + (fan * 100).ToString() + "RPM";
         else
             return GHelper.Properties.Strings.FanSpeed + ": " + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
@@ -70,15 +111,115 @@ public static class HardwareControl
     }
 
 
-    public static void ReadSensors()
+    public static void GetBatteryStatus()
     {
-        batteryDischarge = -1;
-        gpuTemp = -1;
-        gpuUse = -1;
 
-        cpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.CPU_Fan));
-        gpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.GPU_Fan));
-        midFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.Mid_Fan));
+        batteryRate = 0;
+        chargeCapacity = 0;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStatus");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+
+                chargeCapacity = Convert.ToDecimal(obj["RemainingCapacity"]);
+
+                decimal chargeRate = Convert.ToDecimal(obj["ChargeRate"]);
+                decimal dischargeRate = Convert.ToDecimal(obj["DischargeRate"]);
+                
+                if (chargeRate > 0)
+                    batteryRate = chargeRate / 1000;
+                else
+                    batteryRate = -dischargeRate / 1000;
+
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Discharge Reading: " + ex.Message);
+        }
+
+    }
+    public static void ReadFullChargeCapacity()
+    {
+        if (fullCapacity > 0) return;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryFullChargedCapacity");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+                fullCapacity = Convert.ToDecimal(obj["FullChargedCapacity"]);
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Full Charge Reading: " + ex.Message);
+        }
+
+    }
+
+    public static void ReadDesignCapacity()
+    {
+        if (designCapacity > 0) return;
+
+        try
+        {
+            ManagementScope scope = new ManagementScope("root\\WMI");
+            ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStaticData");
+
+            using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
+            foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
+            {
+                designCapacity = Convert.ToDecimal(obj["DesignedCapacity"]);
+            }
+
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine("Design Capacity Reading: " + ex.Message);
+        }
+    }
+
+    public static void RefreshBatteryHealth()
+    {
+        batteryHealth = GetBatteryHealth() * 100;
+    }
+
+
+    public static decimal GetBatteryHealth()
+    {
+        if (designCapacity is null)
+        {
+            ReadDesignCapacity();
+        }
+        ReadFullChargeCapacity();
+
+        if (designCapacity is null || fullCapacity is null || designCapacity == 0 || fullCapacity == 0)
+        {
+            return -1;
+        }
+
+        decimal health = (decimal)fullCapacity / (decimal)designCapacity;
+        Logger.WriteLine("Design Capacity: " + designCapacity + "mWh, Full Charge Capacity: " + fullCapacity + "mWh, Health: " + health + "%");
+
+        return health;
+    }
+
+    public static float? GetCPUTemp() {
+
+        var last = DateTimeOffset.Now.ToUnixTimeSeconds();
+        if (Math.Abs(last - lastUpdate) < 2) return cpuTemp;
+        lastUpdate = last;
 
         cpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_CPU);
 
@@ -94,6 +235,23 @@ public static class HardwareControl
                 Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
             }
 
+
+        return cpuTemp;
+    }
+
+
+    public static void ReadSensors()
+    {
+        batteryRate = 0;
+        gpuTemp = -1;
+        gpuUse = -1;
+
+        cpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.CPU_Fan));
+        gpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.GPU_Fan));
+        midFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.Mid_Fan));
+
+        cpuTemp = GetCPUTemp();
+
         try
         {
             gpuTemp = GpuControl?.GetCurrentTemperature();
@@ -108,17 +266,15 @@ public static class HardwareControl
         if (gpuTemp is null || gpuTemp < 0)
             gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
 
-        try
+        ReadFullChargeCapacity();
+        GetBatteryStatus();
+
+        if (fullCapacity > 0 && chargeCapacity > 0)
         {
-            using (var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true))
-            {
-                batteryDischarge = cb.NextValue() / 1000;
-            }
-        }
-        catch
-        {
-            Debug.WriteLine("Failed reading Battery discharge");
+            batteryCapacity = Math.Min(100, ((decimal)chargeCapacity / (decimal)fullCapacity) * 100);
         }
+
+
     }
 
     public static bool IsUsedGPU(int threshold = 10)
@@ -184,7 +340,7 @@ public static class HardwareControl
         }
         catch (Exception ex)
         {
-            Debug.WriteLine(ex.ToString());
+            Debug.WriteLine("Can't connect to GPU " + ex.ToString());
         }
     }
 

app/Helpers/ClamshellModeControl.cs

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

app/Helpers/ColorUtilities.cs

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

app/Helpers/OptimizationService.cs

@@ -9,6 +9,8 @@ namespace GHelper.Helpers
     {
 
         static List<string> services = new() {
+                "ArmouryCrateControlInterface",
+                "ASUSOptimization",
                 "AsusAppService",
                 "ASUSLinkNear",
                 "ASUSLinkRemote",
@@ -16,9 +18,7 @@ namespace GHelper.Helpers
                 "ASUSSwitch",
                 "ASUSSystemAnalysis",
                 "ASUSSystemDiagnosis",
-                "ArmouryCrateControlInterface",
-                "AsusCertService",
-                "ASUSOptimization"
+                "AsusCertService"
         };
 
         public static void SetChargeLimit(int newValue)

app/Helpers/ProcessHelper.cs

@@ -1,10 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
+using System.Diagnostics;
 using System.Security.Principal;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace GHelper.Helpers
 {
@@ -103,7 +98,7 @@ namespace GHelper.Helpers
         {
             try
             {
-                string script = $"Set-Service -Name \"{serviceName}\" -Status stopped -StartupType disabled";
+                string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType Disabled";
                 Logger.WriteLine(script);
                 RunCMD("powershell", script);
             }

app/Helpers/ToastForm.cs

@@ -132,6 +132,9 @@ namespace GHelper.Helpers
 
         public void RunToast(string text, ToastIcon? icon = null)
         {
+
+            if (AppConfig.Is("disable_osd")) return;
+
             Program.settingsForm.Invoke(delegate
             {
                 //Hide();

app/Input/InputDispatcher.cs

@@ -2,7 +2,6 @@
 using GHelper.Helpers;
 using GHelper.Mode;
 using Microsoft.Win32;
-using NAudio.CoreAudioApi;
 using System.Diagnostics;
 using System.Management;
 
@@ -105,9 +104,19 @@ namespace GHelper.Input
             if (keyProfile != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyProfile);
             if (keyApp != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyApp);
 
+            if (!AppConfig.Is("skip_hotkeys"))
+            {
+                hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeDown);
+                hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeUp);
+                hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeDown);
+                hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeUp);
+            }
+
             if (!AppConfig.ContainsModel("Z13"))
+            {
                 if (actionM1 is not null && actionM1.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeDown);
-            if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
+                if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
+            }
 
             // FN-Lock group
 
@@ -138,6 +147,35 @@ namespace GHelper.Input
 
         }
 
+        public static bool NoMKeys()
+        {
+            return AppConfig.ContainsModel("Z13") ||
+                   AppConfig.ContainsModel("FX706") || 
+                   AppConfig.ContainsModel("FA506") ||
+                   AppConfig.ContainsModel("FX506") ||
+                   AppConfig.ContainsModel("Duo") ||
+                   AppConfig.ContainsModel("FX505");
+        }
+
+        static bool SwappedBrightness()
+        {
+            return (AppConfig.ContainsModel("FA506IH") || AppConfig.ContainsModel("FX506LU"));
+        }
+
+        static void SetBrightness(int delta)
+        {
+            var brightness = ScreenBrightness.Get();
+
+            if (delta > 0 || SwappedBrightness()) HandleOptimizationEvent(32);
+            else HandleOptimizationEvent(16);
+
+            if (!AppConfig.ContainsModel("TUF")) return;
+
+            Thread.Sleep(100);
+            if (brightness == ScreenBrightness.Get())
+                Program.toast.RunToast(ScreenBrightness.Adjust(delta) + "%", (delta < 0 ) ? ToastIcon.BrightnessDown : ToastIcon.BrightnessUp);
+        }
+
         public void KeyPressed(object sender, KeyPressedEventArgs e)
         {
 
@@ -145,7 +183,7 @@ namespace GHelper.Input
             {
                 Logger.WriteLine(e.Key.ToString());
 
-                if (AppConfig.ContainsModel("Z13") || AppConfig.ContainsModel("FA506"))
+                if (NoMKeys())
                 {
                     switch (e.Key)
                     {
@@ -161,7 +199,7 @@ namespace GHelper.Input
                     }
                 }
 
-                if (AppConfig.ContainsModel("Z13")) 
+                if (AppConfig.ContainsModel("Z13") || AppConfig.ContainsModel("Duo"))
                 {
                     switch (e.Key)
                     {
@@ -209,12 +247,10 @@ namespace GHelper.Input
                         KeyboardHook.KeyPress(Keys.Snapshot);
                         break;
                     case Keys.F7:
-                        //if (AppConfig.ContainsModel("TUF")) Program.toast.RunToast(ScreenBrightness.Adjust(-10) + "%", ToastIcon.BrightnessDown);
-                        HandleOptimizationEvent(16);
+                        SetBrightness(-10);
                         break;
                     case Keys.F8:
-                        // if (AppConfig.ContainsModel("TUF")) Program.toast.RunToast(ScreenBrightness.Adjust(+10) + "%", ToastIcon.BrightnessUp);
-                        HandleOptimizationEvent(32);
+                        SetBrightness(+10);
                         break;
                     case Keys.F9:
                         KeyboardHook.KeyWinPress(Keys.P);
@@ -245,7 +281,35 @@ namespace GHelper.Input
                 if (e.Key == keyApp) Program.SettingsToggle();
             }
 
+            if (e.Modifier == (ModifierKeys.Control))
+            {
+                switch (e.Key)
+                {
+                    case Keys.VolumeDown:
+                        // Screen brightness down on CTRL+VolDown
+                        SetBrightness(-10);
+                        break;
+                    case Keys.VolumeUp:
+                        // Screen brightness up on CTRL+VolUp
+                        SetBrightness(+10);
+                        break;
+                }
+            }
 
+            if (e.Modifier == (ModifierKeys.Shift))
+            {
+                switch (e.Key)
+                {
+                    case Keys.VolumeDown:
+                        // Keyboard backlight down on SHIFT+VolDown
+                        SetBacklight(-1);
+                        break;
+                    case Keys.VolumeUp:
+                        // Keyboard backlight up on SHIFT+VolUp
+                        SetBacklight(1);
+                        break;
+                }
+            }
         }
 
 
@@ -265,6 +329,8 @@ namespace GHelper.Input
                     action = "micmute";
                 if (name == "fnc")
                     action = "fnlock";
+                if (name == "fne")
+                    action = "calculator";
             }
 
             switch (action)
@@ -305,15 +371,23 @@ namespace GHelper.Input
                     Program.toast.RunToast(muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
                     break;
                 case "brightness_up":
-                    HandleOptimizationEvent(32);
+                    SetBrightness(+10);
                     break;
                 case "brightness_down":
-                    HandleOptimizationEvent(16);
+                    SetBrightness(-10);
+                    break;
+                case "screenpad_up":
+                    SetScreenpad(10);
+                    break;
+                case "screenpad_down":
+                    SetScreenpad(-10);
                     break;
                 case "custom":
                     CustomKey(name);
                     break;
-
+                case "calculator":
+                    LaunchProcess("calc");
+                    break;
                 default:
                     break;
             }
@@ -356,42 +430,74 @@ namespace GHelper.Input
 
         static void HandleEvent(int EventID)
         {
-            switch (EventID)
+            // The ROG Ally uses different M-key codes.
+            // We'll special-case the translation of those.
+            if (AppConfig.ContainsModel("RC71"))
             {
-                case 124:    // M3
-                    KeyProcess("m3");
-                    return;
-                case 56:    // M4 / Rog button
-                    KeyProcess("m4");
-                    return;
-                case 174:   // FN+F5
-                    modeControl.CyclePerformanceMode();
-                    return;
-                case 179:   // FN+F4
-                case 178:   // FN+F4
-                    KeyProcess("fnf4");
-                    return;
-                case 158:   // Fn + C
-                    KeyProcess("fnc");
-                    return;
-                case 78:    // Fn + ESC
-                    ToggleFnLock();
-                    return;
-                case 189: // Tablet mode 
-                    TabletMode();
-                    return;
-                case 197: // FN+F2
-                    SetBacklight(-1);
-                    return;
-                case 196: // FN+F3
-                    SetBacklight(1);
-                    return;
-                case 199: // ON Z13 - FN+F11 - cycles backlight
-                    SetBacklight(4);
-                    return;
-                case 53:    // FN+F6 on GA-502DU model
-                    NativeMethods.TurnOffScreen(Program.settingsForm.Handle);
-                    return;
+                switch(EventID)
+                {
+
+                    // This is both the M1 and M2 keys.
+                    // There's a way to differentiate, apparently, but it isn't over USB or any other obvious protocol.
+                    case 165:
+                        KeyProcess("m1");
+                        return;
+                    // The Command Center ("play-looking") button below the select key.
+                    // We'll call this M3.
+                    case 166:
+                        KeyProcess("m3");
+                        return;
+                    // The M4/ROG key.
+                    case 56:
+                        KeyProcess("m4");
+                        return;
+
+                }
+            }
+            // All other devices seem to use the same HID key-codes,
+            // so we can process them all the same.
+            else
+            {
+                switch (EventID)
+                {
+                    case 124:    // M3
+                        KeyProcess("m3");
+                        return;
+                    case 56:    // M4 / Rog button
+                        KeyProcess("m4");
+                        return;
+                    case 181:    // FN + Numpad Enter
+                        KeyProcess("fne");
+                        return;
+                    case 174:   // FN+F5
+                        modeControl.CyclePerformanceMode();
+                        return;
+                    case 179:   // FN+F4
+                    case 178:   // FN+F4
+                        KeyProcess("fnf4");
+                        return;
+                    case 158:   // Fn + C
+                        KeyProcess("fnc");
+                        return;
+                    case 78:    // Fn + ESC
+                        ToggleFnLock();
+                        return;
+                    case 189: // Tablet mode
+                        TabletMode();
+                        return;
+                    case 197: // FN+F2
+                        SetBacklight(-1);
+                        return;
+                    case 196: // FN+F3
+                        SetBacklight(1);
+                        return;
+                    case 199: // ON Z13 - FN+F11 - cycles backlight
+                        SetBacklight(4);
+                        return;
+                    case 53:    // FN+F6 on GA-502DU model
+                        NativeMethods.TurnOffScreen(Program.settingsForm.Handle);
+                        return;
+                }
             }
 
             if (!OptimizationService.IsRunning())
@@ -414,7 +520,7 @@ namespace GHelper.Input
                     break;
                 case 107: // FN+F10
                     AsusUSB.TouchpadToggle();
-                    Thread.Sleep(50);
+                    Thread.Sleep(200);
                     Program.toast.RunToast(GetTouchpadState() ? "On" : "Off", ToastIcon.Touchpad);
                     break;
                 case 108: // FN+F11
@@ -474,14 +580,36 @@ namespace GHelper.Input
 
         }
 
+        public static void SetScreenpad(int delta)
+        {
+            int brightness = AppConfig.Get("screenpad", 100);
+            brightness = Math.Max(Math.Min(100, brightness + delta), 0);
+
+            AppConfig.Set("screenpad", brightness);
+
+            Program.acpi.DeviceSet(AsusACPI.ScreenPadBrightness, (brightness * 255 / 100), "Screenpad");
+            if (brightness == 0) Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, brightness, "ScreenpadToggle");
+
+            Program.toast.RunToast($"Screen Pad {brightness}", delta > 0 ? ToastIcon.BrightnessUp : ToastIcon.BrightnessDown);
+
+        }
+
+
         static void LaunchProcess(string command = "")
         {
 
             try
             {
-                string executable = command.Split(' ')[0];
-                string arguments = command.Substring(executable.Length).Trim();
-                Process proc = Process.Start(executable, arguments);
+
+                //string executable = command.Split(' ')[0];
+                //string arguments = command.Substring(executable.Length).Trim();
+
+                ProcessStartInfo startInfo = new ProcessStartInfo();
+                startInfo.UseShellExecute = true;
+                startInfo.WorkingDirectory = Environment.CurrentDirectory;
+                startInfo.FileName = command;
+                //startInfo.Arguments = arguments;
+                Process proc = Process.Start(startInfo);
             }
             catch
             {

app/Mode/ModeControl.cs

@@ -143,7 +143,7 @@ namespace GHelper.Mode
                 }
 
                 // force set PPTs for missbehaving bios on FX507/517 series
-                if ((AppConfig.ContainsModel("FX507") || AppConfig.ContainsModel("FX517") || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
+                if ((AppConfig.ContainsModel("FX507") || AppConfig.ContainsModel("FX517") || AppConfig.ContainsModel("FX707") || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
                 {
                     Task.Run(async () =>
                     {
@@ -172,7 +172,7 @@ namespace GHelper.Mode
 
         private static bool IsFanRequired()
         {
-            return AppConfig.ContainsModel("GA402XI") || AppConfig.ContainsModel("G513");
+            return AppConfig.ContainsModel("GA402X") || AppConfig.ContainsModel("G513");
         }
 
         public void AutoPower(int delay = 0)
@@ -209,7 +209,7 @@ namespace GHelper.Mode
                     timer.Dispose();
 
                     if (applyPower) SetPower();
-                    Thread.Sleep(1000);
+                    Thread.Sleep(500);
                     SetGPUPower();
                     AutoRyzen();
                 };
@@ -366,6 +366,8 @@ namespace GHelper.Mode
 
         public void SetUV(int cpuUV)
         {
+            if (!RyzenControl.IsSupportedUV()) return;
+
             if (cpuUV >= RyzenControl.MinCPUUV && cpuUV <= RyzenControl.MaxCPUUV)
             {
                 var uvResult = SendCommand.set_coall(cpuUV);
@@ -376,6 +378,8 @@ namespace GHelper.Mode
 
         public void SetUViGPU(int igpuUV)
         {
+            if (!RyzenControl.IsSupportedUViGPU()) return;
+
             if (igpuUV >= RyzenControl.MinIGPUUV && igpuUV <= RyzenControl.MaxIGPUUV)
             {
                 var iGPUResult = SendCommand.set_cogfx(igpuUV);

app/Mode/PowerNative.cs

@@ -60,6 +60,9 @@ namespace GHelper.Mode
         private static Guid GUID_SLEEP_SUBGROUP = new Guid("238c9fa8-0aad-41ed-83f4-97be242c8f20");
         private static Guid GUID_HIBERNATEIDLE = new Guid("9d7815a6-7ee4-497e-8888-515a05f02364");
 
+        private static Guid GUID_SYSTEM_BUTTON_SUBGROUP = new Guid("4f971e89-eebd-4455-a8de-9e59040e7347");
+        private static Guid GUID_LIDACTION = new Guid("5CA83367-6E45-459F-A27B-476B1D01C936");
+
         [DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
         public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
 
@@ -163,5 +166,62 @@ namespace GHelper.Mode
                     break;
             }
         }
+
+        public static int GetLidAction(bool ac)
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            IntPtr activeIndex;
+            if (ac)
+                PowerReadACValueIndex(IntPtr.Zero,
+                     activeSchemeGuid,
+                     GUID_SYSTEM_BUTTON_SUBGROUP,
+                     GUID_LIDACTION, out activeIndex);
+
+            else
+                PowerReadDCValueIndex(IntPtr.Zero,
+                    activeSchemeGuid,
+                    GUID_SYSTEM_BUTTON_SUBGROUP,
+                    GUID_LIDACTION, out activeIndex);
+
+
+            return activeIndex.ToInt32();
+        }
+
+
+        public static void SetLidAction(int action, bool acOnly = false)
+        {
+            /**
+             * 1: Do nothing
+             * 2: Seelp
+             * 3: Hibernate
+             * 4: Shutdown
+             */
+
+            Guid activeSchemeGuid = GetActiveScheme();
+
+            var hrAC = PowerWriteACValueIndex(
+                IntPtr.Zero,
+                activeSchemeGuid,
+                GUID_SYSTEM_BUTTON_SUBGROUP,
+                GUID_LIDACTION,
+                action);
+
+            PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+
+            if (!acOnly)
+            {
+                var hrDC = PowerWriteDCValueIndex(
+                  IntPtr.Zero,
+                  activeSchemeGuid,
+                  GUID_SYSTEM_BUTTON_SUBGROUP,
+                  GUID_LIDACTION,
+                  action);
+
+                PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
+            }
+
+            Logger.WriteLine("Changed Lid Action to " + action);
+        }
     }
 }

app/Peripherals/IPeripheral.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace GHelper.Peripherals
+{
+    public enum PeripheralType
+    {
+        Mouse,
+        Keyboard
+    }
+
+    public interface IPeripheral
+    {
+        public bool IsDeviceReady { get; }
+        public bool Wireless { get; }
+        public int Battery { get; }
+        public bool Charging { get; }
+
+        public PeripheralType DeviceType();
+
+        public string GetDisplayName();
+
+        public bool HasBattery();
+
+        public void SynchronizeDevice();
+
+        public void ReadBattery();
+    }
+}

app/Peripherals/Mouse/Models/ChakramX.cs

@@ -0,0 +1,117 @@
+
+namespace GHelper.Peripherals.Mouse.Models
+{
+    public class ChakramX : AsusMouse
+    {
+        public ChakramX() : base(0x0B05, 0x1A1A, "mi_00", true)
+        {
+        }
+
+        protected ChakramX(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Chakram X (Wireless)";
+        }
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override int ProfileCount()
+        {
+            return 5;
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override int MaxDPI()
+        {
+            return 36_000;
+        }
+
+        public override bool HasXYDPI()
+        {
+            return true;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return true;
+        }
+    }
+
+    public class ChakramXWired : ChakramX
+    {
+        public ChakramXWired() : base(0x1A18, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Chakram X (Wired)";
+        }
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz,
+                PollingRate.PR2000Hz,
+                PollingRate.PR4000Hz,
+                PollingRate.PR8000Hz
+            };
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusIII.cs

@@ -0,0 +1,91 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P706_Wireless
+    public class GladiusIII : AsusMouse
+    {
+        public GladiusIII() : base(0x0B05, 0x197F, "mi_00", true)
+        {
+        }
+
+        protected GladiusIII(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III (Wireless)";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 5;
+        }
+        public override int MaxDPI()
+        {
+            return 26_000;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+    }
+
+    public class GladiusIIIWired : GladiusIII
+    {
+        public GladiusIIIWired() : base(0x197d, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusIIIAimpoint.cs

@@ -0,0 +1,106 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P711
+    public class GladiusIIIAimpoint : AsusMouse
+    {
+        public GladiusIIIAimpoint() : base(0x0B05, 0x1A70, "mi_00", true)
+        {
+        }
+
+        protected GladiusIIIAimpoint(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III Aimpoint (Wireless)";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 5;
+        }
+        public override int MaxDPI()
+        {
+            return 36_000;
+        }
+
+        public override bool HasXYDPI()
+        {
+            return true;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return true;
+        }
+    }
+
+    public class GladiusIIIAimpointWired : GladiusIIIAimpoint
+    {
+        public GladiusIIIAimpointWired() : base(0x1A72, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III Aimpoint (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/ROGKerisWireless.cs

@@ -0,0 +1,173 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P513
+    public class ROGKerisWireless : AsusMouse
+    {
+        public ROGKerisWireless() : base(0x0B05, 0x1960, "mi_00", true)
+        {
+        }
+
+        protected ROGKerisWireless(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris (Wireless)";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 3;
+        }
+        public override int MaxDPI()
+        {
+            return 16_000;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return false;
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.BatteryState
+                || lightingMode == LightingMode.Off;
+        }
+
+        //Has 25% increments
+        protected override int ParseBattery(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x07)
+            {
+                return packet[5] * 25;
+            }
+
+            return -1;
+        }
+
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return false;
+        }
+
+        protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
+        {
+            return base.GetUpdateEnergySettingsPacket(lowBatteryWarning / 25, powerOff);
+        }
+
+        protected override int ParseLowBatteryWarning(byte[] packet)
+        {
+            int lowBat = base.ParseLowBatteryWarning(packet);
+
+            return lowBat * 25;
+        }
+
+        protected override LiftOffDistance ParseLiftOffDistance(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x06)
+            {
+                return LiftOffDistance.Low;
+            }
+
+            return (LiftOffDistance)packet[5];
+        }
+
+        protected override byte[] GetUpdateLiftOffDistancePacket(LiftOffDistance liftOffDistance)
+        {
+            return new byte[] { 0x00, 0x51, 0x35, 0x00, 0x00, ((byte)liftOffDistance) };
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        protected override byte IndexForLightingMode(LightingMode lightingMode)
+        {
+            if (lightingMode == LightingMode.Off)
+            {
+                return 0xFF;
+            }
+            return ((byte)lightingMode);
+        }
+    }
+
+    public class ROGKerisWirelessWired : ROGKerisWireless
+    {
+        public ROGKerisWirelessWired() : base(0x195E, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/StrixImpactIIWireless.cs

@@ -0,0 +1,226 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P513
+    public class StrixImpactIIWireless : AsusMouse
+    {
+        public StrixImpactIIWireless() : base(0x0B05, 0x1949, "mi_00", true)
+        {
+        }
+
+        protected StrixImpactIIWireless(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Impact II (Wireless)";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 3;
+        }
+        public override int MaxDPI()
+        {
+            return 16_000;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return false;
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.BatteryState
+                || lightingMode == LightingMode.Off;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
+        }
+
+        //Has 25% increments
+        protected override int ParseBattery(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x07)
+            {
+                return packet[5] * 25;
+            }
+
+            return -1;
+        }
+
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return false;
+        }
+
+        protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
+        {
+            return base.GetUpdateEnergySettingsPacket(lowBatteryWarning / 25, powerOff);
+        }
+
+        protected override int ParseLowBatteryWarning(byte[] packet)
+        {
+            int lowBat = base.ParseLowBatteryWarning(packet);
+
+            return lowBat * 25;
+        }
+
+        protected override LiftOffDistance ParseLiftOffDistance(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x06)
+            {
+                return LiftOffDistance.Low;
+            }
+
+            return (LiftOffDistance)packet[5];
+        }
+
+        protected override byte[] GetUpdateLiftOffDistancePacket(LiftOffDistance liftOffDistance)
+        {
+            return new byte[] { 0x00, 0x51, 0x35, 0x00, 0x00, ((byte)liftOffDistance) };
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        protected override byte IndexForLightingMode(LightingMode lightingMode)
+        {
+            if (lightingMode == LightingMode.Off)
+            {
+                return 0xFF;
+            }
+            return ((byte)lightingMode);
+        }
+
+        protected override byte[] GetReadLightingModePacket(LightingZone zone)
+        {
+            return new byte[] { 0x00, 0x12, 0x03, 0x00 };
+        }
+
+        protected LightingSetting? ParseLightingSetting(byte[] packet, LightingZone zone)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x03)
+            {
+                return null;
+            }
+
+            int offset = 5 + (((int)zone) * 5);
+
+            LightingSetting setting = new LightingSetting();
+
+            setting.LightingMode = LightingModeForIndex(packet[offset + 0]);
+            setting.Brightness = packet[offset + 1];
+
+            setting.RGBColor = Color.FromArgb(packet[offset + 2], packet[offset + 3], packet[offset + 4]);
+
+
+            return setting;
+        }
+
+        public override void ReadLightingSetting()
+        {
+            if (!HasRGB())
+            {
+                return;
+            }
+            //Mouse sends all lighting zones in one response
+            //00 12 03 00 00 [00 04 ff 00 80] [00 04 00 ff ff] [00 04 ff ff ff] 00 00 00 00 00 00 00 00 00 00 00 00 00 0
+            //No idea what the 3rd zone is as the mouse only has 2
+            byte[]? response = WriteForResponse(GetReadLightingModePacket(LightingZone.All));
+            if (response is null) return;
+
+            LightingZone[] lz = SupportedLightingZones();
+            for (int i = 0; i < lz.Length; ++i)
+            {
+                LightingSetting? ls = ParseLightingSetting(response, lz[i]);
+                if (ls is null)
+                {
+                    Logger.WriteLine(GetDisplayName() + ": Failed to read RGB Setting for Zone " + lz[i].ToString());
+                    continue;
+                }
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+    }
+
+    public class StrixImpactIIWirelessWired : StrixImpactIIWireless
+    {
+        public StrixImpactIIWirelessWired() : base(0x1947, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Impact II (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/TUFM3.cs

@@ -0,0 +1,112 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P306_Wireless
+    public class TUFM3 : AsusMouse
+    {
+        public TUFM3() : base(0x0B05, 0x1910, "mi_01", false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TUF GAMING M3";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        //Mouse has React mapped to 0x03 instead of 0x04 like other mice
+        protected override byte IndexForLightingMode(LightingMode lightingMode)
+        {
+            if (lightingMode == LightingMode.React)
+            {
+                return 0x03;
+            }
+            return ((byte)lightingMode);
+        }
+
+        //Mouse has React mapped to 0x03 instead of 0x04 like other mice
+        protected override LightingMode LightingModeForIndex(byte lightingMode)
+        {
+            if (lightingMode == 0x03)
+            {
+                return LightingMode.React;
+            }
+            return base.LightingModeForIndex(lightingMode);
+
+        }
+
+        public override int ProfileCount()
+        {
+            return 1;
+        }
+        public override int MaxDPI()
+        {
+            return 7_000;
+        }
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return false;
+        }
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo };
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React;
+        }
+    }
+}

app/Peripherals/Mouse/Models/TUFM4Wireless.cs

@@ -0,0 +1,85 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P306_Wireless
+    public class TUFM4Wirelss : AsusMouse
+    {
+        public TUFM4Wirelss() : base(0x0B05, 0x19F4, "mi_00", true)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TUF GAMING M4 (Wireless)";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 3;
+        }
+        public override int MaxDPI()
+        {
+            return 12_000;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return false;
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+    }
+}

app/Peripherals/PeripheralsProvider.cs

@@ -0,0 +1,231 @@
+using GHelper.Peripherals.Mouse;
+using GHelper.Peripherals.Mouse.Models;
+using System.Runtime.CompilerServices;
+
+namespace GHelper.Peripherals
+{
+    public class PeripheralsProvider
+    {
+        private static readonly object _LOCK = new object();
+
+        public static List<AsusMouse> ConnectedMice = new List<AsusMouse>();
+
+        public static event EventHandler? DeviceChanged;
+
+        private static System.Timers.Timer timer = new System.Timers.Timer(1000);
+
+        static PeripheralsProvider()
+        {
+            timer.Elapsed += DeviceTimer_Elapsed;
+        }
+
+
+        private static long lastRefresh;
+
+        public static bool IsMouseConnected()
+        {
+            lock (_LOCK)
+            {
+                return ConnectedMice.Count > 0;
+            }
+        }
+
+        public static bool IsDeviceConnected(IPeripheral peripheral)
+        {
+            return AllPeripherals().Contains(peripheral);
+        }
+
+        //Expand if keyboards or other device get supported later.
+        public static bool IsAnyPeripheralConnect()
+        {
+            return IsMouseConnected();
+        }
+
+        public static List<IPeripheral> AllPeripherals()
+        {
+            List<IPeripheral> l = new List<IPeripheral>();
+            lock (_LOCK)
+            {
+                l.AddRange(ConnectedMice);
+            }
+            return l;
+        }
+
+        public static void RefreshBatteryForAllDevices()
+        {
+            RefreshBatteryForAllDevices(false);
+        }
+
+        public static void RefreshBatteryForAllDevices(bool force)
+        {
+            //Polling the battery every 20s should be enough
+            if (!force && Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastRefresh) < 20_000) return;
+            lastRefresh = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+
+            List<IPeripheral> l = AllPeripherals();
+
+            foreach (IPeripheral m in l)
+            {
+                if (!m.IsDeviceReady)
+                {
+                    //Try to sync the device if that hasn't been done yet
+                    m.SynchronizeDevice();
+                }
+                else
+                {
+                    m.ReadBattery();
+                }
+            }
+        }
+
+        public static void Disconnect(AsusMouse am)
+        {
+            lock (_LOCK)
+            {
+                am.Disconnect -= Mouse_Disconnect;
+                am.MouseReadyChanged -= MouseReadyChanged;
+                am.BatteryUpdated -= BatteryUpdated;
+                ConnectedMice.Remove(am);
+            }
+            if (DeviceChanged is not null)
+            {
+                DeviceChanged(am, EventArgs.Empty);
+            }
+        }
+
+        public static void Connect(AsusMouse am)
+        {
+
+            if (IsDeviceConnected(am))
+            {
+                //Mouse already connected;
+                return;
+            }
+
+            try
+            {
+                am.Connect();
+            }
+            catch (IOException e)
+            {
+                Logger.WriteLine(am.GetDisplayName() + " failed to connect to device: " + e);
+                return;
+            }
+
+            //The Mouse might needs a few ms to register all its subdevices or the sync will fail.
+            //Retry 3 times. Do not call this on main thread! It would block the UI
+
+            int tries = 0;
+            while (!am.IsDeviceReady && tries < 3)
+            {
+                Thread.Sleep(250);
+                Logger.WriteLine(am.GetDisplayName() + " synchronising. Try " + (tries + 1));
+                am.SynchronizeDevice();
+                ++tries;
+            }
+
+            lock (_LOCK)
+            {
+                ConnectedMice.Add(am);
+            }
+            Logger.WriteLine(am.GetDisplayName() + " added to the list: " + ConnectedMice.Count + " device are conneted.");
+
+
+            am.Disconnect += Mouse_Disconnect;
+            am.MouseReadyChanged += MouseReadyChanged;
+            am.BatteryUpdated += BatteryUpdated;
+            if (DeviceChanged is not null)
+            {
+                DeviceChanged(am, EventArgs.Empty);
+            }
+            UpdateSettingsView();
+        }
+
+        private static void BatteryUpdated(object? sender, EventArgs e)
+        {
+            UpdateSettingsView();
+        }
+
+        private static void MouseReadyChanged(object? sender, EventArgs e)
+        {
+            UpdateSettingsView();
+        }
+
+        private static void Mouse_Disconnect(object? sender, EventArgs e)
+        {
+            if (sender is null)
+            {
+                return;
+            }
+
+            AsusMouse am = (AsusMouse)sender;
+            lock (_LOCK)
+            {
+                ConnectedMice.Remove(am);
+            }
+
+            Logger.WriteLine(am.GetDisplayName() + " reported disconnect. " + ConnectedMice.Count + " device are conneted.");
+            am.Dispose();
+
+            UpdateSettingsView();
+        }
+
+
+        private static void UpdateSettingsView()
+        {
+            Program.settingsForm.Invoke(delegate
+            {
+                Program.settingsForm.VisualizePeripherals();
+            });
+        }
+
+        [MethodImpl(MethodImplOptions.Synchronized)]
+        public static void DetectAllAsusMice()
+        {
+            //Add one line for every supported mouse class here to support them.
+            DetectMouse(new ChakramX());
+            DetectMouse(new ChakramXWired());
+            DetectMouse(new GladiusIIIAimpoint());
+            DetectMouse(new GladiusIIIAimpointWired());
+            DetectMouse(new ROGKerisWireless());
+            DetectMouse(new ROGKerisWirelessWired());
+            DetectMouse(new TUFM4Wirelss());
+            DetectMouse(new StrixImpactIIWireless());
+            DetectMouse(new StrixImpactIIWirelessWired());
+            DetectMouse(new GladiusIII());
+            DetectMouse(new GladiusIIIWired());
+            DetectMouse(new TUFM3());
+        }
+
+        public static void DetectMouse(AsusMouse am)
+        {
+            if (am.IsDeviceConnected() && !IsDeviceConnected(am))
+            {
+                Logger.WriteLine("Detected a new" + am.GetDisplayName() + " . Connecting...");
+                Connect(am);
+            }
+        }
+
+        public static void RegisterForDeviceEvents()
+        {
+            HidSharp.DeviceList.Local.Changed += Device_Changed;
+        }
+
+        public static void UnregisterForDeviceEvents()
+        {
+            HidSharp.DeviceList.Local.Changed -= Device_Changed;
+        }
+
+        private static void Device_Changed(object? sender, HidSharp.DeviceListChangedEventArgs e)
+        {
+            timer.Start();
+        }
+
+        private static void DeviceTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            timer.Stop();
+            Logger.WriteLine("HID Device Event: Checking for new ASUS Mice");
+            DetectAllAsusMice();
+        }
+    }
+}

app/Program.cs

@@ -4,6 +4,7 @@ using GHelper.Gpu;
 using GHelper.Helpers;
 using GHelper.Input;
 using GHelper.Mode;
+using GHelper.Peripherals;
 using Microsoft.Win32;
 using Ryzen;
 using System.Diagnostics;
@@ -30,6 +31,7 @@ namespace GHelper
         public static ModeControl modeControl = new ModeControl();
         static GPUModeControl gpuControl = new GPUModeControl(settingsForm);
         static ScreenControl screenControl = new ScreenControl();
+        static ClamshellModeControl clamshellControl = new ClamshellModeControl();
 
         public static ToastForm toast = new ToastForm();
 
@@ -100,11 +102,20 @@ namespace GHelper
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
             SystemEvents.UserPreferenceChanged += SystemEvents_UserPreferenceChanged;
 
+            SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
+            SystemEvents.SessionEnding += SystemEvents_SessionEnding;
+
+            clamshellControl.RegisterDisplayEvents();
+            clamshellControl.ToggleLidAction();
+
             // Subscribing for monitor power on events
             PowerSettingGuid settingGuid = new NativeMethods.PowerSettingGuid();
             unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(settingsForm.Handle, settingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
 
 
+            Task task = Task.Run((Action)PeripheralsProvider.DetectAllAsusMice);
+            PeripheralsProvider.RegisterForDeviceEvents();
+
             if (Environment.CurrentDirectory.Trim('\\') == Application.StartupPath.Trim('\\') || action.Length > 0)
             {
                 SettingsToggle(action);
@@ -114,7 +125,19 @@ namespace GHelper
 
         }
 
+        private static void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)
+        {
+            gpuControl.StandardModeFix();
+        }
 
+        private static void SystemEvents_SessionSwitch(object sender, SessionSwitchEventArgs e)
+        {
+            if (e.Reason == SessionSwitchReason.SessionLogon || e.Reason == SessionSwitchReason.SessionUnlock)
+            {
+                Logger.WriteLine("Session:" + e.Reason.ToString());
+                screenControl.AutoScreen();
+            }
+        }
 
         static void SystemEvents_UserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
         {
@@ -175,8 +198,12 @@ namespace GHelper
 
         private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
         {
+            Logger.WriteLine("Power Mode:" + e.Mode.ToString());
+            
+
+            if (e.Mode == PowerModes.Suspend) gpuControl.StandardModeFix();
+
             if (SystemInformation.PowerStatus.PowerLineStatus == isPlugged) return;
-            Logger.WriteLine("Power Mode Changed");
             SetAutoModes(true);
         }
 
@@ -238,6 +265,8 @@ namespace GHelper
         static void OnExit(object sender, EventArgs e)
         {
             trayIcon.Visible = false;
+            PeripheralsProvider.UnregisterForDeviceEvents();
+            clamshellControl.UnregisterDisplayEvents();
             NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotify);
             Application.Exit();
         }

app/Properties/Resources.Designer.cs

@@ -140,6 +140,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_batterie_voll_geladen_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_batterie_voll_geladen_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -280,6 +290,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_ladende_batterie_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_ladende_batterie_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -320,6 +340,36 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_maus_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_maus_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_maus_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_maus_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_mauszeiger_50 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_mauszeiger_50", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -360,6 +410,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_quit_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-quit-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -440,6 +500,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_software_32_white {
+            get {
+                object obj = ResourceManager.GetObject("icons8-software-32-white", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -501,7 +571,37 @@ namespace GHelper.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        ///   Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_24 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_24", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_32 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_48 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon ähnlich wie (Symbol).
         /// </summary>
         internal static System.Drawing.Icon standard {
             get {

app/Properties/Resources.resx

@@ -118,24 +118,30 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="icons8-gauge-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-gauge-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
   <data name="brightness_up" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\brightness-up.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_temperature_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-temperature-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="backlight_down" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\backlight-down.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8_mute_unmute_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-mute-unmute-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-quit-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-quit-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-fiat-500-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-fiat-500-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8_microphone_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-microphone-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8_voltage_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-voltage-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-project-management-48 (1)" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-project-management-48 (1).png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
@@ -145,6 +151,9 @@
   <data name="icons8_touchpad_96" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-touchpad-96.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-automation-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-automation-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8-help-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-help-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
@@ -154,8 +163,8 @@
   <data name="icons8-game-controller-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-game-controller-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-matrix-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-matrix-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_video_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-video-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-refresh-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-refresh-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -181,6 +190,12 @@
   <data name="eco" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\eco.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="icons8-video-card-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-video-card-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-rocket-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-rocket-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
   <data name="icons8_edit_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-edit-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
@@ -208,8 +223,20 @@
   <data name="icons8_remove_64" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-remove-64.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8_video_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-video-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-matrix-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-matrix-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-keyboard-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-keyboard-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_fan_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-fan-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_software_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-software-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8-gauge-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-gauge-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-leaf-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-leaf-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
@@ -217,43 +244,46 @@
   <data name="ultimate" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\ultimate.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-rocket-48" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-rocket-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
   <data name="backlight" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\backlight.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-settings-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-settings-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-keyboard-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-keyboard-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="icons8-automation-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-automation-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_processor_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-processor-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="icons8-laptop-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-laptop-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8-video-card-32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-video-card-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="icons8_fan_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-fan-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="icons8_processor_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-processor-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
   <data name="icons8_rocket_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\icons8-rocket-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8_software_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-software-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8-software-32-white" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-software-32-white.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8_temperature_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-temperature-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_maus_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-maus-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="icons8_voltage_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\icons8-voltage-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="icons8_maus_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-maus-32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_mauszeiger_50" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-mauszeiger-50.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_batterie_voll_geladen_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-batterie-voll-geladen-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="icons8_ladende_batterie_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\icons8-ladende-batterie-48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="lighting_dot_32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\lighting_dot_32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="lighting_dot_48" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\lighting_dot_48.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="lighting_dot_24" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\lighting_dot_24.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
 </root>

app/Properties/Strings.Designer.cs

@@ -195,6 +195,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Battery State.
+        /// </summary>
+        internal static string AuraBatteryState {
+            get {
+                return ResourceManager.GetString("AuraBatteryState", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Breathe.
         /// </summary>
@@ -204,6 +213,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Clockwise.
+        /// </summary>
+        internal static string AuraClockwise {
+            get {
+                return ResourceManager.GetString("AuraClockwise", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Color Cycle.
         /// </summary>
@@ -213,6 +231,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Comet.
+        /// </summary>
+        internal static string AuraComet {
+            get {
+                return ResourceManager.GetString("AuraComet", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Counterclockwise.
+        /// </summary>
+        internal static string AuraCounterClockwise {
+            get {
+                return ResourceManager.GetString("AuraCounterClockwise", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Fast.
         /// </summary>
@@ -222,6 +258,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Lighting Mode.
+        /// </summary>
+        internal static string AuraLightingMode {
+            get {
+                return ResourceManager.GetString("AuraLightingMode", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Normal.
         /// </summary>
@@ -240,6 +285,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Random.
+        /// </summary>
+        internal static string AuraRandomColor {
+            get {
+                return ResourceManager.GetString("AuraRandomColor", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to React.
+        /// </summary>
+        internal static string AuraReact {
+            get {
+                return ResourceManager.GetString("AuraReact", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Slow.
         /// </summary>
@@ -267,6 +330,51 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to All.
+        /// </summary>
+        internal static string AuraZoneAll {
+            get {
+                return ResourceManager.GetString("AuraZoneAll", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Dock.
+        /// </summary>
+        internal static string AuraZoneDock {
+            get {
+                return ResourceManager.GetString("AuraZoneDock", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Logo.
+        /// </summary>
+        internal static string AuraZoneLogo {
+            get {
+                return ResourceManager.GetString("AuraZoneLogo", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Scrollwheel.
+        /// </summary>
+        internal static string AuraZoneScroll {
+            get {
+                return ResourceManager.GetString("AuraZoneScroll", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Underglow.
+        /// </summary>
+        internal static string AuraZoneUnderglow {
+            get {
+                return ResourceManager.GetString("AuraZoneUnderglow", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Auto Apply.
         /// </summary>
@@ -321,6 +429,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Charge.
+        /// </summary>
+        internal static string BatteryCharge {
+            get {
+                return ResourceManager.GetString("BatteryCharge", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Battery Charge Limit.
         /// </summary>
@@ -330,6 +447,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Battery Health.
+        /// </summary>
+        internal static string BatteryHealth {
+            get {
+                return ResourceManager.GetString("BatteryHealth", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to BIOS and Driver Updates.
         /// </summary>
@@ -375,6 +501,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Charging.
+        /// </summary>
+        internal static string Charging {
+            get {
+                return ResourceManager.GetString("Charging", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Color.
         /// </summary>
@@ -485,6 +620,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Energy Settings.
+        /// </summary>
+        internal static string EnergySettings {
+            get {
+                return ResourceManager.GetString("EnergySettings", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Extra.
         /// </summary>
@@ -683,6 +827,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to High.
+        /// </summary>
+        internal static string High {
+            get {
+                return ResourceManager.GetString("High", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Key Bindings.
         /// </summary>
@@ -755,6 +908,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Lighting.
+        /// </summary>
+        internal static string Lighting {
+            get {
+                return ResourceManager.GetString("Lighting", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Logo.
         /// </summary>
@@ -764,6 +926,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Low.
+        /// </summary>
+        internal static string Low {
+            get {
+                return ResourceManager.GetString("Low", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Audio Visualizer.
         /// </summary>
@@ -863,6 +1034,87 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Minute.
+        /// </summary>
+        internal static string Minute {
+            get {
+                return ResourceManager.GetString("Minute", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Minutes.
+        /// </summary>
+        internal static string Minutes {
+            get {
+                return ResourceManager.GetString("Minutes", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Angle Snapping.
+        /// </summary>
+        internal static string MouseAngleSnapping {
+            get {
+                return ResourceManager.GetString("MouseAngleSnapping", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Auto Power Off After.
+        /// </summary>
+        internal static string MouseAutoPowerOff {
+            get {
+                return ResourceManager.GetString("MouseAutoPowerOff", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Button Response.
+        /// </summary>
+        internal static string MouseButtonResponse {
+            get {
+                return ResourceManager.GetString("MouseButtonResponse", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Lift Off Distance.
+        /// </summary>
+        internal static string MouseLiftOffDistance {
+            get {
+                return ResourceManager.GetString("MouseLiftOffDistance", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Low Battery Warning at.
+        /// </summary>
+        internal static string MouseLowBatteryWarning {
+            get {
+                return ResourceManager.GetString("MouseLowBatteryWarning", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Performance.
+        /// </summary>
+        internal static string MousePerformance {
+            get {
+                return ResourceManager.GetString("MousePerformance", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Synchronize with mouse.
+        /// </summary>
+        internal static string MouseSynchronize {
+            get {
+                return ResourceManager.GetString("MouseSynchronize", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Multizone.
         /// </summary>
@@ -881,6 +1133,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Never.
+        /// </summary>
+        internal static string Never {
+            get {
+                return ResourceManager.GetString("Never", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to New updates.
         /// </summary>
@@ -899,6 +1160,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Not Connected.
+        /// </summary>
+        internal static string NotConnected {
+            get {
+                return ResourceManager.GetString("NotConnected", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Open G-Helper window.
         /// </summary>
@@ -962,6 +1232,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Peripherals.
+        /// </summary>
+        internal static string Peripherals {
+            get {
+                return ResourceManager.GetString("Peripherals", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Picture / Gif.
         /// </summary>
@@ -980,6 +1259,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Polling Rate.
+        /// </summary>
+        internal static string PollingRate {
+            get {
+                return ResourceManager.GetString("PollingRate", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Power Limits.
         /// </summary>
@@ -1007,6 +1295,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Profile.
+        /// </summary>
+        internal static string Profile {
+            get {
+                return ResourceManager.GetString("Profile", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Quit.
         /// </summary>
@@ -1043,6 +1340,24 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Screenpad Brightness Down.
+        /// </summary>
+        internal static string ScreenPadDown {
+            get {
+                return ResourceManager.GetString("ScreenPadDown", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Screenpad Brightness Up.
+        /// </summary>
+        internal static string ScreenPadUp {
+            get {
+                return ResourceManager.GetString("ScreenPadUp", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Shutdown.
         /// </summary>
@@ -1151,6 +1466,15 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Auto Toggle Clamshell Mode.
+        /// </summary>
+        internal static string ToggleClamshellMode {
+            get {
+                return ResourceManager.GetString("ToggleClamshellMode", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Toggle Fn-Lock.
         /// </summary>

app/Properties/Strings.de.resx

@@ -133,7 +133,7 @@
     <value>Ultimate Modus benötigt einen Neustart</value>
   </data>
   <data name="AlertUltimateTitle" xml:space="preserve">
-    <value>Jetzt neustarten?</value>
+    <value>Jetzt neu starten?</value>
   </data>
   <data name="AnimationSpeed" xml:space="preserve">
     <value>Animationsgeschwindigkeit</value>
@@ -148,13 +148,13 @@
     <value>G-Helper läuft bereits. Bitte prüfe den Systemtray.</value>
   </data>
   <data name="Apply" xml:space="preserve">
-    <value>Apply</value>
+    <value>Anwenden</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
-    <value>Lüfterkurve anweden</value>
+    <value>Lüfterkurve anwenden</value>
   </data>
   <data name="ApplyPowerLimits" xml:space="preserve">
-    <value>Leistunsgrenzen anwenden</value>
+    <value>Leistungsgrenzen anwenden</value>
   </data>
   <data name="ApplyWindowsPowerPlan" xml:space="preserve">
     <value>Windows Leistungsmodus automatisch anpassen</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>ASUS Dienste laufen</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Batteriezustand</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Atmen</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Im Uhrzeigersinn</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Farbwechsel</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Komet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Gegen den Uhrzeigersinn</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Schnell</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Beleuchtungsmodus</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Regenbogen</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Zufällig</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>Reagierend</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Langsam</value>
   </data>
@@ -186,14 +207,29 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Stroboskop</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>Alle</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollrad</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Front</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
-    <value>Auto Apply</value>
+    <value>Automatisch anwenden</value>
   </data>
   <data name="AutoMode" xml:space="preserve">
     <value>Auto</value>
   </data>
   <data name="AutoRefreshTooltip" xml:space="preserve">
-    <value>60Hz im Batteriebetrieb Maximal wenn eingesteckt.</value>
+    <value>60Hz im Batteriebetrieb. Maximal, wenn eingesteckt.</value>
   </data>
   <data name="Awake" xml:space="preserve">
     <value>Im Betrieb</value>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Ausbalanciert</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Ladebegrenzung</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Batteriezustand</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS und Treiber Updates</value>
   </data>
@@ -217,16 +259,19 @@
     <value>Helligkeit</value>
   </data>
   <data name="BrightnessDown" xml:space="preserve">
-    <value>Helligkeit erhöhen</value>
+    <value>Helligkeit verringern</value>
   </data>
   <data name="BrightnessUp" xml:space="preserve">
-    <value>Helligkeit verringern</value>
+    <value>Helligkeit erhöhen</value>
+  </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Lädt</value>
   </data>
   <data name="Color" xml:space="preserve">
     <value>Farbe</value>
   </data>
   <data name="CPUBoost" xml:space="preserve">
-    <value>CPU Boost</value>
+    <value>CPU-Boost</value>
   </data>
   <data name="Custom" xml:space="preserve">
     <value>Benutzerdefiniert</value>
@@ -253,13 +298,16 @@
     <value>Eco</value>
   </data>
   <data name="EnableOptimusText" xml:space="preserve">
-    <value>Wenn Sie die dGPU deaktivieren, indem Sie in den Eco Modus wechseln, kann zu Problemen mit der Helligkeitseinstellung führen, wenn der Anzeigemodus nicht auf Optimus eingestellt ist.
+    <value>Wenn Sie die dGPU deaktivieren, indem Sie in den Eco-Modus wechseln, kann zu Problemen mit der Helligkeitseinstellung führen, wenn der Anzeigemodus nicht auf Optimus eingestellt ist.
 
 Trotzdem fortfahren?</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>Nvidia Anzeigemodus ist nicht auf Optimus eingestellt</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energieeinstellungen</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
   </data>
@@ -288,7 +336,7 @@ Trotzdem fortfahren?</value>
     <value>Lüfter und Leistung</value>
   </data>
   <data name="FanSpeed" xml:space="preserve">
-    <value>Fan</value>
+    <value>Lüfter</value>
   </data>
   <data name="FansPower" xml:space="preserve">
     <value>Lüfter + Leistung</value>
@@ -326,6 +374,9 @@ Trotzdem fortfahren?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Maximale GPU Temperatur</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>Hoch</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Tastenbelegung</value>
   </data>
@@ -350,14 +401,20 @@ Trotzdem fortfahren?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Leuchtstreifen</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Beleuchtung</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Niedrig</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Audio Visualisierung</value>
   </data>
   <data name="MatrixBanner" xml:space="preserve">
-    <value>Binary Banner</value>
+    <value>Binäres Banner</value>
   </data>
   <data name="MatrixBright" xml:space="preserve">
     <value>Hell</value>
@@ -386,18 +443,51 @@ Trotzdem fortfahren?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>60Hz um Strom zu sparen</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minuten</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Mausglättung</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Automatisch abschalten nach</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Tastenreaktionsgeschwindigkeit</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Batteriewarnung bei</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Leistung</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Maus synchronisieren</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multi-Zone</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Mikrofon stummschalten</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Niemals</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Neue Updates:</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Keine Updates verfügbar</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Nicht verbunden</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>G-Helper Fenster öffnen</value>
   </data>
@@ -405,10 +495,10 @@ Trotzdem fortfahren?</value>
     <value>Optimiert</value>
   </data>
   <data name="OptimizedGPUTooltip" xml:space="preserve">
-    <value>Eco Modus im Batteriebetrieb, Standard wenn eingesteckt.</value>
+    <value>Eco-Modus im Batteriebetrieb. Standard, wenn eingesteckt.</value>
   </data>
   <data name="OptimizedUSBC" xml:space="preserve">
-    <value>GPU beim USB-C Laden im Optimierten Modus deaktiviert lassen</value>
+    <value>dGPU beim USB-C Laden im Optimierten Modus deaktiviert lassen</value>
   </data>
   <data name="Other" xml:space="preserve">
     <value>Sonstiges</value>
@@ -419,12 +509,18 @@ Trotzdem fortfahren?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Leistungsmodus</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Zubehör</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Bild / GIF</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Wiedergabe / Pause</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Abfragerate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Leistungsbegrenzung</value>
   </data>
@@ -434,11 +530,14 @@ Trotzdem fortfahren?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Druck</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profil</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Schließen</value>
   </data>
   <data name="RestartGPU" xml:space="preserve">
-    <value>Ein Prozess verhindert den Wechsel in den Eco Modus. dGPU neustarten? Fortfahren auf eigene Gefahr.</value>
+    <value>Ein Prozess verhindert den Wechsel in den Eco-Modus. dGPU neu starten? Fortfahren auf eigene Gefahr.</value>
   </data>
   <data name="RPM" xml:space="preserve">
     <value>U/Min</value>
@@ -446,6 +545,12 @@ Trotzdem fortfahren?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Beim Start ausführen</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Helligkeit verringern</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad-Helligkeit erhöhen</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Herunterfahren</value>
   </data>
@@ -482,6 +587,9 @@ Trotzdem fortfahren?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Aura umschalten</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Clamshell Modus automatisch aktivieren</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>FN Sperre umschalten</value>
   </data>
@@ -504,13 +612,13 @@ Trotzdem fortfahren?</value>
     <value>Verbindet den Bildschirm mit der dGPU für maximale Leistung.</value>
   </data>
   <data name="UltimateMode" xml:space="preserve">
-    <value>Ultimate</value>
+    <value>Ultimativ</value>
   </data>
   <data name="UndervoltingRisky" xml:space="preserve">
     <value>Die Spannungsabsenkung (Undervolting) ist experimentell und birgt u.U. ein Risik. Wenn die Spannung zu weit abgesenkt wird, wird der Computer instabil und kann abstürzen, was zu Datenverlust führen kann. Es empfiehlt sich mit kleinen Werten anzufangen und es ausgiebig zu testen, um den idealen Wert zu finden.</value>
   </data>
   <data name="Updates" xml:space="preserve">
-    <value>Updates</value>
+    <value>Aktualisierungen</value>
   </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>Version</value>

app/Properties/Strings.es.resx

@@ -139,7 +139,7 @@
     <value>Velocidad</value>
   </data>
   <data name="AnimeMatrix" xml:space="preserve">
-    <value>Anime Matrix</value>
+    <value>AniMe Matrix</value>
   </data>
   <data name="AppAlreadyRunning" xml:space="preserve">
     <value>La apliación ya está ejecutándose</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Servicios de Asus en ejecución</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Estado de la batería</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Respiración</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Sentido horario</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Ciclo de color</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Cometa</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Sentido anti-horario</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Rápido</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Modo de iluminación</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Arcoíris</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Aleatorio</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>Sensible</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Lento</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Estroboscópico</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>Todo</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Rueda de desplazamiento</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Autoaplicar</value>
   </data>
@@ -193,20 +229,26 @@
     <value>Automático</value>
   </data>
   <data name="AutoRefreshTooltip" xml:space="preserve">
-    <value>Establece 60Hz con batería y vuelve cuando está enchufado</value>
+    <value>Establece 60Hz con batería y revierte cuando está enchufado</value>
   </data>
   <data name="Awake" xml:space="preserve">
     <value>Encendida</value>
   </data>
   <data name="BacklightTimeout" xml:space="preserve">
-    <value>Tiempo de espera conectado / con batería (0 - ACT)</value>
+    <value>Tiempo de espera conectado / con batería (0 - ON)</value>
   </data>
   <data name="Balanced" xml:space="preserve">
     <value>Equilibrado</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Límite de carga</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Salud de la batería</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>Actualizaciones de BIOS y Drivers</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Subir brillo</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Cargando</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Color</value>
   </data>
@@ -253,13 +298,16 @@
     <value>Eco</value>
   </data>
   <data name="EnableOptimusText" xml:space="preserve">
-    <value>Deshabilitar la dGPU cambiando a modo Eco moentras el Modo de Pantalla en el Panel de Control de NVIDIA no está configurado en Optimus puede causar problemas con el control del brillo hasta después del próximo reinicio.
+    <value>Deshabilitar la dGPU cambiando a modo Eco mientras el Modo de Pantalla en el Panel de Control de NVIDIA no está configurado en Optimus puede causar problemas con el control del brillo hasta después del próximo reinicio.
 
 ¿Seguro que desea continuar?</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>Modo de Pantalla NVIDIA no está configurado en Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Ajustes de energía</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Adicional</value>
   </data>
@@ -326,6 +374,9 @@
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperatura objetivo</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>Alto</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Atajos de teclado</value>
   </data>
@@ -350,9 +401,15 @@
   <data name="Lightbar" xml:space="preserve">
     <value>Barra de luz</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Iluminación</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Bajo</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Visualizador de audio</value>
   </data>
@@ -386,17 +443,50 @@
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Frecuencia de actualización de 60Hz para ahorrar batería</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minuto</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutos</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Ajuste de ángulo</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto-apagar tras</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Respuesta del botón</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Distancia de despegue (LOD)</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Aviso de batería baja al</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Rendimiento</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Sincronizar con el ratón</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizona</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Silenciar micrófono</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Nunca</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Nuevas actualizaciones</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
-    <value>No hay nuevas actualizaciones</value>
+    <value>No hay actualizaciones</value>
+  </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>No conectado</value>
   </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Abrir ventana G-Helper</value>
@@ -419,12 +509,18 @@
   <data name="PerformanceMode" xml:space="preserve">
     <value>Modo</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Periféricos</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Imagen / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Reproducir / Pausar</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Velocidad de respuesta</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Límites de energía</value>
   </data>
@@ -434,6 +530,9 @@
   <data name="PrintScreen" xml:space="preserve">
     <value>Capturar pantalla</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Perfil</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Quitar</value>
   </data>
@@ -446,6 +545,12 @@
   <data name="RunOnStartup" xml:space="preserve">
     <value>Ejecutar al inicio</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Bajar brillo ScreenPad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Subir brillo ScreenPad</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Al apagar</value>
   </data>
@@ -468,7 +573,7 @@
     <value>Iniciando servicios</value>
   </data>
   <data name="StartupError" xml:space="preserve">
-    <value>Error de inicio</value>
+    <value>Error al iniciar</value>
   </data>
   <data name="Stop" xml:space="preserve">
     <value>Detener</value>
@@ -482,11 +587,14 @@
   <data name="ToggleAura" xml:space="preserve">
     <value>Alternar Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Cambiar automáticamente a modo Clamshell</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Alternar Fn-Lock</value>
   </data>
   <data name="ToggleMiniled" xml:space="preserve">
-    <value>Alternar Miniled (si comp.)</value>
+    <value>Alternar Miniled (si compatible)</value>
   </data>
   <data name="ToggleScreen" xml:space="preserve">
     <value>Alternar pantalla</value>

app/Properties/Strings.fr.resx

@@ -118,7 +118,7 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="ACPIError" xml:space="preserve">
-    <value>Connexion impossible avec ASUS ACPI. L'application ne peut fonctionner sans. Veuillez installer Asus System Control Interface.</value>
+    <value>Connexion impossible avec ASUS ACPI. L'application ne peut fonctionner sans. Veuillez installer Asus System Control Interface</value>
   </data>
   <data name="AlertDGPU" xml:space="preserve">
     <value>Le GPU semble être surchargé, voulez vous le désactiver ?</value>
@@ -148,7 +148,7 @@
     <value>G-Helper est déjà en cours d'exécution. Vérifiez la barre d'état système.</value>
   </data>
   <data name="Apply" xml:space="preserve">
-    <value>Apply</value>
+    <value>Appliquer</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
     <value>Appliquer la courbe</value>
@@ -160,23 +160,44 @@
     <value>Ajustement auto des modes de gestion alim. Windows</value>
   </data>
   <data name="AsusServicesRunning" xml:space="preserve">
-    <value>Asus Services Running</value>
+    <value>Services Asus actifs</value>
+  </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>État de la batterie</value>
   </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Pulsation</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Sens horaire</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Cycle de couleur</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comète</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Sens antihoraire</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Rapide</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Arc-en-ciel</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Aléatoire</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Lent</value>
   </data>
@@ -186,8 +207,23 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Stroboscopique</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
-    <value>Auto Apply</value>
+    <value>Appliquer automatiquement</value>
   </data>
   <data name="AutoMode" xml:space="preserve">
     <value>Automatique</value>
@@ -204,11 +240,17 @@
   <data name="Balanced" xml:space="preserve">
     <value>Équilibré</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Limite de charge </value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Santé de la batterie</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
-    <value>BIOS and Driver Updates</value>
+    <value>Mise à jour BIOS et pilotes</value>
   </data>
   <data name="Boot" xml:space="preserve">
     <value>Au démarrage</value>
@@ -217,10 +259,13 @@
     <value>Luminosité</value>
   </data>
   <data name="BrightnessDown" xml:space="preserve">
-    <value>Brightness Down</value>
+    <value>Baisser la luminosité</value>
   </data>
   <data name="BrightnessUp" xml:space="preserve">
-    <value>Brightness Up</value>
+    <value>Augmenter la luminosité</value>
+  </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Chargement en cours</value>
   </data>
   <data name="Color" xml:space="preserve">
     <value>Couleur</value>
@@ -244,7 +289,7 @@
     <value>Télécharger la mise à jour</value>
   </data>
   <data name="DriverAndSoftware" xml:space="preserve">
-    <value>Drivers and Software</value>
+    <value>Pilotes et Logiciels</value>
   </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
     <value>Désactive le dGPU pour préserver la batterie</value>
@@ -253,12 +298,15 @@
     <value>Éco</value>
   </data>
   <data name="EnableOptimusText" xml:space="preserve">
-    <value>Disabling the dGPU by going into Eco mode while Display Mode in NVIDIA Control Panel is not set to Optimus might cause problems with brightness controls until after the next reboot. 
+    <value>Désactiver la dGPU en passant au mode Eco pendant que le mode d'affichage dans le panneau de configuration NVIDIA n'est pas réglé sur Optimus peut causer des problèmes avec les commandes de luminosité jusqu'au prochain redémarrage.
 
-Do you still want to continue?</value>
+Voulez-vous continuer ?</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
-    <value>NVIDIA Display Mode is not set to Optimus</value>
+    <value>Le mode d'affichage NVIDIA n'est pas réglé sur Optimus</value>
+  </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Paramètres d'énergie</value>
   </data>
   <data name="Extra" xml:space="preserve">
     <value>+ d'options</value>
@@ -288,13 +336,13 @@ Do you still want to continue?</value>
     <value>Ventilateurs + Puissance</value>
   </data>
   <data name="FanSpeed" xml:space="preserve">
-    <value>Fan</value>
+    <value>Ventilateur</value>
   </data>
   <data name="FansPower" xml:space="preserve">
     <value>Ventilateurs + Puissance</value>
   </data>
   <data name="FnLock" xml:space="preserve">
-    <value>Process Fn+F hotkeys without Fn</value>
+    <value>Traiter les raccourcis clavier Fn+F sans Fn</value>
   </data>
   <data name="GPUBoost" xml:space="preserve">
     <value>Dynamic Boost</value>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Température cible</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Raccourcis clavier</value>
   </data>
@@ -333,7 +384,7 @@ Do you still want to continue?</value>
     <value>Clavier</value>
   </data>
   <data name="KillGpuApps" xml:space="preserve">
-    <value>Stop all apps using GPU when switching to Eco</value>
+    <value>Arrêter toutes les applications utilisant la dGPU lors du passage au mode Eco</value>
   </data>
   <data name="LaptopBacklight" xml:space="preserve">
     <value>Rétroéclairage de l'ordinateur</value>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Barre lumineuse</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Éclairage</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Visualiseur Audio</value>
   </data>
@@ -386,17 +443,50 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Rafraichîssement 60 Hz pour économiser de la batterie</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Arrêt automatique après</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Avertissement de batterie faible à</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchroniser avec le pointeur</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multi-zone</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Désactiver le micro</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Jamais</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
-    <value>New updates</value>
+    <value>Nouvelles mises à jour</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
-    <value>No new updates</value>
+    <value>Aucune mise à jour disponible</value>
+  </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Non connecté</value>
   </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Ouvrir G-Helper</value>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Mode Performance</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Périphériques</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Image / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Lecture / Pause</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Limites de puissance</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Capture d'écran</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profil</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Quitter</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Exécuter au démarrage</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Baisser la luminosité du Screenpad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Augmenter la luminosité du Screenpad</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Arrêter</value>
   </data>
@@ -462,10 +567,10 @@ Do you still want to continue?</value>
     <value>Standard</value>
   </data>
   <data name="Start" xml:space="preserve">
-    <value>Start</value>
+    <value>Démarrer</value>
   </data>
   <data name="StartingServices" xml:space="preserve">
-    <value>Starting Services</value>
+    <value>Démarrage des services</value>
   </data>
   <data name="StartupError" xml:space="preserve">
     <value>Erreur au lancement</value>
@@ -474,16 +579,19 @@ Do you still want to continue?</value>
     <value>Stop</value>
   </data>
   <data name="StopGPUApps" xml:space="preserve">
-    <value>Stop GPU Applications</value>
+    <value>Arrêt des applications dGPU</value>
   </data>
   <data name="StoppingServices" xml:space="preserve">
-    <value>Stopping Services</value>
+    <value>Arrêt des services</value>
   </data>
   <data name="ToggleAura" xml:space="preserve">
     <value>Activer Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Basculer automatiquement en mode Clamshell</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
-    <value>Toggle Fn-Lock</value>
+    <value>Activer/désactiver Fn-Lock</value>
   </data>
   <data name="ToggleMiniled" xml:space="preserve">
     <value>Activer Miniled (si supporté)</value>
@@ -507,10 +615,10 @@ Do you still want to continue?</value>
     <value>Ultime</value>
   </data>
   <data name="UndervoltingRisky" xml:space="preserve">
-    <value>Undervolting is an experimental and risky feature. If applied values are too low for your hardware, it can become unstable, shut down or cause data corruption. If you want to try - start from small values first, click Apply and test what works for you.</value>
+    <value>L'undervolting est une fonctionnalité expérimentale et risquée. Si les valeurs appliquées sont trop faibles, elles peuvent causer de l'instabilité, éteindre l'ordinateur ou causer une corruption de données. Si vous voulez essayer - commencer avec des petites valeurs, cliquez sur Appliquer et testez ce qui fonctionne pour vous.</value>
   </data>
   <data name="Updates" xml:space="preserve">
-    <value>Updates</value>
+    <value>Mises à jour</value>
   </data>
   <data name="VersionLabel" xml:space="preserve">
     <value>Version </value>

app/Properties/Strings.hu.resx

@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Asus szolgáltatások futnak</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Lélegző</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Színváltás</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Gyors</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normál</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Szivárvány</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Lassú</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Stroboszkóp</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Automatikus alkalmazás</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Teljesítmény</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Töltési korlát</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS és illesztőprogram frissítések</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Fényerő növelése</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Szín</value>
   </data>
@@ -260,6 +305,9 @@ Do you still want to continue?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA kijelzőmód nincs Optimus-ra állítva</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
   </data>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Célhőmérséklet</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Gyorsbillentyűk</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Fénysáv</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logó</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Hang vizualizáció</value>
   </data>
@@ -386,18 +443,51 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>60Hz-s frissítési gyakoriság, hogy spóroljon az akkuval</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Többzónás</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Mikrofon némítása</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Új frissítés</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Nincs új frissítés</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>G-Helper ablak megnyitása</value>
   </data>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Üzemmód</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Kép / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Indít / Megállít</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Teljesítménykorlátok</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Bezárás</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Futtatás rendszerindításkor</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Brightness Down</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad Brightness Up</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Leállítás</value>
   </data>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>AURA ki-/bekapcsolása</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Fn-Lock ki-/bekapcsolása</value>
   </data>

app/Properties/Strings.it.resx

@@ -118,7 +118,7 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="ACPIError" xml:space="preserve">
-    <value>Impossibile connettersi ad ASUS ACPI. Senza di essa l'applicazione non può funzionare. Prova ad installare Asus System Control Interface</value>
+    <value>Impossibile connettersi ad ASUS ACPI. Senza di essa l'applicazione non può funzionare. Prova a installare Asus Satem Contro Interfacce</value>
   </data>
   <data name="AlertDGPU" xml:space="preserve">
     <value>Uso intensivo della GPU, disabilitare?</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Servizi Asus in Esecuzione</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Respiro</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Ciclo Colori</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Veloce</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normale</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Arcobaleno</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Lenta</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Strobo</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Auto Applica</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Bilanciato</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Limite Ricarica Batteria</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Salute Batteria</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>Aggiornamenti Driver e BIOS</value>
   </data>
@@ -222,11 +264,14 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Aumenta Luminosità</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>In carica</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Colore</value>
   </data>
   <data name="CPUBoost" xml:space="preserve">
-    <value>CPU Boost</value>
+    <value>Boost CPU</value>
   </data>
   <data name="Custom" xml:space="preserve">
     <value>Personalizzato</value>
@@ -260,6 +305,9 @@ Sei sicuro di voler continuare?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>Modalità schermo NVIDIA non impostata su Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
   </data>
@@ -326,6 +374,9 @@ Sei sicuro di voler continuare?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperatura Target</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Associazione Tasti</value>
   </data>
@@ -350,9 +401,15 @@ Sei sicuro di voler continuare?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Barra Luminosa</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Visualizzatore Audio</value>
   </data>
@@ -386,18 +443,51 @@ Sei sicuro di voler continuare?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>60Hz refresh rate per risparmiare batteria</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizona</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Silenzia microfono</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Nuovi aggiornamenti</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Sistema aggiornato</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Apri G-Helper</value>
   </data>
@@ -408,7 +498,7 @@ Sei sicuro di voler continuare?</value>
     <value>Passa ad Eco se alimentato a batteria e a Standard quando in carica</value>
   </data>
   <data name="OptimizedUSBC" xml:space="preserve">
-    <value>Lascia la GPU disabilitata sulla porta USB-C in modalità Ottimizzata</value>
+    <value>Disabilita GPU durante ricarica tramite USB-C in modalità Ottimizzata</value>
   </data>
   <data name="Other" xml:space="preserve">
     <value>Altro</value>
@@ -419,12 +509,18 @@ Sei sicuro di voler continuare?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Profilo</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Immagine / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Riproduci / Pausa</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Limiti di Potenza</value>
   </data>
@@ -434,6 +530,9 @@ Sei sicuro di voler continuare?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Esci</value>
   </data>
@@ -446,6 +545,12 @@ Sei sicuro di voler continuare?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Esegui all'Avvio</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Riduci luminosità Screenpad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Aumenta luminosità Screenpad</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Spegnimento</value>
   </data>
@@ -482,6 +587,9 @@ Sei sicuro di voler continuare?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Alterna Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Attiva automaticamente la modalità a conchiglia</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Alterna Blocco-Fn</value>
   </data>

app/Properties/Strings.ko.resx

@@ -148,7 +148,7 @@
     <value>G-Helper가 이미 실행중입니다. 시스템 트레이에서 아이콘을 확인하십시오.</value>
   </data>
   <data name="Apply" xml:space="preserve">
-    <value>Apply</value>
+    <value>적용</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
     <value>사용자 설정 팬 커브 적용</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>실행중인 Asus 서비스</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Breathe</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Color Cycle</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>빠르게</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>보통</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Rainbow</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>느리게</value>
   </data>
@@ -186,8 +207,23 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Strobe</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
-    <value>Auto Apply</value>
+    <value>자동 적용</value>
   </data>
   <data name="AutoMode" xml:space="preserve">
     <value>자동</value>
@@ -199,14 +235,20 @@
     <value>Awake</value>
   </data>
   <data name="BacklightTimeout" xml:space="preserve">
-    <value>배터리 사용 중 백라이트 자동 꺼짐</value>
+    <value>전원 연결 / 배터리 사용 중 자동 꺼짐 시간 (0 - 항상 켜짐)</value>
   </data>
   <data name="Balanced" xml:space="preserve">
     <value>균형</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>배터리 충전 제한</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>바이오스/드라이버 업데이트</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>밝기 증가</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>색상</value>
   </data>
@@ -253,12 +298,15 @@
     <value>Eco</value>
   </data>
   <data name="EnableOptimusText" xml:space="preserve">
-    <value>Disabling the dGPU by going into Eco mode while Display Mode in NVIDIA Control Panel is not set to Optimus might cause problems with brightness controls until after the next reboot. 
+    <value>NVIDIA 디스플레이 모드가 Optimus로 설정되어 있지 않을 때 Eco 모드로 전환하여 dGPU를 비활성화하면 다시 시작하기 전까지 밝기 조절 문제가 생길 수 있습니다.
 
-Do you still want to continue?</value>
+계속하시겠습니까?</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
-    <value>NVIDIA Display Mode is not set to Optimus</value>
+    <value>NVIDIA 디스플레이 모드가 Optimus로 설정되어 있지 않습니다.</value>
+  </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
   </data>
   <data name="Extra" xml:space="preserve">
     <value>추가 설정</value>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>목표 온도</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>키 설정</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>라이트바</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>로고</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>오디오 비주얼라이저</value>
   </data>
@@ -386,17 +443,50 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>60Hz 주사율 설정</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>멀티존</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>마이크 음소거</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
-    <value>New updates</value>
+    <value>새 업데이트</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
-    <value>No new updates</value>
+    <value>새 업데이트 없음</value>
+  </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
   </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>G-Helper 열기</value>
@@ -419,21 +509,30 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>성능 모드</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>사진 / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>재생 / 정지</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>전력 제한</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>전력 제한 은 실험적인 기능입니다. 주의하여 사용하세요!</value>
+    <value>전력 제한은 실험적인 기능입니다. 주의하여 사용하세요!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>종료</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>시스템 시작 시 실행</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad 밝기 감소</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad 밝기 증가</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>꺼짐</value>
   </data>
@@ -474,7 +579,7 @@ Do you still want to continue?</value>
     <value>중지</value>
   </data>
   <data name="StopGPUApps" xml:space="preserve">
-    <value>Stop GPU Applications</value>
+    <value>GPU를 사용하는 앱 중지</value>
   </data>
   <data name="StoppingServices" xml:space="preserve">
     <value>서비스 중지 중</value>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Aura 토글 키</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Fn-Lock 토글 키</value>
   </data>
@@ -507,7 +615,7 @@ Do you still want to continue?</value>
     <value>Ultimate</value>
   </data>
   <data name="UndervoltingRisky" xml:space="preserve">
-    <value>Undervolting is an experimental and risky feature. If applied values are too low for your hardware, it can become unstable, shut down or cause data corruption. If you want to try - start from small values first, click Apply and test what works for you.</value>
+    <value>언더볼팅은 실험적이며 위험한 기능입니다. 적용 값이 너무 낮은 경우 시스템이 불안정해지고, 종료되거나 데이터 손상을 유발할 수 있습니다. 작은 값부터 적용하여 잘 작동하는지 확인해 보십시오.</value>
   </data>
   <data name="Updates" xml:space="preserve">
     <value>업데이트</value>

app/Properties/Strings.lt.resx

@@ -0,0 +1,638 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" id="root">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0"/>
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string"/>
+              <xsd:attribute name="type" type="xsd:string"/>
+              <xsd:attribute name="mimetype" type="xsd:string"/>
+              <xsd:attribute ref="xml:space"/>
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string"/>
+              <xsd:attribute name="name" type="xsd:string"/>
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1"/>
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2"/>
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1"/>
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3"/>
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4"/>
+              <xsd:attribute ref="xml:space"/>
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1"/>
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required"/>
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ACPIError" xml:space="preserve">
+    <value>Nepavyko prisijungti prie ASUS ACPI. Programėlė be jo negali veikti. Pabandykite įdiegti Asus System Control Interface</value>
+  </data>
+  <data name="AlertDGPU" xml:space="preserve">
+    <value>Panašu, kad jūsų GPU yra intensyviai naudojamas. Išjungti jį?</value>
+  </data>
+  <data name="AlertDGPUTitle" xml:space="preserve">
+    <value>Ekonomiškas režimas</value>
+  </data>
+  <data name="AlertUltimateOff" xml:space="preserve">
+    <value>Maksimalaus režimo išjungimas reikalauja paleidimo iš naujo</value>
+  </data>
+  <data name="AlertUltimateOn" xml:space="preserve">
+    <value>Maksimalus režimas reikalauja paleidimo iš naujo</value>
+  </data>
+  <data name="AlertUltimateTitle" xml:space="preserve">
+    <value>Paleisti iš naujo dabar?</value>
+  </data>
+  <data name="AnimationSpeed" xml:space="preserve">
+    <value>Animacijos greitis</value>
+  </data>
+  <data name="AnimeMatrix" xml:space="preserve">
+    <value>Anime matrica</value>
+  </data>
+  <data name="AppAlreadyRunning" xml:space="preserve">
+    <value>Programėlė jau paleista</value>
+  </data>
+  <data name="AppAlreadyRunningText" xml:space="preserve">
+    <value>G-Helper jau paleistas. Patikrinkite, ar sistemos juostelėje nėra piktogramos.</value>
+  </data>
+  <data name="Apply" xml:space="preserve">
+    <value>Taikyti</value>
+  </data>
+  <data name="ApplyFanCurve" xml:space="preserve">
+    <value>Taikyti tinkintą aušintuvo kreivę</value>
+  </data>
+  <data name="ApplyPowerLimits" xml:space="preserve">
+    <value>Taikyti galios ribas</value>
+  </data>
+  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
+    <value>Automatiškai derinti Windows energijos režimus</value>
+  </data>
+  <data name="AsusServicesRunning" xml:space="preserve">
+    <value>Veikiančios Asus tarnybos</value>
+  </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Būsena</value>
+  </data>
+  <data name="AuraBreathe" xml:space="preserve">
+    <value>Kvėpavimas</value>
+  </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Pagal laikrodžio rodyklę</value>
+  </data>
+  <data name="AuraColorCycle" xml:space="preserve">
+    <value>Spalvų ciklas</value>
+  </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Prieš laikrodžio rodyklę</value>
+  </data>
+  <data name="AuraFast" xml:space="preserve">
+    <value>Greitas</value>
+  </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Apšvietimo režimas</value>
+  </data>
+  <data name="AuraNormal" xml:space="preserve">
+    <value>Normalus</value>
+  </data>
+  <data name="AuraRainbow" xml:space="preserve">
+    <value>Vaivorykštė</value>
+  </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Atsitiktinė</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
+  <data name="AuraSlow" xml:space="preserve">
+    <value>Lėtas</value>
+  </data>
+  <data name="AuraStatic" xml:space="preserve">
+    <value>Statinis</value>
+  </data>
+  <data name="AuraStrobe" xml:space="preserve">
+    <value>Blyksniai</value>
+  </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>Visi</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Jungčių stotelė</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logotipas</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Ratukas</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Apatinis apšvietimas</value>
+  </data>
+  <data name="AutoApply" xml:space="preserve">
+    <value>Taikyti automatiškai</value>
+  </data>
+  <data name="AutoMode" xml:space="preserve">
+    <value>Automatinis</value>
+  </data>
+  <data name="AutoRefreshTooltip" xml:space="preserve">
+    <value>Nustato 60Hz, kad taupytų energiją, ir atgal, kai įjungtas į lizdą</value>
+  </data>
+  <data name="Awake" xml:space="preserve">
+    <value>Pabudęs</value>
+  </data>
+  <data name="BacklightTimeout" xml:space="preserve">
+    <value>Laiko riba su lizdu / akumuliatoriumi (0 – ĮJUNGTA)</value>
+  </data>
+  <data name="Balanced" xml:space="preserve">
+    <value>Balansuotas</value>
+  </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
+  <data name="BatteryChargeLimit" xml:space="preserve">
+    <value>Įkrovos riba</value>
+  </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Sveikata</value>
+  </data>
+  <data name="BiosAndDriverUpdates" xml:space="preserve">
+    <value>BIOS ir tvarkyklių naujinimai</value>
+  </data>
+  <data name="Boot" xml:space="preserve">
+    <value>Paleidimas</value>
+  </data>
+  <data name="Brightness" xml:space="preserve">
+    <value>Ryškumas</value>
+  </data>
+  <data name="BrightnessDown" xml:space="preserve">
+    <value>Ryškumo mažinimas</value>
+  </data>
+  <data name="BrightnessUp" xml:space="preserve">
+    <value>Ryškumo didinimas</value>
+  </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Įkrovimas</value>
+  </data>
+  <data name="Color" xml:space="preserve">
+    <value>Spalva</value>
+  </data>
+  <data name="CPUBoost" xml:space="preserve">
+    <value>CPU spartinimas</value>
+  </data>
+  <data name="Custom" xml:space="preserve">
+    <value>Tinkintas</value>
+  </data>
+  <data name="Default" xml:space="preserve">
+    <value>Numatytas</value>
+  </data>
+  <data name="DisableOverdrive" xml:space="preserve">
+    <value>Išjungti ekrano pikselių spartinimą</value>
+  </data>
+  <data name="Discharging" xml:space="preserve">
+    <value>Iškrovimas</value>
+  </data>
+  <data name="DownloadUpdate" xml:space="preserve">
+    <value>Atsisiųsti naujinimą</value>
+  </data>
+  <data name="DriverAndSoftware" xml:space="preserve">
+    <value>Tvarkyklės ir programinė įranga</value>
+  </data>
+  <data name="EcoGPUTooltip" xml:space="preserve">
+    <value>Išjungia dGPU, kad taupytų energiją</value>
+  </data>
+  <data name="EcoMode" xml:space="preserve">
+    <value>Ekonomiškas</value>
+  </data>
+  <data name="EnableOptimusText" xml:space="preserve">
+    <value>Jei ekrano režimas NVIDIA valdymo skyde yra nenustatytas į Optimus, kai dGPU yra išjungtas perjungus į ekonominį režimą, gali kilti problemų su ryškumo valdymu iki kito paleidimo iš naujo. 
+
+Vis tiek norite tęsti?</value>
+  </data>
+  <data name="EnableOptimusTitle" xml:space="preserve">
+    <value>NVIDIA ekrano režimas nenustatytas į Optimus</value>
+  </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energijos nustatymai</value>
+  </data>
+  <data name="Extra" xml:space="preserve">
+    <value>Išplėstiniai</value>
+  </data>
+  <data name="ExtraSettings" xml:space="preserve">
+    <value>Išplėstiniai nustatymai</value>
+  </data>
+  <data name="FactoryDefaults" xml:space="preserve">
+    <value>Numatytieji</value>
+  </data>
+  <data name="FanCurves" xml:space="preserve">
+    <value>Aušintuvų kreivės</value>
+  </data>
+  <data name="FanProfileCPU" xml:space="preserve">
+    <value>CPU aušintuvo profilis</value>
+  </data>
+  <data name="FanProfileGPU" xml:space="preserve">
+    <value>GPU aušintuvo profilis</value>
+  </data>
+  <data name="FanProfileMid" xml:space="preserve">
+    <value>Vidurinio aušintuvo profilis</value>
+  </data>
+  <data name="FanProfiles" xml:space="preserve">
+    <value>Aušintuvų profiliai</value>
+  </data>
+  <data name="FansAndPower" xml:space="preserve">
+    <value>Aušintuvai ir galia</value>
+  </data>
+  <data name="FanSpeed" xml:space="preserve">
+    <value>Aušintuvas</value>
+  </data>
+  <data name="FansPower" xml:space="preserve">
+    <value>Aušintuvai + galia</value>
+  </data>
+  <data name="FnLock" xml:space="preserve">
+    <value>Apdoroti Fn+F sparčiuosius klavišus be Fn</value>
+  </data>
+  <data name="GPUBoost" xml:space="preserve">
+    <value>Dinaminis spartinimas</value>
+  </data>
+  <data name="GPUChanging" xml:space="preserve">
+    <value>Keičiamas</value>
+  </data>
+  <data name="GPUCoreClockOffset" xml:space="preserve">
+    <value>Branduolių taktų poslinkis</value>
+  </data>
+  <data name="GPUMemoryClockOffset" xml:space="preserve">
+    <value>Atminties taktų poslinkis</value>
+  </data>
+  <data name="GPUMode" xml:space="preserve">
+    <value>GPU režimas</value>
+  </data>
+  <data name="GPUModeEco" xml:space="preserve">
+    <value>Tik iGPU</value>
+  </data>
+  <data name="GPUModeStandard" xml:space="preserve">
+    <value>iGPU + dGPU</value>
+  </data>
+  <data name="GPUModeUltimate" xml:space="preserve">
+    <value>Tik dGPU</value>
+  </data>
+  <data name="GPUSettings" xml:space="preserve">
+    <value>GPU nustatymai</value>
+  </data>
+  <data name="GPUTempTarget" xml:space="preserve">
+    <value>Temperatūros tikslas</value>
+  </data>
+  <data name="High" xml:space="preserve">
+    <value>Aukštas</value>
+  </data>
+  <data name="KeyBindings" xml:space="preserve">
+    <value>Klavišų priskyrimas</value>
+  </data>
+  <data name="Keyboard" xml:space="preserve">
+    <value>Klaviatūra</value>
+  </data>
+  <data name="KillGpuApps" xml:space="preserve">
+    <value>Sustabdyti visas GPU naudojančias programėles, kai perjungiama į ekonomišką režimą</value>
+  </data>
+  <data name="LaptopBacklight" xml:space="preserve">
+    <value>Apšvietimas</value>
+  </data>
+  <data name="LaptopKeyboard" xml:space="preserve">
+    <value>Klaviatūra</value>
+  </data>
+  <data name="LaptopScreen" xml:space="preserve">
+    <value>Ekranas</value>
+  </data>
+  <data name="Lid" xml:space="preserve">
+    <value>Korpusas</value>
+  </data>
+  <data name="Lightbar" xml:space="preserve">
+    <value>Šviesos juosta</value>
+  </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Apšvietimas</value>
+  </data>
+  <data name="Logo" xml:space="preserve">
+    <value>Logotipas</value>
+  </data>
+  <data name="Low" xml:space="preserve">
+    <value>Žemas</value>
+  </data>
+  <data name="MatrixAudio" xml:space="preserve">
+    <value>Garso vizualizatorius</value>
+  </data>
+  <data name="MatrixBanner" xml:space="preserve">
+    <value>Dvejetainė vėliava</value>
+  </data>
+  <data name="MatrixBright" xml:space="preserve">
+    <value>Šviesi</value>
+  </data>
+  <data name="MatrixClock" xml:space="preserve">
+    <value>Laikrodis</value>
+  </data>
+  <data name="MatrixDim" xml:space="preserve">
+    <value>Temdymas</value>
+  </data>
+  <data name="MatrixLogo" xml:space="preserve">
+    <value>Rog logotipas</value>
+  </data>
+  <data name="MatrixMedium" xml:space="preserve">
+    <value>Vidutinis</value>
+  </data>
+  <data name="MatrixOff" xml:space="preserve">
+    <value>Išjungta</value>
+  </data>
+  <data name="MatrixPicture" xml:space="preserve">
+    <value>Paveikslėlis</value>
+  </data>
+  <data name="MaxRefreshTooltip" xml:space="preserve">
+    <value>Maksimalus kadrų dažnis už mažesnę delsą</value>
+  </data>
+  <data name="MinRefreshTooltip" xml:space="preserve">
+    <value>60Hz kadrų dažnis, kad taupytumėte energiją</value>
+  </data>
+  <data name="Minute" xml:space="preserve">
+    <value>min.</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>min.</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Automatiškai išjungti po</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Klavišo atsakas</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Pakilimo atstumas</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Senkančio akumuliatoriaus įspėjimas</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Našumas</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Sinchronizuoti su pele</value>
+  </data>
+  <data name="Multizone" xml:space="preserve">
+    <value>Daugiazonis</value>
+  </data>
+  <data name="MuteMic" xml:space="preserve">
+    <value>Mikrofono nutildymas</value>
+  </data>
+  <data name="Never" xml:space="preserve">
+    <value>Niekada</value>
+  </data>
+  <data name="NewUpdates" xml:space="preserve">
+    <value>Naujinimai</value>
+  </data>
+  <data name="NoNewUpdates" xml:space="preserve">
+    <value>Nėra naujinimų</value>
+  </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Neprijungta</value>
+  </data>
+  <data name="OpenGHelper" xml:space="preserve">
+    <value>Atidaryti G-Helper langą</value>
+  </data>
+  <data name="Optimized" xml:space="preserve">
+    <value>Optimizuotas</value>
+  </data>
+  <data name="OptimizedGPUTooltip" xml:space="preserve">
+    <value>Perjungti į ekonomišką, kai naudojamas akumuliatorius, ir į standartinį, kai įjungtas į lizdą</value>
+  </data>
+  <data name="OptimizedUSBC" xml:space="preserve">
+    <value>Neįjungti GPU, kai naudojamas USB-C įkroviklis optimizuotame režime</value>
+  </data>
+  <data name="Other" xml:space="preserve">
+    <value>Kita</value>
+  </data>
+  <data name="Overdrive" xml:space="preserve">
+    <value>Pikselių spartinimas</value>
+  </data>
+  <data name="PerformanceMode" xml:space="preserve">
+    <value>Režimas</value>
+  </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Išoriniai įrenginiai</value>
+  </data>
+  <data name="PictureGif" xml:space="preserve">
+    <value>Paveikslėlis / GIF</value>
+  </data>
+  <data name="PlayPause" xml:space="preserve">
+    <value>Paleisti / Pristabdyti</value>
+  </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Iškvietų dažnis</value>
+  </data>
+  <data name="PowerLimits" xml:space="preserve">
+    <value>Galios ribos</value>
+  </data>
+  <data name="PPTExperimental" xml:space="preserve">
+    <value>Galios ribos yra eksperimentinė funkcija. Naudokitės atsargiai!</value>
+  </data>
+  <data name="PrintScreen" xml:space="preserve">
+    <value>Ekrano kopija</value>
+  </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profilis</value>
+  </data>
+  <data name="Quit" xml:space="preserve">
+    <value>Išeiti</value>
+  </data>
+  <data name="RestartGPU" xml:space="preserve">
+    <value>Kažkas naudoja dGPU ir neleidžia nustatyti ekonomiško režimo. Iš naujo paleisti dGPU įrenginių tvarkytuvėje? * Tęskite savo rizika.</value>
+  </data>
+  <data name="RPM" xml:space="preserve">
+    <value>RPM</value>
+  </data>
+  <data name="RunOnStartup" xml:space="preserve">
+    <value>Paleisti įjungus sistemą</value>
+  </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Ekrano skydelio ryškumo mažinimas</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Ekrano skydelio ryškumo didinimas</value>
+  </data>
+  <data name="Shutdown" xml:space="preserve">
+    <value>Išjungimas</value>
+  </data>
+  <data name="Silent" xml:space="preserve">
+    <value>Tylus</value>
+  </data>
+  <data name="Sleep" xml:space="preserve">
+    <value>Miegas</value>
+  </data>
+  <data name="StandardGPUTooltip" xml:space="preserve">
+    <value>Įjungia dGPU įprastam naudojimui</value>
+  </data>
+  <data name="StandardMode" xml:space="preserve">
+    <value>Įprastas</value>
+  </data>
+  <data name="Start" xml:space="preserve">
+    <value>Paleisti</value>
+  </data>
+  <data name="StartingServices" xml:space="preserve">
+    <value>Paleidžiamos tarnybos</value>
+  </data>
+  <data name="StartupError" xml:space="preserve">
+    <value>Paleidimo klaida</value>
+  </data>
+  <data name="Stop" xml:space="preserve">
+    <value>Stabdyti</value>
+  </data>
+  <data name="StopGPUApps" xml:space="preserve">
+    <value>Stabdyti GPU programėles</value>
+  </data>
+  <data name="StoppingServices" xml:space="preserve">
+    <value>Stabdomos tarnybos</value>
+  </data>
+  <data name="ToggleAura" xml:space="preserve">
+    <value>Perjungti Aura</value>
+  </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Automatiškai perjungti Clamshell režimą</value>
+  </data>
+  <data name="ToggleFnLock" xml:space="preserve">
+    <value>Perjungti Fn-Lock</value>
+  </data>
+  <data name="ToggleMiniled" xml:space="preserve">
+    <value>Perjungti Miniled (jei palaikoma)</value>
+  </data>
+  <data name="ToggleScreen" xml:space="preserve">
+    <value>Perjungti ekraną</value>
+  </data>
+  <data name="Turbo" xml:space="preserve">
+    <value>Turbo</value>
+  </data>
+  <data name="TurnedOff" xml:space="preserve">
+    <value>Išjungta</value>
+  </data>
+  <data name="TurnOffOnBattery" xml:space="preserve">
+    <value>Išjungti naudojant akumuliatorių</value>
+  </data>
+  <data name="UltimateGPUTooltip" xml:space="preserve">
+    <value>Nukreipia ekraną į dGPU, kad maksimizuotų kadrų dažnį</value>
+  </data>
+  <data name="UltimateMode" xml:space="preserve">
+    <value>Maksimalus</value>
+  </data>
+  <data name="UndervoltingRisky" xml:space="preserve">
+    <value>Įtampos mažinimas yra eksperimentinė ir pavojinga funkcija. Jei pritaikytos reikšmės yra per mažos jūsų aparatinei įrangai, ji gali tapti nestabili, išsijungti arba pažeisti duomenų vientisumą. Jei norite pabandyti, iš pirmo pradėkite nuo mažų reikšmių, spustelėkite „Taikyti“ ir išbandykite, kas jums tinka.</value>
+  </data>
+  <data name="Updates" xml:space="preserve">
+    <value>Naujinimai</value>
+  </data>
+  <data name="VersionLabel" xml:space="preserve">
+    <value>Versija</value>
+  </data>
+  <data name="VolumeDown" xml:space="preserve">
+    <value>Garsumo mažinimas</value>
+  </data>
+  <data name="VolumeMute" xml:space="preserve">
+    <value>Garsumo nutildymas</value>
+  </data>
+  <data name="VolumeUp" xml:space="preserve">
+    <value>Garsumo didinimas</value>
+  </data>
+  <data name="WindowTop" xml:space="preserve">
+    <value>Visada rodyti programėlės langą viršuje</value>
+  </data>
+</root>

app/Properties/Strings.pl.resx

@@ -157,26 +157,47 @@
     <value>Zastosuj limity</value>
   </data>
   <data name="ApplyWindowsPowerPlan" xml:space="preserve">
-    <value>Automatycznie dostosuj Plan Zasilania Windows</value>
+    <value>Dostosuj systemowy Tryb Zasilania</value>
   </data>
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Uruchomione usługi Asus</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Stan baterii</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Oddychanie</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>W prawo</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Pętla kolorów</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Kometa</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>W lewo</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Szybka</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Tryb oświetlenia</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normalna</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Tęcza</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Losowo</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>Tryb reaktywny</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Powolna</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Stroboskop</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>Wszystko</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Rolka</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Dolna poświata</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Zastosuj automatycznie</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Balans</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Limit ładowania baterii</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Stan baterii</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>Aktualizacje BIOS i sterowników</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Zwiększ jasność</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Ładowanie</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Kolor</value>
   </data>
@@ -260,6 +305,9 @@ Nadal chcesz kontynuować?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>Tryb wyświetlania NVIDIA nie jest ustawiony na Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Ustawienia zasilania</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Ustawienia</value>
   </data>
@@ -288,7 +336,7 @@ Nadal chcesz kontynuować?</value>
     <value>Wentylatory i moc</value>
   </data>
   <data name="FanSpeed" xml:space="preserve">
-    <value>Wentylator</value>
+    <value>Went</value>
   </data>
   <data name="FansPower" xml:space="preserve">
     <value>Dostosuj</value>
@@ -326,6 +374,9 @@ Nadal chcesz kontynuować?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperatura docelowa</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>Wysoka</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Ustawienia klawiszy skrótów</value>
   </data>
@@ -350,9 +401,15 @@ Nadal chcesz kontynuować?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Lightbar</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Oświetlenie</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Niska</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Wizualizer muzyki</value>
   </data>
@@ -386,18 +443,51 @@ Nadal chcesz kontynuować?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Częstotliwość odświeżania 60 Hz dla oszczędzania baterii</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>min.</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>min.</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Korekcja kąta ruchu</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Przejście w tryb uśpienia po</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Wysokość reakcji sensora</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Ostrzeżenie o niskim poziomie baterii</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Wydajność</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronizuj z myszką</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizone</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Wyciszenie mikrofonu</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Nigdy</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Nowe aktualizacje</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Brak aktualizacji</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Nie połączono</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Otwórz okno G-Helper</value>
   </data>
@@ -419,12 +509,18 @@ Nadal chcesz kontynuować?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Tryb zasilania</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Urządzenia peryferyjne</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Obraz / GIF</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Odtwórz / Pauza</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Częstotliwość raportowania</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Limit mocy</value>
   </data>
@@ -434,6 +530,9 @@ Nadal chcesz kontynuować?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Zrzut ekranu</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profil</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Zamknij</value>
   </data>
@@ -446,6 +545,12 @@ Nadal chcesz kontynuować?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Uruchom przy starcie systemu</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Zmniejsz jasność ScreenPad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Zwiększ jasność ScreenPad</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Zamknij</value>
   </data>
@@ -482,6 +587,9 @@ Nadal chcesz kontynuować?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Przełącz Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Automatyczne przełączanie trybu klapki</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Przełącz Fn-Lock</value>
   </data>

app/Properties/Strings.pt.resx

@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Serviços da Asus em execução</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Repiração</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Ciclo de cores</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Rápido</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Arco-íris</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Lento</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Estroboscópio</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Auto Apply</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Equilibrado</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Limite de carga</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS and Driver Updates</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Brightness Up</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Cor</value>
   </data>
@@ -260,6 +305,9 @@ Do you still want to continue?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA Display Mode is not set to Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Adicional</value>
   </data>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Alvo de temperatura</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Combinações de teclas</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Lightbar</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Audio Visualizer</value>
   </data>
@@ -386,18 +443,51 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Taxa de atualização à 60Hz para economizar bateria</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizona</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Desligar microfone</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>New updates</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>No new updates</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Abrir G-Helper</value>
   </data>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Modo</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Imagem / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Reproduzir / Pausar</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Limitações de Energia</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Captura de tela</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Sair</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Executar ao iniciar</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Brightness Down</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad Brightness Up</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Desligar</value>
   </data>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Alternar Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Toggle Fn-Lock</value>
   </data>

app/Properties/Strings.resx

@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Asus Services Running</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Breathe</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Color Cycle</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Fast</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Rainbow</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Slow</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Strobe</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Auto Apply</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Balanced</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Battery Charge Limit</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS and Driver Updates</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Brightness Up</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Color</value>
   </data>
@@ -260,6 +305,9 @@ Do you still want to continue?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA Display Mode is not set to Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
   </data>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperature Target</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Key Bindings</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Lightbar</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Audio Visualizer</value>
   </data>
@@ -386,18 +443,51 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>60Hz refresh rate to save battery</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizone</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Mute Mic</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>New updates</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>No new updates</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Open G-Helper window</value>
   </data>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Mode</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Picture / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Play / Pause</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Power Limits</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Quit</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Run on Startup</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Brightness Down</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad Brightness Up</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Shutdown</value>
   </data>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Toggle Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Toggle Fn-Lock</value>
   </data>

app/Properties/Strings.ro.resx

@@ -151,32 +151,53 @@
     <value>Aplică</value>
   </data>
   <data name="ApplyFanCurve" xml:space="preserve">
-    <value>Apply Custom Fan Curve</value>
+    <value>Aplicați curba personalizată</value>
   </data>
   <data name="ApplyPowerLimits" xml:space="preserve">
     <value>Aplică limitele de putere</value>
   </data>
   <data name="ApplyWindowsPowerPlan" xml:space="preserve">
-    <value>Auto adjust Windows Power Modes</value>
+    <value>Reglare automată a modului de alimentare Windows</value>
   </data>
   <data name="AsusServicesRunning" xml:space="preserve">
-    <value>Asus Services Running</value>
+    <value>Servicii Asus în derulare</value>
+  </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
   </data>
   <data name="AuraBreathe" xml:space="preserve">
-    <value>Breathe</value>
+    <value>Respirație</value>
+  </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
   </data>
   <data name="AuraColorCycle" xml:space="preserve">
-    <value>Color Cycle</value>
+    <value>Ciclu de culori</value>
+  </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
   </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Rapid</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Curcubeu</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Încet</value>
   </data>
@@ -184,7 +205,22 @@
     <value>Static</value>
   </data>
   <data name="AuraStrobe" xml:space="preserve">
-    <value>Strobe</value>
+    <value>Stroboscop</value>
+  </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
   </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Aplicare automată</value>
@@ -193,40 +229,49 @@
     <value>Automat</value>
   </data>
   <data name="AutoRefreshTooltip" xml:space="preserve">
-    <value>Sets 60Hz to save battery, and back when plugged</value>
+    <value>Setează ecranul la 60Hz pentru a economisi bateria, și înapoi cât se încarcă</value>
   </data>
   <data name="Awake" xml:space="preserve">
-    <value>Awake</value>
+    <value>Treaz</value>
   </data>
   <data name="BacklightTimeout" xml:space="preserve">
-    <value>Timeout plugged / on battery (0 - ON)</value>
+    <value>Timeout conectat / folosind bateria (0 - ON)</value>
   </data>
   <data name="Balanced" xml:space="preserve">
     <value>Echilibrat</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
-    <value>Battery Charge Limit</value>
+    <value>Limita de încărcare a bateriei</value>
+  </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Sănătatea bateriei</value>
   </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
-    <value>BIOS and Driver Updates</value>
+    <value>Actualizări BIOS și Driver</value>
   </data>
   <data name="Boot" xml:space="preserve">
-    <value>Boot</value>
+    <value>Pornire</value>
   </data>
   <data name="Brightness" xml:space="preserve">
     <value>Luminozitate</value>
   </data>
   <data name="BrightnessDown" xml:space="preserve">
-    <value>Brightness Down</value>
+    <value>Scăderea luminozității</value>
   </data>
   <data name="BrightnessUp" xml:space="preserve">
-    <value>Brightness Up</value>
+    <value>Mărirea luminozității</value>
+  </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Se încarcă</value>
   </data>
   <data name="Color" xml:space="preserve">
     <value>Culoare</value>
   </data>
   <data name="CPUBoost" xml:space="preserve">
-    <value>CPU Boost</value>
+    <value>Accelerare CPU</value>
   </data>
   <data name="Custom" xml:space="preserve">
     <value>Personalizat</value>
@@ -235,7 +280,7 @@
     <value>Implicit</value>
   </data>
   <data name="DisableOverdrive" xml:space="preserve">
-    <value>Disable screen overdrive</value>
+    <value>Dezactivează screen overdrive</value>
   </data>
   <data name="Discharging" xml:space="preserve">
     <value>Se descarcă</value>
@@ -244,21 +289,24 @@
     <value>Descărcați actualizarea</value>
   </data>
   <data name="DriverAndSoftware" xml:space="preserve">
-    <value>Drivers and Software</value>
+    <value>Drivers și Aplicații</value>
   </data>
   <data name="EcoGPUTooltip" xml:space="preserve">
-    <value>Disables dGPU to save battery</value>
+    <value>Dezactivează dGPU pentru a economisi bateria</value>
   </data>
   <data name="EcoMode" xml:space="preserve">
     <value>Eco</value>
   </data>
   <data name="EnableOptimusText" xml:space="preserve">
-    <value>Disabling the dGPU by going into Eco mode while Display Mode in NVIDIA Control Panel is not set to Optimus might cause problems with brightness controls until after the next reboot. 
+    <value>Dezactivarea dGPU pentru a utiliza modul Eco, în timp ce Display Mode în NVIDIA Control Panel nu este setat la modul Optimus, poate cauza probleme cu controalele de luminozitate până la următoarea repornire. 
 
-Do you still want to continue?</value>
+Încă mai vrei să continui?</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
-    <value>NVIDIA Display Mode is not set to Optimus</value>
+    <value>NVIDIA Display Mode nu este setat la modul Optimus</value>
+  </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
   </data>
   <data name="Extra" xml:space="preserve">
     <value>Extra</value>
@@ -270,37 +318,37 @@ Do you still want to continue?</value>
     <value>Setările implicite ale fabricii</value>
   </data>
   <data name="FanCurves" xml:space="preserve">
-    <value>Fan Curves</value>
+    <value>Curbe ventilator</value>
   </data>
   <data name="FanProfileCPU" xml:space="preserve">
-    <value>CPU Fan Profile</value>
+    <value>Profil ventilator CPU</value>
   </data>
   <data name="FanProfileGPU" xml:space="preserve">
-    <value>GPU Fan Profile</value>
+    <value>Profil ventilator GPU</value>
   </data>
   <data name="FanProfileMid" xml:space="preserve">
-    <value>Mid Fan Profile</value>
+    <value>Profil mediu ventilator</value>
   </data>
   <data name="FanProfiles" xml:space="preserve">
-    <value>Fan Profiles</value>
+    <value>Profiluri ventilatoare</value>
   </data>
   <data name="FansAndPower" xml:space="preserve">
-    <value>Fans and Power</value>
+    <value>Vent. și putere</value>
   </data>
   <data name="FanSpeed" xml:space="preserve">
-    <value>Fan</value>
+    <value>Vent</value>
   </data>
   <data name="FansPower" xml:space="preserve">
     <value>Fans + Power</value>
   </data>
   <data name="FnLock" xml:space="preserve">
-    <value>Process Fn+F hotkeys without Fn</value>
+    <value>Procesează tastele Fn+F fără Fn</value>
   </data>
   <data name="GPUBoost" xml:space="preserve">
     <value>Dynamic Boost</value>
   </data>
   <data name="GPUChanging" xml:space="preserve">
-    <value>Changing</value>
+    <value>Modificare</value>
   </data>
   <data name="GPUCoreClockOffset" xml:space="preserve">
     <value>Core Clock Offset</value>
@@ -309,40 +357,43 @@ Do you still want to continue?</value>
     <value>Memory Clock Offset</value>
   </data>
   <data name="GPUMode" xml:space="preserve">
-    <value>GPU Mode</value>
+    <value>Modul GPU</value>
   </data>
   <data name="GPUModeEco" xml:space="preserve">
-    <value>iGPU only</value>
+    <value>Doar iGPU</value>
   </data>
   <data name="GPUModeStandard" xml:space="preserve">
     <value>iGPU + dGPU</value>
   </data>
   <data name="GPUModeUltimate" xml:space="preserve">
-    <value>dGPU exclusive</value>
+    <value>exclusiv dGPU</value>
   </data>
   <data name="GPUSettings" xml:space="preserve">
-    <value>GPU Settings</value>
+    <value>Setări GPU</value>
   </data>
   <data name="GPUTempTarget" xml:space="preserve">
-    <value>Temperature Target</value>
+    <value>Temperatura țintă</value>
+  </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
   </data>
   <data name="KeyBindings" xml:space="preserve">
-    <value>Key Bindings</value>
+    <value>Asocieri taste</value>
   </data>
   <data name="Keyboard" xml:space="preserve">
     <value>Tastatură</value>
   </data>
   <data name="KillGpuApps" xml:space="preserve">
-    <value>Stop all apps using GPU when switching to Eco</value>
+    <value>Opriți toate aplicațiile care folosesc GPU când treceți în modul Eco</value>
   </data>
   <data name="LaptopBacklight" xml:space="preserve">
-    <value>Laptop Backlight</value>
+    <value>Lumina de fundal</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
-    <value>Laptop Keyboard</value>
+    <value>Tastatură Laptop</value>
   </data>
   <data name="LaptopScreen" xml:space="preserve">
-    <value>Laptop Screen</value>
+    <value>Ecran Laptop</value>
   </data>
   <data name="Lid" xml:space="preserve">
     <value>Lid</value>
@@ -350,17 +401,23 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Lightbar</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo-ul</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
-    <value>Audio Visualizer</value>
+    <value>Vizualizator audio</value>
   </data>
   <data name="MatrixBanner" xml:space="preserve">
     <value>Binary Banner</value>
   </data>
   <data name="MatrixBright" xml:space="preserve">
-    <value>Bright</value>
+    <value>Luminos</value>
   </data>
   <data name="MatrixClock" xml:space="preserve">
     <value>Ceas</value>
@@ -375,22 +432,52 @@ Do you still want to continue?</value>
     <value>Mediu</value>
   </data>
   <data name="MatrixOff" xml:space="preserve">
-    <value>Off</value>
+    <value>Oprit</value>
   </data>
   <data name="MatrixPicture" xml:space="preserve">
-    <value>Picture</value>
+    <value>Imagine</value>
   </data>
   <data name="MaxRefreshTooltip" xml:space="preserve">
-    <value>Max refresh rate for lower latency</value>
+    <value>Valoare maximă refresh rate pentru latență mai mică</value>
   </data>
   <data name="MinRefreshTooltip" xml:space="preserve">
-    <value>60Hz refresh rate to save battery</value>
+    <value>60Hz refresh rate pentru a economisi bateria</value>
+  </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
   </data>
   <data name="Multizone" xml:space="preserve">
     <value>Multizone</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
-    <value>Mute Mic</value>
+    <value>Oprire microfon</value>
+  </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
   </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Actualizări noi</value>
@@ -398,65 +485,83 @@ Do you still want to continue?</value>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Nu există actualizări noi</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
-    <value>Open G-Helper window</value>
+    <value>Deschide fereastra G-Helper</value>
   </data>
   <data name="Optimized" xml:space="preserve">
-    <value>Optimized</value>
+    <value>Optimizat</value>
   </data>
   <data name="OptimizedGPUTooltip" xml:space="preserve">
-    <value>Switch to Eco on battery and to Standard when plugged</value>
+    <value>Schimbă la modul Eco pe baterie și la Standard când este conectat</value>
   </data>
   <data name="OptimizedUSBC" xml:space="preserve">
-    <value>Keep GPU disabled on USB-C charger in Optimized mode</value>
+    <value>Păstraţi GPU dezactivat când încărcătorul USB-C e folosit în modul Optimized</value>
   </data>
   <data name="Other" xml:space="preserve">
-    <value>Other</value>
+    <value>Altele</value>
   </data>
   <data name="Overdrive" xml:space="preserve">
     <value>Overdrive</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
-    <value>Mode</value>
+    <value>Mod</value>
+  </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
   </data>
   <data name="PictureGif" xml:space="preserve">
-    <value>Picture / Gif</value>
+    <value>Poză / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
-    <value>Play / Pause</value>
+    <value>Redare / Pauză</value>
+  </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
   </data>
   <data name="PowerLimits" xml:space="preserve">
-    <value>Power Limits</value>
+    <value>Limite de putere</value>
   </data>
   <data name="PPTExperimental" xml:space="preserve">
-    <value>Power Limits is an experimental feature. Use carefully and at your own risk!</value>
+    <value>Limitele de putere sunt o funcție experimentală. Folosiți cu atenție și pe propriul risc!</value>
   </data>
   <data name="PrintScreen" xml:space="preserve">
     <value>PrintScreen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
-    <value>Quit</value>
+    <value>Închide</value>
   </data>
   <data name="RestartGPU" xml:space="preserve">
-    <value>Something is using dGPU and preventing Eco mode. Restart dGPU in device manager? * Please proceed at your own risk.</value>
+    <value>O aplicație folosește dGPU și previne pornirea modului Eco. Reporniți dGPU în device manager? * Continuați pe propriul risc.</value>
   </data>
   <data name="RPM" xml:space="preserve">
     <value>RPM</value>
   </data>
   <data name="RunOnStartup" xml:space="preserve">
-    <value>Run on Startup</value>
+    <value>Rulează la pornirea sistemului</value>
+  </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Scade luminozitate Screenpad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Mărește luminozitate Screenpad</value>
   </data>
   <data name="Shutdown" xml:space="preserve">
-    <value>Shutdown</value>
+    <value>Oprire</value>
   </data>
   <data name="Silent" xml:space="preserve">
-    <value>Silent</value>
+    <value>Silențios</value>
   </data>
   <data name="Sleep" xml:space="preserve">
-    <value>Sleep</value>
+    <value>Somn</value>
   </data>
   <data name="StandardGPUTooltip" xml:space="preserve">
-    <value>Enables dGPU for standard use</value>
+    <value>Activează dGPU pentru uz standard</value>
   </data>
   <data name="StandardMode" xml:space="preserve">
     <value>Standard</value>
@@ -465,66 +570,69 @@ Do you still want to continue?</value>
     <value>Start</value>
   </data>
   <data name="StartingServices" xml:space="preserve">
-    <value>Starting Services</value>
+    <value>Se pornesc serviciile</value>
   </data>
   <data name="StartupError" xml:space="preserve">
-    <value>Startup Error</value>
+    <value>Eroare la Pornire</value>
   </data>
   <data name="Stop" xml:space="preserve">
     <value>Stop</value>
   </data>
   <data name="StopGPUApps" xml:space="preserve">
-    <value>Stop GPU Applications</value>
+    <value>Oprește aplicațiile care folosesc GPU</value>
   </data>
   <data name="StoppingServices" xml:space="preserve">
-    <value>Stopping Services</value>
+    <value>Se opresc serviciile</value>
   </data>
   <data name="ToggleAura" xml:space="preserve">
     <value>Toggle Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Mod Clamshell</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Toggle Fn-Lock</value>
   </data>
   <data name="ToggleMiniled" xml:space="preserve">
-    <value>Toggle Miniled (if supported)</value>
+    <value>Toggle Miniled (dacă e suportat)</value>
   </data>
   <data name="ToggleScreen" xml:space="preserve">
-    <value>Toggle Screen</value>
+    <value>Toggle Ecran</value>
   </data>
   <data name="Turbo" xml:space="preserve">
     <value>Turbo</value>
   </data>
   <data name="TurnedOff" xml:space="preserve">
-    <value>Turned off</value>
+    <value>Dezactivat</value>
   </data>
   <data name="TurnOffOnBattery" xml:space="preserve">
-    <value>Turn off on battery</value>
+    <value>Dezactivează când bateria e folosită</value>
   </data>
   <data name="UltimateGPUTooltip" xml:space="preserve">
-    <value>Routes laptop screen to dGPU, maximizing FPS</value>
+    <value>Rutează ecranul laptop-ului spre dGPU, maximizând FPS</value>
   </data>
   <data name="UltimateMode" xml:space="preserve">
     <value>Ultimate</value>
   </data>
   <data name="UndervoltingRisky" xml:space="preserve">
-    <value>Undervolting is an experimental and risky feature. If applied values are too low for your hardware, it can become unstable, shut down or cause data corruption. If you want to try - start from small values first, click Apply and test what works for you.</value>
+    <value>Undervolting este o funcțiune experimentală și riscantă. Dacă valorile aplicate sunt prea mici pentru hardware-ul dumneavoastră, acesta poate deveni instabil, a se opri sau să corupă datele. Dacă vrei să încerci - mai întâi începe de la valori mici, apasă Aplică și testează ce funcționează pentru tine.</value>
   </data>
   <data name="Updates" xml:space="preserve">
-    <value>Updates</value>
+    <value>Actualizări</value>
   </data>
   <data name="VersionLabel" xml:space="preserve">
-    <value>Version</value>
+    <value>Versiune</value>
   </data>
   <data name="VolumeDown" xml:space="preserve">
-    <value>Volume Down</value>
+    <value>Buton scădere volum</value>
   </data>
   <data name="VolumeMute" xml:space="preserve">
-    <value>Volume Mute</value>
+    <value>Buton dezactivare sunet</value>
   </data>
   <data name="VolumeUp" xml:space="preserve">
-    <value>Volume Up</value>
+    <value>Buton mărire volum</value>
   </data>
   <data name="WindowTop" xml:space="preserve">
-    <value>Keep app window always on top</value>
+    <value>Păstrează aplicația mereu deasupra</value>
   </data>
 </root>

app/Properties/Strings.tr.resx

@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Asus Services Running</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Nefes</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Renk Döngüsü</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Hızlı</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Normal</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Gökkuşağı</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Yavaş</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Flaş</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Auto Apply</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Dengeli</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Pil Şarj Limiti</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS and Driver Updates</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Brightness Up</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Renk</value>
   </data>
@@ -260,6 +305,9 @@ Do you still want to continue?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA Display Mode is not set to Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Ekstra</value>
   </data>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperature Target</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Tuş Bağlantıları</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Lightbar</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Audio Visualizer</value>
   </data>
@@ -386,18 +443,51 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Pil tasarrufu için 60Hz yenileme hızı</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Çoklu Bölge</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Mute Mic</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>New updates</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>No new updates</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>G-Helper penceresini aç</value>
   </data>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Performans Modu</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Resim / Gif</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Oynat / Duraklat</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Güç Sınırları</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Ekran Görüntüsü Al</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Çıkış Yap</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Başlangıçta Çalıştır</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Brightness Down</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad Brightness Up</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Kapalı</value>
   </data>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Aura'yı Değiştir</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Toggle Fn-Lock</value>
   </data>

app/Properties/Strings.uk.resx

@@ -118,7 +118,7 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <data name="ACPIError" xml:space="preserve">
-    <value>Не вдається підключитися до ASUS ACPI. Програма не може працювати без нього. Спробуйте встановити Asus System Control Interface</value>
+    <value>Не вдається під'єднатися до ASUS ACPI. Програма не може працювати без нього. Спробуйте встановити Asus System Control Interface</value>
   </data>
   <data name="AlertDGPU" xml:space="preserve">
     <value>Здається, що GPU використовується, вимкнути її?</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Кількість запущених сервісів Asus</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Стан батареї</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Дихання</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Направо</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Зміна Кольорів</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Комета</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Наліво</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Швидка</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Підсвітка</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Нормальна</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Веселка</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Випадкова</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>Реактивна</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Повільна</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Стробоскоп</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>Все</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Док</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Лого</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Колесо</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Низ</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Автоматично</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Баланс</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Ліміт заряду батареї</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Стан батареї</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>Оновлення BIOS та драйверів</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Підвищити яскравість</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Зарядка</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Колір</value>
   </data>
@@ -260,6 +305,9 @@
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA Display Mode не в режимі Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Налаштування Енергії</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Додатково</value>
   </data>
@@ -326,6 +374,9 @@
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Temperature Target</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>Висока</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Прив'язки клавіш</value>
   </data>
@@ -350,9 +401,15 @@
   <data name="Lightbar" xml:space="preserve">
     <value>Лайтбар</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Ілюмінація</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Лого</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Низька</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Аудіо візуалізатор</value>
   </data>
@@ -386,18 +443,51 @@
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Частота 60Гц, щоб зберегти заряд батареї</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Хвил.</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Хвилини</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Фіксація Кута</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Авто-вимикання</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Відповідь Кнопок</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Відстань підйому</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Попередження про низький заряд</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Режим Швидкодії</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Синхронізувати з мишею</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Мультизони</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Вимкнути мікрофон</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Ніколи</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>Є оновлення</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>Немає оновлень</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Не під'єднано</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Відкрити вікно G-Helper</value>
   </data>
@@ -419,12 +509,18 @@
   <data name="PerformanceMode" xml:space="preserve">
     <value>Режим</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Периферія</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Картинка / GIF</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Відтворення / Пауза</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Частота опитування</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Ліміти Потужності</value>
   </data>
@@ -434,6 +530,9 @@
   <data name="PrintScreen" xml:space="preserve">
     <value>Print Screen</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Профіль</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Вихід</value>
   </data>
@@ -446,6 +545,12 @@
   <data name="RunOnStartup" xml:space="preserve">
     <value>Запускати на старті</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Зменшити яскравість Screenpad</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Збільшити яскравість Screenpad</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Вимикання</value>
   </data>
@@ -482,6 +587,9 @@
   <data name="ToggleAura" xml:space="preserve">
     <value>Аура</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Автоматично вмикати режим Clamshell</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Fn-Lock</value>
   </data>

app/Properties/Strings.vi.resx

@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>Dịch vụ Asus đang chạy</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>Battery State</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>Hơi thở</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>Clockwise</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>Chuyển màu</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>Comet</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>Counterclockwise</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>Nhanh</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>Lighting Mode</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>Bình thường</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>Cầu vồng</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>Random</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>React</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>Chậm</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>Nhấp nháy</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>All</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>Scrollwheel</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>Áp dụng tự động</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>Cân bằng</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>Giới hạn sạc</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>Battery Health</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>Cập nhật BIOS và driver</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>Tăng độ sáng</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>Charging</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>Màu</value>
   </data>
@@ -260,6 +305,9 @@ Do you still want to continue?</value>
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>NVIDIA Display Mode is not set to Optimus</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>Energy Settings</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>Thêm</value>
   </data>
@@ -326,6 +374,9 @@ Do you still want to continue?</value>
   <data name="GPUTempTarget" xml:space="preserve">
     <value>Nhiệt độ đích</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>High</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>Tổ hợp phím</value>
   </data>
@@ -350,9 +401,15 @@ Do you still want to continue?</value>
   <data name="Lightbar" xml:space="preserve">
     <value>Thanh sáng</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>Lighting</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>Low</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>Sóng nhạc</value>
   </data>
@@ -386,18 +443,51 @@ Do you still want to continue?</value>
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>Tần số quét 60Hz để tiết kiệm pin</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>Minute</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>Minutes</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>Angle Snapping</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>Auto Power Off After</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>Lift Off Distance</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>Low Battery Warning at</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>Performance</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>Synchronize with mouse</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>Đèn nền Đa vùng(Multi-Zone)</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>Tắt Mic</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>Never</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>New updates</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>No new updates</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>Not Connected</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>Mở cửa sổ G-Helper</value>
   </data>
@@ -419,12 +509,18 @@ Do you still want to continue?</value>
   <data name="PerformanceMode" xml:space="preserve">
     <value>Chế độ Hiệu suất</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>Peripherals</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>Ảnh tĩnh / Ảnh động</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>Phát / Dừng</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>Polling Rate</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>Giới hạn công suất</value>
   </data>
@@ -434,6 +530,9 @@ Do you still want to continue?</value>
   <data name="PrintScreen" xml:space="preserve">
     <value>Chụp màn hình</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>Profile</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>Thoát</value>
   </data>
@@ -446,6 +545,12 @@ Do you still want to continue?</value>
   <data name="RunOnStartup" xml:space="preserve">
     <value>Chạy khi khởi động</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad Brightness Down</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad Brightness Up</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>Tắt nguồn</value>
   </data>
@@ -482,6 +587,9 @@ Do you still want to continue?</value>
   <data name="ToggleAura" xml:space="preserve">
     <value>Bật tắt Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>Auto Toggle Clamshell Mode</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>Toggle Fn-Lock</value>
   </data>

app/Properties/Strings.zh-CN.resx

@@ -124,7 +124,7 @@
     <value>看起来 GPU 正在被重度使用，是否禁用？</value>
   </data>
   <data name="AlertDGPUTitle" xml:space="preserve">
-    <value>节能模式</value>
+    <value>集显模式</value>
   </data>
   <data name="AlertUltimateOff" xml:space="preserve">
     <value>关闭独显直连需要重启</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>正在运行的 Asus 服务</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>电池状态</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>呼吸</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>顺时针</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>彩色循环</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>彗星</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>逆时针</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>快速</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>灯效模式</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>正常</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>彩虹</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>随机</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>触发</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>慢</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>闪烁</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>全部</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>滚轮</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>自动应用</value>
   </data>
@@ -199,14 +235,20 @@
     <value>唤醒时</value>
   </data>
   <data name="BacklightTimeout" xml:space="preserve">
-    <value>背光超时时间 (0表示长亮)</value>
+    <value>插电/电池时熄灭时间（0表示长亮）</value>
   </data>
   <data name="Balanced" xml:space="preserve">
     <value>平衡模式</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>电池充电限制</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>电池健康</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS 和驱动程序更新</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>提高亮度</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>充电中</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>颜色</value>
   </data>
@@ -258,7 +303,10 @@
 确定还要继续吗？</value>
   </data>
   <data name="EnableOptimusTitle" xml:space="preserve">
-    <value>nVIDIA显示模式尚未设置至Optimus</value>
+    <value>NVIDIA 显示模式未设置为自动切换</value>
+  </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>电源设置</value>
   </data>
   <data name="Extra" xml:space="preserve">
     <value>更多</value>
@@ -291,7 +339,7 @@
     <value>风扇</value>
   </data>
   <data name="FansPower" xml:space="preserve">
-    <value>高级设置</value>
+    <value>风扇 + 功率</value>
   </data>
   <data name="FnLock" xml:space="preserve">
     <value>打开FnLock (无需按下FN使用FN+(F1-F12)热键)</value>
@@ -326,6 +374,9 @@
   <data name="GPUTempTarget" xml:space="preserve">
     <value>温度目标</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>高</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>按键绑定</value>
   </data>
@@ -336,7 +387,7 @@
     <value>当切换到集显模式时，停止所有正在使用独显的应用</value>
   </data>
   <data name="LaptopBacklight" xml:space="preserve">
-    <value>笔记本背光</value>
+    <value>背光</value>
   </data>
   <data name="LaptopKeyboard" xml:space="preserve">
     <value>笔记本键盘</value>
@@ -350,9 +401,15 @@
   <data name="Lightbar" xml:space="preserve">
     <value>灯条</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>背光</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>徽标</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>低</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>音频可视化器</value>
   </data>
@@ -386,18 +443,51 @@
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>调整刷新率为60Hz以节省电量</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>分钟</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>分组</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>角度校正</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>自动关闭时间</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>按键响应</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>静默高度</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>低于该电量时警告</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>性能</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>和鼠标同步</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>多区域设置</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>静音麦克风</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>从不</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>有更新</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>无更新</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>未连接</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>打开G-Helper窗口</value>
   </data>
@@ -414,17 +504,23 @@
     <value>其他</value>
   </data>
   <data name="Overdrive" xml:space="preserve">
-    <value>OD</value>
+    <value>超频</value>
   </data>
   <data name="PerformanceMode" xml:space="preserve">
     <value>性能模式</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>外设</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>图片/动图</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>播放/暂停</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>回报率</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>功率限制</value>
   </data>
@@ -434,6 +530,9 @@
   <data name="PrintScreen" xml:space="preserve">
     <value>截图</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>配置</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>退出</value>
   </data>
@@ -446,6 +545,12 @@
   <data name="RunOnStartup" xml:space="preserve">
     <value>开机自启</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>Screenpad亮度降低</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>Screenpad亮度增加</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>关机时</value>
   </data>
@@ -482,6 +587,9 @@
   <data name="ToggleAura" xml:space="preserve">
     <value>切换 Aura 模式</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>自动切换合盖模式</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>切换 Fn 锁定</value>
   </data>

app/Properties/Strings.zh-TW.resx

@@ -139,7 +139,7 @@
     <value>動畫速度</value>
   </data>
   <data name="AnimeMatrix" xml:space="preserve">
-    <value>AnimeMatrix</value>
+    <value>AniMeMatrix</value>
   </data>
   <data name="AppAlreadyRunning" xml:space="preserve">
     <value>程式已正在執行</value>
@@ -162,21 +162,42 @@
   <data name="AsusServicesRunning" xml:space="preserve">
     <value>執行中的華碩服務</value>
   </data>
+  <data name="AuraBatteryState" xml:space="preserve">
+    <value>電池狀態</value>
+  </data>
   <data name="AuraBreathe" xml:space="preserve">
     <value>呼吸</value>
   </data>
+  <data name="AuraClockwise" xml:space="preserve">
+    <value>順時針</value>
+  </data>
   <data name="AuraColorCycle" xml:space="preserve">
     <value>循環</value>
   </data>
+  <data name="AuraComet" xml:space="preserve">
+    <value>彗星</value>
+  </data>
+  <data name="AuraCounterClockwise" xml:space="preserve">
+    <value>逆時針</value>
+  </data>
   <data name="AuraFast" xml:space="preserve">
     <value>快速</value>
   </data>
+  <data name="AuraLightingMode" xml:space="preserve">
+    <value>燈效模式</value>
+  </data>
   <data name="AuraNormal" xml:space="preserve">
     <value>正常</value>
   </data>
   <data name="AuraRainbow" xml:space="preserve">
     <value>彩虹</value>
   </data>
+  <data name="AuraRandomColor" xml:space="preserve">
+    <value>隨機</value>
+  </data>
+  <data name="AuraReact" xml:space="preserve">
+    <value>觸發</value>
+  </data>
   <data name="AuraSlow" xml:space="preserve">
     <value>慢</value>
   </data>
@@ -186,6 +207,21 @@
   <data name="AuraStrobe" xml:space="preserve">
     <value>閃爍</value>
   </data>
+  <data name="AuraZoneAll" xml:space="preserve">
+    <value>全部</value>
+  </data>
+  <data name="AuraZoneDock" xml:space="preserve">
+    <value>Dock</value>
+  </data>
+  <data name="AuraZoneLogo" xml:space="preserve">
+    <value>Logo</value>
+  </data>
+  <data name="AuraZoneScroll" xml:space="preserve">
+    <value>滾輪</value>
+  </data>
+  <data name="AuraZoneUnderglow" xml:space="preserve">
+    <value>Underglow</value>
+  </data>
   <data name="AutoApply" xml:space="preserve">
     <value>自動套用</value>
   </data>
@@ -204,9 +240,15 @@
   <data name="Balanced" xml:space="preserve">
     <value>平衡模式</value>
   </data>
+  <data name="BatteryCharge" xml:space="preserve">
+    <value>Charge</value>
+  </data>
   <data name="BatteryChargeLimit" xml:space="preserve">
     <value>電池充電上限</value>
   </data>
+  <data name="BatteryHealth" xml:space="preserve">
+    <value>電池健康度</value>
+  </data>
   <data name="BiosAndDriverUpdates" xml:space="preserve">
     <value>BIOS與驅動程式更新 Updates</value>
   </data>
@@ -222,6 +264,9 @@
   <data name="BrightnessUp" xml:space="preserve">
     <value>螢幕亮度提高</value>
   </data>
+  <data name="Charging" xml:space="preserve">
+    <value>充電中</value>
+  </data>
   <data name="Color" xml:space="preserve">
     <value>顏色</value>
   </data>
@@ -260,6 +305,9 @@
   <data name="EnableOptimusTitle" xml:space="preserve">
     <value>Nvidia顯示模式未設置為自動切換</value>
   </data>
+  <data name="EnergySettings" xml:space="preserve">
+    <value>電源設定</value>
+  </data>
   <data name="Extra" xml:space="preserve">
     <value>更多</value>
   </data>
@@ -326,6 +374,9 @@
   <data name="GPUTempTarget" xml:space="preserve">
     <value>GPU溫度上限</value>
   </data>
+  <data name="High" xml:space="preserve">
+    <value>高</value>
+  </data>
   <data name="KeyBindings" xml:space="preserve">
     <value>按鍵綁定</value>
   </data>
@@ -350,9 +401,15 @@
   <data name="Lightbar" xml:space="preserve">
     <value>燈條</value>
   </data>
+  <data name="Lighting" xml:space="preserve">
+    <value>亮度</value>
+  </data>
   <data name="Logo" xml:space="preserve">
     <value>Logo</value>
   </data>
+  <data name="Low" xml:space="preserve">
+    <value>低</value>
+  </data>
   <data name="MatrixAudio" xml:space="preserve">
     <value>音效視覺化</value>
   </data>
@@ -386,18 +443,51 @@
   <data name="MinRefreshTooltip" xml:space="preserve">
     <value>維持60Hz以節省電量</value>
   </data>
+  <data name="Minute" xml:space="preserve">
+    <value>分鐘</value>
+  </data>
+  <data name="Minutes" xml:space="preserve">
+    <value>分鐘</value>
+  </data>
+  <data name="MouseAngleSnapping" xml:space="preserve">
+    <value>角度修正</value>
+  </data>
+  <data name="MouseAutoPowerOff" xml:space="preserve">
+    <value>自動關閉電源</value>
+  </data>
+  <data name="MouseButtonResponse" xml:space="preserve">
+    <value>Button Response</value>
+  </data>
+  <data name="MouseLiftOffDistance" xml:space="preserve">
+    <value>響應高度(LOD)</value>
+  </data>
+  <data name="MouseLowBatteryWarning" xml:space="preserve">
+    <value>低電量警告</value>
+  </data>
+  <data name="MousePerformance" xml:space="preserve">
+    <value>性能設定</value>
+  </data>
+  <data name="MouseSynchronize" xml:space="preserve">
+    <value>與滑鼠同步</value>
+  </data>
   <data name="Multizone" xml:space="preserve">
     <value>多區域</value>
   </data>
   <data name="MuteMic" xml:space="preserve">
     <value>麥克風開關</value>
   </data>
+  <data name="Never" xml:space="preserve">
+    <value>永不</value>
+  </data>
   <data name="NewUpdates" xml:space="preserve">
     <value>新的更新</value>
   </data>
   <data name="NoNewUpdates" xml:space="preserve">
     <value>沒有新的更新</value>
   </data>
+  <data name="NotConnected" xml:space="preserve">
+    <value>未連線</value>
+  </data>
   <data name="OpenGHelper" xml:space="preserve">
     <value>開啟G-Helper視窗</value>
   </data>
@@ -419,12 +509,18 @@
   <data name="PerformanceMode" xml:space="preserve">
     <value>性能模式:</value>
   </data>
+  <data name="Peripherals" xml:space="preserve">
+    <value>週邊設備</value>
+  </data>
   <data name="PictureGif" xml:space="preserve">
     <value>圖片/動圖</value>
   </data>
   <data name="PlayPause" xml:space="preserve">
     <value>播放/暫停</value>
   </data>
+  <data name="PollingRate" xml:space="preserve">
+    <value>輪循率</value>
+  </data>
   <data name="PowerLimits" xml:space="preserve">
     <value>功率限制</value>
   </data>
@@ -434,6 +530,9 @@
   <data name="PrintScreen" xml:space="preserve">
     <value>截圖</value>
   </data>
+  <data name="Profile" xml:space="preserve">
+    <value>設定檔</value>
+  </data>
   <data name="Quit" xml:space="preserve">
     <value>退出</value>
   </data>
@@ -446,6 +545,12 @@
   <data name="RunOnStartup" xml:space="preserve">
     <value>開機自動開啟</value>
   </data>
+  <data name="ScreenPadDown" xml:space="preserve">
+    <value>第二觸控螢幕亮度降低</value>
+  </data>
+  <data name="ScreenPadUp" xml:space="preserve">
+    <value>第二觸控螢幕亮度提高</value>
+  </data>
   <data name="Shutdown" xml:space="preserve">
     <value>關機時</value>
   </data>
@@ -482,6 +587,9 @@
   <data name="ToggleAura" xml:space="preserve">
     <value>切換Aura</value>
   </data>
+  <data name="ToggleClamshellMode" xml:space="preserve">
+    <value>翻蓋模式 (蓋上筆電但有外接螢幕時，系統仍會持續運行)</value>
+  </data>
   <data name="ToggleFnLock" xml:space="preserve">
     <value>免按Fn鍵使用Fn+F1~F12功能</value>
   </data>

app/Ryzen/RyzenControl.cs

@@ -130,10 +130,16 @@ namespace Ryzen
             return CPUName.Contains("AMD") || CPUName.Contains("Ryzen") || CPUName.Contains("Athlon") || CPUName.Contains("Radeon") || CPUName.Contains("AMD Custom APU 0405");
         }
 
-        public static bool IsRyzen9()
+        public static bool IsSupportedUV()
         {
             if (CPUName.Length == 0) Init();
-            return CPUName.Contains("Ryzen 9");
+            return CPUName.Contains("Ryzen 9") || CPUName.Contains("4900H") || CPUName.Contains("4800H") || CPUName.Contains("4600H");
+        }
+
+        public static bool IsSupportedUViGPU()
+        {
+            if (CPUName.Length == 0) Init();
+            return CPUName.Contains("6900H") || CPUName.Contains("7945H") || CPUName.Contains("7845H");
         }
 
         public static void SetAddresses()

app/Settings.cs

@@ -6,6 +6,8 @@ using GHelper.Gpu;
 using GHelper.Helpers;
 using GHelper.Input;
 using GHelper.Mode;
+using GHelper.Peripherals;
+using GHelper.Peripherals.Mouse;
 using GHelper.UI;
 using System.Diagnostics;
 using System.Timers;
@@ -32,8 +34,10 @@ namespace GHelper
         public Updates? updates;
 
         static long lastRefresh;
+        static long lastBatteryRefresh;
 
         bool isGpuSection = true;
+        bool batteryMouseOver = false;
 
         public SettingsForm()
         {
@@ -68,6 +72,7 @@ namespace GHelper
             labelKeyboard.Text = Properties.Strings.LaptopKeyboard;
             labelMatrix.Text = Properties.Strings.AnimeMatrix;
             labelBatteryTitle.Text = Properties.Strings.BatteryChargeLimit;
+            labelPeripherals.Text = Properties.Strings.Peripherals;
 
             checkMatrix.Text = Properties.Strings.TurnOffOnBattery;
             checkStartup.Text = Properties.Strings.RunOnStartup;
@@ -173,11 +178,56 @@ namespace GHelper
             sensorTimer.Elapsed += OnTimedEvent;
             sensorTimer.Enabled = true;
 
-            labelModel.Text = AppConfig.GetModelShort() + (ProcessHelper.IsUserAdministrator() ? "." : "");
+            labelCharge.MouseEnter += PanelBattery_MouseEnter;
+            labelCharge.MouseLeave += PanelBattery_MouseLeave;
+
+            buttonPeripheral1.Click += ButtonPeripheral_Click;
+            buttonPeripheral2.Click += ButtonPeripheral_Click;
+            buttonPeripheral3.Click += ButtonPeripheral_Click;
+
+            buttonPeripheral1.MouseEnter += ButtonPeripheral_MouseEnter;
+            buttonPeripheral2.MouseEnter += ButtonPeripheral_MouseEnter;
+            buttonPeripheral3.MouseEnter += ButtonPeripheral_MouseEnter;
+
+            Text = "G-Helper " + (ProcessHelper.IsUserAdministrator() ? "—" : "-") + " " + AppConfig.GetModelShort();
             TopMost = AppConfig.Is("topmost");
 
+            //This will auto position the window again when it resizes. Might mess with position if people drag the window somewhere else.
+            this.Resize += SettingsForm_Resize;
             SetContextMenu();
+        }
 
+        private void SettingsForm_Resize(object? sender, EventArgs e)
+        {
+            Left = Screen.FromControl(this).WorkingArea.Width - 10 - Width;
+            Top = Screen.FromControl(this).WorkingArea.Height - 10 - Height;
+        }
+
+        private void PanelBattery_MouseEnter(object? sender, EventArgs e)
+        {
+            batteryMouseOver = true;
+            ShowBatteryWear();
+        }
+
+        private void PanelBattery_MouseLeave(object? sender, EventArgs e)
+        {
+            batteryMouseOver = false;
+            RefreshSensors(true);
+        }
+
+        private void ShowBatteryWear()
+        {
+            //Refresh again only after 15 Minutes since the last refresh
+            if (lastBatteryRefresh == 0 || Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastBatteryRefresh) > 15 * 60_000)
+            {
+                lastBatteryRefresh = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+                HardwareControl.RefreshBatteryHealth();
+            }
+
+            if (HardwareControl.batteryHealth != -1)
+            {
+                labelCharge.Text = Properties.Strings.BatteryHealth + ": " + Math.Round(HardwareControl.batteryHealth, 1) + "%";
+            }
         }
 
         private void SettingsForm_VisibleChanged(object? sender, EventArgs e)
@@ -187,10 +237,16 @@ namespace GHelper
             {
                 screenControl.InitScreen();
                 gpuControl.InitXGM();
+                Task.Run((Action)RefreshPeripheralsBattery);
                 updateControl.CheckForUpdates();
             }
         }
 
+        private void RefreshPeripheralsBattery()
+        {
+            PeripheralsProvider.RefreshBatteryForAllDevices(true);
+        }
+
         private void ButtonUpdates_Click(object? sender, EventArgs e)
         {
             if (updates == null || updates.Text == "")
@@ -475,7 +531,7 @@ namespace GHelper
 
         private void LabelCPUFan_Click(object? sender, EventArgs e)
         {
-            AppConfig.Set("fan_rpm", (AppConfig.Get("fan_rpm") == 1) ? 0 : 1);
+            HardwareControl.fanRpm = !HardwareControl.fanRpm;
             RefreshSensors(true);
         }
 
@@ -489,7 +545,8 @@ namespace GHelper
             if (colorDlg.ShowDialog() == DialogResult.OK)
             {
                 AppConfig.Set("aura_color2", colorDlg.Color.ToArgb());
-                SetAura();
+                AsusUSB.ApplyAura();
+                VisualiseAura();
             }
         }
 
@@ -554,7 +611,8 @@ namespace GHelper
             if (colorDlg.ShowDialog() == DialogResult.OK)
             {
                 AppConfig.Set("aura_color", colorDlg.Color.ToArgb());
-                SetAura();
+                AsusUSB.ApplyAura();
+                VisualiseAura();
             }
         }
 
@@ -572,9 +630,6 @@ namespace GHelper
             comboKeyboard.SelectedValue = AsusUSB.Mode;
             comboKeyboard.SelectedValueChanged += ComboKeyboard_SelectedValueChanged;
 
-            pictureColor.BackColor = AsusUSB.Color1;
-            pictureColor2.BackColor = AsusUSB.Color2;
-            pictureColor2.Visible = AsusUSB.HasSecondColor();
 
             if (AsusUSB.HasColor())
             {
@@ -586,6 +641,15 @@ namespace GHelper
                 comboKeyboard.Visible = false;
             }
 
+            VisualiseAura();
+
+        }
+
+        public void VisualiseAura()
+        {
+            pictureColor.BackColor = AsusUSB.Color1;
+            pictureColor2.BackColor = AsusUSB.Color2;
+            pictureColor2.Visible = AsusUSB.HasSecondColor();
         }
 
         public void InitMatrix()
@@ -606,21 +670,6 @@ namespace GHelper
         }
 
 
-        public void SetAura()
-        {
-            AsusUSB.Mode = AppConfig.Get("aura_mode");
-            AsusUSB.Speed = AppConfig.Get("aura_speed");
-            AsusUSB.SetColor(AppConfig.Get("aura_color"));
-            AsusUSB.SetColor2(AppConfig.Get("aura_color2"));
-
-            pictureColor.BackColor = AsusUSB.Color1;
-            pictureColor2.BackColor = AsusUSB.Color2;
-            pictureColor2.Visible = AsusUSB.HasSecondColor();
-
-            AsusUSB.ApplyAura();
-
-        }
-
         public void CycleAuraMode()
         {
             if (comboKeyboard.SelectedIndex < comboKeyboard.Items.Count - 1)
@@ -632,7 +681,8 @@ namespace GHelper
         private void ComboKeyboard_SelectedValueChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("aura_mode", (int)comboKeyboard.SelectedValue);
-            SetAura();
+            AsusUSB.ApplyAura();
+            VisualiseAura();
         }
 
 
@@ -719,6 +769,7 @@ namespace GHelper
             this.Hide();
             if (fans != null && fans.Text != "") fans.Close();
             if (keyb != null && keyb.Text != "") keyb.Close();
+            if (updates != null && updates.Text != "") updates.Close();
         }
 
 
@@ -768,29 +819,37 @@ namespace GHelper
             string cpuTemp = "";
             string gpuTemp = "";
             string battery = "";
+            string charge = "";
 
             HardwareControl.ReadSensors();
+            Task.Run((Action)PeripheralsProvider.RefreshBatteryForAllDevices);
 
             if (HardwareControl.cpuTemp > 0)
                 cpuTemp = ": " + Math.Round((decimal)HardwareControl.cpuTemp).ToString() + "°C";
 
-            if (HardwareControl.batteryDischarge > 0)
-                battery = Properties.Strings.Discharging + ": " + Math.Round((decimal)HardwareControl.batteryDischarge, 1).ToString() + "W";
+            if (HardwareControl.batteryCapacity > 0)
+                charge = Properties.Strings.BatteryCharge + ": " + Math.Round(HardwareControl.batteryCapacity, 1) + "% ";
+
+            if (HardwareControl.batteryRate < 0)
+                battery = Properties.Strings.Discharging + ": " + Math.Round(-(decimal)HardwareControl.batteryRate, 1).ToString() + "W";
+            else if (HardwareControl.batteryRate > 0)
+                battery = Properties.Strings.Charging + ": " + Math.Round((decimal)HardwareControl.batteryRate, 1).ToString() + "W";
+
 
             if (HardwareControl.gpuTemp > 0)
             {
                 gpuTemp = $": {HardwareControl.gpuTemp}°C";
             }
 
-
             Program.settingsForm.BeginInvoke(delegate
             {
                 labelCPUFan.Text = "CPU" + cpuTemp + " " + HardwareControl.cpuFan;
                 labelGPUFan.Text = "GPU" + gpuTemp + " " + HardwareControl.gpuFan;
                 if (HardwareControl.midFan is not null)
-                    labelMidFan.Text = "Mid" + HardwareControl.midFan;
+                    labelMidFan.Text = "Mid " + HardwareControl.midFan;
 
                 labelBattery.Text = battery;
+                if (!batteryMouseOver) labelCharge.Text = charge;
             });
 
             string trayTip = "CPU" + cpuTemp + " " + HardwareControl.cpuFan;
@@ -859,9 +918,14 @@ namespace GHelper
 
         public void AutoKeyboard()
         {
-            InputDispatcher.SetBacklightAuto(true);
 
-            AsusUSB.ApplyAuraPower();
+            if (!AppConfig.Is("skip_aura"))
+            {
+                AsusUSB.ApplyAuraPower();
+                AsusUSB.ApplyAura();
+            }
+
+            InputDispatcher.SetBacklightAuto(true);
 
             if (Program.acpi.IsXGConnected())
                 AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
@@ -1020,6 +1084,110 @@ namespace GHelper
         }
 
 
+        public void VisualizePeripherals()
+        {
+            if (!PeripheralsProvider.IsAnyPeripheralConnect())
+            {
+                panelPeripherals.Visible = false;
+                return;
+            }
+
+            Button[] buttons = new Button[] { buttonPeripheral1, buttonPeripheral2, buttonPeripheral3 };
+
+            //we only support 4 devces for now. Who has more than 4 mice connected to the same PC anyways....
+            List<IPeripheral> lp = PeripheralsProvider.AllPeripherals();
+
+            for (int i = 0; i < lp.Count && i < buttons.Length; ++i)
+            {
+                IPeripheral m = lp.ElementAt(i);
+                Button b = buttons[i];
+
+                if (m.IsDeviceReady)
+                {
+                    b.Text = m.GetDisplayName() + "\n" + m.Battery + "%"
+                    + (m.Charging ? "(" + Properties.Strings.Charging + ")" : "");
+                }
+                else
+                {
+                    //Mouse is either not connected or in standby
+                    b.Text = m.GetDisplayName() + "\n(" + Properties.Strings.NotConnected + ")";
+                }
+
+                switch (m.DeviceType())
+                {
+                    case PeripheralType.Mouse:
+                        b.Image = ControlHelper.TintImage(Properties.Resources.icons8_maus_32, b.ForeColor);
+                        break;
+
+                    case PeripheralType.Keyboard:
+                        b.Image = ControlHelper.TintImage(Properties.Resources.icons8_keyboard_32, b.ForeColor);
+                        break;
+                }
+
+                b.Visible = true;
+            }
+
+            for (int i = lp.Count; i < buttons.Length; ++i)
+            {
+                buttons[i].Visible = false;
+            }
+
+            panelPeripherals.Visible = true;
+        }
+
+        private void ButtonPeripheral_MouseEnter(object? sender, EventArgs e)
+        {
+            int index = 0;
+            if (sender == buttonPeripheral2) index = 1;
+            if (sender == buttonPeripheral3) index = 2;
+            IPeripheral iph = PeripheralsProvider.AllPeripherals().ElementAt(index);
+
+
+            if (iph is null)
+            {
+                return;
+            }
+
+            if (!iph.IsDeviceReady)
+            {
+                //Refresh battery on hover if the device is marked as "Not Ready"
+                iph.ReadBattery();
+            }
+        }
+
+        private void ButtonPeripheral_Click(object? sender, EventArgs e)
+        {
+            int index = 0;
+            if (sender == buttonPeripheral2) index = 1;
+            if (sender == buttonPeripheral3) index = 2;
+
+            IPeripheral iph = PeripheralsProvider.AllPeripherals().ElementAt(index);
+
+            if (iph is null)
+            {
+                //Can only happen when the user hits the button in the exact moment a device is disconnected.
+                return;
+            }
+
+            if (iph.DeviceType() == PeripheralType.Mouse)
+            {
+                AsusMouse? am = iph as AsusMouse;
+                if (am is null || !am.IsDeviceReady)
+                {
+                    //Should not happen if all device classes are implemented correctly. But better safe than sorry.
+                    return;
+                }
+                AsusMouseSettings s = new AsusMouseSettings(am);
+                if (!s.IsDisposed)
+                {
+                    s.Show();
+                }
+
+            }
+
+
+
+        }
     }
 
 

app/UI/ControlHelper.cs

@@ -77,6 +77,12 @@ public static class ControlHelper
                 combo.ButtonColor = RForm.buttonMain;
                 combo.ArrowColor = RForm.foreMain;
             }
+            var numbericUpDown = control as NumericUpDown;
+            if(numbericUpDown is not null)
+            {
+                numbericUpDown.ForeColor = RForm.foreMain;
+                numbericUpDown.BackColor = RForm.buttonMain;
+            }
 
             var gb = control as GroupBox;
             if (gb != null)
@@ -172,4 +178,20 @@ public static class ControlHelper
 
     }
 
+    public static Image TintImage(Image image, Color tintColor)
+    {
+        var pic = new Bitmap(image);
+
+        for (int y = 0; (y <= (pic.Height - 1)); y++)
+        {
+            for (int x = 0; (x <= (pic.Width - 1)); x++)
+            {
+                Color col = pic.GetPixel(x, y);
+                pic.SetPixel(x, y, Color.FromArgb(col.A, tintColor.R, tintColor.G, tintColor.B));
+            }
+        }
+        
+        return pic;
+    }
+
 }

app/Updates.cs

@@ -25,10 +25,10 @@ namespace GHelper
         static int updatesCount = 0;
         private static long lastUpdate;
 
-        private void LoadUpdates()
+        private void LoadUpdates(bool force = false)
         {
 
-            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastUpdate) < 5000) return;
+            if (!force && (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastUpdate) < 5000)) return;
             lastUpdate = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
             InitBiosAndModel();
@@ -77,7 +77,7 @@ namespace GHelper
             InitTheme(true);
 
 
-            LoadUpdates();
+            LoadUpdates(true);
 
             //buttonRefresh.Visible = false;
             buttonRefresh.Click += ButtonRefresh_Click;

app/global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "7.0.203"
+    "version": "7.0.306"
   }
 }

docs/README.md

@@ -18,20 +18,21 @@ Lightweight Armoury Crate alternative for Asus laptops. A small utility that all
 5. FN-Lock
 6. Doesn't need administrator privileges to run (*)
 
-## [:floppy_disk: Download App](https://github.com/seerge/g-helper/releases/latest/download/GHelper.zip)
+# [:floppy_disk: Download G-Helper App](https://github.com/seerge/g-helper/releases/latest/download/GHelper.zip)
+
+- Don't forget to read [:question: FAQ ](#question-faq)
+- If you like this app, please [star :star: it on Github](https://github.com/seerge/g-helper) and spread a word about it!
 
-If you like this app, please [star :star: it on Github](https://github.com/seerge/g-helper) and spread a word about it!
 #### Support project in [:euro: EUR](https://www.paypal.com/donate/?hosted_button_id=4HMSHS4EBQWTA) | [💵 USD](https://www.paypal.com/donate/?hosted_button_id=SRM6QUX6ACXDY) | [:credit_card: Stripe](https://buy.stripe.com/00gaFJ9Lf79v7WobII)
 
-_If you post about the app - please include a link. Thanks._
 
 ![Gihhub](https://github.com/seerge/g-helper/assets/5920850/4d98465a-63a5-4498-ae14-afb3e67e7e82)
 
-### :zap: Main features
+### :zap: Features
 
 1. **Performance modes**: Silent - Balanced - Turbo (built-in, with default fan curves)
 2. **GPU modes**: Eco - Standard - Ultimate - Optimized
-3. Laptop screen refresh rate 60hz or 120hz (144hz, etc) with display overdrive (OD) and miniled multizone switch
+3. Laptop screen refresh rate 60hz or 120hz (144hz, etc) with display overdrive (OD) and mini-led multi-zone switch
 4. Custom fan curve editor, power limits (PPT) and turbo boost selection for every performance mode
 5. Anime matrix control thanks to [Starlight](https://github.com/vddCore/Starlight) + some tweaks from my side including animated GIFs, clock and audio visualizer
 6. Keyboard backlit animation and colors (including sleep animation and support for TUF models)
@@ -40,14 +41,15 @@ _If you post about the app - please include a link. Thanks._
 9. Battery charge limit to preserve battery health
 10. NVidia GPU overclocking
 11. XG Mobile Control
+12. AMD CPU Undervolting
 
 ![Screenshot 2023-04-13 190951](https://user-images.githubusercontent.com/5920850/231859391-c4963af4-491c-4523-95d4-0bdcfd7cfd6f.png)
 
 ### :gear: Automatic switching when on battery or plugged in
-- Performance modes (app remembers last mode used on battery or when plugged)
+- App remembers last Mode used on battery or when plugged
 - Optimized GPU mode - disables dGPU on battery and enables when plugged
-- Auto Screen refresh rate (60hz on battery, 120+ hz when plugged)
-- Keyboard backlight can be turned off on battery
+- Auto Screen refresh rate (60hz on battery, max hz when plugged)
+- Keyboard backlight timeout on battery or when plugged
 
 To keep auto switching and hotkeys working the app needs to stay running in the tray. It doesn't consume any resources. 
 
@@ -55,20 +57,20 @@ To keep auto switching and hotkeys working the app needs to stay running in the
 
 Modes are **same** as in Armoury Crate as they are stored in bios including default fan curves
 
-1. Silent (minimal or no fans, 70W PPT total, up to 45W PPT to CPU) + Best power efficiency setting in windows
-2. Balanced (balanced fans, 100W PPT total, up to 45W PPT to CPU) + Balanced setting in windows
-3. Turbo (intense fans, 125W PPT total, up to 80W PPT to CPU) + Best performance setting in windows
+1. **Silent** (minimal or no fans, 70W PPT total, up to 45W PPT to CPU) + Best power efficiency setting in windows
+2. **Balanced** (balanced fans, 100W PPT total, up to 45W PPT to CPU) + Balanced setting in windows
+3. **Turbo** (intense fans, 125W PPT total, up to 80W PPT to CPU) + Best performance setting in windows
 
 _PPTs are shown for G14 2022, for other models PPTs will be different as they are set in bios._
 
 ### :video_game: GPU Modes
 
-1. Eco mode : only low power integrated GPU enabled, iGPU drives built in display
-2. Standard mode (MS Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
-3. Ultimate mode: iGPU and dGPU enabled, but dGPU drives built in display (supported only on G14 2022 model)
-4. Optimized: disables dGPU on battery (Eco) and enables when plugged (Standard)
+1. **Eco** : only low power integrated GPU enabled, iGPU drives built in display
+2. **Standard** (MS Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
+3. **Ultimate**: iGPU and dGPU enabled, but dGPU drives built in display (supported on 2022+ models)
+4. **Optimized**: disables dGPU on battery (Eco) and enables when plugged (Standard)
 
-![Screenshot 2023-05-07 182519](https://user-images.githubusercontent.com/5920850/236697890-26938ac4-8840-4fed-a7b1-9a7b839fb865.png)
+![Screenshot 2023-08-03 193646](https://github.com/seerge/g-helper/assets/5920850/ac7debcf-163a-4529-b7fd-fb4d2f3bb1da)
 
 ## :question: FAQ
 
@@ -94,46 +96,53 @@ Click on them
 Most probably either you are using Eco / Optimized mode and your dGPU is simply off, or your windows has put the dGPU into sleep (to preserve power). In this situations G-helper won't be able to reach your GPU and get readings
 
 #### I don't see app after starting it
-Please check system tray for a (G) icon. By default windows is keen to hide all icons, so you may need to click ^ to see them all. I would advise to right click on Task Bar select Task Bar Settings -> Other System Tray icons -> Mark G-Helper to be always ON.
+Please check the system tray for a (G) icon. By default windows is keen to hide all icons, so you may need to click ^ to see them all. I would advise to right click on Taskbar select TaskBar Settings -> Other System Tray icons -> Mark G-Helper to be always ON.
 
-#### App crash or doesn't work properly what should I do ?
-Open "Event Viewer" from start menu, go to Windows Logs -> Application and check for recent Errors mentioning G-Helper. If you see one - please post a [new issue](https://github.com/seerge/g-helper/issues) with all details from this error.
+#### App crashes or doesn't work properly, what should I do ?
+Open "Event Viewer" from the start menu, go to Windows Logs -> Application and check for recent Errors mentioning G-Helper. If you see one - please post a [new issue](https://github.com/seerge/g-helper/issues) with all details from this error.
 
 #### Battery charge limiter is not working
-It could be that Asus services are overwriting this limit after. You may want to stop them by clicking "Stop" in Asus Services section (under Extra).
+It could be that Asus services are overwriting this limit after. You may want to stop them by clicking "Stop" in the Asus Services section (under Extra).
 
 #### Can I use MyASUS app along with G-Helper?
 You can, the only problem is that MyASUS may override the battery charge limit that you set before. My advice in such a situation would be to set the same limit (i.e. 80%) in both MyASUS and G-Helper.
 
 #### How do I set Mute Microphone to M3?
-If you have Asus Optimization Service running, it's controlled by that service (therefore G-helper doesn't interfere and doesn't touch this function). Alternatively you can stop that service - and you can bind M3 to anything you want.
+If you have the Asus Optimization Service running, it's controlled by that service (therefore G-helper doesn't interfere and doesn't touch this function). Alternatively you can stop that service - and you can bind M3 to anything you want.
 
 #### How do I set different "Visual styles"?
-Personally, i'm not a big fan of them, as they make colors very inaccurate. But if you want so - you can adjust display colors using either Nvidia Control panel or AMD Adrenaline (appropriate display sections). If you really want you can also use [own ASUS utility from MS Store](https://apps.microsoft.com/store/detail/gamevisual/9P4K1LFTXSH8?hl=nl-nl&gl=nl&rtc=1)
+Personally, I'm not a big fan of them, as they make colors very inaccurate. But if you want so - you can adjust display colors using either Nvidia Control panel or AMD Adrenaline (appropriate display sections). If you really want you can also use [own ASUS utility from MS Store](https://apps.microsoft.com/store/detail/gamevisual/9P4K1LFTXSH8?hl=nl-nl&gl=nl&rtc=1)
 
 #### Can I overclock Nvidia GPU core / memory? 
-Make sure that your dGPU is enabled (i.e. it's not in Eco mode). Open Fans + Power section and adjust core / memory clock offsets. They work same as in armoury's manual mode. Please keep in mind that (unfortunately) you need admin permissions for that, and app will ask you for them. (*)
+Make sure that your dGPU is enabled (i.e. it's not in Eco mode). Open Fans + Power section and adjust core / memory clock offsets. They work the same as in armoury's manual mode. Please keep in mind that (unfortunately) you need admin permissions for that, and the app will ask you for them. (*)
 
 #### Windows defender marks app download as malware / virus
-False positives from Windows Defender (or any other similar system that uses machine learning for detection) is possible as application is not digitally signed with a certificate. You can always download a version below or compile app by yourself. All application sources are open and can be monitored from A to Z :)
+False positives from Windows Defender (or any other similar system that uses machine learning for detection) is possible as the application is not digitally signed with a certificate. You can always download a version below or compile the app by yourself. All application sources are open and can be monitored from A to Z :)
 
 #### Where can I find app settings or logs ?
-You can find them under ``%AppData%\GHelper`` folder. Please include them when posting a new bug-report or issue.
+You can find them under the ``%AppData%\GHelper`` folder. Please include them when posting a new bug-report or issue.
 
 #### App refuses to run on startup / runs without icon in tray on startup
-Open app, and uncheck and check again "run on startup". If it still doesn't help (by some reason), you can try to manually edit "GHelper" task in windows Task Scheduler, and add couple of seconds delay to start.
+Open the app, and uncheck and check again "run on startup". If it still doesn't help (for some reason), you can try to manually edit the "GHelper" task in Windows Task Scheduler, and add a couple of seconds delay to start.
 
 #### How do I uninstall G-helper?
-G-helper is a single exe, and it doesn't install anything in the system. To remove it - you can simply delete exe :) If you have applied any custom fan profiles or PPTs - before removing I would recommend selecting your favorite performance mode (for example balanced) and clicking "Factory defaults" under Fans + Power.
+G-helper is a single exe, and it doesn't install anything in the system. To remove it - you can simply delete exe :) If you have applied any custom fan profiles or PPTs - before removing I would recommend selecting your 
+favorite performance mode (for example balanced) and clicking "Factory defaults" under Fans + Power.
+
+#### Can I undervolt my CPU ?
+Currently you can undervolt AMD CPUs. If your model supports that - you will see an undervolting slider under ``Fans+Power -> Advanced``. If you don't see a slider there, it means your CPU doesn't support undervolting. Full list of models that support that [can be found here](https://github.com/seerge/g-helper/discussions/736)
 
 #### I have G14 2023 and my GPU refuses to disable/enable
-It seem to be an issue in older BIOS versions. As [users report](https://github.com/seerge/g-helper/issues/680) - latest BIOS 310 (installable via myasus / g-helper -> updates) resolves all issues :) So please update.
+It seems to be an issue in older BIOS versions. As [users report](https://github.com/seerge/g-helper/issues/680) - latest BIOS 312 (installable via MyASUS or G-Helper -> Updates) resolves all issues :) So please update.
 
-#### I have uninstalled Armoury andmy GPU performance is lower than it was
+#### I have G15 2022 and my GPU refuses to disable/enable or my fans missbehave
+G15 2022 is known to have a notoriously bugged BIOS (last one 313). Multiple users have reported that problems can be solved by rolling back to a [revious BIOS 311 from Asus Support website](https://rog.asus.com/nl/laptops/rog-zephyrus/rog-zephyrus-g15-2022-series/helpdesk_bios/).
+
+#### I have uninstalled Armoury and my GPU performance is lower than it was
 Check your NVidia Experience settings and make sure that you have **Whisper Mode** set to ``OFF``. Also you can go to reset all settings ``Nvidia Control panel -> Manage 3D Settings -> Reset to defaults``
 
 #### How do I do a hardware reset on a laptop?
-All Asus laptops have an option to do a hardware reset that can be handy sometimes. It doesn't touch your data, but resets all main hardware-related things (enables your dGPU, wakes up wifi/bt adapter if it hanged by some reason, etc). Turn OFF laptop. Press and hold "power" button for 30-40 seconds. Then boot normally (it will take a bit longer to boot)
+All Asus laptops have an option to do a hardware reset that can be handy sometimes. It doesn't touch your data, but resets all main hardware-related things (enables your dGPU, wakes up wifi/bt adapter if it hangs for some reason, etc). Turn OFF laptop. Press and hold the "power" button for 30-40 seconds. Then boot normally (it will take a bit longer to boot)
 
 #### What is G-helper ?
 G-Helper is a lightweight Armoury Crate alternative for Asus laptops. A small utility that allows you to do almost everything you could do with Armoury Crate but without extra bloat and unnecessary services.
@@ -159,7 +168,7 @@ G-Helper is a lightweight Armoury Crate alternative for Asus laptops. A small ut
 
 - [Microsoft .NET7](https://dotnet.microsoft.com/en-us/download). Most probably you already have it. Otherwise [download it](https://dotnet.microsoft.com/en-us/download/dotnet/thank-you/sdk-7.0.202-windows-x64-installer) from the official website.
 
-- [Asus System Control Interface v3+](https://dlcdnets.asus.com/pub/ASUS/nb/Image/CustomComponent/ASUSSystemControlInterfaceV3/ASUSSystemControlInterfaceV3.exe). This "driver" from asus should be installed automatically by windows update or along other asus apps. If it's not the case by some reason - you can download and install it manually.
+- [Asus System Control Interface v3+](https://dlcdnets.asus.com/pub/ASUS/nb/Image/CustomComponent/ASUSSystemControlInterfaceV3/ASUSSystemControlInterfaceV3.exe). This "driver" from asus should be installed automatically by windows update or along other asus apps. If it's not the case for some reason - you can download and install it manually.
 
 ### Recommendations (optional)
 
@@ -186,25 +195,25 @@ _GENERAL NOTE: "Power user" settings require some config edits. Before making an
 
 ### Manual app language setting
 
-By default app will use your windows language setting. But you can set language manually (if it supported of course)
+By default the app will use your windows language setting. But you can set language manually (if it supported of course)
 
 Add following line to ``%AppData%\GHelper\config.json`` : ``"language" : "en"`` (by replacing "en" with language of your choice)
 
 ### Custom windows power plans with each mode
 
-In ``%AppData%\GHelper\config.json`` you can manually add custom power plan (or power mode) GUID. It can be either "real" power plan that can be switched or "overlay" power plan like the ones g-helper sets by default.
+In ``%AppData%\GHelper\config.json`` you can manually add a custom power plan (or power mode) GUID. It can be either "real" power plan that can be switched or "overlay" power plan like the ones g-helper sets by default.
 
 Format is following : ``"scheme_<mode>" : "GUID" ``
 Where ``mode = 0 (balanced), 1 (turbo), 2 (silent)``
 
-Default behaviour is :
+Default behavior is :
 ```
 "scheme_0": "00000000-0000-0000-0000-000000000000",
 "scheme_1": "ded574b5-45a0-4f42-8737-46345c09c238",
 "scheme_2": "961cc777-2547-4f9d-8174-7d86181b8a7a",
 ```
 
-Make sure to keep json structure (i.e. not to break it with extra or missing comas, etc) - or app will fail to read it and will just recreate a new config instead.
+Make sure to keep json structure (i.e. not to break it with extra or missing commas, etc) - or the app will fail to read it and will just recreate a new config instead.
 
 ### Custom hotkey actions
 
@@ -213,25 +222,34 @@ App supports custom actions for M3, M4 and FN+F4 hotkeys. To set them select "Cu
 1. To run any custom application - put a full path to exe into "action" text field, for example:
 ``C:\Program Files\EA Games\Battlefield 2042\BF2042.exe``
 
-2. To simulate any windows key - put appropriate keycode into "action" field, for example ``0x2C`` for Print screen. 
+2. To simulate any windows key - put appropriate keycode into the "action" field, for example ``0x2C`` for Print Screen. 
 Full list of keycodes https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
 
-![Screenshot 2023-06-04 232848](https://github.com/seerge/g-helper/assets/5920850/3db6f058-af2b-4220-9ac9-3b812ab09903)
+![Screenshot 2023-07-17 192155](https://github.com/seerge/g-helper/assets/5920850/e450e124-1589-4787-bce8-7c37ffe72fbd)
 
-### Workaround for [bugged bios on G15](https://github.com/seerge/g-helper/issues/253) when external monitor is connected
+### Force Standard mode on shutdown / hibernation
+In some rare cases G14 2023 seem to have issues with enabling / disabling dGPU - i.e. Eco mode. Till we wait for a fix from asus on BIOS level, one of the proposed solutions is to always shutdown the laptop in Standard mode (then everything seems to work fine). To enable "forced" Standard mode on shutdown add following line to ``%AppData%\GHelper\config.json``
+```
+"gpu_fix" : 1,
+```
 
-Some people reported that on G15 model bios can be bugged and either not turn on or not turn off fans, when you set custom fan curve (in Armoury or g-helper, or any other app)
-I have added a very optional workaround as it was asked, on launch app will try to disable and re-enable dGPU when external monitor is connected, that seems to wake up fans :)
+### Disable OSD
+You can disable app's OSD (for performance modes, keyboard backlight, etc) by adding following line to ``%AppData%\GHelper\config.json``
+```
+"disable_osd": 1,
+```
 
-To enable this custom workaround you need to add an extra line in config.json (under ``%AppData%\GHelper``) 
-``gpu_reenable : 1,``
+### Extra Keybindings 
+- ``Ctrl + Shift + F5`` - Toggle Performance Modes
+- ``Ctrl + Shift + F12`` - Open G-Helper window 
+- ``Ctrl + M1 / M2`` - Screen brightness Down / Up
+- ``Shift + M1 / M2`` - Backlight brightness Down / Up
+
+If you don't want this bindings to work you can add ``"skip_hotkeys":1,`` to ``%AppData%\GHelper\config.json``
 
 ### Keybinding to toggle performance modes (on external keyboards)
 
-By default app will toggle performance modes with Ctr+Shift+F5. You can change this binding by adding ``"keybind_profile": 116`` in config.json (under ``%AppData%\GHelper``), where 116 is [numerical code for desired key](https://www.oreilly.com/library/view/javascript-dhtml/9780596514082/apb.html). Put 0 to completely disable this binding.
-
-### Keybinding to open G-helper from external keyboards
-Ctrl + Shift + F12
+By default the app will toggle performance modes with Ctr+Shift+F5. You can change this binding by adding ``"keybind_profile": 116`` in config.json (under ``%AppData%\GHelper``), where 116 is [numerical code for desired key](https://www.oreilly.com/library/view/javascript-dhtml/9780596514082/apb.html). Put 0 to completely disable this binding.
 
 ------------
 
@@ -245,3 +263,5 @@ Ctrl + Shift + F12
 "ROG", "TUF", and "Armoury Crate" are trademarked by and belong to AsusTek Computer, Inc. I make no claims to these or any assets belonging to AsusTek Computer and use them purely for informational purposes only.
 
 THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. MISUSE OF THIS SOFTWARE COULD CAUSE SYSTEM INSTABILITY OR MALFUNCTION.
+
+