Core - Split up RGBService into RenderService and DeviceService

Core - Removed rendering from CoreService
Core - Store and restore original device LEDs when applying/clearing layouts

src/Artemis.UI/Screens/Debugger/Tabs/Performance/PerformanceDebugViewModel.cs

@@ -14,7 +14,7 @@ namespace Artemis.UI.Screens.Debugger.Performance;
 
 public class PerformanceDebugViewModel : ActivatableViewModelBase
 {
-    private readonly ICoreService _coreService;
+    private readonly IRenderService _renderService;
     private readonly IPluginManagementService _pluginManagementService;
     private readonly DispatcherTimer _updateTimer;
     private double _currentFps;
@@ -22,9 +22,9 @@ public class PerformanceDebugViewModel : ActivatableViewModelBase
     private int _renderHeight;
     private int _renderWidth;
 
-    public PerformanceDebugViewModel(ICoreService coreService, IPluginManagementService pluginManagementService)
+    public PerformanceDebugViewModel(IRenderService renderService, IPluginManagementService pluginManagementService)
     {
-        _coreService = coreService;
+        _renderService = renderService;
         _pluginManagementService = pluginManagementService;
         _updateTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(500), DispatcherPriority.Background, (_, _) => Update());
 
@@ -87,12 +87,12 @@ public class PerformanceDebugViewModel : ActivatableViewModelBase
     private void HandleActivation()
     {
         Renderer = Constants.ManagedGraphicsContext != null ? Constants.ManagedGraphicsContext.GetType().Name : "Software";
-        _coreService.FrameRendered += CoreServiceOnFrameRendered;
+        _renderService.FrameRendered += RenderServiceOnFrameRendered;
     }
 
     private void HandleDeactivation()
     {
-        _coreService.FrameRendered -= CoreServiceOnFrameRendered;
+        _renderService.FrameRendered -= RenderServiceOnFrameRendered;
     }
 
     private void PopulateItems()
@@ -116,9 +116,9 @@ public class PerformanceDebugViewModel : ActivatableViewModelBase
             viewModel.Update();
     }
 
-    private void CoreServiceOnFrameRendered(object? sender, FrameRenderedEventArgs e)
+    private void RenderServiceOnFrameRendered(object? sender, FrameRenderedEventArgs e)
     {
-        CurrentFps = _coreService.FrameRate;
+        CurrentFps = _renderService.FrameRate;
         SKImageInfo bitmapInfo = e.Texture.ImageInfo;
 
         RenderHeight = bitmapInfo.Height;

src/Artemis.UI/Screens/Debugger/Tabs/Render/RenderDebugViewModel.cs

@@ -11,7 +11,7 @@ namespace Artemis.UI.Screens.Debugger.Render;
 
 public class RenderDebugViewModel : ActivatableViewModelBase
 {
-    private readonly ICoreService _coreService;
+    private readonly IRenderService _renderService;
     private double _currentFps;
 
     private Bitmap? _currentFrame;
@@ -20,9 +20,9 @@ public class RenderDebugViewModel : ActivatableViewModelBase
     private int _renderHeight;
     private int _renderWidth;
 
-    public RenderDebugViewModel(ICoreService coreService)
+    public RenderDebugViewModel(IRenderService renderService)
     {
-        _coreService = coreService;
+        _renderService = renderService;
 
         DisplayName = "Rendering";
 
@@ -66,17 +66,17 @@ public class RenderDebugViewModel : ActivatableViewModelBase
     private void HandleActivation()
     {
         Renderer = Constants.ManagedGraphicsContext != null ? Constants.ManagedGraphicsContext.GetType().Name : "Software";
-        _coreService.FrameRendered += CoreServiceOnFrameRendered;
+        _renderService.FrameRendered += RenderServiceOnFrameRendered;
     }
 
     private void HandleDeactivation()
     {
-        _coreService.FrameRendered -= CoreServiceOnFrameRendered;
+        _renderService.FrameRendered -= RenderServiceOnFrameRendered;
     }
 
-    private void CoreServiceOnFrameRendered(object? sender, FrameRenderedEventArgs e)
+    private void RenderServiceOnFrameRendered(object? sender, FrameRenderedEventArgs e)
     {
-        CurrentFps = _coreService.FrameRate;
+        CurrentFps = _renderService.FrameRate;
         using SKImage skImage = e.Texture.Surface.Snapshot();
         SKImageInfo bitmapInfo = e.Texture.ImageInfo;
 

src/Artemis.UI/Screens/Device/DeviceDetectInputViewModel.cs

@@ -17,20 +17,16 @@ namespace Artemis.UI.Screens.Device;
 public class DeviceDetectInputViewModel : ContentDialogViewModelBase
 {
     private readonly IInputService _inputService;
-    private readonly ListLedGroup _ledGroup;
     private readonly INotificationService _notificationService;
-    private readonly IRgbService _rgbService;
 
-    public DeviceDetectInputViewModel(ArtemisDevice device, IInputService inputService, INotificationService notificationService, IRgbService rgbService)
+    public DeviceDetectInputViewModel(ArtemisDevice device, IInputService inputService, INotificationService notificationService, IRenderService renderService)
     {
         _inputService = inputService;
         _notificationService = notificationService;
-        _rgbService = rgbService;
-
         Device = device;
 
         // Create a LED group way at the top
-        _ledGroup = new ListLedGroup(_rgbService.Surface, Device.Leds.Select(l => l.RgbLed))
+        ListLedGroup ledGroup = new(renderService.Surface, Device.Leds.Select(l => l.RgbLed))
         {
             Brush = new SolidColorBrush(new Color(255, 255, 0)),
             ZIndex = 999
@@ -46,7 +42,7 @@ public class DeviceDetectInputViewModel : ContentDialogViewModelBase
             Disposable.Create(() =>
             {
                 _inputService.StopIdentify();
-                _ledGroup.Detach();
+                ledGroup.Detach();
             }).DisposeWith(disposables);
         });
     }

src/Artemis.UI/Screens/Device/DevicePropertiesViewModel.cs

@@ -17,7 +17,7 @@ public class DevicePropertiesViewModel : DialogViewModelBase<object>
     private readonly IDeviceVmFactory _deviceVmFactory;
     private ArtemisDevice _device;
 
-    public DevicePropertiesViewModel(ArtemisDevice device, ICoreService coreService, IRgbService rgbService, IDeviceVmFactory deviceVmFactory)
+    public DevicePropertiesViewModel(ArtemisDevice device, IRenderService renderService, IDeviceService deviceService, IDeviceVmFactory deviceVmFactory)
     {
         _deviceVmFactory = deviceVmFactory;
         _device = device;
@@ -28,10 +28,15 @@ public class DevicePropertiesViewModel : DialogViewModelBase<object>
         AddTabs();
         this.WhenActivated(d =>
         {
-            rgbService.DeviceAdded += RgbServiceOnDeviceAdded;
-            rgbService.DeviceRemoved += RgbServiceOnDeviceRemoved;
-            coreService.FrameRendering += CoreServiceOnFrameRendering;
-            Disposable.Create(() => coreService.FrameRendering -= CoreServiceOnFrameRendering).DisposeWith(d);
+            deviceService.DeviceAdded += DeviceServiceOnDeviceAdded;
+            deviceService.DeviceRemoved += DeviceServiceOnDeviceRemoved;
+            renderService.FrameRendering += RenderServiceOnFrameRendering;
+            Disposable.Create(() =>
+            {
+                deviceService.DeviceAdded -= DeviceServiceOnDeviceAdded;
+                deviceService.DeviceRemoved -= DeviceServiceOnDeviceRemoved;
+                renderService.FrameRendering -= RenderServiceOnFrameRendering;
+            }).DisposeWith(d);
         });
 
         ClearSelectedLeds = ReactiveCommand.Create(ExecuteClearSelectedLeds);
@@ -47,7 +52,7 @@ public class DevicePropertiesViewModel : DialogViewModelBase<object>
     public ObservableCollection<ActivatableViewModelBase> Tabs { get; }
     public ReactiveCommand<Unit, Unit> ClearSelectedLeds { get; }
 
-    private void RgbServiceOnDeviceAdded(object? sender, DeviceEventArgs e)
+    private void DeviceServiceOnDeviceAdded(object? sender, DeviceEventArgs e)
     {
         if (e.Device.Identifier != Device.Identifier || Device == e.Device)
             return;
@@ -56,7 +61,7 @@ public class DevicePropertiesViewModel : DialogViewModelBase<object>
         AddTabs();
     }
 
-    private void RgbServiceOnDeviceRemoved(object? sender, DeviceEventArgs e)
+    private void DeviceServiceOnDeviceRemoved(object? sender, DeviceEventArgs e)
     {
         Tabs.Clear();
         SelectedLeds.Clear();
@@ -76,7 +81,7 @@ public class DevicePropertiesViewModel : DialogViewModelBase<object>
         SelectedLeds.Clear();
     }
 
-    private void CoreServiceOnFrameRendering(object? sender, FrameRenderingEventArgs e)
+    private void RenderServiceOnFrameRendering(object? sender, FrameRenderingEventArgs e)
     {
         if (!SelectedLeds.Any())
             return;

src/Artemis.UI/Screens/Device/DeviceSettingsViewModel.cs

@@ -18,18 +18,15 @@ public class DeviceSettingsViewModel : ActivatableViewModelBase
     private readonly IDeviceService _deviceService;
     private readonly DevicesTabViewModel _devicesTabViewModel;
     private readonly IDeviceVmFactory _deviceVmFactory;
-    private readonly IRgbService _rgbService;
     private readonly IWindowService _windowService;
     private bool _togglingDevice;
 
-    public DeviceSettingsViewModel(ArtemisDevice device, DevicesTabViewModel devicesTabViewModel, IDeviceService deviceService, IWindowService windowService, IDeviceVmFactory deviceVmFactory,
-        IRgbService rgbService)
+    public DeviceSettingsViewModel(ArtemisDevice device, DevicesTabViewModel devicesTabViewModel, IDeviceService deviceService, IWindowService windowService, IDeviceVmFactory deviceVmFactory)
     {
         _devicesTabViewModel = devicesTabViewModel;
         _deviceService = deviceService;
         _windowService = windowService;
         _deviceVmFactory = deviceVmFactory;
-        _rgbService = rgbService;
         Device = device;
 
         Type = Device.DeviceType.ToString().Humanize();
@@ -87,7 +84,7 @@ public class DeviceSettingsViewModel : ActivatableViewModelBase
             .ShowAsync();
 
         if (viewModel.MadeChanges)
-            _rgbService.SaveDevice(Device);
+            _deviceService.SaveDevice(Device);
     }
 
     private async Task UpdateIsDeviceEnabled(bool value)
@@ -103,9 +100,9 @@ public class DeviceSettingsViewModel : ActivatableViewModelBase
                 value = !await _devicesTabViewModel.ShowDeviceDisableDialog();
 
             if (value)
-                _rgbService.EnableDevice(Device);
+                _deviceService.EnableDevice(Device);
             else
-                _rgbService.DisableDevice(Device);
+                _deviceService.DisableDevice(Device);
 
             this.RaisePropertyChanged(nameof(IsDeviceEnabled));
             SaveDevice();
@@ -118,6 +115,6 @@ public class DeviceSettingsViewModel : ActivatableViewModelBase
 
     private void SaveDevice()
     {
-        _rgbService.SaveDevice(Device);
+        _deviceService.SaveDevice(Device);
     }
 }

src/Artemis.UI/Screens/Device/Tabs/DeviceGeneralTabViewModel.cs

@@ -20,7 +20,8 @@ namespace Artemis.UI.Screens.Device;
 public class DeviceGeneralTabViewModel : ActivatableViewModelBase
 {
     private readonly ICoreService _coreService;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
+    private readonly IRenderService _renderService;
     private readonly IWindowService _windowService;
     private readonly List<DeviceCategory> _categories;
 
@@ -39,10 +40,11 @@ public class DeviceGeneralTabViewModel : ActivatableViewModelBase
     private SKColor _currentColor;
     private bool _displayOnDevices;
 
-    public DeviceGeneralTabViewModel(ArtemisDevice device, ICoreService coreService, IRgbService rgbService, IWindowService windowService)
+    public DeviceGeneralTabViewModel(ArtemisDevice device, ICoreService coreService, IDeviceService deviceService, IRenderService renderService, IWindowService windowService)
     {
         _coreService = coreService;
-        _rgbService = rgbService;
+        _deviceService = deviceService;
+        _renderService = renderService;
         _windowService = windowService;
         _categories = new List<DeviceCategory>(device.Categories);
 
@@ -66,11 +68,11 @@ public class DeviceGeneralTabViewModel : ActivatableViewModelBase
 
         this.WhenActivated(d =>
         {
-            _coreService.FrameRendering += OnFrameRendering;
+            _renderService.FrameRendering += OnFrameRendering;
 
             Disposable.Create(() =>
             {
-                _coreService.FrameRendering -= OnFrameRendering;
+                _renderService.FrameRendering -= OnFrameRendering;
                 Apply();
             }).DisposeWith(d);
         });
@@ -191,17 +193,12 @@ public class DeviceGeneralTabViewModel : ActivatableViewModelBase
             return;
 
         await Task.Delay(400);
-        _rgbService.SaveDevice(Device);
-        _rgbService.ApplyBestDeviceLayout(Device);
+        _deviceService.SaveDevice(Device);
+        _deviceService.ApplyDeviceLayout(Device, Device.GetBestDeviceLayout());
     }
 
     private void Apply()
     {
-        // TODO: Validation
-
-        _coreService.ProfileRenderingDisabled = true;
-        Thread.Sleep(100);
-
         Device.X = X;
         Device.Y = Y;
         Device.Scale = Scale;
@@ -213,9 +210,7 @@ public class DeviceGeneralTabViewModel : ActivatableViewModelBase
         foreach (DeviceCategory deviceCategory in _categories)
             Device.Categories.Add(deviceCategory);
 
-        _rgbService.SaveDevice(Device);
-
-        _coreService.ProfileRenderingDisabled = false;
+        _deviceService.SaveDevice(Device);
     }
 
     public void ApplyScaling()
@@ -224,7 +219,7 @@ public class DeviceGeneralTabViewModel : ActivatableViewModelBase
         Device.GreenScale = GreenScale / 100f;
         Device.BlueScale = BlueScale / 100f;
 
-        _rgbService.FlushLeds = true;
+        _renderService.FlushLeds = true;
     }
 
     public void ResetScaling()

src/Artemis.UI/Screens/Device/Tabs/DeviceLayoutTabViewModel.cs

@@ -22,20 +22,13 @@ public class DeviceLayoutTabViewModel : ActivatableViewModelBase
 {
     private readonly IWindowService _windowService;
     private readonly INotificationService _notificationService;
-    private readonly ICoreService _coreService;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
 
-    public DeviceLayoutTabViewModel(
-        IWindowService windowService,
-        INotificationService notificationService,
-        ICoreService coreService,
-        IRgbService rgbService,
-        ArtemisDevice device)
+    public DeviceLayoutTabViewModel(IWindowService windowService, INotificationService notificationService, IDeviceService deviceService, ArtemisDevice device)
     {
         _windowService = windowService;
         _notificationService = notificationService;
-        _coreService = coreService;
-        _rgbService = rgbService;
+        _deviceService = deviceService;
 
         Device = device;
         DisplayName = "Layout";
@@ -160,6 +153,6 @@ public class DeviceLayoutTabViewModel : ActivatableViewModelBase
     private void DeviceOnPropertyChanged(object? sender, PropertyChangedEventArgs e)
     {
         if (e.PropertyName is nameof(Device.CustomLayoutPath) or nameof(Device.DisableDefaultLayout))
-            Task.Run(() => _rgbService.ApplyBestDeviceLayout(Device));
+            Task.Run(() => _deviceService.ApplyDeviceLayout(Device, Device.GetBestDeviceLayout()));
     }
 }

src/Artemis.UI/Screens/Device/Tabs/InputMappingsTabViewModel.cs

@@ -16,17 +16,17 @@ namespace Artemis.UI.Screens.Device;
 public class InputMappingsTabViewModel : ActivatableViewModelBase
 {
     private readonly IInputService _inputService;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     private readonly ObservableCollection<ArtemisLed> _selectedLeds;
     private ArtemisLed? _selectedLed;
 
-    public InputMappingsTabViewModel(ArtemisDevice device, ObservableCollection<ArtemisLed> selectedLeds, IRgbService rgbService, IInputService inputService)
+    public InputMappingsTabViewModel(ArtemisDevice device, ObservableCollection<ArtemisLed> selectedLeds, IInputService inputService, IDeviceService deviceService)
     {
         if (device.DeviceType != RGBDeviceType.Keyboard)
             throw new ArtemisUIException("The input mappings tab only supports keyboards");
 
-        _rgbService = rgbService;
         _inputService = inputService;
+        _deviceService = deviceService;
         _selectedLeds = selectedLeds;
 
         Device = device;
@@ -81,7 +81,7 @@ public class InputMappingsTabViewModel : ActivatableViewModelBase
 
         // Apply the new LED mapping
         Device.InputMappings[SelectedLed] = artemisLed;
-        _rgbService.SaveDevice(Device);
+        _deviceService.SaveDevice(Device);
         _selectedLeds.Clear();
 
         UpdateInputMappings();

src/Artemis.UI/Screens/ProfileEditor/Panels/ProfileTree/Dialogs/LayerHintsDialogViewModel.cs

@@ -15,12 +15,12 @@ namespace Artemis.UI.Screens.ProfileEditor.ProfileTree.Dialogs;
 
 public class LayerHintsDialogViewModel : DialogViewModelBase<bool>
 {
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     private readonly ILayerHintVmFactory _vmFactory;
 
-    public LayerHintsDialogViewModel(Layer layer, IRgbService rgbService, ILayerHintVmFactory vmFactory)
+    public LayerHintsDialogViewModel(Layer layer, IDeviceService deviceService, ILayerHintVmFactory vmFactory)
     {
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         _vmFactory = vmFactory;
 
         Layer = layer;
@@ -49,7 +49,7 @@ public class LayerHintsDialogViewModel : DialogViewModelBase<bool>
 
     public void AutoDetermineHints()
     {
-        Layer.Adapter.DetermineHints(_rgbService.EnabledDevices);
+        Layer.Adapter.DetermineHints(_deviceService.EnabledDevices);
     }
 
     public void AddCategoryHint()

src/Artemis.UI/Screens/ProfileEditor/Panels/ProfileTree/FolderTreeItemViewModel.cs

@@ -14,17 +14,17 @@ namespace Artemis.UI.Screens.ProfileEditor.ProfileTree;
 
 public class FolderTreeItemViewModel : TreeItemViewModel
 {
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
 
     public FolderTreeItemViewModel(TreeItemViewModel? parent,
         Folder folder,
         IWindowService windowService,
+        IDeviceService deviceService,
         IProfileEditorService profileEditorService,
-        IRgbService rgbService,
         IProfileEditorVmFactory profileEditorVmFactory)
-        : base(parent, folder, windowService, rgbService, profileEditorService, profileEditorVmFactory)
+        : base(parent, folder, windowService, deviceService, profileEditorService, profileEditorVmFactory)
     {
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         Folder = folder;
     }
 
@@ -63,7 +63,7 @@ public class FolderTreeItemViewModel : TreeItemViewModel
             pasted.Name = parent.GetNewFolderName(pasted.Name + " - copy");
 
         ProfileEditorService.ExecuteCommand(new AddProfileElement(pasted, parent, Folder.Order - 1));
-        Folder.Profile.PopulateLeds(_rgbService.EnabledDevices);
+        Folder.Profile.PopulateLeds(_deviceService.EnabledDevices);
     }
 
     private async Task ExecutePasteInto()

src/Artemis.UI/Screens/ProfileEditor/Panels/ProfileTree/LayerTreeItemViewModel.cs

@@ -14,17 +14,17 @@ namespace Artemis.UI.Screens.ProfileEditor.ProfileTree;
 
 public class LayerTreeItemViewModel : TreeItemViewModel
 {
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
 
     public LayerTreeItemViewModel(TreeItemViewModel? parent,
         Layer layer,
         IWindowService windowService,
         IProfileEditorService profileEditorService,
-        IRgbService rgbService,
+        IDeviceService deviceService,
         IProfileEditorVmFactory profileEditorVmFactory)
-        : base(parent, layer, windowService, rgbService, profileEditorService, profileEditorVmFactory)
+        : base(parent, layer, windowService, deviceService, profileEditorService, profileEditorVmFactory)
     {
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         Layer = layer;
     }
 
@@ -43,7 +43,7 @@ public class LayerTreeItemViewModel : TreeItemViewModel
 
         Layer copied = new(Layer.Profile, Layer.Parent, copy, true);
         ProfileEditorService.ExecuteCommand(new AddProfileElement(copied, Layer.Parent, Layer.Order - 1));
-        Layer.Profile.PopulateLeds(_rgbService.EnabledDevices);
+        Layer.Profile.PopulateLeds(_deviceService.EnabledDevices);
     }
 
     protected override async Task ExecuteCopy()
@@ -65,7 +65,7 @@ public class LayerTreeItemViewModel : TreeItemViewModel
             pasted.Name = parent.GetNewLayerName(pasted.Name + " - copy");
 
         ProfileEditorService.ExecuteCommand(new AddProfileElement(pasted, parent, Layer.Order - 1));
-        Layer.Profile.PopulateLeds(_rgbService.EnabledDevices);
+        Layer.Profile.PopulateLeds(_deviceService.EnabledDevices);
     }
 
     /// <inheritdoc />

src/Artemis.UI/Screens/ProfileEditor/Panels/ProfileTree/ProfileTreeViewModel.cs

@@ -23,8 +23,8 @@ public class ProfileTreeViewModel : TreeItemViewModel
     private ObservableAsPropertyHelper<bool>? _keyBindingsEnabled;
     private TreeItemViewModel? _selectedChild;
 
-    public ProfileTreeViewModel(IWindowService windowService, IRgbService rgbService, IProfileEditorService profileEditorService, IProfileEditorVmFactory profileEditorVmFactory)
-        : base(null, null, windowService, rgbService, profileEditorService, profileEditorVmFactory)
+    public ProfileTreeViewModel(IWindowService windowService, IDeviceService deviceService, IProfileEditorService profileEditorService, IProfileEditorVmFactory profileEditorVmFactory)
+        : base(null, null, windowService, deviceService, profileEditorService, profileEditorVmFactory)
     {
         this.WhenActivated(d =>
         {

src/Artemis.UI/Screens/ProfileEditor/Panels/ProfileTree/TreeItemViewModel.cs

@@ -28,7 +28,7 @@ public abstract class TreeItemViewModel : ActivatableViewModelBase
 {
     private readonly IProfileEditorVmFactory _profileEditorVmFactory;
     private readonly IWindowService _windowService;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     protected readonly IProfileEditorService ProfileEditorService;
     private bool _canPaste;
     private RenderProfileElement? _currentProfileElement;
@@ -41,13 +41,13 @@ public abstract class TreeItemViewModel : ActivatableViewModelBase
     protected TreeItemViewModel(TreeItemViewModel? parent,
         ProfileElement? profileElement,
         IWindowService windowService,
-        IRgbService rgbService,
+        IDeviceService deviceService,
         IProfileEditorService profileEditorService,
         IProfileEditorVmFactory profileEditorVmFactory)
     {
         ProfileEditorService = profileEditorService;
         _windowService = windowService;
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         _profileEditorVmFactory = profileEditorVmFactory;
 
         Parent = parent;
@@ -267,7 +267,7 @@ public abstract class TreeItemViewModel : ActivatableViewModelBase
         if (ProfileElement is not Layer layer)
             return;
         
-        ProfileEditorService.ExecuteCommand(new ApplyAdaptionHints(layer, _rgbService.EnabledDevices.ToList()));
+        ProfileEditorService.ExecuteCommand(new ApplyAdaptionHints(layer, _deviceService.EnabledDevices.ToList()));
     }
 
     private async void UpdateCanPaste(bool isFlyoutOpen)

src/Artemis.UI/Screens/ProfileEditor/Panels/VisualEditor/Tools/SelectionAddToolViewModel.cs

@@ -17,14 +17,14 @@ public class SelectionAddToolViewModel : ToolViewModel
 {
     private readonly ObservableAsPropertyHelper<bool>? _isEnabled;
     private readonly IProfileEditorService _profileEditorService;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     private Layer? _layer;
 
     /// <inheritdoc />
-    public SelectionAddToolViewModel(IProfileEditorService profileEditorService, IRgbService rgbService)
+    public SelectionAddToolViewModel(IProfileEditorService profileEditorService, IDeviceService deviceService)
     {
         _profileEditorService = profileEditorService;
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         // Not disposed when deactivated but when really disposed
         _isEnabled = profileEditorService.ProfileElement.Select(p => p is Layer).ToProperty(this, vm => vm.IsEnabled);
 
@@ -57,7 +57,7 @@ public class SelectionAddToolViewModel : ToolViewModel
         if (inverse)
         {
             List<ArtemisLed> toRemove = _layer.Leds.Where(l => l.AbsoluteRectangle.IntersectsWith(rect)).ToList();
-            List<ArtemisLed> toAdd = _rgbService.EnabledDevices.SelectMany(d => d.Leds).Where(l => l.AbsoluteRectangle.IntersectsWith(rect)).Except(toRemove).ToList();
+            List<ArtemisLed> toAdd = _deviceService.EnabledDevices.SelectMany(d => d.Leds).Where(l => l.AbsoluteRectangle.IntersectsWith(rect)).Except(toRemove).ToList();
             List<ArtemisLed> leds = _layer.Leds.Except(toRemove).ToList();
             leds.AddRange(toAdd);
 
@@ -65,7 +65,7 @@ public class SelectionAddToolViewModel : ToolViewModel
         }
         else
         {
-            List<ArtemisLed> leds = _rgbService.EnabledDevices.SelectMany(d => d.Leds).Where(l => l.AbsoluteRectangle.IntersectsWith(rect)).ToList();
+            List<ArtemisLed> leds = _deviceService.EnabledDevices.SelectMany(d => d.Leds).Where(l => l.AbsoluteRectangle.IntersectsWith(rect)).ToList();
             if (expand)
                 leds.AddRange(_layer.Leds);
             _profileEditorService.ExecuteCommand(new ChangeLayerLeds(_layer, leds.Distinct().ToList()));

src/Artemis.UI/Screens/ProfileEditor/Panels/VisualEditor/VisualEditorViewModel.cs

@@ -25,7 +25,7 @@ public class VisualEditorViewModel : ActivatableViewModelBase
     private ObservableAsPropertyHelper<bool>? _suspendedEditing;
     private ReadOnlyObservableCollection<IToolViewModel>? _tools;
 
-    public VisualEditorViewModel(IProfileEditorService profileEditorService, IRgbService rgbService, IProfileEditorVmFactory vmFactory)
+    public VisualEditorViewModel(IProfileEditorService profileEditorService, IDeviceService deviceService, IProfileEditorVmFactory vmFactory)
     {
         _vmFactory = vmFactory;
         _visualizers = new SourceList<IVisualizerViewModel>();
@@ -34,7 +34,7 @@ public class VisualEditorViewModel : ActivatableViewModelBase
             .Bind(out ReadOnlyObservableCollection<IVisualizerViewModel> visualizers)
             .Subscribe();
 
-        Devices = new ObservableCollection<ArtemisDevice>(rgbService.EnabledDevices.OrderBy(d => d.ZIndex));
+        Devices = new ObservableCollection<ArtemisDevice>(deviceService.EnabledDevices.OrderBy(d => d.ZIndex));
         Visualizers = visualizers;
 
         this.WhenActivated(d =>

src/Artemis.UI/Screens/Settings/Tabs/DevicesTabViewModel.cs

@@ -19,15 +19,15 @@ namespace Artemis.UI.Screens.Settings;
 public class DevicesTabViewModel : RoutableScreen
 {
     private readonly IDeviceVmFactory _deviceVmFactory;
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     private readonly IWindowService _windowService;
     private bool _confirmedDisable;
 
-    public DevicesTabViewModel(IRgbService rgbService, IWindowService windowService, IDeviceVmFactory deviceVmFactory)
+    public DevicesTabViewModel(IDeviceService deviceService, IWindowService windowService, IDeviceVmFactory deviceVmFactory)
     {
         DisplayName = "Devices";
 
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         _windowService = windowService;
         _deviceVmFactory = deviceVmFactory;
 
@@ -36,10 +36,10 @@ public class DevicesTabViewModel : RoutableScreen
         {
             GetDevices();
 
-            Observable.FromEventPattern<DeviceEventArgs>(x => rgbService.DeviceAdded += x, x => rgbService.DeviceAdded -= x)
+            Observable.FromEventPattern<DeviceEventArgs>(x => _deviceService.DeviceAdded += x, x => _deviceService.DeviceAdded -= x)
                 .Subscribe(d => AddDevice(d.EventArgs.Device))
                 .DisposeWith(disposables);
-            Observable.FromEventPattern<DeviceEventArgs>(x => rgbService.DeviceRemoved += x, x => rgbService.DeviceRemoved -= x)
+            Observable.FromEventPattern<DeviceEventArgs>(x => _deviceService.DeviceRemoved += x, x => _deviceService.DeviceRemoved -= x)
                 .Subscribe(d => RemoveDevice(d.EventArgs.Device))
                 .DisposeWith(disposables);
         });
@@ -66,7 +66,7 @@ public class DevicesTabViewModel : RoutableScreen
     private void GetDevices()
     {
         Devices.Clear();
-        Dispatcher.UIThread.InvokeAsync(() => { Devices.AddRange(_rgbService.Devices.Select(d => _deviceVmFactory.DeviceSettingsViewModel(d, this))); }, DispatcherPriority.Background);
+        Dispatcher.UIThread.InvokeAsync(() => { Devices.AddRange(_deviceService.Devices.Select(d => _deviceVmFactory.DeviceSettingsViewModel(d, this))); }, DispatcherPriority.Background);
     }
 
     private void AddDevice(ArtemisDevice device)
@@ -81,7 +81,7 @@ public class DevicesTabViewModel : RoutableScreen
     private void RemoveDevice(ArtemisDevice device)
     {
         // If the device was only disabled don't remove it
-        if (_rgbService.Devices.Contains(device))
+        if (_deviceService.Devices.Contains(device))
             return;
 
         DeviceSettingsViewModel? viewModel = Devices.FirstOrDefault(i => i.Device == device);

src/Artemis.UI/Screens/StartupWizard/StartupWizardViewModel.cs

@@ -21,9 +21,9 @@ public class StartupWizardViewModel : DialogViewModelBase<bool>
 {
     private readonly IAutoRunProvider? _autoRunProvider;
     private readonly IProtocolProvider? _protocolProvider;
-    private readonly IRgbService _rgbService;
     private readonly ISettingsService _settingsService;
     private readonly IWindowService _windowService;
+    private readonly IDeviceService _deviceService;
     private int _currentStep;
     private bool _showContinue;
     private bool _showFinish;
@@ -31,14 +31,14 @@ public class StartupWizardViewModel : DialogViewModelBase<bool>
 
     public StartupWizardViewModel(IContainer container,
         ISettingsService settingsService,
-        IRgbService rgbService,
         IPluginManagementService pluginManagementService,
         IWindowService windowService,
+        IDeviceService deviceService,
         ISettingsVmFactory settingsVmFactory)
     {
         _settingsService = settingsService;
-        _rgbService = rgbService;
         _windowService = windowService;
+        _deviceService = deviceService;
         _autoRunProvider = container.Resolve<IAutoRunProvider>(IfUnresolved.ReturnDefault);
         _protocolProvider = container.Resolve<IProtocolProvider>(IfUnresolved.ReturnDefault);
 
@@ -159,7 +159,7 @@ public class StartupWizardViewModel : DialogViewModelBase<bool>
     private void ExecuteSelectLayout(string layout)
     {
         // TODO: Implement the layout
-        _rgbService.AutoArrangeDevices();
+        _deviceService.AutoArrangeDevices();
 
         ExecuteContinue();
     }

src/Artemis.UI/Screens/SurfaceEditor/ListDeviceViewModel.cs

@@ -15,16 +15,16 @@ namespace Artemis.UI.Screens.SurfaceEditor;
 public class ListDeviceViewModel : ViewModelBase
 {
     private static readonly Random Random = new();
-    private readonly IRgbService _rgbService;
     private readonly IWindowService _windowService;
+    private readonly IDeviceService _deviceService;
 
     private SKColor _color;
     private bool _isSelected;
 
-    public ListDeviceViewModel(ArtemisDevice device, SurfaceEditorViewModel surfaceEditorViewModel, IWindowService windowService, IRgbService rgbService)
+    public ListDeviceViewModel(ArtemisDevice device, SurfaceEditorViewModel surfaceEditorViewModel, IWindowService windowService, IDeviceService deviceService)
     {
         _windowService = windowService;
-        _rgbService = rgbService;
+        _deviceService = deviceService;
 
         Device = device;
         SurfaceEditorViewModel = surfaceEditorViewModel;
@@ -62,6 +62,6 @@ public class ListDeviceViewModel : ViewModelBase
             .ShowAsync();
 
         if (viewModel.MadeChanges)
-            _rgbService.SaveDevice(Device);
+            _deviceService.SaveDevice(Device);
     }
 }

src/Artemis.UI/Screens/SurfaceEditor/SurfaceDeviceViewModel.cs

@@ -17,16 +17,16 @@ namespace Artemis.UI.Screens.SurfaceEditor;
 
 public class SurfaceDeviceViewModel : ActivatableViewModelBase
 {
-    private readonly IRgbService _rgbService;
+    private readonly IDeviceService _deviceService;
     private readonly ISettingsService _settingsService;
     private readonly IWindowService _windowService;
     private double _dragOffsetX;
     private double _dragOffsetY;
     private bool _isSelected;
 
-    public SurfaceDeviceViewModel(ArtemisDevice device, SurfaceEditorViewModel surfaceEditorViewModel, IRgbService rgbService, ISettingsService settingsService, IWindowService windowService)
+    public SurfaceDeviceViewModel(ArtemisDevice device, SurfaceEditorViewModel surfaceEditorViewModel, IDeviceService deviceService, ISettingsService settingsService, IWindowService windowService)
     {
-        _rgbService = rgbService;
+        _deviceService = deviceService;
         _settingsService = settingsService;
         _windowService = windowService;
 
@@ -100,7 +100,7 @@ public class SurfaceDeviceViewModel : ActivatableViewModelBase
 
         IEnumerable<SKRect> own = Device.Leds
             .Select(l => SKRect.Create(l.Rectangle.Left + x, l.Rectangle.Top + y, l.Rectangle.Width, l.Rectangle.Height));
-        IEnumerable<SKRect> others = _rgbService.EnabledDevices
+        IEnumerable<SKRect> others = _deviceService.EnabledDevices
             .Where(d => d != Device && d.IsEnabled)
             .SelectMany(d => d.Leds)
             .Select(l => SKRect.Create(l.Rectangle.Left + l.Device.X, l.Rectangle.Top + l.Device.Y, l.Rectangle.Width, l.Rectangle.Height));
@@ -120,6 +120,6 @@ public class SurfaceDeviceViewModel : ActivatableViewModelBase
             .ShowAsync();
 
         if (viewModel.MadeChanges)
-            _rgbService.SaveDevice(Device);
+            _deviceService.SaveDevice(Device);
     }
 }

src/Artemis.UI/Screens/SurfaceEditor/SurfaceEditorViewModel.cs

@@ -21,8 +21,8 @@ namespace Artemis.UI.Screens.SurfaceEditor;
 public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 {
     private readonly IDeviceService _deviceService;
+    private readonly IRenderService _renderService;
     private readonly IDeviceVmFactory _deviceVmFactory;
-    private readonly IRgbService _rgbService;
     private readonly ISettingsService _settingsService;
     private readonly ISurfaceVmFactory _surfaceVmFactory;
     private readonly IWindowService _windowService;
@@ -33,23 +33,23 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
     private bool _saving;
 
     public SurfaceEditorViewModel(ICoreService coreService,
-        IRgbService rgbService,
         ISurfaceVmFactory surfaceVmFactory,
         ISettingsService settingsService,
         IDeviceVmFactory deviceVmFactory,
         IWindowService windowService,
-        IDeviceService deviceService)
+        IDeviceService deviceService,
+        IRenderService renderService)
     {
-        _rgbService = rgbService;
         _surfaceVmFactory = surfaceVmFactory;
         _settingsService = settingsService;
         _deviceVmFactory = deviceVmFactory;
         _windowService = windowService;
         _deviceService = deviceService;
+        _renderService = renderService;
 
         DisplayName = "Surface Editor";
-        SurfaceDeviceViewModels = new ObservableCollection<SurfaceDeviceViewModel>(rgbService.EnabledDevices.OrderBy(d => d.ZIndex).Select(d => surfaceVmFactory.SurfaceDeviceViewModel(d, this)));
-        ListDeviceViewModels = new ObservableCollection<ListDeviceViewModel>(rgbService.EnabledDevices.OrderBy(d => d.ZIndex).Select(d => surfaceVmFactory.ListDeviceViewModel(d, this)));
+        SurfaceDeviceViewModels = new ObservableCollection<SurfaceDeviceViewModel>(deviceService.EnabledDevices.OrderBy(d => d.ZIndex).Select(d => surfaceVmFactory.SurfaceDeviceViewModel(d, this)));
+        ListDeviceViewModels = new ObservableCollection<ListDeviceViewModel>(deviceService.EnabledDevices.OrderBy(d => d.ZIndex).Select(d => surfaceVmFactory.ListDeviceViewModel(d, this)));
 
         AutoArrange = ReactiveCommand.CreateFromTask(ExecuteAutoArrange);
         IdentifyDevice = ReactiveCommand.Create<ArtemisDevice>(ExecuteIdentifyDevice);
@@ -61,14 +61,14 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 
         this.WhenActivated(d =>
         {
-            coreService.FrameRendering += CoreServiceOnFrameRendering;
-            _rgbService.DeviceAdded += RgbServiceOnDeviceAdded;
-            _rgbService.DeviceRemoved += RgbServiceOnDeviceRemoved;
+            _renderService.FrameRendering += RenderServiceOnFrameRendering;
+            _deviceService.DeviceAdded += DeviceServiceOnDeviceAdded;
+            _deviceService.DeviceRemoved += DeviceServiceOnDeviceRemoved;
             Disposable.Create(() =>
             {
-                coreService.FrameRendering -= CoreServiceOnFrameRendering;
-                _rgbService.DeviceAdded -= RgbServiceOnDeviceAdded;
-                _rgbService.DeviceRemoved -= RgbServiceOnDeviceRemoved;
+                _renderService.FrameRendering -= RenderServiceOnFrameRendering;
+                _deviceService.DeviceAdded -= DeviceServiceOnDeviceAdded;
+                _deviceService.DeviceRemoved -= DeviceServiceOnDeviceRemoved;
             }).DisposeWith(d);
         });
     }
@@ -135,7 +135,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
             try
             {
                 _saving = true;
-                _rgbService.SaveDevices();
+                _deviceService.SaveDevices();
             }
             catch (Exception e)
             {
@@ -166,7 +166,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
             surfaceDeviceViewModel.UpdateMouseDrag(mousePosition, round, ignoreOverlap);
     }
 
-    private void RgbServiceOnDeviceAdded(object? sender, DeviceEventArgs e)
+    private void DeviceServiceOnDeviceAdded(object? sender, DeviceEventArgs e)
     {
         if (!e.Device.IsEnabled)
             return;
@@ -177,7 +177,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
         ListDeviceViewModels.Sort(l => l.Device.ZIndex * -1);
     }
 
-    private void RgbServiceOnDeviceRemoved(object? sender, DeviceEventArgs e)
+    private void DeviceServiceOnDeviceRemoved(object? sender, DeviceEventArgs e)
     {
         SurfaceDeviceViewModel? surfaceVm = SurfaceDeviceViewModels.FirstOrDefault(vm => vm.Device == e.Device);
         ListDeviceViewModel? listVm = ListDeviceViewModels.FirstOrDefault(vm => vm.Device == e.Device);
@@ -193,10 +193,10 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
         if (!confirmed)
             return;
 
-        _rgbService.AutoArrangeDevices();
+        _deviceService.AutoArrangeDevices();
     }
 
-    private void CoreServiceOnFrameRendering(object? sender, FrameRenderingEventArgs e)
+    private void RenderServiceOnFrameRendering(object? sender, FrameRenderingEventArgs e)
     {
         // Animate the overlay because I'm vain
         if (ColorDevices && _overlayOpacity < 1)
@@ -255,7 +255,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 
         ListDeviceViewModels.Sort(l => l.Device.ZIndex * -1);
 
-        _rgbService.SaveDevices();
+        _deviceService.SaveDevices();
     }
 
     private void ExecuteBringForward(ArtemisDevice device)
@@ -273,7 +273,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 
         ListDeviceViewModels.Sort(l => l.Device.ZIndex * -1);
 
-        _rgbService.SaveDevices();
+        _deviceService.SaveDevices();
     }
 
     private void ExecuteSendToBack(ArtemisDevice device)
@@ -288,7 +288,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 
         ListDeviceViewModels.Sort(l => l.Device.ZIndex * -1);
 
-        _rgbService.SaveDevices();
+        _deviceService.SaveDevices();
     }
 
     private void ExecuteSendBackward(ArtemisDevice device)
@@ -305,7 +305,7 @@ public class SurfaceEditorViewModel : RoutableScreen, IMainScreenViewModel
 
         ListDeviceViewModels.Sort(l => l.Device.ZIndex * -1);
 
-        _rgbService.SaveDevices();
+        _deviceService.SaveDevices();
     }
 
     #endregion

src/Artemis.UI/Screens/Workshop/Profile/ProfilePreviewViewModel.cs

@@ -16,12 +16,12 @@ public class ProfilePreviewViewModel : ActivatableViewModelBase
     private readonly IWindowService _windowService;
     private ProfileConfiguration? _profileConfiguration;
 
-    public ProfilePreviewViewModel(IProfileService profileService, IRgbService rgbService, IWindowService windowService)
+    public ProfilePreviewViewModel(IProfileService profileService, IDeviceService deviceService, IWindowService windowService)
     {
         _profileService = profileService;
         _windowService = windowService;
 
-        Devices = new ObservableCollection<ArtemisDevice>(rgbService.EnabledDevices.OrderBy(d => d.ZIndex));
+        Devices = new ObservableCollection<ArtemisDevice>(deviceService.EnabledDevices.OrderBy(d => d.ZIndex));
 
         this.WhenAnyValue(vm => vm.ProfileConfiguration).Subscribe(_ => Update());
         this.WhenActivated(d => Disposable.Create(() => PreviewProfile(null)).DisposeWith(d));