add Enable/Disable checkbox for rgb.net devices

Aytackydln · Aytackydln · commit bdd1aaa0ff05 · 2025-12-09T20:37:05.000+01:00
diff --git a/Project-Aurora/AuroraCommon/Devices/DeviceCommands.cs b/Project-Aurora/AuroraCommon/Devices/DeviceCommands.cs
@@ -5,12 +5,14 @@ public static class DeviceCommands
     public const string Quit = "quit";
     public const string Enable = "enable";
     public const string Disable = "disable";
+    public const string EnableDevice = "enableDevice";
+    public const string DisableDevice = "disableDevice";
     public const string Blink = "blink";
     public const string Remap = "remap";
     public const string Unmap = "unmap";
     public const string Share = "share";
     public const string Recalibrate = "recalibrate";
-    
+
     // Aurora Interface
     public const string RemappableDevices = "remappableDevices";
 }
diff --git a/Project-Aurora/AuroraCommon/Devices/DeviceConfig.cs b/Project-Aurora/AuroraCommon/Devices/DeviceConfig.cs
@@ -4,7 +4,7 @@
 
 namespace Common.Devices;
 
-public sealed class DeviceConfig : INotifyPropertyChanged, IAuroraConfig
+public sealed partial class DeviceConfig : INotifyPropertyChanged, IAuroraConfig
 {
     public const string FileName = "DeviceConfig.json";
 
@@ -32,11 +32,19 @@ public sealed class DeviceConfig : INotifyPropertyChanged, IAuroraConfig
     
     public bool DangerousOpenRgbNonDirectEnable { get; set; }
 
-    private ObservableCollection<string>? _enabledDevices;
-    public ObservableCollection<string> EnabledDevices
+    private ObservableCollection<string>? _enabledControllers;
+    [JsonPropertyName("EnabledDevices")]
+    public ObservableCollection<string> EnabledControllers
     {
-        get => _enabledDevices ??= new ObservableCollection<string>(DefaultEnabledDevices);
-        set => _enabledDevices = value;
+        get => _enabledControllers ??= new ObservableCollection<string>(DefaultEnabledControllers);
+        set => _enabledControllers = value;
+    }
+
+    private ObservableCollection<string>? _disabledControllerDevices;
+    public ObservableCollection<string> DisabledControllerDevices
+    {
+        get => _disabledControllerDevices ??= [];
+        set => _disabledControllerDevices = value;
     }
 
     private static readonly Dictionary<string,string> Migrations = new()
@@ -74,7 +82,7 @@ public ObservableCollection<string> EnabledDevices
         {"Wooting", "Wooting (RGB.NET)"},
     };
 
-    private static HashSet<string> DefaultEnabledDevices =>
+    private static HashSet<string> DefaultEnabledControllers =>
     [
         "Corsair (RGB.NET)",
         "Logitech (RGB.NET)",
@@ -85,32 +93,32 @@ public ObservableCollection<string> EnabledDevices
 
     public void OnPostLoad()
     {
-        _enabledDevices ??= new ObservableCollection<string>(DefaultEnabledDevices);
+        _enabledControllers ??= new ObservableCollection<string>(DefaultEnabledControllers);
 
         MigrateDevices();
 
         PrioritizeDevice("Logitech (RGB.NET)", "Logitech");
 
-        EnabledDevices.CollectionChanged += (_, _) =>
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EnabledDevices)));
+        EnabledControllers.CollectionChanged += (_, _) =>
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EnabledControllers)));
     }
 
     private void MigrateDevices()
     {
-        foreach (var loadedDeviceString in EnabledDevices.ToArray())
+        foreach (var loadedDeviceString in EnabledControllers.ToArray())
         {
             var typeName = loadedDeviceString.Split(",")[0];
             if (!Migrations.TryGetValue(typeName, out var migratedValue)) continue;
-            EnabledDevices.Remove(loadedDeviceString);
-            EnabledDevices.Add(migratedValue);
+            EnabledControllers.Remove(loadedDeviceString);
+            EnabledControllers.Add(migratedValue);
         }
     }
 
     private void PrioritizeDevice(string primary, string secondary)
     {
-        if (EnabledDevices.Contains(primary))
+        if (EnabledControllers.Contains(primary))
         {
-            EnabledDevices.Remove(secondary);
+            EnabledControllers.Remove(secondary);
         }
     }
 }
diff --git a/Project-Aurora/AuroraCommon/Devices/RGBNet/RemappableDevice.cs b/Project-Aurora/AuroraCommon/Devices/RGBNet/RemappableDevice.cs
@@ -4,8 +4,10 @@
 namespace Common.Devices.RGBNet;
 
 [method: JsonConstructor]
-public class RemappableDevice(string deviceId, string deviceSummary, List<LedId> rgbNetLeds, SimpleColor calibration, bool remapEnabled)
+public class RemappableDevice(bool isEnabled, string deviceId, string deviceSummary, List<LedId> rgbNetLeds, SimpleColor calibration, bool remapEnabled)
 {
+    public bool IsEnabled { get; } = isEnabled;
+
     public string DeviceId { get; } = deviceId;
     public string DeviceSummary { get; } = deviceSummary;
 
diff --git a/Project-Aurora/AuroraDeviceManager/AuroraPipe.cs b/Project-Aurora/AuroraDeviceManager/AuroraPipe.cs
@@ -75,6 +75,18 @@ async void ReceiveCommand(IAsyncResult ar)
                     await _deviceManager.Disable(deviceController);
                     break;
                 }
+                case DeviceCommands.EnableDevice:
+                {
+                    var deviceId = splits.Next();
+                    await _deviceManager.EnableDevice(deviceId);
+                    break;
+                }
+                case DeviceCommands.DisableDevice:
+                {
+                    var deviceId = splits.Next();
+                    await _deviceManager.DisableDevice(deviceId);
+                    break;
+                }
                 case DeviceCommands.Blink:
                 {
                     var deviceId = splits.Next();
diff --git a/Project-Aurora/AuroraDeviceManager/ConfigManager.cs b/Project-Aurora/AuroraDeviceManager/ConfigManager.cs
@@ -100,7 +100,7 @@ private async Task<DeviceConfig> CreateDefaultConfigurationFile()
 
         var migratedConfig = new DeviceConfig
         {
-            EnabledDevices = new ObservableCollection<string>(auroraConfig.EnabledDevices.Values),
+            EnabledControllers = new ObservableCollection<string>(auroraConfig.EnabledDevices.Values),
             DeviceCalibrations = new Dictionary<string, SimpleColor>(auroraConfig.DeviceCalibrations.Values),
             AllowPeripheralDevices = auroraConfig.AllowPeripheralDevices,
             DevicesDisableHeadset = auroraConfig.DevicesDisableHeadset,
@@ -116,6 +116,11 @@ private async Task<DeviceConfig> CreateDefaultConfigurationFile()
         return migratedConfig;
     }
 
+    public static Task SaveDeviceConfig()
+    {
+        return Save(Global.DeviceConfig, DeviceConfig.ConfigFile);
+    }
+
     private static Task Save(object configuration, string path)
     {
         var content = JsonSerializer.Serialize(configuration, JsonSerializerOptions);
diff --git a/Project-Aurora/AuroraDeviceManager/Devices/DeviceManager.cs b/Project-Aurora/AuroraDeviceManager/Devices/DeviceManager.cs
@@ -226,10 +226,12 @@ public async Task ShareRemappableDevices()
         var remappableDevices = (
             from rgbNetController in rgbNetControllers
             from device in rgbNetController.DeviceList
-            let calibration = Global.DeviceConfig.DeviceCalibrations.GetValueOrDefault(device.DeviceInfo.DeviceName, SimpleColor.White)
-            let deviceSummary = $"{rgbNetController.DeviceName}: [{device.DeviceInfo.DeviceType}] {device.DeviceInfo.DeviceName}"
+            let deviceId = device.DeviceInfo.DeviceName
+            let isEnabled = !Global.DeviceConfig.DisabledControllerDevices.Contains(deviceId)
+            let calibration = Global.DeviceConfig.DeviceCalibrations.GetValueOrDefault(deviceId, SimpleColor.White)
+            let deviceSummary = $"{rgbNetController.DeviceName}: [{device.DeviceInfo.DeviceType}] {deviceId}"
             let rgbNetLeds = device.Select(l => l.Id).ToList()
-            select new RemappableDevice(device.DeviceInfo.DeviceName, deviceSummary, rgbNetLeds, calibration, !rgbNetController.NeedsLayout())
+            select new RemappableDevice(isEnabled, deviceId, deviceSummary, rgbNetLeds, calibration, !rgbNetController.NeedsLayout())
         ).ToList();
 
         var currentDevices = new CurrentDevices(remappableDevices);
@@ -299,14 +301,18 @@ public async Task Disable(string deviceController)
         await DeviceContainers.First(dc => dc.Device.DeviceName == deviceController).Disable();
     }
 
-    public async Task EnableDevice(string deviceController, string deviceId)
+    public async Task EnableDevice(string deviceId)
     {
-        await DeviceContainers.First(dc => dc.Device.DeviceName == deviceController).EnableDevice(deviceId);
+        Global.DeviceConfig.DisabledControllerDevices.Remove(deviceId);
+        await ShareRemappableDevices();
+        await ConfigManager.SaveDeviceConfig();
     }
 
-    public async Task DisableDevice(string deviceController, string deviceId)
+    public async Task DisableDevice(string deviceId)
     {
-        await DeviceContainers.First(dc => dc.Device.DeviceName == deviceController).DisableDevice(deviceId);
+        Global.DeviceConfig.DisabledControllerDevices.Add(deviceId);
+        await ShareRemappableDevices();
+        await ConfigManager.SaveDeviceConfig();
     }
 
     private readonly byte[] _end = "\n"u8.ToArray();
diff --git a/Project-Aurora/AuroraDeviceManager/Devices/RGBNet/RgbNetDevice.cs b/Project-Aurora/AuroraDeviceManager/Devices/RGBNet/RgbNetDevice.cs
@@ -118,6 +118,7 @@ protected override async Task<bool> DoInitialize(CancellationToken cancellationT
                 }
                 catch (TaskCanceledException)
                 {
+                    ErrorMessage = null;
                     return false;
                 }
             }
@@ -222,6 +223,7 @@ protected override Task Shutdown()
         Provider.DevicesChanged -= ProviderOnDevicesChanged;
 
         IsInitialized = false;
+        ErrorMessage = null;
         return Task.CompletedTask;
     }
 
@@ -261,6 +263,10 @@ protected override Task<bool> UpdateDevice(Dictionary<DeviceKeys, SimpleColor> k
         {
             foreach (var device in DeviceList)
             {
+                if (Global.DeviceConfig.DisabledControllerDevices.Contains(device.DeviceInfo.DeviceName))
+                {
+                    continue;
+                }
                 _updater.UpdateDevice(keyColors, device);
             }
         }
diff --git a/Project-Aurora/Project-Aurora/Controls/Control_DeviceItem.xaml.cs b/Project-Aurora/Project-Aurora/Controls/Control_DeviceItem.xaml.cs
@@ -75,10 +75,10 @@ private void btnToggleOnOff_Click(object? sender, EventArgs e)
 
     private void btnToggleEnableDisable_Click(object? sender, EventArgs e)
     {
-        var deviceEnabled = !_deviceConfigs.EnabledDevices.Contains(_device.Device.DeviceName);
+        var deviceEnabled = !_deviceConfigs.EnabledControllers.Contains(_device.Device.DeviceName);
         if (deviceEnabled)
         {
-            _deviceConfigs.EnabledDevices.Add(_device.Device.DeviceName);
+            _deviceConfigs.EnabledControllers.Add(_device.Device.DeviceName);
             var device = _device;
             Task.Run(async () =>
             {
@@ -87,7 +87,7 @@ private void btnToggleEnableDisable_Click(object? sender, EventArgs e)
         }
         else
         {
-            _deviceConfigs.EnabledDevices.Remove(_device.Device.DeviceName);
+            _deviceConfigs.EnabledControllers.Remove(_device.Device.DeviceName);
         }
         UpdateDynamic();
 
@@ -206,7 +206,7 @@ private void UpdateDynamic()
         DeviceDetails.Text = _device.Device.DeviceDetails;
         DevicePerformance.Text = _device.Device.DeviceUpdatePerformance;
 
-        if (!_deviceConfigs.EnabledDevices.Contains(_device.Device.DeviceName))
+        if (!_deviceConfigs.EnabledControllers.Contains(_device.Device.DeviceName))
         {
             BtnEnable.Content = "Enable";
             BtnStart.IsEnabled = false;
diff --git a/Project-Aurora/Project-Aurora/Devices/DeviceContainer.cs b/Project-Aurora/Project-Aurora/Devices/DeviceContainer.cs
@@ -9,12 +9,12 @@ public sealed class DeviceContainer(MemorySharedDevice device, DeviceManager dev
 
     public async Task EnableDevice()
     {
-        await deviceManager.DevicesPipe.EnableDevice(Device.DeviceName);
+        await deviceManager.DevicesPipe.EnableController(Device.DeviceName);
     }
 
     public async Task DisableDevice()
     {
-        await deviceManager.DevicesPipe.DisableDevice(Device.DeviceName);
+        await deviceManager.DevicesPipe.DisableController(Device.DeviceName);
     }
 
     public void Dispose()
diff --git a/Project-Aurora/Project-Aurora/Devices/DevicesPipe.cs b/Project-Aurora/Project-Aurora/Devices/DevicesPipe.cs
@@ -57,19 +57,31 @@ public async Task RemapKey(string deviceId, LedId led, DeviceKeys? newKey)
 
     public async Task RequestRemappableDevices()
     {
-        await SendCommand( DeviceCommands.Share);
+        await SendCommand(DeviceCommands.Share);
     }
 
-    public async Task EnableDevice(string deviceDeviceName)
+    public async Task EnableController(string controllerName)
     {
-        var command = DeviceCommands.Enable + Constants.StringSplit + deviceDeviceName;
-        await SendCommand( command);
+        var command = DeviceCommands.Enable + Constants.StringSplit + controllerName;
+        await SendCommand(command);
     }
 
-    public async Task DisableDevice(string deviceDeviceName)
+    public async Task DisableController(string controllerName)
     {
-        var command = DeviceCommands.Disable + Constants.StringSplit + deviceDeviceName;
-        await SendCommand( command);
+        var command = DeviceCommands.Disable + Constants.StringSplit + controllerName;
+        await SendCommand(command);
+    }
+    
+    public async Task EnableDevice(string deviceName)
+    {
+        var command = DeviceCommands.EnableDevice + Constants.StringSplit + deviceName;
+        await SendCommand(command);
+    }
+    
+    public async Task DisableDevice(string deviceName)
+    {
+        var command = DeviceCommands.DisableDevice + Constants.StringSplit + deviceName;
+        await SendCommand(command);
     }
 
     public async Task Recalibrate(string deviceName, SimpleColor color)
diff --git a/Project-Aurora/Project-Aurora/Devices/RGBNet/Config/DeviceMapping.xaml b/Project-Aurora/Project-Aurora/Devices/RGBNet/Config/DeviceMapping.xaml
@@ -35,9 +35,10 @@
                     VerticalAlignment="Stretch"
                     Height="auto">
                     <StackPanel Orientation="Vertical">
+                        <CheckBox Name="DeviceEnabledChckBox">Enabled</CheckBox>
                         <StackPanel Orientation="Horizontal" > 
-                            <Button Name="SetAllNoneBtn" Content="Set All None" DockPanel.Dock="Top" Click="SetAllNone_Click" ToolTip="Set all of the lights to NONE"/>
-                            <Button Name="SetAllLogoBtn" Content="Set All Logo" DockPanel.Dock="Top" Click="SetAllLogo_Click" ToolTip="Set all of the lights to PERIPHERAL_LOGO"/>
+                            <Button Margin="8 4" Name="SetAllNoneBtn" Content="Set All None" DockPanel.Dock="Top" Click="SetAllNone_Click" ToolTip="Set all of the lights to NONE"/>
+                            <Button Margin="8 4" Name="SetAllLogoBtn" Content="Set All Logo" DockPanel.Dock="Top" Click="SetAllLogo_Click" ToolTip="Set all of the lights to PERIPHERAL_LOGO"/>
                         </StackPanel>
                         <Separator DockPanel.Dock="Top" Height="10"/>
                         <TextBlock Name="NotRemappableTextBlock" Visibility="Collapsed" Foreground="Red">This device cannot be remapped. You need to choose a correct layout.</TextBlock>
diff --git a/Project-Aurora/Project-Aurora/Devices/RGBNet/Config/DeviceMapping.xaml.cs b/Project-Aurora/Project-Aurora/Devices/RGBNet/Config/DeviceMapping.xaml.cs
@@ -24,6 +24,8 @@ public partial class DeviceMapping
 
     private readonly Lazy<DeviceMappingConfig> _config = new(() => DeviceMappingConfig.Config);
 
+    private RemappableDevice? _remappableDevice;
+
     public DeviceMapping(Task<DeviceManager> deviceManager, Task<IpcListener?> ipcListener)
     {
         _deviceManager = deviceManager;
@@ -80,6 +82,7 @@ private async void OnUnloaded(object? sender, EventArgs e)
 
     private async Task ReloadDevices()
     {
+        _remappableDevice = null;
         var deviceManager = await _deviceManager;
 
         if (!await deviceManager.IsDeviceManagerUp())
@@ -110,7 +113,7 @@ private void LoadDevices(CurrentDevices remappableDevices)
                 // create a new button for the ui
                 var button = new Button
                 {
-                    Content = device.DeviceSummary
+                    Content = device.DeviceSummary + (device.IsEnabled ? "" : " (Disabled)"),
                 };
 
                 button.Click += async (_, _) =>
@@ -137,11 +140,17 @@ private static CurrentDevices ReadDevices(string json)
 
     private async Task DeviceSelect(RemappableDevice remappableDevice)
     {
+        DeviceEnabledChckBox.Click -= DeviceEnabledChckBox_OnClicked;
         // Rebuild the key area
         RemappableDeviceKeys.Children.Clear();
         NotRemappableTextBlock.Visibility = remappableDevice.RemapEnabled ? Visibility.Collapsed : Visibility.Visible;
         SetAllNoneBtn.IsEnabled = remappableDevice.RemapEnabled;
         SetAllLogoBtn.IsEnabled = remappableDevice.RemapEnabled;
+        DeviceEnabledChckBox.IsChecked = remappableDevice.IsEnabled;
+
+        _remappableDevice = remappableDevice;
+
+        DeviceEnabledChckBox.Click += DeviceEnabledChckBox_OnClicked;
 
         await Task.Run(async () =>
         {
@@ -249,4 +258,23 @@ private void SetAllLogo_Click(object? sender, RoutedEventArgs e)
     }
 
     #endregion
+
+    private async void DeviceEnabledChckBox_OnClicked(object sender, RoutedEventArgs e)
+    {
+        if (_remappableDevice == null)
+        {
+            return;
+        }
+ 
+        var isEnabled = DeviceEnabledChckBox.IsChecked ?? false;
+        var deviceManager = await _deviceManager;
+        if (isEnabled)
+        {
+            await deviceManager.DevicesPipe.EnableDevice(_remappableDevice.DeviceId);
+        }
+        else
+        {
+            await deviceManager.DevicesPipe.DisableDevice(_remappableDevice.DeviceId);
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace Common.Devices;`
`6`	`6`
`7`		`-public sealed class DeviceConfig : INotifyPropertyChanged, IAuroraConfig`
	`7`	`+public sealed partial class DeviceConfig : INotifyPropertyChanged, IAuroraConfig`
`8`	`8`	`{`
`9`	`9`	`public const string FileName = "DeviceConfig.json";`
`10`	`10`
`@@ -32,11 +32,19 @@ public sealed class DeviceConfig : INotifyPropertyChanged, IAuroraConfig`
`32`	`32`
`33`	`33`	`public bool DangerousOpenRgbNonDirectEnable { get; set; }`
`34`	`34`
`35`		`- private ObservableCollection<string>? _enabledDevices;`
`36`		`- public ObservableCollection<string> EnabledDevices`
	`35`	`+ private ObservableCollection<string>? _enabledControllers;`
	`36`	`+ [JsonPropertyName("EnabledDevices")]`
	`37`	`+ public ObservableCollection<string> EnabledControllers`
`37`	`38`	`{`
`38`		`- get => _enabledDevices ??= new ObservableCollection<string>(DefaultEnabledDevices);`
`39`		`- set => _enabledDevices = value;`
	`39`	`+ get => _enabledControllers ??= new ObservableCollection<string>(DefaultEnabledControllers);`
	`40`	`+ set => _enabledControllers = value;`
	`41`	`+ }`
	`42`	`+`
	`43`	`+ private ObservableCollection<string>? _disabledControllerDevices;`
	`44`	`+ public ObservableCollection<string> DisabledControllerDevices`
	`45`	`+ {`
	`46`	`+ get => _disabledControllerDevices ??= [];`
	`47`	`+ set => _disabledControllerDevices = value;`
`40`	`48`	`}`
`41`	`49`
`42`	`50`	`private static readonly Dictionary<string,string> Migrations = new()`
`@@ -74,7 +82,7 @@ public ObservableCollection<string> EnabledDevices`
`74`	`82`	`{"Wooting", "Wooting (RGB.NET)"},`
`75`	`83`	`};`
`76`	`84`
`77`		`- private static HashSet<string> DefaultEnabledDevices =>`
	`85`	`+ private static HashSet<string> DefaultEnabledControllers =>`
`78`	`86`	`[`
`79`	`87`	`"Corsair (RGB.NET)",`
`80`	`88`	`"Logitech (RGB.NET)",`
`@@ -85,32 +93,32 @@ public ObservableCollection<string> EnabledDevices`
`85`	`93`
`86`	`94`	`public void OnPostLoad()`
`87`	`95`	`{`
`88`		`- _enabledDevices ??= new ObservableCollection<string>(DefaultEnabledDevices);`
	`96`	`+ _enabledControllers ??= new ObservableCollection<string>(DefaultEnabledControllers);`
`89`	`97`
`90`	`98`	`MigrateDevices();`
`91`	`99`
`92`	`100`	`PrioritizeDevice("Logitech (RGB.NET)", "Logitech");`
`93`	`101`
`94`		`- EnabledDevices.CollectionChanged += (_, _) =>`
`95`		`- PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EnabledDevices)));`
	`102`	`+ EnabledControllers.CollectionChanged += (_, _) =>`
	`103`	`+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EnabledControllers)));`
`96`	`104`	`}`
`97`	`105`
`98`	`106`	`private void MigrateDevices()`
`99`	`107`	`{`
`100`		`- foreach (var loadedDeviceString in EnabledDevices.ToArray())`
	`108`	`+ foreach (var loadedDeviceString in EnabledControllers.ToArray())`
`101`	`109`	`{`
`102`	`110`	`var typeName = loadedDeviceString.Split(",")[0];`
`103`	`111`	`if (!Migrations.TryGetValue(typeName, out var migratedValue)) continue;`
`104`		`- EnabledDevices.Remove(loadedDeviceString);`
`105`		`- EnabledDevices.Add(migratedValue);`
	`112`	`+ EnabledControllers.Remove(loadedDeviceString);`
	`113`	`+ EnabledControllers.Add(migratedValue);`
`106`	`114`	`}`
`107`	`115`	`}`
`108`	`116`
`109`	`117`	`private void PrioritizeDevice(string primary, string secondary)`
`110`	`118`	`{`
`111`		`- if (EnabledDevices.Contains(primary))`
	`119`	`+ if (EnabledControllers.Contains(primary))`
`112`	`120`	`{`
`113`		`- EnabledDevices.Remove(secondary);`
	`121`	`+ EnabledControllers.Remove(secondary);`
`114`	`122`	`}`
`115`	`123`	`}`
`116`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ private async Task<DeviceConfig> CreateDefaultConfigurationFile()`
`100`	`100`
`101`	`101`	`var migratedConfig = new DeviceConfig`
`102`	`102`	`{`
`103`		`- EnabledDevices = new ObservableCollection<string>(auroraConfig.EnabledDevices.Values),`
	`103`	`+ EnabledControllers = new ObservableCollection<string>(auroraConfig.EnabledDevices.Values),`
`104`	`104`	`DeviceCalibrations = new Dictionary<string, SimpleColor>(auroraConfig.DeviceCalibrations.Values),`
`105`	`105`	`AllowPeripheralDevices = auroraConfig.AllowPeripheralDevices,`
`106`	`106`	`DevicesDisableHeadset = auroraConfig.DevicesDisableHeadset,`
`@@ -116,6 +116,11 @@ private async Task<DeviceConfig> CreateDefaultConfigurationFile()`
`116`	`116`	`return migratedConfig;`
`117`	`117`	`}`
`118`	`118`
	`119`	`+ public static Task SaveDeviceConfig()`
	`120`	`+ {`
	`121`	`+ return Save(Global.DeviceConfig, DeviceConfig.ConfigFile);`
	`122`	`+ }`
	`123`	`+`
`119`	`124`	`private static Task Save(object configuration, string path)`
`120`	`125`	`{`
`121`	`126`	`var content = JsonSerializer.Serialize(configuration, JsonSerializerOptions);`
Original file line number	Diff line number	Diff line change
`@@ -118,6 +118,7 @@ protected override async Task<bool> DoInitialize(CancellationToken cancellationT`
`118`	`118`	`}`
`119`	`119`	`catch (TaskCanceledException)`
`120`	`120`	`{`
	`121`	`+ ErrorMessage = null;`
`121`	`122`	`return false;`
`122`	`123`	`}`
`123`	`124`	`}`
`@@ -222,6 +223,7 @@ protected override Task Shutdown()`
`222`	`223`	`Provider.DevicesChanged -= ProviderOnDevicesChanged;`
`223`	`224`
`224`	`225`	`IsInitialized = false;`
	`226`	`+ ErrorMessage = null;`
`225`	`227`	`return Task.CompletedTask;`
`226`	`228`	`}`
`227`	`229`
`@@ -261,6 +263,10 @@ protected override Task<bool> UpdateDevice(Dictionary<DeviceKeys, SimpleColor> k`
`261`	`263`	`{`
`262`	`264`	`foreach (var device in DeviceList)`
`263`	`265`	`{`
	`266`	`+ if (Global.DeviceConfig.DisabledControllerDevices.Contains(device.DeviceInfo.DeviceName))`
	`267`	`+ {`
	`268`	`+ continue;`
	`269`	`+ }`
`264`	`270`	`_updater.UpdateDevice(keyColors, device);`
`265`	`271`	`}`
`266`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,10 +75,10 @@ private void btnToggleOnOff_Click(object? sender, EventArgs e)`
`75`	`75`
`76`	`76`	`private void btnToggleEnableDisable_Click(object? sender, EventArgs e)`
`77`	`77`	`{`
`78`		`- var deviceEnabled = !_deviceConfigs.EnabledDevices.Contains(_device.Device.DeviceName);`
	`78`	`+ var deviceEnabled = !_deviceConfigs.EnabledControllers.Contains(_device.Device.DeviceName);`
`79`	`79`	`if (deviceEnabled)`
`80`	`80`	`{`
`81`		`- _deviceConfigs.EnabledDevices.Add(_device.Device.DeviceName);`
	`81`	`+ _deviceConfigs.EnabledControllers.Add(_device.Device.DeviceName);`
`82`	`82`	`var device = _device;`
`83`	`83`	`Task.Run(async () =>`
`84`	`84`	`{`
`@@ -87,7 +87,7 @@ private void btnToggleEnableDisable_Click(object? sender, EventArgs e)`
`87`	`87`	`}`
`88`	`88`	`else`
`89`	`89`	`{`
`90`		`- _deviceConfigs.EnabledDevices.Remove(_device.Device.DeviceName);`
	`90`	`+ _deviceConfigs.EnabledControllers.Remove(_device.Device.DeviceName);`
`91`	`91`	`}`
`92`	`92`	`UpdateDynamic();`
`93`	`93`
`@@ -206,7 +206,7 @@ private void UpdateDynamic()`
`206`	`206`	`DeviceDetails.Text = _device.Device.DeviceDetails;`
`207`	`207`	`DevicePerformance.Text = _device.Device.DeviceUpdatePerformance;`
`208`	`208`
`209`		`- if (!_deviceConfigs.EnabledDevices.Contains(_device.Device.DeviceName))`
	`209`	`+ if (!_deviceConfigs.EnabledControllers.Contains(_device.Device.DeviceName))`
`210`	`210`	`{`
`211`	`211`	`BtnEnable.Content = "Enable";`
`212`	`212`	`BtnStart.IsEnabled = false;`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,12 @@ public sealed class DeviceContainer(MemorySharedDevice device, DeviceManager dev`
`9`	`9`
`10`	`10`	`public async Task EnableDevice()`
`11`	`11`	`{`
`12`		`- await deviceManager.DevicesPipe.EnableDevice(Device.DeviceName);`
	`12`	`+ await deviceManager.DevicesPipe.EnableController(Device.DeviceName);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`public async Task DisableDevice()`
`16`	`16`	`{`
`17`		`- await deviceManager.DevicesPipe.DisableDevice(Device.DeviceName);`
	`17`	`+ await deviceManager.DevicesPipe.DisableController(Device.DeviceName);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public void Dispose()`